ReactOS 0.4.15-dev-8241-g63935f8
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
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;
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;
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 }
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 }
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
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 }
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;
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 }
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;
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 }
479 }
480 }
481 }
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;
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 }
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
#define MAX_POINT_SIZE
Definition: config.h:113
#define MIN_POINT_SIZE
Definition: config.h:112
#define DEPTH_SCALE
Definition: config.h:146
void gl_error(GLcontext *ctx, GLenum error, const char *s)
Definition: context.c:1421
#define NEW_RASTER_OPS
Definition: types.h:1233
GLint GLdepth
Definition: types.h:218
#define PB
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
void gl_update_hitflag(GLcontext *ctx, GLfloat z)
Definition: feedback.c:240
#define FEEDBACK_TOKEN(CTX, T)
Definition: feedback.h:39
#define FixedToFloat(X)
Definition: fixed.h:52
#define GL_RENDER
Definition: gl.h:388
#define GL_INVALID_VALUE
Definition: gl.h:695
#define GL_POINT_TOKEN
Definition: gl.h:397
float GLfloat
Definition: gl.h:161
GLclampf green
Definition: gl.h:1740
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
#define GL_INVALID_OPERATION
Definition: gl.h:696
GLclampf GLclampf GLclampf alpha
Definition: gl.h:1740
#define GL_SMOOTH
Definition: gl.h:339
GLdouble s
Definition: gl.h:2039
#define GL_FEEDBACK
Definition: gl.h:387
unsigned int GLuint
Definition: gl.h:159
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLclampf GLclampf blue
Definition: gl.h:1740
GLdouble GLdouble t
Definition: gl.h:2047
int GLint
Definition: gl.h:156
unsigned char GLboolean
Definition: gl.h:151
GLsizeiptr size
Definition: glext.h:5919
GLuint color
Definition: glext.h:6243
const GLint * first
Definition: glext.h:5794
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
GLdouble GLdouble z
Definition: glext.h:5874
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
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
static real win[4][36]
GLint dy
Definition: linetemp.h:97
GLint y0
Definition: linetemp.h:96
GLint x0
Definition: linetemp.h:95
GLint dx
Definition: linetemp.h:97
#define red
Definition: linetest.c:67
#define INSIDE_BEGIN_END(CTX)
Definition: macros.h:135
static UINT UINT last
Definition: font.c:45
#define PB_SET_INDEX(CTX, PB, I)
Definition: pb.h:105
#define PB_WRITE_PIXEL(PB, X, Y, Z)
Definition: pb.h:116
#define PB_WRITE_TEX_PIXEL(PB, X, Y, Z, R, G, B, A, S, T, U)
Definition: pb.h:150
#define PB_CHECK_FLUSH(CTX, PB)
Definition: pb.h:167
#define PB_SET_COLOR(CTX, PB, R, G, B, A)
Definition: pb.h:89
#define PB_WRITE_RGBA_PIXEL(PB, X, Y, Z, R, G, B, A)
Definition: pb.h:126
static void general_rgba_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:307
static void select_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:179
static void general_ci_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:257
static void antialiased_rgba_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:430
static void feedback_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:127
void size1_ci_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:195
void gl_set_point_function(GLcontext *ctx)
Definition: points.c:541
static void null_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:531
static void size1_rgba_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:226
static void textured_rgba_points(GLcontext *ctx, GLuint first, GLuint last)
Definition: points.c:363
void gl_PointSize(GLcontext *ctx, GLfloat size)
Definition: points.c:91
#define CLAMP(f, min, max)
Definition: tif_color.c:177
int iy
Definition: tritemp.h:491
struct vertex_buffer * VB
Definition: tritemp.h:139
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG y1
Definition: winddi.h:3709
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3708
_Inout_ PERBANDINFO * pbi
Definition: winddi.h:3917