ReactOS 0.4.15-dev-7897-g78dc504
varray.h File Reference
#include "types.h"
Include dependency graph for varray.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void gl_VertexPointer (GLcontext *ctx, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 
void gl_NormalPointer (GLcontext *ctx, GLenum type, GLsizei stride, const GLvoid *ptr)
 
void gl_ColorPointer (GLcontext *ctx, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 
void gl_IndexPointer (GLcontext *ctx, GLenum type, GLsizei stride, const GLvoid *ptr)
 
void gl_TexCoordPointer (GLcontext *ctx, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 
void gl_EdgeFlagPointer (GLcontext *ctx, GLsizei stride, const GLboolean *ptr)
 
void gl_GetPointerv (GLcontext *ctx, GLenum pname, GLvoid **params)
 
void gl_ArrayElement (GLcontext *ctx, GLint i)
 
void gl_save_ArrayElement (GLcontext *ctx, GLint i)
 
void gl_DrawArrays (GLcontext *ctx, GLenum mode, GLint first, GLsizei count)
 
void gl_save_DrawArrays (GLcontext *ctx, GLenum mode, GLint first, GLsizei count)
 
void gl_DrawElements (GLcontext *ctx, GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 
void gl_save_DrawElements (GLcontext *ctx, GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 
void gl_InterleavedArrays (GLcontext *ctx, GLenum format, GLsizei stride, const GLvoid *pointer)
 
void gl_save_InterleavedArrays (GLcontext *ctx, GLenum format, GLsizei stride, const GLvoid *pointer)
 

Function Documentation

◆ gl_ArrayElement()

void gl_ArrayElement ( GLcontext ctx,
GLint  i 
)

Definition at line 317 of file varray.c.

318{
319 struct vertex_buffer *VB = ctx->VB;
320 GLint count = VB->Count;
321
322 /* copy vertex data into the Vertex Buffer */
323
324 if (ctx->Array.NormalEnabled) {
325 GLbyte *p = (GLbyte*) ctx->Array.NormalPtr
326 + i * ctx->Array.NormalStrideB;
327 switch (ctx->Array.NormalType) {
328 case GL_BYTE:
329 VB->Normal[count][0] = BYTE_TO_FLOAT( p[0] );
330 VB->Normal[count][1] = BYTE_TO_FLOAT( p[1] );
331 VB->Normal[count][2] = BYTE_TO_FLOAT( p[2] );
332 break;
333 case GL_SHORT:
334 VB->Normal[count][0] = SHORT_TO_FLOAT( ((GLshort*)p)[0] );
335 VB->Normal[count][1] = SHORT_TO_FLOAT( ((GLshort*)p)[1] );
336 VB->Normal[count][2] = SHORT_TO_FLOAT( ((GLshort*)p)[2] );
337 break;
338 case GL_INT:
339 VB->Normal[count][0] = INT_TO_FLOAT( ((GLint*)p)[0] );
340 VB->Normal[count][1] = INT_TO_FLOAT( ((GLint*)p)[1] );
341 VB->Normal[count][2] = INT_TO_FLOAT( ((GLint*)p)[2] );
342 break;
343 case GL_FLOAT:
344 VB->Normal[count][0] = ((GLfloat*)p)[0];
345 VB->Normal[count][1] = ((GLfloat*)p)[1];
346 VB->Normal[count][2] = ((GLfloat*)p)[2];
347 break;
348 case GL_DOUBLE:
349 VB->Normal[count][0] = ((GLdouble*)p)[0];
350 VB->Normal[count][1] = ((GLdouble*)p)[1];
351 VB->Normal[count][2] = ((GLdouble*)p)[2];
352 break;
353 default:
354 gl_problem(ctx, "Bad normal type in gl_ArrayElement");
355 return;
356 }
357 VB->MonoNormal = GL_FALSE;
358 }
359 else {
360 VB->Normal[count][0] = ctx->Current.Normal[0];
361 VB->Normal[count][1] = ctx->Current.Normal[1];
362 VB->Normal[count][2] = ctx->Current.Normal[2];
363 }
364
365 /* TODO: directly set VB->Fcolor instead of calling a glColor command */
366 if (ctx->Array.ColorEnabled) {
367 GLbyte *p = (GLbyte*) ctx->Array.ColorPtr + i * ctx->Array.ColorStrideB;
368 switch (ctx->Array.ColorType) {
369 case GL_BYTE:
370 switch (ctx->Array.ColorSize) {
371 case 4: glColor4bv( (GLbyte*) p ); break;
372 case 3: glColor3bv( (GLbyte*) p ); break;
373 }
374 break;
375 case GL_UNSIGNED_BYTE:
376 switch (ctx->Array.ColorSize) {
377 case 3: glColor3ubv( (GLubyte*) p ); break;
378 case 4: glColor4ubv( (GLubyte*) p ); break;
379 }
380 break;
381 case GL_SHORT:
382 switch (ctx->Array.ColorSize) {
383 case 3: glColor3sv( (GLshort*) p ); break;
384 case 4: glColor4sv( (GLshort*) p ); break;
385 }
386 break;
388 switch (ctx->Array.ColorSize) {
389 case 3: glColor3usv( (GLushort*) p ); break;
390 case 4: glColor4usv( (GLushort*) p ); break;
391 }
392 break;
393 case GL_INT:
394 switch (ctx->Array.ColorSize) {
395 case 3: glColor3iv( (GLint*) p ); break;
396 case 4: glColor4iv( (GLint*) p ); break;
397 }
398 break;
399 case GL_UNSIGNED_INT:
400 switch (ctx->Array.ColorSize) {
401 case 3: glColor3uiv( (GLuint*) p ); break;
402 case 4: glColor4uiv( (GLuint*) p ); break;
403 }
404 break;
405 case GL_FLOAT:
406 switch (ctx->Array.ColorSize) {
407 case 3: glColor3fv( (GLfloat*) p ); break;
408 case 4: glColor4fv( (GLfloat*) p ); break;
409 }
410 break;
411 case GL_DOUBLE:
412 switch (ctx->Array.ColorSize) {
413 case 3: glColor3dv( (GLdouble*) p ); break;
414 case 4: glColor4dv( (GLdouble*) p ); break;
415 }
416 break;
417 default:
418 gl_problem(ctx, "Bad color type in gl_ArrayElement");
419 return;
420 }
421 ctx->VB->MonoColor = GL_FALSE;
422 }
423
424 /* current color has been updated. store in vertex buffer now */
425 {
426 COPY_4UBV( VB->Fcolor[count], ctx->Current.ByteColor );
427 if (ctx->Light.ColorMaterialEnabled) {
428 GLfloat color[4];
429 color[0] = ctx->Current.ByteColor[0] * ctx->Visual->InvRedScale;
430 color[1] = ctx->Current.ByteColor[1] * ctx->Visual->InvGreenScale;
431 color[2] = ctx->Current.ByteColor[2] * ctx->Visual->InvBlueScale;
432 color[3] = ctx->Current.ByteColor[3] * ctx->Visual->InvAlphaScale;
433 gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, color );
434 }
435 }
436
437 if (ctx->Array.IndexEnabled) {
438 GLbyte *p = (GLbyte*) ctx->Array.IndexPtr + i * ctx->Array.IndexStrideB;
439 switch (ctx->Array.IndexType) {
440 case GL_SHORT:
441 VB->Findex[count] = (GLuint) (*((GLshort*) p));
442 break;
443 case GL_INT:
444 VB->Findex[count] = (GLuint) (*((GLint*) p));
445 break;
446 case GL_FLOAT:
447 VB->Findex[count] = (GLuint) (*((GLfloat*) p));
448 break;
449 case GL_DOUBLE:
450 VB->Findex[count] = (GLuint) (*((GLdouble*) p));
451 break;
452 default:
453 gl_problem(ctx, "Bad index type in gl_ArrayElement");
454 return;
455 }
456 ctx->VB->MonoColor = GL_FALSE;
457 }
458 else {
459 VB->Findex[count] = ctx->Current.Index;
460 }
461
462 if (ctx->Array.TexCoordEnabled) {
463 GLbyte *p = (GLbyte*) ctx->Array.TexCoordPtr
464 + i * ctx->Array.TexCoordStrideB;
465 VB->TexCoord[count][1] = 0.0F;
466 VB->TexCoord[count][2] = 0.0F;
467 VB->TexCoord[count][3] = 1.0F;
468 switch (ctx->Array.TexCoordType) {
469 case GL_SHORT:
470 switch (ctx->Array.TexCoordSize) {
471 /* FALL THROUGH! */
472 case 4: VB->TexCoord[count][3] = ((GLshort*) p)[3];
473 case 3: VB->TexCoord[count][2] = ((GLshort*) p)[2];
474 case 2: VB->TexCoord[count][1] = ((GLshort*) p)[1];
475 case 1: VB->TexCoord[count][0] = ((GLshort*) p)[0];
476 }
477 break;
478 case GL_INT:
479 switch (ctx->Array.TexCoordSize) {
480 /* FALL THROUGH! */
481 case 4: VB->TexCoord[count][3] = ((GLint*) p)[3];
482 case 3: VB->TexCoord[count][2] = ((GLint*) p)[2];
483 case 2: VB->TexCoord[count][1] = ((GLint*) p)[1];
484 case 1: VB->TexCoord[count][0] = ((GLint*) p)[0];
485 }
486 break;
487 case GL_FLOAT:
488 switch (ctx->Array.TexCoordSize) {
489 /* FALL THROUGH! */
490 case 4: VB->TexCoord[count][3] = ((GLfloat*) p)[3];
491 case 3: VB->TexCoord[count][2] = ((GLfloat*) p)[2];
492 case 2: VB->TexCoord[count][1] = ((GLfloat*) p)[1];
493 case 1: VB->TexCoord[count][0] = ((GLfloat*) p)[0];
494 }
495 break;
496 case GL_DOUBLE:
497 switch (ctx->Array.TexCoordSize) {
498 /* FALL THROUGH! */
499 case 4: VB->TexCoord[count][3] = ((GLdouble*) p)[3];
500 case 3: VB->TexCoord[count][2] = ((GLdouble*) p)[2];
501 case 2: VB->TexCoord[count][1] = ((GLdouble*) p)[1];
502 case 1: VB->TexCoord[count][0] = ((GLdouble*) p)[0];
503 }
504 break;
505 default:
506 gl_problem(ctx, "Bad texcoord type in gl_ArrayElement");
507 return;
508 }
509 }
510 else {
511 COPY_4V( VB->TexCoord[count], ctx->Current.TexCoord );
512 }
513
514 if (ctx->Array.EdgeFlagEnabled) {
515 GLbyte *b = (GLbyte*) ctx->Array.EdgeFlagPtr
516 + i * ctx->Array.EdgeFlagStrideB;
517 VB->Edgeflag[count] = *((GLboolean*) b);
518 }
519 else {
520 VB->Edgeflag[count] = ctx->Current.EdgeFlag;
521 }
522
523 if (ctx->Array.VertexEnabled) {
524 GLbyte *b = (GLbyte*) ctx->Array.VertexPtr
525 + i * ctx->Array.VertexStrideB;
526 VB->Obj[count][2] = 0.0F;
527 VB->Obj[count][3] = 1.0F;
528 switch (ctx->Array.VertexType) {
529 case GL_SHORT:
530 switch (ctx->Array.VertexSize) {
531 /* FALL THROUGH */
532 case 4: VB->Obj[count][3] = ((GLshort*) b)[3];
533 case 3: VB->Obj[count][2] = ((GLshort*) b)[2];
534 case 2: VB->Obj[count][1] = ((GLshort*) b)[1];
535 VB->Obj[count][0] = ((GLshort*) b)[0];
536 }
537 break;
538 case GL_INT:
539 switch (ctx->Array.VertexSize) {
540 /* FALL THROUGH */
541 case 4: VB->Obj[count][3] = ((GLint*) b)[3];
542 case 3: VB->Obj[count][2] = ((GLint*) b)[2];
543 case 2: VB->Obj[count][1] = ((GLint*) b)[1];
544 VB->Obj[count][0] = ((GLint*) b)[0];
545 }
546 break;
547 case GL_FLOAT:
548 switch (ctx->Array.VertexSize) {
549 /* FALL THROUGH */
550 case 4: VB->Obj[count][3] = ((GLfloat*) b)[3];
551 case 3: VB->Obj[count][2] = ((GLfloat*) b)[2];
552 case 2: VB->Obj[count][1] = ((GLfloat*) b)[1];
553 VB->Obj[count][0] = ((GLfloat*) b)[0];
554 }
555 break;
556 case GL_DOUBLE:
557 switch (ctx->Array.VertexSize) {
558 /* FALL THROUGH */
559 case 4: VB->Obj[count][3] = ((GLdouble*) b)[3];
560 case 3: VB->Obj[count][2] = ((GLdouble*) b)[2];
561 case 2: VB->Obj[count][1] = ((GLdouble*) b)[1];
562 VB->Obj[count][0] = ((GLdouble*) b)[0];
563 }
564 break;
565 default:
566 gl_problem(ctx, "Bad vertex type in gl_ArrayElement");
567 return;
568 }
569
570 /* Only store vertex if Vertex array pointer is enabled */
571 count++;
572 VB->Count = count;
573 if (count==VB_MAX) {
575 }
576
577 }
578 else {
579 /* vertex array pointer not enabled: no vertex to process */
580 }
581}
void gl_problem(const GLcontext *ctx, const char *s)
Definition: context.c:1394
switch(r->id)
Definition: btrfs.c:3046
unsigned char GLubyte
Definition: gl.h:157
GLAPI void GLAPIENTRY glColor4usv(const GLushort *v)
signed char GLbyte
Definition: gl.h:154
#define GL_INT
Definition: gl.h:181
#define GL_DOUBLE
Definition: gl.h:187
GLAPI void GLAPIENTRY glColor4iv(const GLint *v)
short GLshort
Definition: gl.h:155
float GLfloat
Definition: gl.h:161
#define GL_UNSIGNED_SHORT
Definition: gl.h:180
GLAPI void GLAPIENTRY glColor3fv(const GLfloat *v)
double GLdouble
Definition: gl.h:163
GLAPI void GLAPIENTRY glColor3sv(const GLshort *v)
#define GL_BYTE
Definition: gl.h:177
unsigned int GLuint
Definition: gl.h:159
#define GL_UNSIGNED_INT
Definition: gl.h:182
#define GL_FLOAT
Definition: gl.h:183
GLAPI void GLAPIENTRY glColor4dv(const GLdouble *v)
GLAPI void GLAPIENTRY glColor4sv(const GLshort *v)
#define GL_SHORT
Definition: gl.h:179
GLAPI void GLAPIENTRY glColor3ubv(const GLubyte *v)
GLAPI void GLAPIENTRY glColor3dv(const GLdouble *v)
#define GL_UNSIGNED_BYTE
Definition: gl.h:178
GLAPI void GLAPIENTRY glColor3usv(const GLushort *v)
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLAPI void GLAPIENTRY glColor4ubv(const GLubyte *v)
GLAPI void GLAPIENTRY glColor3uiv(const GLuint *v)
GLAPI void GLAPIENTRY glColor3bv(const GLbyte *v)
#define GL_FALSE
Definition: gl.h:173
unsigned short GLushort
Definition: gl.h:158
GLAPI void GLAPIENTRY glColor4bv(const GLbyte *v)
GLAPI void GLAPIENTRY glColor4uiv(const GLuint *v)
int GLint
Definition: gl.h:156
GLAPI void GLAPIENTRY glColor4fv(const GLfloat *v)
unsigned char GLboolean
Definition: gl.h:151
GLAPI void GLAPIENTRY glColor3iv(const GLint *v)
GLuint color
Definition: glext.h:6243
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLfloat GLfloat p
Definition: glext.h:8902
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
#define b
Definition: ke_i.h:79
#define INT_TO_FLOAT(I)
Definition: macros.h:215
#define BYTE_TO_FLOAT(B)
Definition: macros.h:187
#define SHORT_TO_FLOAT(S)
Definition: macros.h:201
#define COPY_4UBV(DST, SRC)
Definition: macros.h:110
#define COPY_4V(DST, SRC)
Definition: macros.h:102
void gl_set_material(GLcontext *ctx, GLuint bitmask, const GLfloat *params)
Definition: light.c:413
struct vertex_buffer * VB
Definition: tritemp.h:139
#define VB_MAX
Definition: vb.h:86
void gl_transform_vb_part1(GLcontext *ctx, GLboolean allDone)
Definition: vbxform.c:1120

Referenced by gl_DrawArrays(), gl_DrawElements(), and init_exec_pointers().

◆ gl_ColorPointer()

void gl_ColorPointer ( GLcontext ctx,
GLint  size,
GLenum  type,
GLsizei  stride,
const GLvoid ptr 
)

Definition at line 183 of file varray.c.

186{
187 if (size<3 || size>4) {
188 gl_error( ctx, GL_INVALID_VALUE, "glColorPointer(size)" );
189 return;
190 }
191 if (stride<0) {
192 gl_error( ctx, GL_INVALID_VALUE, "glColorPointer(stride)" );
193 return;
194 }
195 switch (type) {
196 case GL_BYTE:
197 ctx->Array.ColorStrideB = stride ? stride : size*sizeof(GLbyte);
198 break;
199 case GL_UNSIGNED_BYTE:
200 ctx->Array.ColorStrideB = stride ? stride : size*sizeof(GLubyte);
201 break;
202 case GL_SHORT:
203 ctx->Array.ColorStrideB = stride ? stride : size*sizeof(GLshort);
204 break;
206 ctx->Array.ColorStrideB = stride ? stride : size*sizeof(GLushort);
207 break;
208 case GL_INT:
209 ctx->Array.ColorStrideB = stride ? stride : size*sizeof(GLint);
210 break;
211 case GL_UNSIGNED_INT:
212 ctx->Array.ColorStrideB = stride ? stride : size*sizeof(GLuint);
213 break;
214 case GL_FLOAT:
215 ctx->Array.ColorStrideB = stride ? stride : size*sizeof(GLfloat);
216 break;
217 case GL_DOUBLE:
218 ctx->Array.ColorStrideB = stride ? stride : size*sizeof(GLdouble);
219 break;
220 default:
221 gl_error( ctx, GL_INVALID_ENUM, "glColorPointer(type)" );
222 return;
223 }
224 ctx->Array.ColorSize = size;
225 ctx->Array.ColorType = type;
226 ctx->Array.ColorStride = stride;
227 ctx->Array.ColorPtr = (void *) ptr;
228}
void gl_error(GLcontext *ctx, GLenum error, const char *s)
Definition: context.c:1421
#define GL_INVALID_VALUE
Definition: gl.h:695
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define GL_INVALID_ENUM
Definition: gl.h:694
GLsizeiptr size
Definition: glext.h:5919
GLsizei stride
Definition: glext.h:5848
static PVOID ptr
Definition: dispmode.c:27

Referenced by gl_InterleavedArrays(), init_dlist_pointers(), and init_exec_pointers().

◆ gl_DrawArrays()

void gl_DrawArrays ( GLcontext ctx,
GLenum  mode,
GLint  first,
GLsizei  count 
)

Definition at line 788 of file varray.c.

790{
791 struct vertex_buffer* VB = ctx->VB;
792
793 GLint i;
794 GLboolean need_edges;
795
796 if (INSIDE_BEGIN_END(ctx)) {
797 gl_error( ctx, GL_INVALID_OPERATION, "glDrawArrays" );
798 return;
799 }
800 if (count<0) {
801 gl_error( ctx, GL_INVALID_VALUE, "glDrawArrays(count)" );
802 return;
803 }
804
805 if (ctx->Primitive==GL_TRIANGLES || ctx->Primitive==GL_QUADS
806 || ctx->Primitive==GL_POLYGON) {
807 need_edges = GL_TRUE;
808 }
809 else {
810 need_edges = GL_FALSE;
811 }
812
813 if (!ctx->Light.Enabled
814 && !ctx->Texture.Enabled
815 && ctx->Array.VertexEnabled && ctx->Array.VertexType==GL_FLOAT
816 && ctx->Array.VertexStride==0 && ctx->Array.VertexSize==3
817 && !ctx->Array.NormalEnabled
818 && !ctx->Array.ColorEnabled
819 && !ctx->Array.IndexEnabled
820 && !ctx->Array.TexCoordEnabled
821 && !ctx->Array.EdgeFlagEnabled) {
822 /*
823 * SPECIAL CASE: glVertex3fv() with no lighting
824 */
825 GLfloat (*vptr)[3];
826 GLint remaining;
827
828 gl_Begin( ctx, mode );
829
830 remaining = count;
831 vptr = (GLfloat (*)[3]) ctx->Array.VertexPtr;
832 vptr += 3 * first;
833 while (remaining>0) {
834 GLint vbspace, n;
835
836 vbspace = VB_MAX - VB->Start;
837 n = MIN2( vbspace, remaining );
838
839 gl_xform_points_3fv( n, VB->Eye+VB->Start, ctx->ModelViewMatrix, vptr );
840
841 /* assign vertex colors */
842 {
843 GLint i, start = VB->Start;
844 for (i=0;i<n;i++) {
845 COPY_4UBV( VB->Fcolor[start+i], ctx->Current.ByteColor );
846 }
847 }
848
849 /* assign polygon edgeflags */
850 if (need_edges) {
851 GLint i;
852 for (i=0;i<n;i++) {
853 VB->Edgeflag[VB->Start+i] = ctx->Current.EdgeFlag;
854 }
855 }
856
857 remaining -= n;
858
859 VB->MonoNormal = GL_FALSE;
860 VB->Count = VB->Start + n;
861 gl_transform_vb_part2( ctx, remaining==0 ? GL_TRUE : GL_FALSE );
862
863 vptr += n;
864 }
865
866 gl_End( ctx );
867 }
868 else if (!ctx->CompileFlag
869 && ctx->Light.Enabled
870 && !ctx->Texture.Enabled
871 && ctx->Array.VertexEnabled && ctx->Array.VertexType==GL_FLOAT
872 && ctx->Array.VertexStride==0 && ctx->Array.VertexSize==4
873 && ctx->Array.NormalEnabled && ctx->Array.NormalType==GL_FLOAT
874 && ctx->Array.NormalStride==0
875 && !ctx->Array.ColorEnabled
876 && !ctx->Array.IndexEnabled
877 && !ctx->Array.TexCoordEnabled
878 && !ctx->Array.EdgeFlagEnabled) {
879 /*
880 * SPECIAL CASE: glNormal3fv(); glVertex4fv(); with lighting
881 */
882 GLfloat (*vptr)[4], (*nptr)[3];
883 GLint remaining;
884
885 gl_Begin( ctx, mode );
886
887 remaining = count;
888 vptr = (GLfloat (*)[4]) ctx->Array.VertexPtr;
889 vptr += 4 * first;
890 nptr = (GLfloat (*)[3]) ctx->Array.NormalPtr;
891 nptr += 3 * first;
892 while (remaining>0) {
893 GLint vbspace, n;
894
895 vbspace = VB_MAX - VB->Start;
896 n = MIN2( vbspace, remaining );
897
898 gl_xform_points_4fv( n, VB->Eye+VB->Start, ctx->ModelViewMatrix, vptr );
899 gl_xform_normals_3fv( n, VB->Normal+VB->Start, ctx->ModelViewInv, nptr,
900 ctx->Transform.Normalize );
901
902 /* assign polygon edgeflags */
903 if (need_edges) {
904 GLint i;
905 for (i=0;i<n;i++) {
906 VB->Edgeflag[VB->Start+i] = ctx->Current.EdgeFlag;
907 }
908 }
909
910 remaining -= n;
911
912 VB->MonoNormal = GL_FALSE;
913 VB->Count = VB->Start + n;
914 gl_transform_vb_part2( ctx, remaining==0 ? GL_TRUE : GL_FALSE );
915
916 vptr += n;
917 nptr += n;
918 }
919
920 gl_End( ctx );
921 }
922 else if (!ctx->CompileFlag
923 && ctx->Light.Enabled
924 && !ctx->Texture.Enabled
925 && ctx->Array.VertexEnabled && ctx->Array.VertexType==GL_FLOAT
926 && ctx->Array.VertexStride==0 && ctx->Array.VertexSize==3
927 && ctx->Array.NormalEnabled && ctx->Array.NormalType==GL_FLOAT
928 && ctx->Array.NormalStride==0
929 && !ctx->Array.ColorEnabled
930 && !ctx->Array.IndexEnabled
931 && !ctx->Array.TexCoordEnabled
932 && !ctx->Array.EdgeFlagEnabled) {
933 /*
934 * SPECIAL CASE: glNormal3fv(); glVertex3fv(); with lighting
935 */
936 GLfloat (*vptr)[3], (*nptr)[3];
937 GLint remaining;
938
939 gl_Begin( ctx, mode );
940
941 remaining = count;
942 vptr = (GLfloat (*)[3]) ctx->Array.VertexPtr;
943 vptr += 3 * first;
944 nptr = (GLfloat (*)[3]) ctx->Array.NormalPtr;
945 nptr += 3 * first;
946 while (remaining>0) {
947 GLint vbspace, n;
948
949 vbspace = VB_MAX - VB->Start;
950 n = MIN2( vbspace, remaining );
951
952 gl_xform_points_3fv( n, VB->Eye+VB->Start, ctx->ModelViewMatrix, vptr );
953 gl_xform_normals_3fv( n, VB->Normal+VB->Start, ctx->ModelViewInv, nptr,
954 ctx->Transform.Normalize );
955
956 /* assign polygon edgeflags */
957 if (need_edges) {
958 GLint i;
959 for (i=0;i<n;i++) {
960 VB->Edgeflag[VB->Start+i] = ctx->Current.EdgeFlag;
961 }
962 }
963
964 remaining -= n;
965
966 VB->MonoNormal = GL_FALSE;
967 VB->Count = VB->Start + n;
968 gl_transform_vb_part2( ctx, remaining==0 ? GL_TRUE : GL_FALSE );
969
970 vptr += n;
971 nptr += n;
972 }
973
974 gl_End( ctx );
975 }
976 else {
977 /*
978 * GENERAL CASE:
979 */
980 gl_Begin( ctx, mode );
981 for (i=0;i<count;i++) {
983 }
984 gl_End( ctx );
985 }
986}
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
#define GL_TRUE
Definition: gl.h:174
GLuint start
Definition: gl.h:1545
#define GL_QUADS
Definition: gl.h:197
#define GL_INVALID_OPERATION
Definition: gl.h:696
#define GL_TRIANGLES
Definition: gl.h:194
#define GL_POLYGON
Definition: gl.h:199
GLdouble n
Definition: glext.h:7729
GLenum mode
Definition: glext.h:6217
const GLint * first
Definition: glext.h:5794
#define INSIDE_BEGIN_END(CTX)
Definition: macros.h:135
#define MIN2(A, B)
Definition: macros.h:159
void gl_ArrayElement(GLcontext *ctx, GLint i)
Definition: varray.c:317
void gl_End(GLcontext *ctx)
Definition: vbfill.c:1424
void gl_Begin(GLcontext *ctx, GLenum p)
Definition: vbfill.c:1341
void gl_transform_vb_part2(GLcontext *ctx, GLboolean allDone)
Definition: vbxform.c:1165
void gl_xform_points_4fv(GLuint n, GLfloat q[][4], const GLfloat m[16], GLfloat p[][4])
Definition: xform.c:88
void gl_xform_points_3fv(GLuint n, GLfloat q[][4], const GLfloat m[16], GLfloat p[][3])
Definition: xform.c:145
void gl_xform_normals_3fv(GLuint n, GLfloat v[][3], const GLfloat m[16], GLfloat u[][3], GLboolean normalize)
Definition: xform.c:195

Referenced by init_exec_pointers().

◆ gl_DrawElements()

void gl_DrawElements ( GLcontext ctx,
GLenum  mode,
GLsizei  count,
GLenum  type,
const GLvoid indices 
)

Definition at line 1039 of file varray.c.

1042{
1043
1044 if (INSIDE_BEGIN_END(ctx)) {
1045 gl_error( ctx, GL_INVALID_OPERATION, "glDrawElements" );
1046 return;
1047 }
1048 if (count<0) {
1049 gl_error( ctx, GL_INVALID_VALUE, "glDrawElements(count)" );
1050 return;
1051 }
1052 switch (mode) {
1053 case GL_POINTS:
1054 case GL_LINES:
1055 case GL_LINE_STRIP:
1056 case GL_LINE_LOOP:
1057 case GL_TRIANGLES:
1058 case GL_TRIANGLE_STRIP:
1059 case GL_TRIANGLE_FAN:
1060 case GL_QUADS:
1061 case GL_QUAD_STRIP:
1062 case GL_POLYGON:
1063 /* OK */
1064 break;
1065 default:
1066 gl_error( ctx, GL_INVALID_ENUM, "glDrawArrays(mode)" );
1067 return;
1068 }
1069 switch (type) {
1070 case GL_UNSIGNED_BYTE:
1071 {
1072 GLubyte *ub_indices = (GLubyte *) indices;
1073 GLint i;
1074 gl_Begin( ctx, mode );
1075 for (i=0;i<count;i++) {
1076 gl_ArrayElement( ctx, (GLint) ub_indices[i] );
1077 }
1078 gl_End( ctx );
1079 }
1080 break;
1081 case GL_UNSIGNED_SHORT:
1082 {
1083 GLushort *us_indices = (GLushort *) indices;
1084 GLint i;
1085 gl_Begin( ctx, mode );
1086 for (i=0;i<count;i++) {
1087 gl_ArrayElement( ctx, (GLint) us_indices[i] );
1088 }
1089 gl_End( ctx );
1090 }
1091 break;
1092 case GL_UNSIGNED_INT:
1093 {
1094 GLuint *ui_indices = (GLuint *) indices;
1095 GLint i;
1096 gl_Begin( ctx, mode );
1097 for (i=0;i<count;i++) {
1098 gl_ArrayElement( ctx, (GLint) ui_indices[i] );
1099 }
1100 gl_End( ctx );
1101 }
1102 break;
1103 default:
1104 gl_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
1105 return;
1106 }
1107}
#define GL_TRIANGLE_FAN
Definition: gl.h:196
#define GL_LINE_STRIP
Definition: gl.h:193
#define GL_LINES
Definition: gl.h:191
#define GL_POINTS
Definition: gl.h:190
#define GL_LINE_LOOP
Definition: gl.h:192
#define GL_TRIANGLE_STRIP
Definition: gl.h:195
GLuint GLuint GLsizei GLenum const GLvoid * indices
Definition: gl.h:1545
#define GL_QUAD_STRIP
Definition: gl.h:198

Referenced by init_exec_pointers().

◆ gl_EdgeFlagPointer()

void gl_EdgeFlagPointer ( GLcontext ctx,
GLsizei  stride,
const GLboolean ptr 
)

Definition at line 300 of file varray.c.

302{
303 if (stride<0) {
304 gl_error( ctx, GL_INVALID_VALUE, "glEdgeFlagPointer(stride)" );
305 return;
306 }
307 ctx->Array.EdgeFlagStride = stride;
308 ctx->Array.EdgeFlagStrideB = stride ? stride : sizeof(GLboolean);
309 ctx->Array.EdgeFlagPtr = (GLboolean *) ptr;
310}

Referenced by init_dlist_pointers(), and init_exec_pointers().

◆ gl_GetPointerv()

void gl_GetPointerv ( GLcontext ctx,
GLenum  pname,
GLvoid **  params 
)

Definition at line 3170 of file get.c.

3171{
3172 switch (pname) {
3174 *params = ctx->Array.VertexPtr;
3175 break;
3177 *params = ctx->Array.NormalPtr;
3178 break;
3180 *params = ctx->Array.ColorPtr;
3181 break;
3183 *params = ctx->Array.IndexPtr;
3184 break;
3186 *params = ctx->Array.TexCoordPtr;
3187 break;
3189 *params = ctx->Array.EdgeFlagPtr;
3190 break;
3192 *params = ctx->Feedback.Buffer;
3193 break;
3194 default:
3195 gl_error( ctx, GL_INVALID_ENUM, "glGetPointerv" );
3196 return;
3197 }
3198}
#define GL_FEEDBACK_BUFFER_POINTER
Definition: gl.h:405
#define GL_TEXTURE_COORD_ARRAY_POINTER
Definition: gl.h:226
#define GL_EDGE_FLAG_ARRAY_POINTER
Definition: gl.h:227
#define GL_NORMAL_ARRAY_POINTER
Definition: gl.h:223
#define GL_INDEX_ARRAY_POINTER
Definition: gl.h:225
#define GL_VERTEX_ARRAY_POINTER
Definition: gl.h:222
#define GL_COLOR_ARRAY_POINTER
Definition: gl.h:224
GLenum pname
Definition: glext.h:5645
GLenum const GLfloat * params
Definition: glext.h:5645

Referenced by init_dlist_pointers(), and init_exec_pointers().

◆ gl_IndexPointer()

void gl_IndexPointer ( GLcontext ctx,
GLenum  type,
GLsizei  stride,
const GLvoid ptr 
)

Definition at line 232 of file varray.c.

234{
235 if (stride<0) {
236 gl_error( ctx, GL_INVALID_VALUE, "glIndexPointer(stride)" );
237 return;
238 }
239 switch (type) {
240 case GL_SHORT:
241 ctx->Array.IndexStrideB = stride ? stride : sizeof(GLbyte);
242 break;
243 case GL_INT:
244 ctx->Array.IndexStrideB = stride ? stride : sizeof(GLint);
245 break;
246 case GL_FLOAT:
247 ctx->Array.IndexStrideB = stride ? stride : sizeof(GLfloat);
248 break;
249 case GL_DOUBLE:
250 ctx->Array.IndexStrideB = stride ? stride : sizeof(GLdouble);
251 break;
252 default:
253 gl_error( ctx, GL_INVALID_ENUM, "glIndexPointer(type)" );
254 return;
255 }
256 ctx->Array.IndexType = type;
257 ctx->Array.IndexStride = stride;
258 ctx->Array.IndexPtr = (void *) ptr;
259}

Referenced by init_dlist_pointers(), and init_exec_pointers().

◆ gl_InterleavedArrays()

void gl_InterleavedArrays ( GLcontext ctx,
GLenum  format,
GLsizei  stride,
const GLvoid pointer 
)

Definition at line 1162 of file varray.c.

1165{
1166 GLboolean tflag, cflag, nflag; /* enable/disable flags */
1167 GLint tcomps, ccomps, vcomps; /* components per texcoord, color, vertex */
1168 GLenum ctype; /* color type */
1169 GLint coffset, noffset, voffset;/* color, normal, vertex offsets */
1170 GLint defstride; /* default stride */
1171 GLint c, f;
1172
1173 f = sizeof(GLfloat);
1174 c = f * ((4*sizeof(GLubyte) + (f-1)) / f);
1175
1176 if (stride<0) {
1177 gl_error( ctx, GL_INVALID_VALUE, "glInterleavedArrays(stride)" );
1178 return;
1179 }
1180
1181 switch (format) {
1182 case GL_V2F:
1183 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_FALSE;
1184 tcomps = 0; ccomps = 0; vcomps = 2;
1185 voffset = 0;
1186 defstride = 2*f;
1187 break;
1188 case GL_V3F:
1189 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_FALSE;
1190 tcomps = 0; ccomps = 0; vcomps = 3;
1191 voffset = 0;
1192 defstride = 3*f;
1193 break;
1194 case GL_C4UB_V2F:
1195 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE;
1196 tcomps = 0; ccomps = 4; vcomps = 2;
1198 coffset = 0;
1199 voffset = c;
1200 defstride = c + 2*f;
1201 break;
1202 case GL_C4UB_V3F:
1203 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE;
1204 tcomps = 0; ccomps = 4; vcomps = 3;
1206 coffset = 0;
1207 voffset = c;
1208 defstride = c + 3*f;
1209 break;
1210 case GL_C3F_V3F:
1211 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE;
1212 tcomps = 0; ccomps = 3; vcomps = 3;
1213 ctype = GL_FLOAT;
1214 coffset = 0;
1215 voffset = 3*f;
1216 defstride = 6*f;
1217 break;
1218 case GL_N3F_V3F:
1219 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_TRUE;
1220 tcomps = 0; ccomps = 0; vcomps = 3;
1221 noffset = 0;
1222 voffset = 3*f;
1223 defstride = 6*f;
1224 break;
1225 case GL_C4F_N3F_V3F:
1226 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_TRUE;
1227 tcomps = 0; ccomps = 4; vcomps = 3;
1228 ctype = GL_FLOAT;
1229 coffset = 0;
1230 noffset = 4*f;
1231 voffset = 7*f;
1232 defstride = 10*f;
1233 break;
1234 case GL_T2F_V3F:
1235 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_FALSE;
1236 tcomps = 2; ccomps = 0; vcomps = 3;
1237 voffset = 2*f;
1238 defstride = 5*f;
1239 break;
1240 case GL_T4F_V4F:
1241 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_FALSE;
1242 tcomps = 4; ccomps = 0; vcomps = 4;
1243 voffset = 4*f;
1244 defstride = 8*f;
1245 break;
1246 case GL_T2F_C4UB_V3F:
1247 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_FALSE;
1248 tcomps = 2; ccomps = 4; vcomps = 3;
1250 coffset = 2*f;
1251 voffset = c+2*f;
1252 defstride = c+5*f;
1253 break;
1254 case GL_T2F_C3F_V3F:
1255 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_FALSE;
1256 tcomps = 2; ccomps = 3; vcomps = 3;
1257 ctype = GL_FLOAT;
1258 coffset = 2*f;
1259 voffset = 5*f;
1260 defstride = 8*f;
1261 break;
1262 case GL_T2F_N3F_V3F:
1263 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_TRUE;
1264 tcomps = 2; ccomps = 0; vcomps = 3;
1265 noffset = 2*f;
1266 voffset = 5*f;
1267 defstride = 8*f;
1268 break;
1269 case GL_T2F_C4F_N3F_V3F:
1270 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_TRUE;
1271 tcomps = 2; ccomps = 4; vcomps = 3;
1272 ctype = GL_FLOAT;
1273 coffset = 2*f;
1274 noffset = 6*f;
1275 voffset = 9*f;
1276 defstride = 12*f;
1277 break;
1278 case GL_T4F_C4F_N3F_V4F:
1279 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_TRUE;
1280 tcomps = 4; ccomps = 4; vcomps = 4;
1281 ctype = GL_FLOAT;
1282 coffset = 4*f;
1283 noffset = 8*f;
1284 voffset = 11*f;
1285 defstride = 15*f;
1286 break;
1287 default:
1288 gl_error( ctx, GL_INVALID_ENUM, "glInterleavedArrays(format)" );
1289 return;
1290 }
1291
1292 if (stride==0) {
1293 stride = defstride;
1294 }
1295
1298
1299 if (tflag) {
1302 }
1303 else {
1305 }
1306
1307 if (cflag) {
1309 gl_ColorPointer( ctx, ccomps, ctype, stride,
1310 (GLubyte*) pointer + coffset );
1311 }
1312 else {
1314 }
1315
1316 if (nflag) {
1319 (GLubyte*) pointer + noffset );
1320 }
1321 else {
1323 }
1324
1327 (GLubyte *) pointer + voffset );
1328}
Definition: _ctype.h:58
void gl_DisableClientState(GLcontext *ctx, GLenum cap)
Definition: enable.c:648
void gl_EnableClientState(GLcontext *ctx, GLenum cap)
Definition: enable.c:641
#define GL_TEXTURE_COORD_ARRAY
Definition: gl.h:206
#define GL_V2F
Definition: gl.h:228
#define GL_V3F
Definition: gl.h:229
#define GL_COLOR_ARRAY
Definition: gl.h:204
#define GL_NORMAL_ARRAY
Definition: gl.h:203
#define GL_T2F_N3F_V3F
Definition: gl.h:239
#define GL_T2F_C4F_N3F_V3F
Definition: gl.h:240
#define GL_INDEX_ARRAY
Definition: gl.h:205
#define GL_C3F_V3F
Definition: gl.h:232
#define GL_N3F_V3F
Definition: gl.h:233
unsigned int GLenum
Definition: gl.h:150
#define GL_C4F_N3F_V3F
Definition: gl.h:234
#define GL_T4F_V4F
Definition: gl.h:236
#define GL_VERTEX_ARRAY
Definition: gl.h:202
#define GL_T4F_C4F_N3F_V4F
Definition: gl.h:241
#define GL_T2F_C3F_V3F
Definition: gl.h:238
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
#define GL_T2F_V3F
Definition: gl.h:235
#define GL_EDGE_FLAG_ARRAY
Definition: gl.h:207
#define GL_C4UB_V3F
Definition: gl.h:231
#define GL_C4UB_V2F
Definition: gl.h:230
#define GL_T2F_C4UB_V3F
Definition: gl.h:237
const GLubyte * c
Definition: glext.h:8905
GLsizei const GLvoid * pointer
Definition: glext.h:5848
GLfloat f
Definition: glext.h:7540
#define f
Definition: ke_i.h:83
#define c
Definition: ke_i.h:80
void gl_TexCoordPointer(GLcontext *ctx, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
Definition: varray.c:263
void gl_NormalPointer(GLcontext *ctx, GLenum type, GLsizei stride, const GLvoid *ptr)
Definition: varray.c:149
void gl_VertexPointer(GLcontext *ctx, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
Definition: varray.c:111
void gl_ColorPointer(GLcontext *ctx, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
Definition: varray.c:183

Referenced by gl_save_InterleavedArrays(), and init_exec_pointers().

◆ gl_NormalPointer()

void gl_NormalPointer ( GLcontext ctx,
GLenum  type,
GLsizei  stride,
const GLvoid ptr 
)

Definition at line 149 of file varray.c.

151{
152 if (stride<0) {
153 gl_error( ctx, GL_INVALID_VALUE, "glNormalPointer(stride)" );
154 return;
155 }
156 switch (type) {
157 case GL_BYTE:
158 ctx->Array.NormalStrideB = stride ? stride : 3*sizeof(GLbyte);
159 break;
160 case GL_SHORT:
161 ctx->Array.NormalStrideB = stride ? stride : 3*sizeof(GLshort);
162 break;
163 case GL_INT:
164 ctx->Array.NormalStrideB = stride ? stride : 3*sizeof(GLint);
165 break;
166 case GL_FLOAT:
167 ctx->Array.NormalStrideB = stride ? stride : 3*sizeof(GLfloat);
168 break;
169 case GL_DOUBLE:
170 ctx->Array.NormalStrideB = stride ? stride : 3*sizeof(GLdouble);
171 break;
172 default:
173 gl_error( ctx, GL_INVALID_ENUM, "glNormalPointer(type)" );
174 return;
175 }
176 ctx->Array.NormalType = type;
177 ctx->Array.NormalStride = stride;
178 ctx->Array.NormalPtr = (void *) ptr;
179}

Referenced by gl_InterleavedArrays(), init_dlist_pointers(), and init_exec_pointers().

◆ gl_save_ArrayElement()

void gl_save_ArrayElement ( GLcontext ctx,
GLint  i 
)

Definition at line 592 of file varray.c.

593{
594 if (ctx->Array.NormalEnabled) {
595 GLbyte *p = (GLbyte*) ctx->Array.NormalPtr
596 + i * ctx->Array.NormalStrideB;
597 switch (ctx->Array.NormalType) {
598 case GL_BYTE:
599 glNormal3bv( (GLbyte*) p );
600 break;
601 case GL_SHORT:
602 glNormal3sv( (GLshort*) p );
603 break;
604 case GL_INT:
605 glNormal3iv( (GLint*) p );
606 break;
607 case GL_FLOAT:
608 glNormal3fv( (GLfloat*) p );
609 break;
610 case GL_DOUBLE:
611 glNormal3dv( (GLdouble*) p );
612 break;
613 default:
614 gl_problem(ctx, "Bad normal type in gl_save_ArrayElement");
615 return;
616 }
617 }
618
619 if (ctx->Array.ColorEnabled) {
620 GLbyte *p = (GLbyte*) ctx->Array.ColorPtr + i * ctx->Array.ColorStrideB;
621 switch (ctx->Array.ColorType) {
622 case GL_BYTE:
623 switch (ctx->Array.ColorSize) {
624 case 3: glColor3bv( (GLbyte*) p ); break;
625 case 4: glColor4bv( (GLbyte*) p ); break;
626 }
627 break;
628 case GL_UNSIGNED_BYTE:
629 switch (ctx->Array.ColorSize) {
630 case 3: glColor3ubv( (GLubyte*) p ); break;
631 case 4: glColor4ubv( (GLubyte*) p ); break;
632 }
633 break;
634 case GL_SHORT:
635 switch (ctx->Array.ColorSize) {
636 case 3: glColor3sv( (GLshort*) p ); break;
637 case 4: glColor4sv( (GLshort*) p ); break;
638 }
639 break;
641 switch (ctx->Array.ColorSize) {
642 case 3: glColor3usv( (GLushort*) p ); break;
643 case 4: glColor4usv( (GLushort*) p ); break;
644 }
645 break;
646 case GL_INT:
647 switch (ctx->Array.ColorSize) {
648 case 3: glColor3iv( (GLint*) p ); break;
649 case 4: glColor4iv( (GLint*) p ); break;
650 }
651 break;
652 case GL_UNSIGNED_INT:
653 switch (ctx->Array.ColorSize) {
654 case 3: glColor3uiv( (GLuint*) p ); break;
655 case 4: glColor4uiv( (GLuint*) p ); break;
656 }
657 break;
658 case GL_FLOAT:
659 switch (ctx->Array.ColorSize) {
660 case 3: glColor3fv( (GLfloat*) p ); break;
661 case 4: glColor4fv( (GLfloat*) p ); break;
662 }
663 break;
664 case GL_DOUBLE:
665 switch (ctx->Array.ColorSize) {
666 case 3: glColor3dv( (GLdouble*) p ); break;
667 case 4: glColor4dv( (GLdouble*) p ); break;
668 }
669 break;
670 default:
671 gl_problem(ctx, "Bad color type in gl_save_ArrayElement");
672 return;
673 }
674 }
675
676 if (ctx->Array.IndexEnabled) {
677 GLbyte *p = (GLbyte*) ctx->Array.IndexPtr + i * ctx->Array.IndexStrideB;
678 switch (ctx->Array.IndexType) {
679 case GL_SHORT:
680 glIndexsv( (GLshort*) p );
681 break;
682 case GL_INT:
683 glIndexiv( (GLint*) p );
684 break;
685 case GL_FLOAT:
686 glIndexfv( (GLfloat*) p );
687 break;
688 case GL_DOUBLE:
689 glIndexdv( (GLdouble*) p );
690 break;
691 default:
692 gl_problem(ctx, "Bad index type in gl_save_ArrayElement");
693 return;
694 }
695 }
696
697 if (ctx->Array.TexCoordEnabled) {
698 GLbyte *p = (GLbyte*) ctx->Array.TexCoordPtr
699 + i * ctx->Array.TexCoordStrideB;
700 switch (ctx->Array.TexCoordType) {
701 case GL_SHORT:
702 switch (ctx->Array.TexCoordSize) {
703 case 1: glTexCoord1sv( (GLshort*) p ); break;
704 case 2: glTexCoord2sv( (GLshort*) p ); break;
705 case 3: glTexCoord3sv( (GLshort*) p ); break;
706 case 4: glTexCoord4sv( (GLshort*) p ); break;
707 }
708 break;
709 case GL_INT:
710 switch (ctx->Array.TexCoordSize) {
711 case 1: glTexCoord1iv( (GLint*) p ); break;
712 case 2: glTexCoord2iv( (GLint*) p ); break;
713 case 3: glTexCoord3iv( (GLint*) p ); break;
714 case 4: glTexCoord4iv( (GLint*) p ); break;
715 }
716 break;
717 case GL_FLOAT:
718 switch (ctx->Array.TexCoordSize) {
719 case 1: glTexCoord1fv( (GLfloat*) p ); break;
720 case 2: glTexCoord2fv( (GLfloat*) p ); break;
721 case 3: glTexCoord3fv( (GLfloat*) p ); break;
722 case 4: glTexCoord4fv( (GLfloat*) p ); break;
723 }
724 break;
725 case GL_DOUBLE:
726 switch (ctx->Array.TexCoordSize) {
727 case 1: glTexCoord1dv( (GLdouble*) p ); break;
728 case 2: glTexCoord2dv( (GLdouble*) p ); break;
729 case 3: glTexCoord3dv( (GLdouble*) p ); break;
730 case 4: glTexCoord4dv( (GLdouble*) p ); break;
731 }
732 break;
733 default:
734 gl_problem(ctx, "Bad texcoord type in gl_save_ArrayElement");
735 return;
736 }
737 }
738
739 if (ctx->Array.EdgeFlagEnabled) {
740 GLbyte *b = (GLbyte*) ctx->Array.EdgeFlagPtr + i * ctx->Array.EdgeFlagStrideB;
741 glEdgeFlagv( (GLboolean*) b );
742 }
743
744 if (ctx->Array.VertexEnabled) {
745 GLbyte *b = (GLbyte*) ctx->Array.VertexPtr
746 + i * ctx->Array.VertexStrideB;
747 switch (ctx->Array.VertexType) {
748 case GL_SHORT:
749 switch (ctx->Array.VertexSize) {
750 case 2: glVertex2sv( (GLshort*) b ); break;
751 case 3: glVertex3sv( (GLshort*) b ); break;
752 case 4: glVertex4sv( (GLshort*) b ); break;
753 }
754 break;
755 case GL_INT:
756 switch (ctx->Array.VertexSize) {
757 case 2: glVertex2iv( (GLint*) b ); break;
758 case 3: glVertex3iv( (GLint*) b ); break;
759 case 4: glVertex4iv( (GLint*) b ); break;
760 }
761 break;
762 case GL_FLOAT:
763 switch (ctx->Array.VertexSize) {
764 case 2: glVertex2fv( (GLfloat*) b ); break;
765 case 3: glVertex3fv( (GLfloat*) b ); break;
766 case 4: glVertex4fv( (GLfloat*) b ); break;
767 }
768 break;
769 case GL_DOUBLE:
770 switch (ctx->Array.VertexSize) {
771 case 2: glVertex2dv( (GLdouble*) b ); break;
772 case 3: glVertex3dv( (GLdouble*) b ); break;
773 case 4: glVertex4dv( (GLdouble*) b ); break;
774 }
775 break;
776 default:
777 gl_problem(ctx, "Bad vertex type in gl_save_ArrayElement");
778 return;
779 }
780 }
781}
GLAPI void GLAPIENTRY glTexCoord1iv(const GLint *v)
GLAPI void GLAPIENTRY glVertex2dv(const GLdouble *v)
GLAPI void GLAPIENTRY glTexCoord4dv(const GLdouble *v)
GLAPI void GLAPIENTRY glVertex4sv(const GLshort *v)
GLAPI void GLAPIENTRY glTexCoord3iv(const GLint *v)
GLAPI void GLAPIENTRY glVertex2iv(const GLint *v)
GLAPI void GLAPIENTRY glIndexdv(const GLdouble *c)
GLAPI void GLAPIENTRY glVertex4dv(const GLdouble *v)
GLAPI void GLAPIENTRY glIndexiv(const GLint *c)
GLAPI void GLAPIENTRY glVertex4iv(const GLint *v)
GLAPI void GLAPIENTRY glTexCoord3sv(const GLshort *v)
GLAPI void GLAPIENTRY glVertex2sv(const GLshort *v)
GLAPI void GLAPIENTRY glNormal3bv(const GLbyte *v)
GLAPI void GLAPIENTRY glVertex3sv(const GLshort *v)
GLAPI void GLAPIENTRY glTexCoord3fv(const GLfloat *v)
GLAPI void GLAPIENTRY glNormal3iv(const GLint *v)
GLAPI void GLAPIENTRY glVertex3iv(const GLint *v)
GLAPI void GLAPIENTRY glNormal3sv(const GLshort *v)
GLAPI void GLAPIENTRY glVertex3dv(const GLdouble *v)
GLAPI void GLAPIENTRY glTexCoord4fv(const GLfloat *v)
GLAPI void GLAPIENTRY glTexCoord1dv(const GLdouble *v)
GLAPI void GLAPIENTRY glEdgeFlagv(const GLboolean *flag)
GLAPI void GLAPIENTRY glTexCoord2fv(const GLfloat *v)
GLAPI void GLAPIENTRY glTexCoord2dv(const GLdouble *v)
GLAPI void GLAPIENTRY glVertex4fv(const GLfloat *v)
GLAPI void GLAPIENTRY glTexCoord4iv(const GLint *v)
GLAPI void GLAPIENTRY glNormal3dv(const GLdouble *v)
GLAPI void GLAPIENTRY glTexCoord1fv(const GLfloat *v)
GLAPI void GLAPIENTRY glTexCoord4sv(const GLshort *v)
GLAPI void GLAPIENTRY glVertex3fv(const GLfloat *v)
GLAPI void GLAPIENTRY glTexCoord3dv(const GLdouble *v)
GLAPI void GLAPIENTRY glTexCoord1sv(const GLshort *v)
GLAPI void GLAPIENTRY glIndexsv(const GLshort *c)
GLAPI void GLAPIENTRY glTexCoord2sv(const GLshort *v)
GLAPI void GLAPIENTRY glIndexfv(const GLfloat *c)
GLAPI void GLAPIENTRY glNormal3fv(const GLfloat *v)
GLAPI void GLAPIENTRY glTexCoord2iv(const GLint *v)
GLAPI void GLAPIENTRY glVertex2fv(const GLfloat *v)

Referenced by gl_save_DrawArrays(), gl_save_DrawElements(), and init_dlist_pointers().

◆ gl_save_DrawArrays()

void gl_save_DrawArrays ( GLcontext ctx,
GLenum  mode,
GLint  first,
GLsizei  count 
)

Definition at line 993 of file varray.c.

995{
996 GLint i;
997
998 if (INSIDE_BEGIN_END(ctx)) {
999 gl_error( ctx, GL_INVALID_OPERATION, "glDrawArrays" );
1000 return;
1001 }
1002 if (count<0) {
1003 gl_error( ctx, GL_INVALID_VALUE, "glDrawArrays(count)" );
1004 return;
1005 }
1006 switch (mode) {
1007 case GL_POINTS:
1008 case GL_LINES:
1009 case GL_LINE_STRIP:
1010 case GL_LINE_LOOP:
1011 case GL_TRIANGLES:
1012 case GL_TRIANGLE_STRIP:
1013 case GL_TRIANGLE_FAN:
1014 case GL_QUADS:
1015 case GL_QUAD_STRIP:
1016 case GL_POLYGON:
1017 /* OK */
1018 break;
1019 default:
1020 gl_error( ctx, GL_INVALID_ENUM, "glDrawArrays(mode)" );
1021 return;
1022 }
1023
1024
1025 /* Note: this will do compile AND execute if needed */
1027 for (i=0;i<count;i++) {
1029 }
1030 gl_save_End( ctx );
1031}
void gl_save_Begin(GLcontext *ctx, GLenum mode)
Definition: dlist.c:722
void gl_save_End(GLcontext *ctx)
Definition: dlist.c:1292
void gl_save_ArrayElement(GLcontext *ctx, GLint i)
Definition: varray.c:592

Referenced by init_dlist_pointers().

◆ gl_save_DrawElements()

void gl_save_DrawElements ( GLcontext ctx,
GLenum  mode,
GLsizei  count,
GLenum  type,
const GLvoid indices 
)

Definition at line 1115 of file varray.c.

1118{
1119 switch (type) {
1120 case GL_UNSIGNED_BYTE:
1121 {
1122 GLubyte *ub_indices = (GLubyte *) indices;
1123 GLint i;
1125 for (i=0;i<count;i++) {
1126 gl_save_ArrayElement( ctx, (GLint) ub_indices[i] );
1127 }
1128 gl_save_End( ctx );
1129 }
1130 break;
1131 case GL_UNSIGNED_SHORT:
1132 {
1133 GLushort *us_indices = (GLushort *) indices;
1134 GLint i;
1136 for (i=0;i<count;i++) {
1137 gl_save_ArrayElement( ctx, (GLint) us_indices[i] );
1138 }
1139 gl_save_End( ctx );
1140 }
1141 break;
1142 case GL_UNSIGNED_INT:
1143 {
1144 GLuint *ui_indices = (GLuint *) indices;
1145 GLint i;
1147 for (i=0;i<count;i++) {
1148 gl_save_ArrayElement( ctx, (GLint) ui_indices[i] );
1149 }
1150 gl_save_End( ctx );
1151 }
1152 break;
1153 default:
1154 gl_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
1155 return;
1156 }
1157}

Referenced by init_dlist_pointers().

◆ gl_save_InterleavedArrays()

void gl_save_InterleavedArrays ( GLcontext ctx,
GLenum  format,
GLsizei  stride,
const GLvoid pointer 
)

Definition at line 1332 of file varray.c.

1335{
1336 /* Just execute since client-side state changes aren't put in
1337 * display lists.
1338 */
1340}
void gl_InterleavedArrays(GLcontext *ctx, GLenum format, GLsizei stride, const GLvoid *pointer)
Definition: varray.c:1162

Referenced by init_dlist_pointers().

◆ gl_TexCoordPointer()

void gl_TexCoordPointer ( GLcontext ctx,
GLint  size,
GLenum  type,
GLsizei  stride,
const GLvoid ptr 
)

Definition at line 263 of file varray.c.

266{
267 if (size<1 || size>4) {
268 gl_error( ctx, GL_INVALID_VALUE, "glTexCoordPointer(size)" );
269 return;
270 }
271 switch (type) {
272 case GL_SHORT:
273 ctx->Array.TexCoordStrideB = stride ? stride : size*sizeof(GLshort);
274 break;
275 case GL_INT:
276 ctx->Array.TexCoordStrideB = stride ? stride : size*sizeof(GLint);
277 break;
278 case GL_FLOAT:
279 ctx->Array.TexCoordStrideB = stride ? stride : size*sizeof(GLfloat);
280 break;
281 case GL_DOUBLE:
282 ctx->Array.TexCoordStrideB = stride ? stride : size*sizeof(GLdouble);
283 break;
284 default:
285 gl_error( ctx, GL_INVALID_ENUM, "glTexCoordPointer(type)" );
286 return;
287 }
288 if (stride<0) {
289 gl_error( ctx, GL_INVALID_VALUE, "glTexCoordPointer(stride)" );
290 return;
291 }
292 ctx->Array.TexCoordSize = size;
293 ctx->Array.TexCoordType = type;
294 ctx->Array.TexCoordStride = stride;
295 ctx->Array.TexCoordPtr = (void *) ptr;
296}

Referenced by gl_InterleavedArrays(), init_dlist_pointers(), and init_exec_pointers().

◆ gl_VertexPointer()

void gl_VertexPointer ( GLcontext ctx,
GLint  size,
GLenum  type,
GLsizei  stride,
const GLvoid ptr 
)

Definition at line 111 of file varray.c.

114{
115 if (size<2 || size>4) {
116 gl_error( ctx, GL_INVALID_VALUE, "glVertexPointer(size)" );
117 return;
118 }
119 if (stride<0) {
120 gl_error( ctx, GL_INVALID_VALUE, "glVertexPointer(stride)" );
121 return;
122 }
123 switch (type) {
124 case GL_SHORT:
125 ctx->Array.VertexStrideB = stride ? stride : size*sizeof(GLshort);
126 break;
127 case GL_INT:
128 ctx->Array.VertexStrideB = stride ? stride : size*sizeof(GLint);
129 break;
130 case GL_FLOAT:
131 ctx->Array.VertexStrideB = stride ? stride : size*sizeof(GLfloat);
132 break;
133 case GL_DOUBLE:
134 ctx->Array.VertexStrideB = stride ? stride : size*sizeof(GLdouble);
135 break;
136 default:
137 gl_error( ctx, GL_INVALID_ENUM, "glVertexPointer(type)" );
138 return;
139 }
140 ctx->Array.VertexSize = size;
141 ctx->Array.VertexType = type;
142 ctx->Array.VertexStride = stride;
143 ctx->Array.VertexPtr = (void *) ptr;
144}

Referenced by gl_InterleavedArrays(), init_dlist_pointers(), and init_exec_pointers().