ReactOS  0.4.13-dev-257-gfabbd7c
points.c
Go to the documentation of this file.
1 /* $Id: points.c,v 1.15 1998/02/03 23:46:00 brianp Exp $ */
2 
3 /*
4  * Mesa 3-D graphics library
5  * Version: 2.5
6  * Copyright (C) 1995-1997 Brian Paul
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public
19  * License along with this library; if not, write to the Free
20  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22 
23 
24 /*
25  * $Log: points.c,v $
26  * Revision 1.15 1998/02/03 23:46:00 brianp
27  * fixed a few problems with condition expressions for Amiga StormC compiler
28  *
29  * Revision 1.14 1997/10/29 01:29:09 brianp
30  * added GL_EXT_point_parameters extension from Daniel Barrero
31  *
32  * Revision 1.13 1997/07/24 01:23:44 brianp
33  * changed precompiled header symbol from PCH to PC_HEADER
34  *
35  * Revision 1.12 1997/06/20 02:50:39 brianp
36  * changed color components from GLfixed to GLubyte
37  *
38  * Revision 1.11 1997/05/28 03:26:02 brianp
39  * added precompiled header (PCH) support
40  *
41  * Revision 1.10 1997/05/03 00:51:02 brianp
42  * removed calls to gl_texturing_enabled()
43  *
44  * Revision 1.9 1997/04/14 02:00:39 brianp
45  * #include "texstate.h" instead of "texture.h"
46  *
47  * Revision 1.8 1997/04/12 12:24:43 brianp
48  * replaced ctx->PointsFunc with ctx->Driver.PointsFunc
49  *
50  * Revision 1.7 1997/04/02 03:11:38 brianp
51  * replaced VB->Unclipped with VB->ClipMask
52  *
53  * Revision 1.6 1997/03/08 02:04:27 brianp
54  * better implementation of feedback function
55  *
56  * Revision 1.5 1997/02/09 18:43:52 brianp
57  * added GL_EXT_texture3D support
58  *
59  * Revision 1.4 1997/01/09 19:48:00 brianp
60  * now call gl_texturing_enabled()
61  *
62  * Revision 1.3 1996/11/08 02:21:21 brianp
63  * added null drawing function for GL_NO_RASTER
64  *
65  * Revision 1.2 1996/09/15 14:18:37 brianp
66  * now use GLframebuffer and GLvisual
67  *
68  * Revision 1.1 1996/09/13 01:38:16 brianp
69  * Initial revision
70  *
71  */
72 
73 
74 #ifdef PC_HEADER
75 #include "all.h"
76 #else
77 #include "context.h"
78 #include "feedback.h"
79 #include "dlist.h"
80 #include "macros.h"
81 #include "pb.h"
82 #include "span.h"
83 #include "texstate.h"
84 #include "types.h"
85 #include "vb.h"
86 #include "mmath.h"
87 #endif
88 
89 
90 
92 {
93  if (size<=0.0) {
94  gl_error( ctx, GL_INVALID_VALUE, "glPointSize" );
95  return;
96  }
97  if (INSIDE_BEGIN_END(ctx)) {
98  gl_error( ctx, GL_INVALID_OPERATION, "glPointSize" );
99  return;
100  }
101  ctx->Point.Size = size;
102  ctx->NewState |= NEW_RASTER_OPS;
103 }
104 
105 
106 /**********************************************************************/
107 /***** Rasterization *****/
108 /**********************************************************************/
109 
110 
111 /*
112  * There are 3 pairs (RGBA, CI) of point rendering functions:
113  * 1. simple: size=1 and no special rasterization functions (fastest)
114  * 2. size1: size=1 and any rasterization functions
115  * 3. general: any size and rasterization functions (slowest)
116  *
117  * All point rendering functions take the same two arguments: first and
118  * last which specify that the points specified by VB[first] through
119  * VB[last] are to be rendered.
120  */
121 
122 
123 
124 /*
125  * Put points in feedback buffer.
126  */
128 {
129  struct vertex_buffer *VB = ctx->VB;
130  GLuint i;
131  GLfloat invRedScale = ctx->Visual->InvRedScale;
132  GLfloat invGreenScale = ctx->Visual->InvGreenScale;
133  GLfloat invBlueScale = ctx->Visual->InvBlueScale;
134  GLfloat invAlphaScale = ctx->Visual->InvAlphaScale;
135 
136  for (i=first;i<=last;i++) {
137  if (VB->ClipMask[i]==0) {
138  GLfloat x, y, z, w, invq;
139  GLfloat color[4], texcoord[4];
140 
141  x = VB->Win[i][0];
142  y = VB->Win[i][1];
143  z = VB->Win[i][2] / DEPTH_SCALE;
144  w = VB->Clip[i][3];
145 
146  /* convert color from integer back to a float in [0,1] */
147  if (ctx->Light.ShadeModel==GL_SMOOTH) {
148  /* smooth shading - colors are in fixed point */
149  color[0] = FixedToFloat(VB->Color[i][0]) * invRedScale;
150  color[1] = FixedToFloat(VB->Color[i][1]) * invGreenScale;
151  color[2] = FixedToFloat(VB->Color[i][2]) * invBlueScale;
152  color[3] = FixedToFloat(VB->Color[i][3]) * invAlphaScale;
153  }
154  else {
155  /* flat shading - colors are integers */
156  color[0] = VB->Color[i][0] * invRedScale;
157  color[1] = VB->Color[i][1] * invGreenScale;
158  color[2] = VB->Color[i][2] * invBlueScale;
159  color[3] = VB->Color[i][3] * invAlphaScale;
160  }
161  invq = 1.0F / VB->TexCoord[i][3];
162  texcoord[0] = VB->TexCoord[i][0] * invq;
163  texcoord[1] = VB->TexCoord[i][1] * invq;
164  texcoord[2] = VB->TexCoord[i][2] * invq;
165  texcoord[3] = VB->TexCoord[i][3];
166 
168  gl_feedback_vertex( ctx, x, y, z, w, color,
169  (GLfloat) VB->Index[i], texcoord );
170  }
171  }
172 }
173 
174 
175 
176 /*
177  * Put points in selection buffer.
178  */
180 {
181  struct vertex_buffer *VB = ctx->VB;
182  GLuint i;
183 
184  for (i=first;i<=last;i++) {
185  if (VB->ClipMask[i]==0) {
186  gl_update_hitflag( ctx, VB->Win[i][2] / DEPTH_SCALE );
187  }
188  }
189 }
190 
191 
192 /*
193  * CI points with size == 1.0
194  */
196 {
197  struct vertex_buffer *VB = ctx->VB;
198  struct pixel_buffer *PB = ctx->PB;
199  GLfloat *win;
200  GLint *pbx = PB->x, *pby = PB->y;
201  GLdepth *pbz = PB->z;
202  GLuint *pbi = PB->i;
203  GLuint pbcount = PB->count;
204  GLuint i;
205 
206  win = &VB->Win[first][0];
207  for (i=first;i<=last;i++) {
208  if (VB->ClipMask[i]==0) {
209  pbx[pbcount] = (GLint) win[0];
210  pby[pbcount] = (GLint) win[1];
211  pbz[pbcount] = (GLint) (win[2] + ctx->PointZoffset);
212  pbi[pbcount] = VB->Index[i];
213  pbcount++;
214  }
215  win += 3;
216  }
217  PB->count = pbcount;
218  PB_CHECK_FLUSH(ctx, PB)
219 }
220 
221 
222 
223 /*
224  * RGBA points with size == 1.0
225  */
227 {
228  struct vertex_buffer *VB = ctx->VB;
229  struct pixel_buffer *PB = ctx->PB;
230  GLuint i;
231 
232  for (i=first;i<=last;i++) {
233  if (VB->ClipMask[i]==0) {
234  GLint x, y, z;
235  GLint red, green, blue, alpha;
236 
237  x = (GLint) VB->Win[i][0];
238  y = (GLint) VB->Win[i][1];
239  z = (GLint) (VB->Win[i][2] + ctx->PointZoffset);
240 
241  red = VB->Color[i][0];
242  green = VB->Color[i][1];
243  blue = VB->Color[i][2];
244  alpha = VB->Color[i][3];
245 
247  }
248  }
249  PB_CHECK_FLUSH(ctx,PB)
250 }
251 
252 
253 
254 /*
255  * General CI points.
256  */
258 {
259  struct vertex_buffer *VB = ctx->VB;
260  struct pixel_buffer *PB = ctx->PB;
261  GLuint i;
262  GLint isize;
263 
264  isize = (GLint) (CLAMP(ctx->Point.Size,MIN_POINT_SIZE,MAX_POINT_SIZE) + 0.5F);
265 
266  for (i=first;i<=last;i++) {
267  if (VB->ClipMask[i]==0) {
268  GLint x, y, z;
269  GLint x0, x1, y0, y1;
270  GLint ix, iy;
271 
272  x = (GLint) VB->Win[i][0];
273  y = (GLint) VB->Win[i][1];
274  z = (GLint) (VB->Win[i][2] + ctx->PointZoffset);
275 
276  if (isize&1) {
277  /* odd size */
278  x0 = x - isize/2;
279  x1 = x + isize/2;
280  y0 = y - isize/2;
281  y1 = y + isize/2;
282  }
283  else {
284  /* even size */
285  x0 = (GLint) (x + 0.5F) - isize/2;
286  x1 = x0 + isize-1;
287  y0 = (GLint) (y + 0.5F) - isize/2;
288  y1 = y0 + isize-1;
289  }
290 
291  PB_SET_INDEX( ctx, PB, VB->Index[i] );
292 
293  for (iy=y0;iy<=y1;iy++) {
294  for (ix=x0;ix<=x1;ix++) {
295  PB_WRITE_PIXEL( PB, ix, iy, z );
296  }
297  }
298  PB_CHECK_FLUSH(ctx,PB)
299  }
300  }
301 }
302 
303 
304 /*
305  * General RGBA points.
306  */
308 {
309  struct vertex_buffer *VB = ctx->VB;
310  struct pixel_buffer *PB = ctx->PB;
311  GLuint i;
312  GLint isize;
313 
314  isize = (GLint) (CLAMP(ctx->Point.Size,MIN_POINT_SIZE,MAX_POINT_SIZE) + 0.5F);
315 
316  for (i=first;i<=last;i++) {
317  if (VB->ClipMask[i]==0) {
318  GLint x, y, z;
319  GLint x0, x1, y0, y1;
320  GLint ix, iy;
321 
322  x = (GLint) VB->Win[i][0];
323  y = (GLint) VB->Win[i][1];
324  z = (GLint) (VB->Win[i][2] + ctx->PointZoffset);
325 
326  if (isize&1) {
327  /* odd size */
328  x0 = x - isize/2;
329  x1 = x + isize/2;
330  y0 = y - isize/2;
331  y1 = y + isize/2;
332  }
333  else {
334  /* even size */
335  x0 = (GLint) (x + 0.5F) - isize/2;
336  x1 = x0 + isize-1;
337  y0 = (GLint) (y + 0.5F) - isize/2;
338  y1 = y0 + isize-1;
339  }
340 
341  PB_SET_COLOR( ctx, PB,
342  VB->Color[i][0],
343  VB->Color[i][1],
344  VB->Color[i][2],
345  VB->Color[i][3] );
346 
347  for (iy=y0;iy<=y1;iy++) {
348  for (ix=x0;ix<=x1;ix++) {
349  PB_WRITE_PIXEL( PB, ix, iy, z );
350  }
351  }
352  PB_CHECK_FLUSH(ctx,PB)
353  }
354  }
355 }
356 
357 
358 
359 
360 /*
361  * Textured RGBA points.
362  */
364 {
365  struct vertex_buffer *VB = ctx->VB;
366  struct pixel_buffer *PB = ctx->PB;
367  GLuint i;
368 
369  for (i=first;i<=last;i++) {
370  if (VB->ClipMask[i]==0) {
371  GLint x, y, z;
372  GLint x0, x1, y0, y1;
373  GLint ix, iy;
374  GLint isize;
375  GLint red, green, blue, alpha;
376  GLfloat s, t, u;
377 
378  x = (GLint) VB->Win[i][0];
379  y = (GLint) VB->Win[i][1];
380  z = (GLint) (VB->Win[i][2] + ctx->PointZoffset);
381 
382  isize = (GLint)
383  (CLAMP(ctx->Point.Size,MIN_POINT_SIZE,MAX_POINT_SIZE) + 0.5F);
384  if (isize<1) {
385  isize = 1;
386  }
387 
388  if (isize&1) {
389  /* odd size */
390  x0 = x - isize/2;
391  x1 = x + isize/2;
392  y0 = y - isize/2;
393  y1 = y + isize/2;
394  }
395  else {
396  /* even size */
397  x0 = (GLint) (x + 0.5F) - isize/2;
398  x1 = x0 + isize-1;
399  y0 = (GLint) (y + 0.5F) - isize/2;
400  y1 = y0 + isize-1;
401  }
402 
403  red = VB->Color[i][0];
404  green = VB->Color[i][1];
405  blue = VB->Color[i][2];
406  alpha = VB->Color[i][3];
407  s = VB->TexCoord[i][0] / VB->TexCoord[i][3];
408  t = VB->TexCoord[i][1] / VB->TexCoord[i][3];
409  u = VB->TexCoord[i][2] / VB->TexCoord[i][3];
410 
411 /* don't think this is needed
412  PB_SET_COLOR( red, green, blue, alpha );
413 */
414 
415  for (iy=y0;iy<=y1;iy++) {
416  for (ix=x0;ix<=x1;ix++) {
417  PB_WRITE_TEX_PIXEL( PB, ix, iy, z, red, green, blue, alpha, s, t, u );
418  }
419  }
420  PB_CHECK_FLUSH(ctx,PB)
421  }
422  }
423 }
424 
425 
426 
427 /*
428  * Antialiased points with or without texture mapping.
429  */
432 {
433  struct vertex_buffer *VB = ctx->VB;
434  struct pixel_buffer *PB = ctx->PB;
435  GLuint i;
436  GLfloat radius, rmin, rmax, rmin2, rmax2, cscale;
437 
438  radius = CLAMP( ctx->Point.Size, MIN_POINT_SIZE, MAX_POINT_SIZE ) * 0.5F;
439  rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */
440  rmax = radius + 0.7071F;
441  rmin2 = rmin*rmin;
442  rmax2 = rmax*rmax;
443  cscale = 256.0F / (rmax2-rmin2);
444 
445  if (ctx->Texture.Enabled) {
446  for (i=first;i<=last;i++) {
447  if (VB->ClipMask[i]==0) {
448  GLint xmin, ymin, xmax, ymax;
449  GLint x, y, z;
450  GLint red, green, blue, alpha;
451  GLfloat s, t, u;
452 
453  xmin = (GLint) (VB->Win[i][0] - radius);
454  xmax = (GLint) (VB->Win[i][0] + radius);
455  ymin = (GLint) (VB->Win[i][1] - radius);
456  ymax = (GLint) (VB->Win[i][1] + radius);
457  z = (GLint) (VB->Win[i][2] + ctx->PointZoffset);
458 
459  red = VB->Color[i][0];
460  green = VB->Color[i][1];
461  blue = VB->Color[i][2];
462  s = VB->TexCoord[i][0] / VB->TexCoord[i][3];
463  t = VB->TexCoord[i][1] / VB->TexCoord[i][3];
464  u = VB->TexCoord[i][2] / VB->TexCoord[i][3];
465 
466  for (y=ymin;y<=ymax;y++) {
467  for (x=xmin;x<=xmax;x++) {
468  GLfloat dx = x/*+0.5F*/ - VB->Win[i][0];
469  GLfloat dy = y/*+0.5F*/ - VB->Win[i][1];
470  GLfloat dist2 = dx*dx + dy*dy;
471  if (dist2<rmax2) {
472  alpha = VB->Color[i][3];
473  if (dist2>=rmin2) {
474  GLint coverage = (GLint) (256.0F-(dist2-rmin2)*cscale);
475  /* coverage is in [0,256] */
476  alpha = (alpha * coverage) >> 8;
477  }
478  PB_WRITE_TEX_PIXEL( PB, x,y,z, red, green, blue, alpha, s, t, u );
479  }
480  }
481  }
482  PB_CHECK_FLUSH(ctx,PB)
483  }
484  }
485  }
486  else {
487  /* Not texture mapped */
488  for (i=first;i<=last;i++) {
489  if (VB->ClipMask[i]==0) {
490  GLint xmin, ymin, xmax, ymax;
491  GLint x, y, z;
492  GLint red, green, blue, alpha;
493 
494  xmin = (GLint) (VB->Win[i][0] - radius);
495  xmax = (GLint) (VB->Win[i][0] + radius);
496  ymin = (GLint) (VB->Win[i][1] - radius);
497  ymax = (GLint) (VB->Win[i][1] + radius);
498  z = (GLint) (VB->Win[i][2] + ctx->PointZoffset);
499 
500  red = VB->Color[i][0];
501  green = VB->Color[i][1];
502  blue = VB->Color[i][2];
503 
504  for (y=ymin;y<=ymax;y++) {
505  for (x=xmin;x<=xmax;x++) {
506  GLfloat dx = x/*+0.5F*/ - VB->Win[i][0];
507  GLfloat dy = y/*+0.5F*/ - VB->Win[i][1];
508  GLfloat dist2 = dx*dx + dy*dy;
509  if (dist2<rmax2) {
510  alpha = VB->Color[i][3];
511  if (dist2>=rmin2) {
512  GLint coverage = (GLint) (256.0F-(dist2-rmin2)*cscale);
513  /* coverage is in [0,256] */
514  alpha = (alpha * coverage) >> 8;
515  }
517  }
518  }
519  }
520  PB_CHECK_FLUSH(ctx,PB)
521  }
522  }
523  }
524 }
525 
526 
527 
528 /*
529  * Null rasterizer for measuring transformation speed.
530  */
532 {
533 }
534 
535 /* Definition of the functions for GL_EXT_point_parameters */
536 
537 /*
538  * Examine the current context to determine which point drawing function
539  * should be used.
540  */
542 {
543  GLboolean rgbmode = ctx->Visual->RGBAflag;
544 
545  if (ctx->RenderMode==GL_RENDER) {
546  if (ctx->NoRaster) {
547  ctx->Driver.PointsFunc = null_points;
548  return;
549  }
550  if (ctx->Driver.PointsFunc) {
551  /* Device driver will draw points. */
552  ctx->Driver.PointsFunc = ctx->Driver.PointsFunc;
553  }
554  else {
555  if (ctx->Point.SmoothFlag && rgbmode) {
556  ctx->Driver.PointsFunc = antialiased_rgba_points;
557  }
558  else if (ctx->Texture.Enabled) {
559  ctx->Driver.PointsFunc = textured_rgba_points;
560  }
561  else if (ctx->Point.Size==1.0) {
562  /* size=1, any raster ops */
563  if (rgbmode)
564  ctx->Driver.PointsFunc = size1_rgba_points;
565  else
566  ctx->Driver.PointsFunc = size1_ci_points;
567  }
568  else {
569  /* every other kind of point rendering */
570  if (rgbmode)
571  ctx->Driver.PointsFunc = general_rgba_points;
572  else
573  ctx->Driver.PointsFunc = general_ci_points;
574  }
575  }
576  }
577  else if (ctx->RenderMode==GL_FEEDBACK) {
578  ctx->Driver.PointsFunc = feedback_points;
579  }
580  else {
581  /* GL_SELECT mode */
582  ctx->Driver.PointsFunc = select_points;
583  }
584 
585 }
586 
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG y1
Definition: winddi.h:3706
#define MIN_POINT_SIZE
Definition: config.h:112
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
GLint x0
Definition: linetemp.h:95
GLuint NewState
Definition: types.h:1355
POINT last
Definition: font.c:46
GLint dy
Definition: linetemp.h:97
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
const GLint * first
Definition: glext.h:5794
GLboolean RGBAflag
Definition: types.h:1137
struct gl_point_attrib Point
Definition: types.h:1329
static void general_ci_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:257
struct pixel_buffer * PB
Definition: types.h:1383
GLdouble GLdouble t
Definition: gl.h:2047
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLvisual * Visual
Definition: types.h:1272
static void textured_rgba_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:363
#define FEEDBACK_TOKEN(CTX, T)
Definition: feedback.h:39
GLfloat PointZoffset
Definition: types.h:1366
#define GL_SMOOTH
Definition: gl.h:339
int iy
Definition: tritemp.h:491
static void feedback_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:127
#define INSIDE_BEGIN_END(CTX)
Definition: macros.h:135
#define PB_WRITE_RGBA_PIXEL(PB, X, Y, Z, R, G, B, A)
Definition: pb.h:126
#define FixedToFloat(X)
Definition: fixed.h:52
struct dd_function_table Driver
Definition: types.h:1276
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
void gl_set_point_function(GLcontext *ctx)
Definition: points.c:541
void size1_ci_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:195
GLuint color
Definition: glext.h:6243
#define CLAMP(f, min, max)
Definition: tif_color.c:177
unsigned char GLboolean
Definition: gl.h:151
void gl_update_hitflag(GLcontext *ctx, GLfloat z)
Definition: feedback.c:240
GLdouble GLdouble z
Definition: glext.h:5874
void gl_PointSize(GLcontext *ctx, GLfloat size)
Definition: points.c:91
_Inout_ PERBANDINFO * pbi
Definition: winddi.h:3917
static void select_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:179
GLclampf GLclampf blue
Definition: gl.h:1740
#define PB_CHECK_FLUSH(CTX, PB)
Definition: pb.h:167
GLenum RenderMode
Definition: types.h:1356
struct gl_texture_attrib Texture
Definition: types.h:1334
GLfloat InvRedScale
Definition: types.h:1148
GLsizeiptr size
Definition: glext.h:5919
GLint GLdepth
Definition: types.h:218
GLboolean NoRaster
Definition: types.h:1404
GLclampf green
Definition: gl.h:1740
#define GL_POINT_TOKEN
Definition: gl.h:397
#define PB
#define PB_SET_COLOR(CTX, PB, R, G, B, A)
Definition: pb.h:89
#define red
Definition: linetest.c:67
#define GL_INVALID_VALUE
Definition: gl.h:695
#define GL_INVALID_OPERATION
Definition: gl.h:696
struct vertex_buffer * VB
Definition: tritemp.h:139
static void null_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:531
GLdouble s
Definition: gl.h:2039
#define NEW_RASTER_OPS
Definition: types.h:1233
#define PB_WRITE_TEX_PIXEL(PB, X, Y, Z, R, G, B, A, S, T, U)
Definition: pb.h:150
#define PB_WRITE_PIXEL(PB, X, Y, Z)
Definition: pb.h:116
#define MAX_POINT_SIZE
Definition: config.h:113
void gl_error(GLcontext *ctx, GLenum error, const char *s)
Definition: context.c:1421
unsigned int GLuint
Definition: gl.h:159
static real win[4][36]
#define PB_SET_INDEX(CTX, PB, I)
Definition: pb.h:105
#define GL_FEEDBACK
Definition: gl.h:387
GLfloat InvBlueScale
Definition: types.h:1150
GLint y0
Definition: linetemp.h:96
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLint dx
Definition: linetemp.h:97
float GLfloat
Definition: gl.h:161
GLfloat InvGreenScale
Definition: types.h:1149
GLclampf GLclampf GLclampf alpha
Definition: gl.h:1740
int GLint
Definition: gl.h:156
#define GL_RENDER
Definition: gl.h:388
struct gl_light_attrib Light
Definition: types.h:1325
struct vertex_buffer * VB
Definition: types.h:1380
GLfloat InvAlphaScale
Definition: types.h:1151
static void general_rgba_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:307
static void size1_rgba_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:226
static void antialiased_rgba_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:430
#define F(x, y, z)
Definition: md5.c:51
void gl_feedback_vertex(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat w, const GLfloat color[4], GLfloat index, const GLfloat texcoord[4])
Definition: feedback.c:161
#define DEPTH_SCALE
Definition: config.h:146