← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/mesa/vbo/vbo_attrib_tmp.h

  • Committer: mmach
  • Date: 2022-09-22 20:02:48 UTC
  • Revision ID: netbit73@gmail.com-20220922200248-7y4wybmdgipuwdiw
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/vbo/vbo_attrib_tmp.h
248
248
   ATTR4FV(VBO_ATTRIB_POS, v);
249
249
}
250
250
 
251
 
 
252
 
 
253
 
static void GLAPIENTRY
254
 
TAG(TexCoord1f)(GLfloat x)
255
 
{
256
 
   GET_CURRENT_CONTEXT(ctx);
257
 
   ATTR1F(VBO_ATTRIB_TEX0, x);
258
 
}
259
 
 
260
 
static void GLAPIENTRY
261
 
TAG(TexCoord1fv)(const GLfloat * v)
262
 
{
263
 
   GET_CURRENT_CONTEXT(ctx);
264
 
   ATTR1FV(VBO_ATTRIB_TEX0, v);
265
 
}
266
 
 
267
 
static void GLAPIENTRY
268
 
TAG(TexCoord2f)(GLfloat x, GLfloat y)
269
 
{
270
 
   GET_CURRENT_CONTEXT(ctx);
271
 
   ATTR2F(VBO_ATTRIB_TEX0, x, y);
272
 
}
273
 
 
274
 
static void GLAPIENTRY
275
 
TAG(TexCoord2fv)(const GLfloat * v)
276
 
{
277
 
   GET_CURRENT_CONTEXT(ctx);
278
 
   ATTR2FV(VBO_ATTRIB_TEX0, v);
279
 
}
280
 
 
281
 
static void GLAPIENTRY
282
 
TAG(TexCoord3f)(GLfloat x, GLfloat y, GLfloat z)
283
 
{
284
 
   GET_CURRENT_CONTEXT(ctx);
285
 
   ATTR3F(VBO_ATTRIB_TEX0, x, y, z);
286
 
}
287
 
 
288
 
static void GLAPIENTRY
289
 
TAG(TexCoord3fv)(const GLfloat * v)
290
 
{
291
 
   GET_CURRENT_CONTEXT(ctx);
292
 
   ATTR3FV(VBO_ATTRIB_TEX0, v);
293
 
}
294
 
 
295
 
static void GLAPIENTRY
296
 
TAG(TexCoord4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
297
 
{
298
 
   GET_CURRENT_CONTEXT(ctx);
299
 
   ATTR4F(VBO_ATTRIB_TEX0, x, y, z, w);
300
 
}
301
 
 
302
 
static void GLAPIENTRY
303
 
TAG(TexCoord4fv)(const GLfloat * v)
304
 
{
305
 
   GET_CURRENT_CONTEXT(ctx);
306
 
   ATTR4FV(VBO_ATTRIB_TEX0, v);
307
 
}
308
 
 
309
 
 
310
 
 
311
 
static void GLAPIENTRY
312
 
TAG(Normal3f)(GLfloat x, GLfloat y, GLfloat z)
313
 
{
314
 
   GET_CURRENT_CONTEXT(ctx);
315
 
   ATTR3F(VBO_ATTRIB_NORMAL, x, y, z);
316
 
}
317
 
 
318
 
static void GLAPIENTRY
319
 
TAG(Normal3fv)(const GLfloat * v)
320
 
{
321
 
   GET_CURRENT_CONTEXT(ctx);
322
 
   ATTR3FV(VBO_ATTRIB_NORMAL, v);
323
 
}
324
 
 
325
 
 
326
 
 
327
 
static void GLAPIENTRY
328
 
TAG(FogCoordfEXT)(GLfloat x)
329
 
{
330
 
   GET_CURRENT_CONTEXT(ctx);
331
 
   ATTR1F(VBO_ATTRIB_FOG, x);
332
 
}
333
 
 
334
 
 
335
 
 
336
 
static void GLAPIENTRY
337
 
TAG(FogCoordfvEXT)(const GLfloat * v)
338
 
{
339
 
   GET_CURRENT_CONTEXT(ctx);
340
 
   ATTR1FV(VBO_ATTRIB_FOG, v);
341
 
}
342
 
 
343
 
static void GLAPIENTRY
344
 
TAG(Color3f)(GLfloat x, GLfloat y, GLfloat z)
345
 
{
346
 
   GET_CURRENT_CONTEXT(ctx);
347
 
   ATTR3F(VBO_ATTRIB_COLOR0, x, y, z);
348
 
}
349
 
 
350
 
static void GLAPIENTRY
351
 
TAG(Color3fv)(const GLfloat * v)
352
 
{
353
 
   GET_CURRENT_CONTEXT(ctx);
354
 
   ATTR3FV(VBO_ATTRIB_COLOR0, v);
355
 
}
356
 
 
357
 
static void GLAPIENTRY
358
 
TAG(Color4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
359
 
{
360
 
   GET_CURRENT_CONTEXT(ctx);
361
 
   ATTR4F(VBO_ATTRIB_COLOR0, x, y, z, w);
362
 
}
363
 
 
364
 
static void GLAPIENTRY
365
 
TAG(Color4fv)(const GLfloat * v)
366
 
{
367
 
   GET_CURRENT_CONTEXT(ctx);
368
 
   ATTR4FV(VBO_ATTRIB_COLOR0, v);
369
 
}
370
 
 
371
 
 
372
 
 
373
 
static void GLAPIENTRY
374
 
TAG(SecondaryColor3fEXT)(GLfloat x, GLfloat y, GLfloat z)
375
 
{
376
 
   GET_CURRENT_CONTEXT(ctx);
377
 
   ATTR3F(VBO_ATTRIB_COLOR1, x, y, z);
378
 
}
379
 
 
380
 
static void GLAPIENTRY
381
 
TAG(SecondaryColor3fvEXT)(const GLfloat * v)
382
 
{
383
 
   GET_CURRENT_CONTEXT(ctx);
384
 
   ATTR3FV(VBO_ATTRIB_COLOR1, v);
385
 
}
386
 
 
387
 
 
388
 
 
389
 
static void GLAPIENTRY
390
 
TAG(EdgeFlag)(GLboolean b)
391
 
{
392
 
   GET_CURRENT_CONTEXT(ctx);
393
 
   ATTR1F(VBO_ATTRIB_EDGEFLAG, (GLfloat) b);
394
 
}
395
 
 
396
 
 
397
 
 
398
 
static void GLAPIENTRY
399
 
TAG(Indexf)(GLfloat f)
400
 
{
401
 
   GET_CURRENT_CONTEXT(ctx);
402
 
   ATTR1F(VBO_ATTRIB_COLOR_INDEX, f);
403
 
}
404
 
 
405
 
static void GLAPIENTRY
406
 
TAG(Indexfv)(const GLfloat * f)
407
 
{
408
 
   GET_CURRENT_CONTEXT(ctx);
409
 
   ATTR1FV(VBO_ATTRIB_COLOR_INDEX, f);
410
 
}
411
 
 
412
 
 
413
 
 
414
 
static void GLAPIENTRY
415
 
TAG(MultiTexCoord1fARB)(GLenum target, GLfloat x)
416
 
{
417
 
   GET_CURRENT_CONTEXT(ctx);
418
 
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
419
 
   ATTR1F(attr, x);
420
 
}
421
 
 
422
 
static void GLAPIENTRY
423
 
TAG(MultiTexCoord1fvARB)(GLenum target, const GLfloat * v)
424
 
{
425
 
   GET_CURRENT_CONTEXT(ctx);
426
 
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
427
 
   ATTR1FV(attr, v);
428
 
}
429
 
 
430
 
static void GLAPIENTRY
431
 
TAG(MultiTexCoord2fARB)(GLenum target, GLfloat x, GLfloat y)
432
 
{
433
 
   GET_CURRENT_CONTEXT(ctx);
434
 
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
435
 
   ATTR2F(attr, x, y);
436
 
}
437
 
 
438
 
static void GLAPIENTRY
439
 
TAG(MultiTexCoord2fvARB)(GLenum target, const GLfloat * v)
440
 
{
441
 
   GET_CURRENT_CONTEXT(ctx);
442
 
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
443
 
   ATTR2FV(attr, v);
444
 
}
445
 
 
446
 
static void GLAPIENTRY
447
 
TAG(MultiTexCoord3fARB)(GLenum target, GLfloat x, GLfloat y, GLfloat z)
448
 
{
449
 
   GET_CURRENT_CONTEXT(ctx);
450
 
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
451
 
   ATTR3F(attr, x, y, z);
452
 
}
453
 
 
454
 
static void GLAPIENTRY
455
 
TAG(MultiTexCoord3fvARB)(GLenum target, const GLfloat * v)
456
 
{
457
 
   GET_CURRENT_CONTEXT(ctx);
458
 
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
459
 
   ATTR3FV(attr, v);
460
 
}
461
 
 
462
 
static void GLAPIENTRY
463
 
TAG(MultiTexCoord4fARB)(GLenum target, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
464
 
{
465
 
   GET_CURRENT_CONTEXT(ctx);
466
 
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
467
 
   ATTR4F(attr, x, y, z, w);
468
 
}
469
 
 
470
 
static void GLAPIENTRY
471
 
TAG(MultiTexCoord4fvARB)(GLenum target, const GLfloat * v)
472
 
{
473
 
   GET_CURRENT_CONTEXT(ctx);
474
 
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
475
 
   ATTR4FV(attr, v);
476
 
}
477
 
 
478
 
 
479
251
static void GLAPIENTRY
480
252
TAG(VertexAttrib1fARB)(GLuint index, GLfloat x)
481
253
{
871
643
}
872
644
 
873
645
static void GLAPIENTRY
 
646
TAG(VertexAttribP1ui)(GLuint index, GLenum type, GLboolean normalized,
 
647
                      GLuint value)
 
648
{
 
649
   GET_CURRENT_CONTEXT(ctx);
 
650
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP1ui");
 
651
   ATTR_UI_INDEX(ctx, 1, type, normalized, index, value);
 
652
}
 
653
 
 
654
static void GLAPIENTRY
 
655
TAG(VertexAttribP2ui)(GLuint index, GLenum type, GLboolean normalized,
 
656
                      GLuint value)
 
657
{
 
658
   GET_CURRENT_CONTEXT(ctx);
 
659
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP2ui");
 
660
   ATTR_UI_INDEX(ctx, 2, type, normalized, index, value);
 
661
}
 
662
 
 
663
static void GLAPIENTRY
 
664
TAG(VertexAttribP3ui)(GLuint index, GLenum type, GLboolean normalized,
 
665
                      GLuint value)
 
666
{
 
667
   GET_CURRENT_CONTEXT(ctx);
 
668
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP3ui");
 
669
   ATTR_UI_INDEX(ctx, 3, type, normalized, index, value);
 
670
}
 
671
 
 
672
static void GLAPIENTRY
 
673
TAG(VertexAttribP4ui)(GLuint index, GLenum type, GLboolean normalized,
 
674
                      GLuint value)
 
675
{
 
676
   GET_CURRENT_CONTEXT(ctx);
 
677
   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexAttribP4ui");
 
678
   ATTR_UI_INDEX(ctx, 4, type, normalized, index, value);
 
679
}
 
680
 
 
681
static void GLAPIENTRY
 
682
TAG(VertexAttribP1uiv)(GLuint index, GLenum type, GLboolean normalized,
 
683
                       const GLuint *value)
 
684
{
 
685
   GET_CURRENT_CONTEXT(ctx);
 
686
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP1uiv");
 
687
   ATTR_UI_INDEX(ctx, 1, type, normalized, index, *value);
 
688
}
 
689
 
 
690
static void GLAPIENTRY
 
691
TAG(VertexAttribP2uiv)(GLuint index, GLenum type, GLboolean normalized,
 
692
                       const GLuint *value)
 
693
{
 
694
   GET_CURRENT_CONTEXT(ctx);
 
695
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP2uiv");
 
696
   ATTR_UI_INDEX(ctx, 2, type, normalized, index, *value);
 
697
}
 
698
 
 
699
static void GLAPIENTRY
 
700
TAG(VertexAttribP3uiv)(GLuint index, GLenum type, GLboolean normalized,
 
701
                       const GLuint *value)
 
702
{
 
703
   GET_CURRENT_CONTEXT(ctx);
 
704
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP3uiv");
 
705
   ATTR_UI_INDEX(ctx, 3, type, normalized, index, *value);
 
706
}
 
707
 
 
708
static void GLAPIENTRY
 
709
TAG(VertexAttribP4uiv)(GLuint index, GLenum type, GLboolean normalized,
 
710
                      const GLuint *value)
 
711
{
 
712
   GET_CURRENT_CONTEXT(ctx);
 
713
   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexAttribP4uiv");
 
714
   ATTR_UI_INDEX(ctx, 4, type, normalized, index, *value);
 
715
}
 
716
 
 
717
 
 
718
 
 
719
static void GLAPIENTRY
 
720
TAG(VertexAttribL1d)(GLuint index, GLdouble x)
 
721
{
 
722
   GET_CURRENT_CONTEXT(ctx);
 
723
   if (is_vertex_position(ctx, index))
 
724
      ATTR1D(0, x);
 
725
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
726
      ATTR1D(VBO_ATTRIB_GENERIC0 + index, x);
 
727
   else
 
728
      ERROR(GL_INVALID_VALUE);
 
729
}
 
730
 
 
731
static void GLAPIENTRY
 
732
TAG(VertexAttribL1dv)(GLuint index, const GLdouble * v)
 
733
{
 
734
   GET_CURRENT_CONTEXT(ctx);
 
735
   if (is_vertex_position(ctx, index))
 
736
      ATTR1DV(0, v);
 
737
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
738
      ATTR1DV(VBO_ATTRIB_GENERIC0 + index, v);
 
739
   else
 
740
      ERROR(GL_INVALID_VALUE);
 
741
}
 
742
 
 
743
static void GLAPIENTRY
 
744
TAG(VertexAttribL2d)(GLuint index, GLdouble x, GLdouble y)
 
745
{
 
746
   GET_CURRENT_CONTEXT(ctx);
 
747
   if (is_vertex_position(ctx, index))
 
748
      ATTR2D(0, x, y);
 
749
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
750
      ATTR2D(VBO_ATTRIB_GENERIC0 + index, x, y);
 
751
   else
 
752
      ERROR(GL_INVALID_VALUE);
 
753
}
 
754
 
 
755
static void GLAPIENTRY
 
756
TAG(VertexAttribL2dv)(GLuint index, const GLdouble * v)
 
757
{
 
758
   GET_CURRENT_CONTEXT(ctx);
 
759
   if (is_vertex_position(ctx, index))
 
760
      ATTR2DV(0, v);
 
761
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
762
      ATTR2DV(VBO_ATTRIB_GENERIC0 + index, v);
 
763
   else
 
764
      ERROR(GL_INVALID_VALUE);
 
765
}
 
766
 
 
767
static void GLAPIENTRY
 
768
TAG(VertexAttribL3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 
769
{
 
770
   GET_CURRENT_CONTEXT(ctx);
 
771
   if (is_vertex_position(ctx, index))
 
772
      ATTR3D(0, x, y, z);
 
773
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
774
      ATTR3D(VBO_ATTRIB_GENERIC0 + index, x, y, z);
 
775
   else
 
776
      ERROR(GL_INVALID_VALUE);
 
777
}
 
778
 
 
779
static void GLAPIENTRY
 
780
TAG(VertexAttribL3dv)(GLuint index, const GLdouble * v)
 
781
{
 
782
   GET_CURRENT_CONTEXT(ctx);
 
783
   if (is_vertex_position(ctx, index))
 
784
      ATTR3DV(0, v);
 
785
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
786
      ATTR3DV(VBO_ATTRIB_GENERIC0 + index, v);
 
787
   else
 
788
      ERROR(GL_INVALID_VALUE);
 
789
}
 
790
 
 
791
static void GLAPIENTRY
 
792
TAG(VertexAttribL4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
793
{
 
794
   GET_CURRENT_CONTEXT(ctx);
 
795
   if (is_vertex_position(ctx, index))
 
796
      ATTR4D(0, x, y, z, w);
 
797
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
798
      ATTR4D(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
 
799
   else
 
800
      ERROR(GL_INVALID_VALUE);
 
801
}
 
802
 
 
803
static void GLAPIENTRY
 
804
TAG(VertexAttribL4dv)(GLuint index, const GLdouble * v)
 
805
{
 
806
   GET_CURRENT_CONTEXT(ctx);
 
807
   if (is_vertex_position(ctx, index))
 
808
      ATTR4DV(0, v);
 
809
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
810
      ATTR4DV(VBO_ATTRIB_GENERIC0 + index, v);
 
811
   else
 
812
      ERROR(GL_INVALID_VALUE);
 
813
}
 
814
 
 
815
static void GLAPIENTRY
 
816
TAG(VertexAttribL1ui64ARB)(GLuint index, GLuint64EXT x)
 
817
{
 
818
   GET_CURRENT_CONTEXT(ctx);
 
819
   if (is_vertex_position(ctx, index))
 
820
      ATTR1UI64(0, x);
 
821
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
822
      ATTR1UI64(VBO_ATTRIB_GENERIC0 + index, x);
 
823
   else
 
824
      ERROR(GL_INVALID_VALUE);
 
825
}
 
826
 
 
827
static void GLAPIENTRY
 
828
TAG(VertexAttribL1ui64vARB)(GLuint index, const GLuint64EXT *v)
 
829
{
 
830
   GET_CURRENT_CONTEXT(ctx);
 
831
   if (is_vertex_position(ctx, index))
 
832
      ATTR1UIV64(0, v);
 
833
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
834
      ATTR1UIV64(VBO_ATTRIB_GENERIC0 + index, v);
 
835
   else
 
836
      ERROR(GL_INVALID_VALUE);
 
837
}
 
838
 
 
839
/* GL_NV_half_float */
 
840
static void GLAPIENTRY
 
841
TAG(Vertex2hNV)(GLhalfNV x, GLhalfNV y)
 
842
{
 
843
   GET_CURRENT_CONTEXT(ctx);
 
844
   ATTR2H(VBO_ATTRIB_POS, x, y);
 
845
}
 
846
 
 
847
static void GLAPIENTRY
 
848
TAG(Vertex2hvNV)(const GLhalfNV * v)
 
849
{
 
850
   GET_CURRENT_CONTEXT(ctx);
 
851
   ATTR2HV(VBO_ATTRIB_POS, v);
 
852
}
 
853
 
 
854
static void GLAPIENTRY
 
855
TAG(Vertex3hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z)
 
856
{
 
857
   GET_CURRENT_CONTEXT(ctx);
 
858
   ATTR3H(VBO_ATTRIB_POS, x, y, z);
 
859
}
 
860
 
 
861
static void GLAPIENTRY
 
862
TAG(Vertex3hvNV)(const GLhalfNV * v)
 
863
{
 
864
   GET_CURRENT_CONTEXT(ctx);
 
865
   ATTR3HV(VBO_ATTRIB_POS, v);
 
866
}
 
867
 
 
868
static void GLAPIENTRY
 
869
TAG(Vertex4hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
 
870
{
 
871
   GET_CURRENT_CONTEXT(ctx);
 
872
   ATTR4H(VBO_ATTRIB_POS, x, y, z, w);
 
873
}
 
874
 
 
875
static void GLAPIENTRY
 
876
TAG(Vertex4hvNV)(const GLhalfNV * v)
 
877
{
 
878
   GET_CURRENT_CONTEXT(ctx);
 
879
   ATTR4HV(VBO_ATTRIB_POS, v);
 
880
}
 
881
 
 
882
static void GLAPIENTRY
 
883
TAG(VertexAttrib1hNV)(GLuint index, GLhalfNV x)
 
884
{
 
885
   GET_CURRENT_CONTEXT(ctx);
 
886
   if (is_vertex_position(ctx, index))
 
887
      ATTR1H(0, x);
 
888
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
889
      ATTR1H(VBO_ATTRIB_GENERIC0 + index, x);
 
890
   else
 
891
      ERROR(GL_INVALID_VALUE);
 
892
}
 
893
 
 
894
static void GLAPIENTRY
 
895
TAG(VertexAttrib2hNV)(GLuint index, GLhalfNV x, GLhalfNV y)
 
896
{
 
897
   GET_CURRENT_CONTEXT(ctx);
 
898
   if (is_vertex_position(ctx, index))
 
899
      ATTR2H(0, x, y);
 
900
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
901
      ATTR2H(VBO_ATTRIB_GENERIC0 + index, x, y);
 
902
   else
 
903
      ERROR(GL_INVALID_VALUE);
 
904
}
 
905
 
 
906
static void GLAPIENTRY
 
907
TAG(VertexAttrib3hNV)(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z)
 
908
{
 
909
   GET_CURRENT_CONTEXT(ctx);
 
910
   if (is_vertex_position(ctx, index))
 
911
      ATTR3H(0, x, y, z);
 
912
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
913
      ATTR3H(VBO_ATTRIB_GENERIC0 + index, x, y, z);
 
914
   else
 
915
      ERROR(GL_INVALID_VALUE);
 
916
}
 
917
 
 
918
static void GLAPIENTRY
 
919
TAG(VertexAttrib4hNV)(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
 
920
{
 
921
   GET_CURRENT_CONTEXT(ctx);
 
922
   if (is_vertex_position(ctx, index))
 
923
      ATTR4H(0, x, y, z, w);
 
924
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
925
      ATTR4H(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
 
926
   else
 
927
      ERROR(GL_INVALID_VALUE);
 
928
}
 
929
 
 
930
static void GLAPIENTRY
 
931
TAG(VertexAttrib1hvNV)(GLuint index, const GLhalfNV * v)
 
932
{
 
933
   GET_CURRENT_CONTEXT(ctx);
 
934
   if (is_vertex_position(ctx, index))
 
935
      ATTR1HV(0, v);
 
936
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
937
      ATTR1HV(VBO_ATTRIB_GENERIC0 + index, v);
 
938
   else
 
939
      ERROR(GL_INVALID_VALUE);
 
940
}
 
941
 
 
942
static void GLAPIENTRY
 
943
TAG(VertexAttrib2hvNV)(GLuint index, const GLhalfNV * v)
 
944
{
 
945
   GET_CURRENT_CONTEXT(ctx);
 
946
   if (is_vertex_position(ctx, index))
 
947
      ATTR2HV(0, v);
 
948
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
949
      ATTR2HV(VBO_ATTRIB_GENERIC0 + index, v);
 
950
   else
 
951
      ERROR(GL_INVALID_VALUE);
 
952
}
 
953
 
 
954
static void GLAPIENTRY
 
955
TAG(VertexAttrib3hvNV)(GLuint index, const GLhalfNV * v)
 
956
{
 
957
   GET_CURRENT_CONTEXT(ctx);
 
958
   if (is_vertex_position(ctx, index))
 
959
      ATTR3HV(0, v);
 
960
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
961
      ATTR3HV(VBO_ATTRIB_GENERIC0 + index, v);
 
962
   else
 
963
      ERROR(GL_INVALID_VALUE);
 
964
}
 
965
 
 
966
static void GLAPIENTRY
 
967
TAG(VertexAttrib4hvNV)(GLuint index, const GLhalfNV * v)
 
968
{
 
969
   GET_CURRENT_CONTEXT(ctx);
 
970
   if (is_vertex_position(ctx, index))
 
971
      ATTR4HV(0, v);
 
972
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
973
      ATTR4HV(VBO_ATTRIB_GENERIC0 + index, v);
 
974
   else
 
975
      ERROR(GL_INVALID_VALUE);
 
976
}
 
977
 
 
978
static void GLAPIENTRY
 
979
TAG(VertexAttribs1hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
 
980
{
 
981
   GET_CURRENT_CONTEXT(ctx);
 
982
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
983
   for (GLint i = n - 1; i >= 0; i--)
 
984
      ATTR1H(index + i, v[i]);
 
985
}
 
986
 
 
987
static void GLAPIENTRY
 
988
TAG(VertexAttribs2hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
 
989
{
 
990
   GET_CURRENT_CONTEXT(ctx);
 
991
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
992
   for (GLint i = n - 1; i >= 0; i--)
 
993
      ATTR2H(index + i, v[2 * i], v[2 * i + 1]);
 
994
}
 
995
 
 
996
static void GLAPIENTRY
 
997
TAG(VertexAttribs3hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
 
998
{
 
999
   GET_CURRENT_CONTEXT(ctx);
 
1000
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1001
   for (GLint i = n - 1; i >= 0; i--)
 
1002
      ATTR3H(index + i, v[3 * i], v[3 * i + 1], v[3 * i + 2]);
 
1003
}
 
1004
 
 
1005
 
 
1006
static void GLAPIENTRY
 
1007
TAG(VertexAttribs4hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
 
1008
{
 
1009
   GET_CURRENT_CONTEXT(ctx);
 
1010
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1011
   for (GLint i = n - 1; i >= 0; i--)
 
1012
      ATTR4H(index + i, v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3]);
 
1013
}
 
1014
 
 
1015
static void GLAPIENTRY
 
1016
TAG(Vertex2d)(GLdouble x, GLdouble y)
 
1017
{
 
1018
   GET_CURRENT_CONTEXT(ctx);
 
1019
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y);
 
1020
}
 
1021
 
 
1022
static void GLAPIENTRY
 
1023
TAG(Vertex2i)(GLint x, GLint y)
 
1024
{
 
1025
   GET_CURRENT_CONTEXT(ctx);
 
1026
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y);
 
1027
}
 
1028
 
 
1029
static void GLAPIENTRY
 
1030
TAG(Vertex2s)(GLshort x, GLshort y)
 
1031
{
 
1032
   GET_CURRENT_CONTEXT(ctx);
 
1033
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y);
 
1034
}
 
1035
 
 
1036
static void GLAPIENTRY
 
1037
TAG(Vertex3d)(GLdouble x, GLdouble y, GLdouble z)
 
1038
{
 
1039
   GET_CURRENT_CONTEXT(ctx);
 
1040
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z);
 
1041
}
 
1042
 
 
1043
static void GLAPIENTRY
 
1044
TAG(Vertex3i)(GLint x, GLint y, GLint z)
 
1045
{
 
1046
   GET_CURRENT_CONTEXT(ctx);
 
1047
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z);
 
1048
}
 
1049
 
 
1050
static void GLAPIENTRY
 
1051
TAG(Vertex3s)(GLshort x, GLshort y, GLshort z)
 
1052
{
 
1053
   GET_CURRENT_CONTEXT(ctx);
 
1054
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z);
 
1055
}
 
1056
 
 
1057
static void GLAPIENTRY
 
1058
TAG(Vertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
1059
{
 
1060
   GET_CURRENT_CONTEXT(ctx);
 
1061
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 
1062
}
 
1063
 
 
1064
static void GLAPIENTRY
 
1065
TAG(Vertex4i)(GLint x, GLint y, GLint z, GLint w)
 
1066
{
 
1067
   GET_CURRENT_CONTEXT(ctx);
 
1068
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 
1069
}
 
1070
 
 
1071
static void GLAPIENTRY
 
1072
TAG(Vertex4s)(GLshort x, GLshort y, GLshort z, GLshort w)
 
1073
{
 
1074
   GET_CURRENT_CONTEXT(ctx);
 
1075
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 
1076
}
 
1077
 
 
1078
static void GLAPIENTRY
 
1079
TAG(Vertex2dv)(const GLdouble *v)
 
1080
{
 
1081
   GET_CURRENT_CONTEXT(ctx);
 
1082
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1]);
 
1083
}
 
1084
 
 
1085
static void GLAPIENTRY
 
1086
TAG(Vertex2iv)(const GLint *v)
 
1087
{
 
1088
   GET_CURRENT_CONTEXT(ctx);
 
1089
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1]);
 
1090
}
 
1091
 
 
1092
static void GLAPIENTRY
 
1093
TAG(Vertex2sv)(const GLshort *v)
 
1094
{
 
1095
   GET_CURRENT_CONTEXT(ctx);
 
1096
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1]);
 
1097
}
 
1098
 
 
1099
static void GLAPIENTRY
 
1100
TAG(Vertex3dv)(const GLdouble *v)
 
1101
{
 
1102
   GET_CURRENT_CONTEXT(ctx);
 
1103
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
 
1104
}
 
1105
 
 
1106
static void GLAPIENTRY
 
1107
TAG(Vertex3iv)(const GLint *v)
 
1108
{
 
1109
   GET_CURRENT_CONTEXT(ctx);
 
1110
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
 
1111
}
 
1112
 
 
1113
static void GLAPIENTRY
 
1114
TAG(Vertex3sv)(const GLshort *v)
 
1115
{
 
1116
   GET_CURRENT_CONTEXT(ctx);
 
1117
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
 
1118
}
 
1119
 
 
1120
static void GLAPIENTRY
 
1121
TAG(Vertex4dv)(const GLdouble *v)
 
1122
{
 
1123
   GET_CURRENT_CONTEXT(ctx);
 
1124
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1],
 
1125
         (GLfloat) v[2], (GLfloat) v[3]);
 
1126
}
 
1127
 
 
1128
static void GLAPIENTRY
 
1129
TAG(Vertex4iv)(const GLint *v)
 
1130
{
 
1131
   GET_CURRENT_CONTEXT(ctx);
 
1132
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1],
 
1133
         (GLfloat) v[2], (GLfloat) v[3]);
 
1134
}
 
1135
 
 
1136
static void GLAPIENTRY
 
1137
TAG(Vertex4sv)(const GLshort *v)
 
1138
{
 
1139
   GET_CURRENT_CONTEXT(ctx);
 
1140
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1],
 
1141
         (GLfloat) v[2], (GLfloat) v[3]);
 
1142
}
 
1143
 
 
1144
/*
 
1145
 * GL_NV_vertex_program:
 
1146
 * Note that attribute indexes DO alias conventional vertex attributes.
 
1147
 */
 
1148
 
 
1149
static void GLAPIENTRY
 
1150
TAG(VertexAttrib1sNV)(GLuint index, GLshort x)
 
1151
{
 
1152
   GET_CURRENT_CONTEXT(ctx);
 
1153
   if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) x);
 
1154
}
 
1155
 
 
1156
static void GLAPIENTRY
 
1157
TAG(VertexAttrib1dNV)(GLuint index, GLdouble x)
 
1158
{
 
1159
   GET_CURRENT_CONTEXT(ctx);
 
1160
   if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) x);
 
1161
}
 
1162
 
 
1163
static void GLAPIENTRY
 
1164
TAG(VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y)
 
1165
{
 
1166
   GET_CURRENT_CONTEXT(ctx);
 
1167
   if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) x, y);
 
1168
}
 
1169
 
 
1170
static void GLAPIENTRY
 
1171
TAG(VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y)
 
1172
{
 
1173
   GET_CURRENT_CONTEXT(ctx);
 
1174
   if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) x, (GLfloat) y);
 
1175
}
 
1176
 
 
1177
static void GLAPIENTRY
 
1178
TAG(VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z)
 
1179
{
 
1180
   GET_CURRENT_CONTEXT(ctx);
 
1181
   if (index < VBO_ATTRIB_MAX) ATTR3F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z);
 
1182
}
 
1183
 
 
1184
static void GLAPIENTRY
 
1185
TAG(VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 
1186
{
 
1187
   GET_CURRENT_CONTEXT(ctx);
 
1188
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
 
1189
}
 
1190
 
 
1191
static void GLAPIENTRY
 
1192
TAG(VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 
1193
{
 
1194
   GET_CURRENT_CONTEXT(ctx);
 
1195
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 
1196
}
 
1197
 
 
1198
static void GLAPIENTRY
 
1199
TAG(VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
1200
{
 
1201
   GET_CURRENT_CONTEXT(ctx);
 
1202
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 
1203
}
 
1204
 
 
1205
static void GLAPIENTRY
 
1206
TAG(VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 
1207
{
 
1208
   GET_CURRENT_CONTEXT(ctx);
 
1209
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y),
 
1210
                                      UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w));
 
1211
}
 
1212
 
 
1213
static void GLAPIENTRY
 
1214
TAG(VertexAttrib1svNV)(GLuint index, const GLshort *v)
 
1215
{
 
1216
   GET_CURRENT_CONTEXT(ctx);
 
1217
   if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) v[0]);
 
1218
}
 
1219
 
 
1220
static void GLAPIENTRY
 
1221
TAG(VertexAttrib1dvNV)(GLuint index, const GLdouble *v)
 
1222
{
 
1223
   GET_CURRENT_CONTEXT(ctx);
 
1224
   if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) v[0]);
 
1225
}
 
1226
 
 
1227
static void GLAPIENTRY
 
1228
TAG(VertexAttrib2svNV)(GLuint index, const GLshort *v)
 
1229
{
 
1230
   GET_CURRENT_CONTEXT(ctx);
 
1231
   if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) v[0], (GLfloat) v[1]);
 
1232
}
 
1233
 
 
1234
static void GLAPIENTRY
 
1235
TAG(VertexAttrib2dvNV)(GLuint index, const GLdouble *v)
 
1236
{
 
1237
   GET_CURRENT_CONTEXT(ctx);
 
1238
   if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) v[0], (GLfloat) v[1]);
 
1239
}
 
1240
 
 
1241
static void GLAPIENTRY
 
1242
TAG(VertexAttrib3svNV)(GLuint index, const GLshort *v)
 
1243
{
 
1244
   GET_CURRENT_CONTEXT(ctx);
 
1245
   if (index < VBO_ATTRIB_MAX) ATTR3F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
 
1246
}
 
1247
 
 
1248
static void GLAPIENTRY
 
1249
TAG(VertexAttrib3dvNV)(GLuint index, const GLdouble *v)
 
1250
{
 
1251
   GET_CURRENT_CONTEXT(ctx);
 
1252
   if (index < VBO_ATTRIB_MAX) ATTR3F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
 
1253
}
 
1254
 
 
1255
static void GLAPIENTRY
 
1256
TAG(VertexAttrib4svNV)(GLuint index, const GLshort *v)
 
1257
{
 
1258
   GET_CURRENT_CONTEXT(ctx);
 
1259
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2],
 
1260
         (GLfloat)v[3]);
 
1261
}
 
1262
 
 
1263
static void GLAPIENTRY
 
1264
TAG(VertexAttrib4dvNV)(GLuint index, const GLdouble *v)
 
1265
{
 
1266
   GET_CURRENT_CONTEXT(ctx);
 
1267
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
 
1268
}
 
1269
 
 
1270
static void GLAPIENTRY
 
1271
TAG(VertexAttrib4ubvNV)(GLuint index, const GLubyte *v)
 
1272
{
 
1273
   GET_CURRENT_CONTEXT(ctx);
 
1274
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]),
 
1275
         UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
 
1276
}
 
1277
 
 
1278
 
 
1279
static void GLAPIENTRY
 
1280
TAG(VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort *v)
 
1281
{
 
1282
   GET_CURRENT_CONTEXT(ctx);
 
1283
   GLint i;
 
1284
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1285
   for (i = n - 1; i >= 0; i--)
 
1286
      ATTR1F(index + i, (GLfloat) v[i]);
 
1287
}
 
1288
 
 
1289
static void GLAPIENTRY
 
1290
TAG(VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat *v)
 
1291
{
 
1292
   GET_CURRENT_CONTEXT(ctx);
 
1293
   GLint i;
 
1294
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1295
   for (i = n - 1; i >= 0; i--)
 
1296
      ATTR1F(index + i, v[i]);
 
1297
}
 
1298
 
 
1299
static void GLAPIENTRY
 
1300
TAG(VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble *v)
 
1301
{
 
1302
   GET_CURRENT_CONTEXT(ctx);
 
1303
   GLint i;
 
1304
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1305
   for (i = n - 1; i >= 0; i--)
 
1306
      ATTR1F(index + i, (GLfloat) v[i]);
 
1307
}
 
1308
 
 
1309
static void GLAPIENTRY
 
1310
TAG(VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort *v)
 
1311
{
 
1312
   GET_CURRENT_CONTEXT(ctx);
 
1313
   GLint i;
 
1314
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1315
   for (i = n - 1; i >= 0; i--)
 
1316
      ATTR2F(index + i, (GLfloat) v[2 * i], (GLfloat) v[2 * i + 1]);
 
1317
}
 
1318
 
 
1319
static void GLAPIENTRY
 
1320
TAG(VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat *v)
 
1321
{
 
1322
   GET_CURRENT_CONTEXT(ctx);
 
1323
   GLint i;
 
1324
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1325
   for (i = n - 1; i >= 0; i--)
 
1326
      ATTR2F(index + i, v[2 * i], v[2 * i + 1]);
 
1327
}
 
1328
 
 
1329
static void GLAPIENTRY
 
1330
TAG(VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble *v)
 
1331
{
 
1332
   GET_CURRENT_CONTEXT(ctx);
 
1333
   GLint i;
 
1334
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1335
   for (i = n - 1; i >= 0; i--)
 
1336
      ATTR2F(index + i, (GLfloat) v[2 * i], (GLfloat) v[2 * i + 1]);
 
1337
}
 
1338
 
 
1339
static void GLAPIENTRY
 
1340
TAG(VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort *v)
 
1341
{
 
1342
   GET_CURRENT_CONTEXT(ctx);
 
1343
   GLint i;
 
1344
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1345
   for (i = n - 1; i >= 0; i--)
 
1346
      ATTR3F(index + i, (GLfloat) v[3 * i], (GLfloat) v[3 * i + 1], (GLfloat) v[3 * i + 2]);
 
1347
}
 
1348
 
 
1349
static void GLAPIENTRY
 
1350
TAG(VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat *v)
 
1351
{
 
1352
   GET_CURRENT_CONTEXT(ctx);
 
1353
   GLint i;
 
1354
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1355
   for (i = n - 1; i >= 0; i--)
 
1356
      ATTR3F(index + i, v[3 * i], v[3 * i + 1], v[3 * i + 2]);
 
1357
}
 
1358
 
 
1359
static void GLAPIENTRY
 
1360
TAG(VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble *v)
 
1361
{
 
1362
   GET_CURRENT_CONTEXT(ctx);
 
1363
   GLint i;
 
1364
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1365
   for (i = n - 1; i >= 0; i--)
 
1366
      ATTR3F(index + i, (GLfloat) v[3 * i], (GLfloat) v[3 * i + 1], (GLfloat) v[3 * i + 2]);
 
1367
}
 
1368
 
 
1369
static void GLAPIENTRY
 
1370
TAG(VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort *v)
 
1371
{
 
1372
   GET_CURRENT_CONTEXT(ctx);
 
1373
   GLint i;
 
1374
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1375
   for (i = n - 1; i >= 0; i--)
 
1376
      ATTR4F(index + i, (GLfloat) v[4 * i], (GLfloat) v[4 * i + 1], (GLfloat) v[4 * i + 2], (GLfloat) v[4 * i + 3]);
 
1377
}
 
1378
 
 
1379
static void GLAPIENTRY
 
1380
TAG(VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat *v)
 
1381
{
 
1382
   GET_CURRENT_CONTEXT(ctx);
 
1383
   GLint i;
 
1384
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1385
   for (i = n - 1; i >= 0; i--)
 
1386
      ATTR4F(index + i, v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3]);
 
1387
}
 
1388
 
 
1389
static void GLAPIENTRY
 
1390
TAG(VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble *v)
 
1391
{
 
1392
   GET_CURRENT_CONTEXT(ctx);
 
1393
   GLint i;
 
1394
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1395
   for (i = n - 1; i >= 0; i--)
 
1396
      ATTR4F(index + i, (GLfloat) v[4 * i], (GLfloat) v[4 * i + 1], (GLfloat) v[4 * i + 2], (GLfloat) v[4 * i + 3]);
 
1397
}
 
1398
 
 
1399
static void GLAPIENTRY
 
1400
TAG(VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte *v)
 
1401
{
 
1402
   GET_CURRENT_CONTEXT(ctx);
 
1403
   GLint i;
 
1404
   n = MIN2(n, VBO_ATTRIB_MAX - index);
 
1405
   for (i = n - 1; i >= 0; i--)
 
1406
      ATTR4F(index + i, UBYTE_TO_FLOAT(v[4 * i]), UBYTE_TO_FLOAT(v[4 * i + 1]),
 
1407
             UBYTE_TO_FLOAT(v[4 * i + 2]), UBYTE_TO_FLOAT(v[4 * i + 3]));
 
1408
}
 
1409
 
 
1410
 
 
1411
/*
 
1412
 * GL_ARB_vertex_program
 
1413
 * Note that attribute indexes do NOT alias conventional attributes.
 
1414
 */
 
1415
 
 
1416
static void GLAPIENTRY
 
1417
TAG(VertexAttrib1s)(GLuint index, GLshort x)
 
1418
{
 
1419
   GET_CURRENT_CONTEXT(ctx);
 
1420
   if (is_vertex_position(ctx, index))
 
1421
      ATTR1F(0, (GLfloat) x);
 
1422
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1423
      ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x);
 
1424
   else
 
1425
      ERROR(GL_INVALID_VALUE);
 
1426
}
 
1427
 
 
1428
static void GLAPIENTRY
 
1429
TAG(VertexAttrib1d)(GLuint index, GLdouble x)
 
1430
{
 
1431
   GET_CURRENT_CONTEXT(ctx);
 
1432
   if (is_vertex_position(ctx, index))
 
1433
      ATTR1F(0, (GLfloat) x);
 
1434
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1435
      ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x);
 
1436
   else
 
1437
      ERROR(GL_INVALID_VALUE);
 
1438
}
 
1439
 
 
1440
static void GLAPIENTRY
 
1441
TAG(VertexAttrib2s)(GLuint index, GLshort x, GLshort y)
 
1442
{
 
1443
   GET_CURRENT_CONTEXT(ctx);
 
1444
   if (is_vertex_position(ctx, index))
 
1445
      ATTR2F(0, (GLfloat) x, (GLfloat) y);
 
1446
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1447
      ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y);
 
1448
   else
 
1449
      ERROR(GL_INVALID_VALUE);
 
1450
}
 
1451
 
 
1452
static void GLAPIENTRY
 
1453
TAG(VertexAttrib2d)(GLuint index, GLdouble x, GLdouble y)
 
1454
{
 
1455
   GET_CURRENT_CONTEXT(ctx);
 
1456
   if (is_vertex_position(ctx, index))
 
1457
      ATTR2F(0, (GLfloat) x, (GLfloat) y);
 
1458
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1459
      ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y);
 
1460
   else
 
1461
      ERROR(GL_INVALID_VALUE);
 
1462
}
 
1463
 
 
1464
static void GLAPIENTRY
 
1465
TAG(VertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z)
 
1466
{
 
1467
   GET_CURRENT_CONTEXT(ctx);
 
1468
   if (is_vertex_position(ctx, index))
 
1469
      ATTR3F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z);
 
1470
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1471
      ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z);
 
1472
   else
 
1473
      ERROR(GL_INVALID_VALUE);
 
1474
}
 
1475
 
 
1476
static void GLAPIENTRY
 
1477
TAG(VertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 
1478
{
 
1479
   GET_CURRENT_CONTEXT(ctx);
 
1480
   if (is_vertex_position(ctx, index))
 
1481
      ATTR3F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z);
 
1482
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1483
      ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z);
 
1484
   else
 
1485
      ERROR(GL_INVALID_VALUE);
 
1486
}
 
1487
 
 
1488
static void GLAPIENTRY
 
1489
TAG(VertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 
1490
{
 
1491
   GET_CURRENT_CONTEXT(ctx);
 
1492
   if (is_vertex_position(ctx, index))
 
1493
      ATTR4F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 
1494
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1495
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 
1496
   else
 
1497
      ERROR(GL_INVALID_VALUE);
 
1498
}
 
1499
 
 
1500
static void GLAPIENTRY
 
1501
TAG(VertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
1502
{
 
1503
   GET_CURRENT_CONTEXT(ctx);
 
1504
   if (is_vertex_position(ctx, index))
 
1505
      ATTR4F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 
1506
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1507
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 
1508
   else
 
1509
      ERROR(GL_INVALID_VALUE);
 
1510
}
 
1511
 
 
1512
static void GLAPIENTRY
 
1513
TAG(VertexAttrib1sv)(GLuint index, const GLshort *v)
 
1514
{
 
1515
   GET_CURRENT_CONTEXT(ctx);
 
1516
   if (is_vertex_position(ctx, index))
 
1517
      ATTR1F(0, (GLfloat) v[0]);
 
1518
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1519
      ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0]);
 
1520
   else
 
1521
      ERROR(GL_INVALID_VALUE);
 
1522
}
 
1523
 
 
1524
static void GLAPIENTRY
 
1525
TAG(VertexAttrib1dv)(GLuint index, const GLdouble *v)
 
1526
{
 
1527
   GET_CURRENT_CONTEXT(ctx);
 
1528
   if (is_vertex_position(ctx, index))
 
1529
      ATTR1F(0, (GLfloat) v[0]);
 
1530
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1531
      ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0]);
 
1532
   else
 
1533
      ERROR(GL_INVALID_VALUE);
 
1534
}
 
1535
 
 
1536
static void GLAPIENTRY
 
1537
TAG(VertexAttrib2sv)(GLuint index, const GLshort *v)
 
1538
{
 
1539
   GET_CURRENT_CONTEXT(ctx);
 
1540
   if (is_vertex_position(ctx, index))
 
1541
      ATTR2F(0, (GLfloat) v[0], (GLfloat) v[1]);
 
1542
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1543
      ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1]);
 
1544
   else
 
1545
      ERROR(GL_INVALID_VALUE);
 
1546
}
 
1547
 
 
1548
static void GLAPIENTRY
 
1549
TAG(VertexAttrib2dv)(GLuint index, const GLdouble *v)
 
1550
{
 
1551
   GET_CURRENT_CONTEXT(ctx);
 
1552
   if (is_vertex_position(ctx, index))
 
1553
      ATTR2F(0, (GLfloat) v[0], (GLfloat) v[1]);
 
1554
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1555
      ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1]);
 
1556
   else
 
1557
      ERROR(GL_INVALID_VALUE);
 
1558
}
 
1559
 
 
1560
static void GLAPIENTRY
 
1561
TAG(VertexAttrib3sv)(GLuint index, const GLshort *v)
 
1562
{
 
1563
   GET_CURRENT_CONTEXT(ctx);
 
1564
   if (is_vertex_position(ctx, index))
 
1565
      ATTR3F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
 
1566
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1567
      ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
 
1568
   else
 
1569
      ERROR(GL_INVALID_VALUE);
 
1570
}
 
1571
 
 
1572
static void GLAPIENTRY
 
1573
TAG(VertexAttrib3dv)(GLuint index, const GLdouble *v)
 
1574
{
 
1575
   GET_CURRENT_CONTEXT(ctx);
 
1576
   if (is_vertex_position(ctx, index))
 
1577
      ATTR3F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
 
1578
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1579
      ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
 
1580
   else
 
1581
      ERROR(GL_INVALID_VALUE);
 
1582
}
 
1583
 
 
1584
static void GLAPIENTRY
 
1585
TAG(VertexAttrib4sv)(GLuint index, const GLshort *v)
 
1586
{
 
1587
   GET_CURRENT_CONTEXT(ctx);
 
1588
   if (is_vertex_position(ctx, index))
 
1589
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1590
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1591
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1592
   else
 
1593
      ERROR(GL_INVALID_VALUE);
 
1594
}
 
1595
 
 
1596
static void GLAPIENTRY
 
1597
TAG(VertexAttrib4dv)(GLuint index, const GLdouble *v)
 
1598
{
 
1599
   GET_CURRENT_CONTEXT(ctx);
 
1600
   if (is_vertex_position(ctx, index))
 
1601
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1602
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1603
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1604
   else
 
1605
      ERROR(GL_INVALID_VALUE);
 
1606
}
 
1607
 
 
1608
static void GLAPIENTRY
 
1609
TAG(VertexAttrib4bv)(GLuint index, const GLbyte * v)
 
1610
{
 
1611
   GET_CURRENT_CONTEXT(ctx);
 
1612
   if (is_vertex_position(ctx, index))
 
1613
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1614
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1615
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1616
   else
 
1617
      ERROR(GL_INVALID_VALUE);
 
1618
}
 
1619
 
 
1620
static void GLAPIENTRY
 
1621
TAG(VertexAttrib4iv)(GLuint index, const GLint * v)
 
1622
{
 
1623
   GET_CURRENT_CONTEXT(ctx);
 
1624
   if (is_vertex_position(ctx, index))
 
1625
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1626
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1627
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1628
   else
 
1629
      ERROR(GL_INVALID_VALUE);
 
1630
}
 
1631
 
 
1632
static void GLAPIENTRY
 
1633
TAG(VertexAttrib4ubv)(GLuint index, const GLubyte * v)
 
1634
{
 
1635
   GET_CURRENT_CONTEXT(ctx);
 
1636
   if (is_vertex_position(ctx, index))
 
1637
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1638
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1639
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1640
   else
 
1641
      ERROR(GL_INVALID_VALUE);
 
1642
}
 
1643
 
 
1644
static void GLAPIENTRY
 
1645
TAG(VertexAttrib4usv)(GLuint index, const GLushort * v)
 
1646
{
 
1647
   GET_CURRENT_CONTEXT(ctx);
 
1648
   if (is_vertex_position(ctx, index))
 
1649
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1650
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1651
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1652
   else
 
1653
      ERROR(GL_INVALID_VALUE);
 
1654
}
 
1655
 
 
1656
static void GLAPIENTRY
 
1657
TAG(VertexAttrib4uiv)(GLuint index, const GLuint * v)
 
1658
{
 
1659
   GET_CURRENT_CONTEXT(ctx);
 
1660
   if (is_vertex_position(ctx, index))
 
1661
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1662
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1663
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
 
1664
   else
 
1665
      ERROR(GL_INVALID_VALUE);
 
1666
}
 
1667
 
 
1668
static void GLAPIENTRY
 
1669
TAG(VertexAttrib4Nbv)(GLuint index, const GLbyte * v)
 
1670
{
 
1671
   GET_CURRENT_CONTEXT(ctx);
 
1672
   if (is_vertex_position(ctx, index))
 
1673
      ATTR4F(0, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]));
 
1674
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1675
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]));
 
1676
   else
 
1677
      ERROR(GL_INVALID_VALUE);
 
1678
}
 
1679
 
 
1680
static void GLAPIENTRY
 
1681
TAG(VertexAttrib4Nsv)(GLuint index, const GLshort * v)
 
1682
{
 
1683
   GET_CURRENT_CONTEXT(ctx);
 
1684
   if (is_vertex_position(ctx, index))
 
1685
      ATTR4F(0, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]));
 
1686
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1687
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]));
 
1688
   else
 
1689
      ERROR(GL_INVALID_VALUE);
 
1690
}
 
1691
 
 
1692
static void GLAPIENTRY
 
1693
TAG(VertexAttrib4Niv)(GLuint index, const GLint * v)
 
1694
{
 
1695
   GET_CURRENT_CONTEXT(ctx);
 
1696
   if (is_vertex_position(ctx, index))
 
1697
      ATTR4F(0, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]));
 
1698
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1699
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]));
 
1700
   else
 
1701
      ERROR(GL_INVALID_VALUE);
 
1702
}
 
1703
 
 
1704
static void GLAPIENTRY
 
1705
TAG(VertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 
1706
{
 
1707
   GET_CURRENT_CONTEXT(ctx);
 
1708
   if (is_vertex_position(ctx, index))
 
1709
      ATTR4F(0, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y), UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w));
 
1710
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1711
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y), UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w));
 
1712
   else
 
1713
      ERROR(GL_INVALID_VALUE);
 
1714
}
 
1715
 
 
1716
static void GLAPIENTRY
 
1717
TAG(VertexAttrib4Nubv)(GLuint index, const GLubyte * v)
 
1718
{
 
1719
   GET_CURRENT_CONTEXT(ctx);
 
1720
   if (is_vertex_position(ctx, index))
 
1721
      ATTR4F(0, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
 
1722
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1723
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
 
1724
   else
 
1725
      ERROR(GL_INVALID_VALUE);
 
1726
}
 
1727
 
 
1728
static void GLAPIENTRY
 
1729
TAG(VertexAttrib4Nusv)(GLuint index, const GLushort * v)
 
1730
{
 
1731
   GET_CURRENT_CONTEXT(ctx);
 
1732
   if (is_vertex_position(ctx, index))
 
1733
      ATTR4F(0, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]), USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]));
 
1734
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1735
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]), USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]));
 
1736
   else
 
1737
      ERROR(GL_INVALID_VALUE);
 
1738
}
 
1739
 
 
1740
static void GLAPIENTRY
 
1741
TAG(VertexAttrib4Nuiv)(GLuint index, const GLuint * v)
 
1742
{
 
1743
   GET_CURRENT_CONTEXT(ctx);
 
1744
   if (is_vertex_position(ctx, index))
 
1745
      ATTR4F(0, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]), UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]));
 
1746
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1747
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]), UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]));
 
1748
   else
 
1749
      ERROR(GL_INVALID_VALUE);
 
1750
}
 
1751
 
 
1752
/**
 
1753
 * GL_EXT_gpu_shader / GL 3.0 signed/unsigned integer-valued attributes.
 
1754
 * Note that attribute indexes do NOT alias conventional attributes.
 
1755
 */
 
1756
 
 
1757
static void GLAPIENTRY
 
1758
TAG(VertexAttribI1iv)(GLuint index, const GLint *v)
 
1759
{
 
1760
   GET_CURRENT_CONTEXT(ctx);
 
1761
   if (is_vertex_position(ctx, index))
 
1762
      ATTR1I(0, v[0]);
 
1763
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1764
      ATTR1I(VBO_ATTRIB_GENERIC0 + index, v[0]);
 
1765
   else
 
1766
      ERROR(GL_INVALID_VALUE);
 
1767
}
 
1768
 
 
1769
static void GLAPIENTRY
 
1770
TAG(VertexAttribI1uiv)(GLuint index, const GLuint *v)
 
1771
{
 
1772
   GET_CURRENT_CONTEXT(ctx);
 
1773
   if (is_vertex_position(ctx, index))
 
1774
      ATTR1UI(0, v[0]);
 
1775
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1776
      ATTR1UI(VBO_ATTRIB_GENERIC0 + index, v[0]);
 
1777
   else
 
1778
      ERROR(GL_INVALID_VALUE);
 
1779
}
 
1780
 
 
1781
static void GLAPIENTRY
 
1782
TAG(VertexAttribI4bv)(GLuint index, const GLbyte *v)
 
1783
{
 
1784
   GET_CURRENT_CONTEXT(ctx);
 
1785
   if (is_vertex_position(ctx, index))
 
1786
      ATTR4I(0, v[0], v[1], v[2], v[3]);
 
1787
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1788
      ATTR4I(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
 
1789
   else
 
1790
      ERROR(GL_INVALID_VALUE);
 
1791
}
 
1792
 
 
1793
static void GLAPIENTRY
 
1794
TAG(VertexAttribI4sv)(GLuint index, const GLshort *v)
 
1795
{
 
1796
   GET_CURRENT_CONTEXT(ctx);
 
1797
   if (is_vertex_position(ctx, index))
 
1798
      ATTR4I(0, v[0], v[1], v[2], v[3]);
 
1799
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1800
      ATTR4I(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
 
1801
   else
 
1802
      ERROR(GL_INVALID_VALUE);
 
1803
}
 
1804
 
 
1805
static void GLAPIENTRY
 
1806
TAG(VertexAttribI4ubv)(GLuint index, const GLubyte *v)
 
1807
{
 
1808
   GET_CURRENT_CONTEXT(ctx);
 
1809
   if (is_vertex_position(ctx, index))
 
1810
      ATTR4UI(0, v[0], v[1], v[2], v[3]);
 
1811
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1812
      ATTR4UI(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
 
1813
   else
 
1814
      ERROR(GL_INVALID_VALUE);
 
1815
}
 
1816
 
 
1817
static void GLAPIENTRY
 
1818
TAG(VertexAttribI4usv)(GLuint index, const GLushort *v)
 
1819
{
 
1820
   GET_CURRENT_CONTEXT(ctx);
 
1821
   if (is_vertex_position(ctx, index))
 
1822
      ATTR4UI(0, v[0], v[1], v[2], v[3]);
 
1823
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
 
1824
      ATTR4UI(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
 
1825
   else
 
1826
      ERROR(GL_INVALID_VALUE);
 
1827
}
 
1828
 
 
1829
/* define this macro to exclude folllowing none-vertex functions */
 
1830
#ifndef HW_SELECT_MODE
 
1831
 
 
1832
static void GLAPIENTRY
 
1833
TAG(TexCoord1f)(GLfloat x)
 
1834
{
 
1835
   GET_CURRENT_CONTEXT(ctx);
 
1836
   ATTR1F(VBO_ATTRIB_TEX0, x);
 
1837
}
 
1838
 
 
1839
static void GLAPIENTRY
 
1840
TAG(TexCoord1fv)(const GLfloat * v)
 
1841
{
 
1842
   GET_CURRENT_CONTEXT(ctx);
 
1843
   ATTR1FV(VBO_ATTRIB_TEX0, v);
 
1844
}
 
1845
 
 
1846
static void GLAPIENTRY
 
1847
TAG(TexCoord2f)(GLfloat x, GLfloat y)
 
1848
{
 
1849
   GET_CURRENT_CONTEXT(ctx);
 
1850
   ATTR2F(VBO_ATTRIB_TEX0, x, y);
 
1851
}
 
1852
 
 
1853
static void GLAPIENTRY
 
1854
TAG(TexCoord2fv)(const GLfloat * v)
 
1855
{
 
1856
   GET_CURRENT_CONTEXT(ctx);
 
1857
   ATTR2FV(VBO_ATTRIB_TEX0, v);
 
1858
}
 
1859
 
 
1860
static void GLAPIENTRY
 
1861
TAG(TexCoord3f)(GLfloat x, GLfloat y, GLfloat z)
 
1862
{
 
1863
   GET_CURRENT_CONTEXT(ctx);
 
1864
   ATTR3F(VBO_ATTRIB_TEX0, x, y, z);
 
1865
}
 
1866
 
 
1867
static void GLAPIENTRY
 
1868
TAG(TexCoord3fv)(const GLfloat * v)
 
1869
{
 
1870
   GET_CURRENT_CONTEXT(ctx);
 
1871
   ATTR3FV(VBO_ATTRIB_TEX0, v);
 
1872
}
 
1873
 
 
1874
static void GLAPIENTRY
 
1875
TAG(TexCoord4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 
1876
{
 
1877
   GET_CURRENT_CONTEXT(ctx);
 
1878
   ATTR4F(VBO_ATTRIB_TEX0, x, y, z, w);
 
1879
}
 
1880
 
 
1881
static void GLAPIENTRY
 
1882
TAG(TexCoord4fv)(const GLfloat * v)
 
1883
{
 
1884
   GET_CURRENT_CONTEXT(ctx);
 
1885
   ATTR4FV(VBO_ATTRIB_TEX0, v);
 
1886
}
 
1887
 
 
1888
 
 
1889
 
 
1890
static void GLAPIENTRY
 
1891
TAG(Normal3f)(GLfloat x, GLfloat y, GLfloat z)
 
1892
{
 
1893
   GET_CURRENT_CONTEXT(ctx);
 
1894
   ATTR3F(VBO_ATTRIB_NORMAL, x, y, z);
 
1895
}
 
1896
 
 
1897
static void GLAPIENTRY
 
1898
TAG(Normal3fv)(const GLfloat * v)
 
1899
{
 
1900
   GET_CURRENT_CONTEXT(ctx);
 
1901
   ATTR3FV(VBO_ATTRIB_NORMAL, v);
 
1902
}
 
1903
 
 
1904
 
 
1905
 
 
1906
static void GLAPIENTRY
 
1907
TAG(FogCoordfEXT)(GLfloat x)
 
1908
{
 
1909
   GET_CURRENT_CONTEXT(ctx);
 
1910
   ATTR1F(VBO_ATTRIB_FOG, x);
 
1911
}
 
1912
 
 
1913
 
 
1914
 
 
1915
static void GLAPIENTRY
 
1916
TAG(FogCoordfvEXT)(const GLfloat * v)
 
1917
{
 
1918
   GET_CURRENT_CONTEXT(ctx);
 
1919
   ATTR1FV(VBO_ATTRIB_FOG, v);
 
1920
}
 
1921
 
 
1922
static void GLAPIENTRY
 
1923
TAG(Color3f)(GLfloat x, GLfloat y, GLfloat z)
 
1924
{
 
1925
   GET_CURRENT_CONTEXT(ctx);
 
1926
   ATTR3F(VBO_ATTRIB_COLOR0, x, y, z);
 
1927
}
 
1928
 
 
1929
static void GLAPIENTRY
 
1930
TAG(Color3fv)(const GLfloat * v)
 
1931
{
 
1932
   GET_CURRENT_CONTEXT(ctx);
 
1933
   ATTR3FV(VBO_ATTRIB_COLOR0, v);
 
1934
}
 
1935
 
 
1936
static void GLAPIENTRY
 
1937
TAG(Color4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 
1938
{
 
1939
   GET_CURRENT_CONTEXT(ctx);
 
1940
   ATTR4F(VBO_ATTRIB_COLOR0, x, y, z, w);
 
1941
}
 
1942
 
 
1943
static void GLAPIENTRY
 
1944
TAG(Color4fv)(const GLfloat * v)
 
1945
{
 
1946
   GET_CURRENT_CONTEXT(ctx);
 
1947
   ATTR4FV(VBO_ATTRIB_COLOR0, v);
 
1948
}
 
1949
 
 
1950
 
 
1951
 
 
1952
static void GLAPIENTRY
 
1953
TAG(SecondaryColor3fEXT)(GLfloat x, GLfloat y, GLfloat z)
 
1954
{
 
1955
   GET_CURRENT_CONTEXT(ctx);
 
1956
   ATTR3F(VBO_ATTRIB_COLOR1, x, y, z);
 
1957
}
 
1958
 
 
1959
static void GLAPIENTRY
 
1960
TAG(SecondaryColor3fvEXT)(const GLfloat * v)
 
1961
{
 
1962
   GET_CURRENT_CONTEXT(ctx);
 
1963
   ATTR3FV(VBO_ATTRIB_COLOR1, v);
 
1964
}
 
1965
 
 
1966
 
 
1967
 
 
1968
static void GLAPIENTRY
 
1969
TAG(EdgeFlag)(GLboolean b)
 
1970
{
 
1971
   GET_CURRENT_CONTEXT(ctx);
 
1972
   ATTR1F(VBO_ATTRIB_EDGEFLAG, (GLfloat) b);
 
1973
}
 
1974
 
 
1975
 
 
1976
 
 
1977
static void GLAPIENTRY
 
1978
TAG(Indexf)(GLfloat f)
 
1979
{
 
1980
   GET_CURRENT_CONTEXT(ctx);
 
1981
   ATTR1F(VBO_ATTRIB_COLOR_INDEX, f);
 
1982
}
 
1983
 
 
1984
static void GLAPIENTRY
 
1985
TAG(Indexfv)(const GLfloat * f)
 
1986
{
 
1987
   GET_CURRENT_CONTEXT(ctx);
 
1988
   ATTR1FV(VBO_ATTRIB_COLOR_INDEX, f);
 
1989
}
 
1990
 
 
1991
 
 
1992
 
 
1993
static void GLAPIENTRY
 
1994
TAG(MultiTexCoord1fARB)(GLenum target, GLfloat x)
 
1995
{
 
1996
   GET_CURRENT_CONTEXT(ctx);
 
1997
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
 
1998
   ATTR1F(attr, x);
 
1999
}
 
2000
 
 
2001
static void GLAPIENTRY
 
2002
TAG(MultiTexCoord1fvARB)(GLenum target, const GLfloat * v)
 
2003
{
 
2004
   GET_CURRENT_CONTEXT(ctx);
 
2005
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
 
2006
   ATTR1FV(attr, v);
 
2007
}
 
2008
 
 
2009
static void GLAPIENTRY
 
2010
TAG(MultiTexCoord2fARB)(GLenum target, GLfloat x, GLfloat y)
 
2011
{
 
2012
   GET_CURRENT_CONTEXT(ctx);
 
2013
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
 
2014
   ATTR2F(attr, x, y);
 
2015
}
 
2016
 
 
2017
static void GLAPIENTRY
 
2018
TAG(MultiTexCoord2fvARB)(GLenum target, const GLfloat * v)
 
2019
{
 
2020
   GET_CURRENT_CONTEXT(ctx);
 
2021
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
 
2022
   ATTR2FV(attr, v);
 
2023
}
 
2024
 
 
2025
static void GLAPIENTRY
 
2026
TAG(MultiTexCoord3fARB)(GLenum target, GLfloat x, GLfloat y, GLfloat z)
 
2027
{
 
2028
   GET_CURRENT_CONTEXT(ctx);
 
2029
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
 
2030
   ATTR3F(attr, x, y, z);
 
2031
}
 
2032
 
 
2033
static void GLAPIENTRY
 
2034
TAG(MultiTexCoord3fvARB)(GLenum target, const GLfloat * v)
 
2035
{
 
2036
   GET_CURRENT_CONTEXT(ctx);
 
2037
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
 
2038
   ATTR3FV(attr, v);
 
2039
}
 
2040
 
 
2041
static void GLAPIENTRY
 
2042
TAG(MultiTexCoord4fARB)(GLenum target, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 
2043
{
 
2044
   GET_CURRENT_CONTEXT(ctx);
 
2045
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
 
2046
   ATTR4F(attr, x, y, z, w);
 
2047
}
 
2048
 
 
2049
static void GLAPIENTRY
 
2050
TAG(MultiTexCoord4fvARB)(GLenum target, const GLfloat * v)
 
2051
{
 
2052
   GET_CURRENT_CONTEXT(ctx);
 
2053
   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
 
2054
   ATTR4FV(attr, v);
 
2055
}
 
2056
 
 
2057
static void GLAPIENTRY
874
2058
TAG(TexCoordP1ui)(GLenum type, GLuint coords)
875
2059
{
876
2060
   GET_CURRENT_CONTEXT(ctx);
1071
2255
}
1072
2256
 
1073
2257
static void GLAPIENTRY
1074
 
TAG(VertexAttribP1ui)(GLuint index, GLenum type, GLboolean normalized,
1075
 
                      GLuint value)
1076
 
{
1077
 
   GET_CURRENT_CONTEXT(ctx);
1078
 
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP1ui");
1079
 
   ATTR_UI_INDEX(ctx, 1, type, normalized, index, value);
1080
 
}
1081
 
 
1082
 
static void GLAPIENTRY
1083
 
TAG(VertexAttribP2ui)(GLuint index, GLenum type, GLboolean normalized,
1084
 
                      GLuint value)
1085
 
{
1086
 
   GET_CURRENT_CONTEXT(ctx);
1087
 
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP2ui");
1088
 
   ATTR_UI_INDEX(ctx, 2, type, normalized, index, value);
1089
 
}
1090
 
 
1091
 
static void GLAPIENTRY
1092
 
TAG(VertexAttribP3ui)(GLuint index, GLenum type, GLboolean normalized,
1093
 
                      GLuint value)
1094
 
{
1095
 
   GET_CURRENT_CONTEXT(ctx);
1096
 
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP3ui");
1097
 
   ATTR_UI_INDEX(ctx, 3, type, normalized, index, value);
1098
 
}
1099
 
 
1100
 
static void GLAPIENTRY
1101
 
TAG(VertexAttribP4ui)(GLuint index, GLenum type, GLboolean normalized,
1102
 
                      GLuint value)
1103
 
{
1104
 
   GET_CURRENT_CONTEXT(ctx);
1105
 
   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexAttribP4ui");
1106
 
   ATTR_UI_INDEX(ctx, 4, type, normalized, index, value);
1107
 
}
1108
 
 
1109
 
static void GLAPIENTRY
1110
 
TAG(VertexAttribP1uiv)(GLuint index, GLenum type, GLboolean normalized,
1111
 
                       const GLuint *value)
1112
 
{
1113
 
   GET_CURRENT_CONTEXT(ctx);
1114
 
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP1uiv");
1115
 
   ATTR_UI_INDEX(ctx, 1, type, normalized, index, *value);
1116
 
}
1117
 
 
1118
 
static void GLAPIENTRY
1119
 
TAG(VertexAttribP2uiv)(GLuint index, GLenum type, GLboolean normalized,
1120
 
                       const GLuint *value)
1121
 
{
1122
 
   GET_CURRENT_CONTEXT(ctx);
1123
 
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP2uiv");
1124
 
   ATTR_UI_INDEX(ctx, 2, type, normalized, index, *value);
1125
 
}
1126
 
 
1127
 
static void GLAPIENTRY
1128
 
TAG(VertexAttribP3uiv)(GLuint index, GLenum type, GLboolean normalized,
1129
 
                       const GLuint *value)
1130
 
{
1131
 
   GET_CURRENT_CONTEXT(ctx);
1132
 
   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP3uiv");
1133
 
   ATTR_UI_INDEX(ctx, 3, type, normalized, index, *value);
1134
 
}
1135
 
 
1136
 
static void GLAPIENTRY
1137
 
TAG(VertexAttribP4uiv)(GLuint index, GLenum type, GLboolean normalized,
1138
 
                      const GLuint *value)
1139
 
{
1140
 
   GET_CURRENT_CONTEXT(ctx);
1141
 
   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexAttribP4uiv");
1142
 
   ATTR_UI_INDEX(ctx, 4, type, normalized, index, *value);
1143
 
}
1144
 
 
1145
 
 
1146
 
 
1147
 
static void GLAPIENTRY
1148
 
TAG(VertexAttribL1d)(GLuint index, GLdouble x)
1149
 
{
1150
 
   GET_CURRENT_CONTEXT(ctx);
1151
 
   if (is_vertex_position(ctx, index))
1152
 
      ATTR1D(0, x);
1153
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1154
 
      ATTR1D(VBO_ATTRIB_GENERIC0 + index, x);
1155
 
   else
1156
 
      ERROR(GL_INVALID_VALUE);
1157
 
}
1158
 
 
1159
 
static void GLAPIENTRY
1160
 
TAG(VertexAttribL1dv)(GLuint index, const GLdouble * v)
1161
 
{
1162
 
   GET_CURRENT_CONTEXT(ctx);
1163
 
   if (is_vertex_position(ctx, index))
1164
 
      ATTR1DV(0, v);
1165
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1166
 
      ATTR1DV(VBO_ATTRIB_GENERIC0 + index, v);
1167
 
   else
1168
 
      ERROR(GL_INVALID_VALUE);
1169
 
}
1170
 
 
1171
 
static void GLAPIENTRY
1172
 
TAG(VertexAttribL2d)(GLuint index, GLdouble x, GLdouble y)
1173
 
{
1174
 
   GET_CURRENT_CONTEXT(ctx);
1175
 
   if (is_vertex_position(ctx, index))
1176
 
      ATTR2D(0, x, y);
1177
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1178
 
      ATTR2D(VBO_ATTRIB_GENERIC0 + index, x, y);
1179
 
   else
1180
 
      ERROR(GL_INVALID_VALUE);
1181
 
}
1182
 
 
1183
 
static void GLAPIENTRY
1184
 
TAG(VertexAttribL2dv)(GLuint index, const GLdouble * v)
1185
 
{
1186
 
   GET_CURRENT_CONTEXT(ctx);
1187
 
   if (is_vertex_position(ctx, index))
1188
 
      ATTR2DV(0, v);
1189
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1190
 
      ATTR2DV(VBO_ATTRIB_GENERIC0 + index, v);
1191
 
   else
1192
 
      ERROR(GL_INVALID_VALUE);
1193
 
}
1194
 
 
1195
 
static void GLAPIENTRY
1196
 
TAG(VertexAttribL3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
1197
 
{
1198
 
   GET_CURRENT_CONTEXT(ctx);
1199
 
   if (is_vertex_position(ctx, index))
1200
 
      ATTR3D(0, x, y, z);
1201
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1202
 
      ATTR3D(VBO_ATTRIB_GENERIC0 + index, x, y, z);
1203
 
   else
1204
 
      ERROR(GL_INVALID_VALUE);
1205
 
}
1206
 
 
1207
 
static void GLAPIENTRY
1208
 
TAG(VertexAttribL3dv)(GLuint index, const GLdouble * v)
1209
 
{
1210
 
   GET_CURRENT_CONTEXT(ctx);
1211
 
   if (is_vertex_position(ctx, index))
1212
 
      ATTR3DV(0, v);
1213
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1214
 
      ATTR3DV(VBO_ATTRIB_GENERIC0 + index, v);
1215
 
   else
1216
 
      ERROR(GL_INVALID_VALUE);
1217
 
}
1218
 
 
1219
 
static void GLAPIENTRY
1220
 
TAG(VertexAttribL4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1221
 
{
1222
 
   GET_CURRENT_CONTEXT(ctx);
1223
 
   if (is_vertex_position(ctx, index))
1224
 
      ATTR4D(0, x, y, z, w);
1225
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1226
 
      ATTR4D(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
1227
 
   else
1228
 
      ERROR(GL_INVALID_VALUE);
1229
 
}
1230
 
 
1231
 
static void GLAPIENTRY
1232
 
TAG(VertexAttribL4dv)(GLuint index, const GLdouble * v)
1233
 
{
1234
 
   GET_CURRENT_CONTEXT(ctx);
1235
 
   if (is_vertex_position(ctx, index))
1236
 
      ATTR4DV(0, v);
1237
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1238
 
      ATTR4DV(VBO_ATTRIB_GENERIC0 + index, v);
1239
 
   else
1240
 
      ERROR(GL_INVALID_VALUE);
1241
 
}
1242
 
 
1243
 
static void GLAPIENTRY
1244
 
TAG(VertexAttribL1ui64ARB)(GLuint index, GLuint64EXT x)
1245
 
{
1246
 
   GET_CURRENT_CONTEXT(ctx);
1247
 
   if (is_vertex_position(ctx, index))
1248
 
      ATTR1UI64(0, x);
1249
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1250
 
      ATTR1UI64(VBO_ATTRIB_GENERIC0 + index, x);
1251
 
   else
1252
 
      ERROR(GL_INVALID_VALUE);
1253
 
}
1254
 
 
1255
 
static void GLAPIENTRY
1256
 
TAG(VertexAttribL1ui64vARB)(GLuint index, const GLuint64EXT *v)
1257
 
{
1258
 
   GET_CURRENT_CONTEXT(ctx);
1259
 
   if (is_vertex_position(ctx, index))
1260
 
      ATTR1UIV64(0, v);
1261
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1262
 
      ATTR1UIV64(VBO_ATTRIB_GENERIC0 + index, v);
1263
 
   else
1264
 
      ERROR(GL_INVALID_VALUE);
1265
 
}
1266
 
 
1267
 
/* GL_NV_half_float */
1268
 
static void GLAPIENTRY
1269
 
TAG(Vertex2hNV)(GLhalfNV x, GLhalfNV y)
1270
 
{
1271
 
   GET_CURRENT_CONTEXT(ctx);
1272
 
   ATTR2H(VBO_ATTRIB_POS, x, y);
1273
 
}
1274
 
 
1275
 
static void GLAPIENTRY
1276
 
TAG(Vertex2hvNV)(const GLhalfNV * v)
1277
 
{
1278
 
   GET_CURRENT_CONTEXT(ctx);
1279
 
   ATTR2HV(VBO_ATTRIB_POS, v);
1280
 
}
1281
 
 
1282
 
static void GLAPIENTRY
1283
 
TAG(Vertex3hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z)
1284
 
{
1285
 
   GET_CURRENT_CONTEXT(ctx);
1286
 
   ATTR3H(VBO_ATTRIB_POS, x, y, z);
1287
 
}
1288
 
 
1289
 
static void GLAPIENTRY
1290
 
TAG(Vertex3hvNV)(const GLhalfNV * v)
1291
 
{
1292
 
   GET_CURRENT_CONTEXT(ctx);
1293
 
   ATTR3HV(VBO_ATTRIB_POS, v);
1294
 
}
1295
 
 
1296
 
static void GLAPIENTRY
1297
 
TAG(Vertex4hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
1298
 
{
1299
 
   GET_CURRENT_CONTEXT(ctx);
1300
 
   ATTR4H(VBO_ATTRIB_POS, x, y, z, w);
1301
 
}
1302
 
 
1303
 
static void GLAPIENTRY
1304
 
TAG(Vertex4hvNV)(const GLhalfNV * v)
1305
 
{
1306
 
   GET_CURRENT_CONTEXT(ctx);
1307
 
   ATTR4HV(VBO_ATTRIB_POS, v);
1308
 
}
1309
 
 
1310
 
 
1311
 
 
1312
 
static void GLAPIENTRY
1313
2258
TAG(Normal3hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z)
1314
2259
{
1315
2260
   GET_CURRENT_CONTEXT(ctx);
1478
2423
}
1479
2424
 
1480
2425
 
1481
 
 
1482
 
static void GLAPIENTRY
1483
 
TAG(VertexAttrib1hNV)(GLuint index, GLhalfNV x)
1484
 
{
1485
 
   GET_CURRENT_CONTEXT(ctx);
1486
 
   if (is_vertex_position(ctx, index))
1487
 
      ATTR1H(0, x);
1488
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1489
 
      ATTR1H(VBO_ATTRIB_GENERIC0 + index, x);
1490
 
   else
1491
 
      ERROR(GL_INVALID_VALUE);
1492
 
}
1493
 
 
1494
 
static void GLAPIENTRY
1495
 
TAG(VertexAttrib2hNV)(GLuint index, GLhalfNV x, GLhalfNV y)
1496
 
{
1497
 
   GET_CURRENT_CONTEXT(ctx);
1498
 
   if (is_vertex_position(ctx, index))
1499
 
      ATTR2H(0, x, y);
1500
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1501
 
      ATTR2H(VBO_ATTRIB_GENERIC0 + index, x, y);
1502
 
   else
1503
 
      ERROR(GL_INVALID_VALUE);
1504
 
}
1505
 
 
1506
 
static void GLAPIENTRY
1507
 
TAG(VertexAttrib3hNV)(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z)
1508
 
{
1509
 
   GET_CURRENT_CONTEXT(ctx);
1510
 
   if (is_vertex_position(ctx, index))
1511
 
      ATTR3H(0, x, y, z);
1512
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1513
 
      ATTR3H(VBO_ATTRIB_GENERIC0 + index, x, y, z);
1514
 
   else
1515
 
      ERROR(GL_INVALID_VALUE);
1516
 
}
1517
 
 
1518
 
static void GLAPIENTRY
1519
 
TAG(VertexAttrib4hNV)(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
1520
 
{
1521
 
   GET_CURRENT_CONTEXT(ctx);
1522
 
   if (is_vertex_position(ctx, index))
1523
 
      ATTR4H(0, x, y, z, w);
1524
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1525
 
      ATTR4H(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
1526
 
   else
1527
 
      ERROR(GL_INVALID_VALUE);
1528
 
}
1529
 
 
1530
 
static void GLAPIENTRY
1531
 
TAG(VertexAttrib1hvNV)(GLuint index, const GLhalfNV * v)
1532
 
{
1533
 
   GET_CURRENT_CONTEXT(ctx);
1534
 
   if (is_vertex_position(ctx, index))
1535
 
      ATTR1HV(0, v);
1536
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1537
 
      ATTR1HV(VBO_ATTRIB_GENERIC0 + index, v);
1538
 
   else
1539
 
      ERROR(GL_INVALID_VALUE);
1540
 
}
1541
 
 
1542
 
static void GLAPIENTRY
1543
 
TAG(VertexAttrib2hvNV)(GLuint index, const GLhalfNV * v)
1544
 
{
1545
 
   GET_CURRENT_CONTEXT(ctx);
1546
 
   if (is_vertex_position(ctx, index))
1547
 
      ATTR2HV(0, v);
1548
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1549
 
      ATTR2HV(VBO_ATTRIB_GENERIC0 + index, v);
1550
 
   else
1551
 
      ERROR(GL_INVALID_VALUE);
1552
 
}
1553
 
 
1554
 
static void GLAPIENTRY
1555
 
TAG(VertexAttrib3hvNV)(GLuint index, const GLhalfNV * v)
1556
 
{
1557
 
   GET_CURRENT_CONTEXT(ctx);
1558
 
   if (is_vertex_position(ctx, index))
1559
 
      ATTR3HV(0, v);
1560
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1561
 
      ATTR3HV(VBO_ATTRIB_GENERIC0 + index, v);
1562
 
   else
1563
 
      ERROR(GL_INVALID_VALUE);
1564
 
}
1565
 
 
1566
 
static void GLAPIENTRY
1567
 
TAG(VertexAttrib4hvNV)(GLuint index, const GLhalfNV * v)
1568
 
{
1569
 
   GET_CURRENT_CONTEXT(ctx);
1570
 
   if (is_vertex_position(ctx, index))
1571
 
      ATTR4HV(0, v);
1572
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1573
 
      ATTR4HV(VBO_ATTRIB_GENERIC0 + index, v);
1574
 
   else
1575
 
      ERROR(GL_INVALID_VALUE);
1576
 
}
1577
 
 
1578
 
static void GLAPIENTRY
1579
 
TAG(VertexAttribs1hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
1580
 
{
1581
 
   GET_CURRENT_CONTEXT(ctx);
1582
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
1583
 
   for (GLint i = n - 1; i >= 0; i--)
1584
 
      ATTR1H(index + i, v[i]);
1585
 
}
1586
 
 
1587
 
static void GLAPIENTRY
1588
 
TAG(VertexAttribs2hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
1589
 
{
1590
 
   GET_CURRENT_CONTEXT(ctx);
1591
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
1592
 
   for (GLint i = n - 1; i >= 0; i--)
1593
 
      ATTR2H(index + i, v[2 * i], v[2 * i + 1]);
1594
 
}
1595
 
 
1596
 
static void GLAPIENTRY
1597
 
TAG(VertexAttribs3hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
1598
 
{
1599
 
   GET_CURRENT_CONTEXT(ctx);
1600
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
1601
 
   for (GLint i = n - 1; i >= 0; i--)
1602
 
      ATTR3H(index + i, v[3 * i], v[3 * i + 1], v[3 * i + 2]);
1603
 
}
1604
 
 
1605
 
 
1606
 
static void GLAPIENTRY
1607
 
TAG(VertexAttribs4hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
1608
 
{
1609
 
   GET_CURRENT_CONTEXT(ctx);
1610
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
1611
 
   for (GLint i = n - 1; i >= 0; i--)
1612
 
      ATTR4H(index + i, v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3]);
1613
 
}
1614
 
 
1615
 
 
1616
 
 
1617
2426
static void GLAPIENTRY
1618
2427
TAG(FogCoordhNV)(GLhalf x)
1619
2428
{
2182
2991
}
2183
2992
 
2184
2993
static void GLAPIENTRY
2185
 
TAG(Vertex2d)(GLdouble x, GLdouble y)
2186
 
{
2187
 
   GET_CURRENT_CONTEXT(ctx);
2188
 
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y);
2189
 
}
2190
 
 
2191
 
static void GLAPIENTRY
2192
 
TAG(Vertex2i)(GLint x, GLint y)
2193
 
{
2194
 
   GET_CURRENT_CONTEXT(ctx);
2195
 
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y);
2196
 
}
2197
 
 
2198
 
static void GLAPIENTRY
2199
 
TAG(Vertex2s)(GLshort x, GLshort y)
2200
 
{
2201
 
   GET_CURRENT_CONTEXT(ctx);
2202
 
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y);
2203
 
}
2204
 
 
2205
 
static void GLAPIENTRY
2206
 
TAG(Vertex3d)(GLdouble x, GLdouble y, GLdouble z)
2207
 
{
2208
 
   GET_CURRENT_CONTEXT(ctx);
2209
 
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z);
2210
 
}
2211
 
 
2212
 
static void GLAPIENTRY
2213
 
TAG(Vertex3i)(GLint x, GLint y, GLint z)
2214
 
{
2215
 
   GET_CURRENT_CONTEXT(ctx);
2216
 
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z);
2217
 
}
2218
 
 
2219
 
static void GLAPIENTRY
2220
 
TAG(Vertex3s)(GLshort x, GLshort y, GLshort z)
2221
 
{
2222
 
   GET_CURRENT_CONTEXT(ctx);
2223
 
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z);
2224
 
}
2225
 
 
2226
 
static void GLAPIENTRY
2227
 
TAG(Vertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2228
 
{
2229
 
   GET_CURRENT_CONTEXT(ctx);
2230
 
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
2231
 
}
2232
 
 
2233
 
static void GLAPIENTRY
2234
 
TAG(Vertex4i)(GLint x, GLint y, GLint z, GLint w)
2235
 
{
2236
 
   GET_CURRENT_CONTEXT(ctx);
2237
 
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
2238
 
}
2239
 
 
2240
 
static void GLAPIENTRY
2241
 
TAG(Vertex4s)(GLshort x, GLshort y, GLshort z, GLshort w)
2242
 
{
2243
 
   GET_CURRENT_CONTEXT(ctx);
2244
 
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
2245
 
}
2246
 
 
2247
 
static void GLAPIENTRY
2248
 
TAG(Vertex2dv)(const GLdouble *v)
2249
 
{
2250
 
   GET_CURRENT_CONTEXT(ctx);
2251
 
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1]);
2252
 
}
2253
 
 
2254
 
static void GLAPIENTRY
2255
 
TAG(Vertex2iv)(const GLint *v)
2256
 
{
2257
 
   GET_CURRENT_CONTEXT(ctx);
2258
 
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1]);
2259
 
}
2260
 
 
2261
 
static void GLAPIENTRY
2262
 
TAG(Vertex2sv)(const GLshort *v)
2263
 
{
2264
 
   GET_CURRENT_CONTEXT(ctx);
2265
 
   ATTR2F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1]);
2266
 
}
2267
 
 
2268
 
static void GLAPIENTRY
2269
 
TAG(Vertex3dv)(const GLdouble *v)
2270
 
{
2271
 
   GET_CURRENT_CONTEXT(ctx);
2272
 
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
2273
 
}
2274
 
 
2275
 
static void GLAPIENTRY
2276
 
TAG(Vertex3iv)(const GLint *v)
2277
 
{
2278
 
   GET_CURRENT_CONTEXT(ctx);
2279
 
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
2280
 
}
2281
 
 
2282
 
static void GLAPIENTRY
2283
 
TAG(Vertex3sv)(const GLshort *v)
2284
 
{
2285
 
   GET_CURRENT_CONTEXT(ctx);
2286
 
   ATTR3F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
2287
 
}
2288
 
 
2289
 
static void GLAPIENTRY
2290
 
TAG(Vertex4dv)(const GLdouble *v)
2291
 
{
2292
 
   GET_CURRENT_CONTEXT(ctx);
2293
 
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1],
2294
 
         (GLfloat) v[2], (GLfloat) v[3]);
2295
 
}
2296
 
 
2297
 
static void GLAPIENTRY
2298
 
TAG(Vertex4iv)(const GLint *v)
2299
 
{
2300
 
   GET_CURRENT_CONTEXT(ctx);
2301
 
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1],
2302
 
         (GLfloat) v[2], (GLfloat) v[3]);
2303
 
}
2304
 
 
2305
 
static void GLAPIENTRY
2306
 
TAG(Vertex4sv)(const GLshort *v)
2307
 
{
2308
 
   GET_CURRENT_CONTEXT(ctx);
2309
 
   ATTR4F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1],
2310
 
         (GLfloat) v[2], (GLfloat) v[3]);
2311
 
}
2312
 
 
2313
 
static void GLAPIENTRY
2314
2994
TAG(MultiTexCoord1d)(GLenum target, GLdouble s)
2315
2995
{
2316
2996
   GET_CURRENT_CONTEXT(ctx);
2696
3376
         UBYTE_TO_FLOAT(v[2]));
2697
3377
}
2698
3378
 
2699
 
 
2700
 
/*
2701
 
 * GL_NV_vertex_program:
2702
 
 * Note that attribute indexes DO alias conventional vertex attributes.
2703
 
 */
2704
 
 
2705
 
static void GLAPIENTRY
2706
 
TAG(VertexAttrib1sNV)(GLuint index, GLshort x)
2707
 
{
2708
 
   GET_CURRENT_CONTEXT(ctx);
2709
 
   if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) x);
2710
 
}
2711
 
 
2712
 
static void GLAPIENTRY
2713
 
TAG(VertexAttrib1dNV)(GLuint index, GLdouble x)
2714
 
{
2715
 
   GET_CURRENT_CONTEXT(ctx);
2716
 
   if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) x);
2717
 
}
2718
 
 
2719
 
static void GLAPIENTRY
2720
 
TAG(VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y)
2721
 
{
2722
 
   GET_CURRENT_CONTEXT(ctx);
2723
 
   if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) x, y);
2724
 
}
2725
 
 
2726
 
static void GLAPIENTRY
2727
 
TAG(VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y)
2728
 
{
2729
 
   GET_CURRENT_CONTEXT(ctx);
2730
 
   if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) x, (GLfloat) y);
2731
 
}
2732
 
 
2733
 
static void GLAPIENTRY
2734
 
TAG(VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z)
2735
 
{
2736
 
   GET_CURRENT_CONTEXT(ctx);
2737
 
   if (index < VBO_ATTRIB_MAX) ATTR3F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z);
2738
 
}
2739
 
 
2740
 
static void GLAPIENTRY
2741
 
TAG(VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
2742
 
{
2743
 
   GET_CURRENT_CONTEXT(ctx);
2744
 
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
2745
 
}
2746
 
 
2747
 
static void GLAPIENTRY
2748
 
TAG(VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
2749
 
{
2750
 
   GET_CURRENT_CONTEXT(ctx);
2751
 
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
2752
 
}
2753
 
 
2754
 
static void GLAPIENTRY
2755
 
TAG(VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2756
 
{
2757
 
   GET_CURRENT_CONTEXT(ctx);
2758
 
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
2759
 
}
2760
 
 
2761
 
static void GLAPIENTRY
2762
 
TAG(VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
2763
 
{
2764
 
   GET_CURRENT_CONTEXT(ctx);
2765
 
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y),
2766
 
                                      UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w));
2767
 
}
2768
 
 
2769
 
static void GLAPIENTRY
2770
 
TAG(VertexAttrib1svNV)(GLuint index, const GLshort *v)
2771
 
{
2772
 
   GET_CURRENT_CONTEXT(ctx);
2773
 
   if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) v[0]);
2774
 
}
2775
 
 
2776
 
static void GLAPIENTRY
2777
 
TAG(VertexAttrib1dvNV)(GLuint index, const GLdouble *v)
2778
 
{
2779
 
   GET_CURRENT_CONTEXT(ctx);
2780
 
   if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) v[0]);
2781
 
}
2782
 
 
2783
 
static void GLAPIENTRY
2784
 
TAG(VertexAttrib2svNV)(GLuint index, const GLshort *v)
2785
 
{
2786
 
   GET_CURRENT_CONTEXT(ctx);
2787
 
   if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) v[0], (GLfloat) v[1]);
2788
 
}
2789
 
 
2790
 
static void GLAPIENTRY
2791
 
TAG(VertexAttrib2dvNV)(GLuint index, const GLdouble *v)
2792
 
{
2793
 
   GET_CURRENT_CONTEXT(ctx);
2794
 
   if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) v[0], (GLfloat) v[1]);
2795
 
}
2796
 
 
2797
 
static void GLAPIENTRY
2798
 
TAG(VertexAttrib3svNV)(GLuint index, const GLshort *v)
2799
 
{
2800
 
   GET_CURRENT_CONTEXT(ctx);
2801
 
   if (index < VBO_ATTRIB_MAX) ATTR3F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
2802
 
}
2803
 
 
2804
 
static void GLAPIENTRY
2805
 
TAG(VertexAttrib3dvNV)(GLuint index, const GLdouble *v)
2806
 
{
2807
 
   GET_CURRENT_CONTEXT(ctx);
2808
 
   if (index < VBO_ATTRIB_MAX) ATTR3F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
2809
 
}
2810
 
 
2811
 
static void GLAPIENTRY
2812
 
TAG(VertexAttrib4svNV)(GLuint index, const GLshort *v)
2813
 
{
2814
 
   GET_CURRENT_CONTEXT(ctx);
2815
 
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2],
2816
 
         (GLfloat)v[3]);
2817
 
}
2818
 
 
2819
 
static void GLAPIENTRY
2820
 
TAG(VertexAttrib4dvNV)(GLuint index, const GLdouble *v)
2821
 
{
2822
 
   GET_CURRENT_CONTEXT(ctx);
2823
 
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
2824
 
}
2825
 
 
2826
 
static void GLAPIENTRY
2827
 
TAG(VertexAttrib4ubvNV)(GLuint index, const GLubyte *v)
2828
 
{
2829
 
   GET_CURRENT_CONTEXT(ctx);
2830
 
   if (index < VBO_ATTRIB_MAX) ATTR4F(index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]),
2831
 
         UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
2832
 
}
2833
 
 
2834
 
 
2835
 
static void GLAPIENTRY
2836
 
TAG(VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort *v)
2837
 
{
2838
 
   GET_CURRENT_CONTEXT(ctx);
2839
 
   GLint i;
2840
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2841
 
   for (i = n - 1; i >= 0; i--)
2842
 
      ATTR1F(index + i, (GLfloat) v[i]);
2843
 
}
2844
 
 
2845
 
static void GLAPIENTRY
2846
 
TAG(VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat *v)
2847
 
{
2848
 
   GET_CURRENT_CONTEXT(ctx);
2849
 
   GLint i;
2850
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2851
 
   for (i = n - 1; i >= 0; i--)
2852
 
      ATTR1F(index + i, v[i]);
2853
 
}
2854
 
 
2855
 
static void GLAPIENTRY
2856
 
TAG(VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble *v)
2857
 
{
2858
 
   GET_CURRENT_CONTEXT(ctx);
2859
 
   GLint i;
2860
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2861
 
   for (i = n - 1; i >= 0; i--)
2862
 
      ATTR1F(index + i, (GLfloat) v[i]);
2863
 
}
2864
 
 
2865
 
static void GLAPIENTRY
2866
 
TAG(VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort *v)
2867
 
{
2868
 
   GET_CURRENT_CONTEXT(ctx);
2869
 
   GLint i;
2870
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2871
 
   for (i = n - 1; i >= 0; i--)
2872
 
      ATTR2F(index + i, (GLfloat) v[2 * i], (GLfloat) v[2 * i + 1]);
2873
 
}
2874
 
 
2875
 
static void GLAPIENTRY
2876
 
TAG(VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat *v)
2877
 
{
2878
 
   GET_CURRENT_CONTEXT(ctx);
2879
 
   GLint i;
2880
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2881
 
   for (i = n - 1; i >= 0; i--)
2882
 
      ATTR2F(index + i, v[2 * i], v[2 * i + 1]);
2883
 
}
2884
 
 
2885
 
static void GLAPIENTRY
2886
 
TAG(VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble *v)
2887
 
{
2888
 
   GET_CURRENT_CONTEXT(ctx);
2889
 
   GLint i;
2890
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2891
 
   for (i = n - 1; i >= 0; i--)
2892
 
      ATTR2F(index + i, (GLfloat) v[2 * i], (GLfloat) v[2 * i + 1]);
2893
 
}
2894
 
 
2895
 
static void GLAPIENTRY
2896
 
TAG(VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort *v)
2897
 
{
2898
 
   GET_CURRENT_CONTEXT(ctx);
2899
 
   GLint i;
2900
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2901
 
   for (i = n - 1; i >= 0; i--)
2902
 
      ATTR3F(index + i, (GLfloat) v[3 * i], (GLfloat) v[3 * i + 1], (GLfloat) v[3 * i + 2]);
2903
 
}
2904
 
 
2905
 
static void GLAPIENTRY
2906
 
TAG(VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat *v)
2907
 
{
2908
 
   GET_CURRENT_CONTEXT(ctx);
2909
 
   GLint i;
2910
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2911
 
   for (i = n - 1; i >= 0; i--)
2912
 
      ATTR3F(index + i, v[3 * i], v[3 * i + 1], v[3 * i + 2]);
2913
 
}
2914
 
 
2915
 
static void GLAPIENTRY
2916
 
TAG(VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble *v)
2917
 
{
2918
 
   GET_CURRENT_CONTEXT(ctx);
2919
 
   GLint i;
2920
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2921
 
   for (i = n - 1; i >= 0; i--)
2922
 
      ATTR3F(index + i, (GLfloat) v[3 * i], (GLfloat) v[3 * i + 1], (GLfloat) v[3 * i + 2]);
2923
 
}
2924
 
 
2925
 
static void GLAPIENTRY
2926
 
TAG(VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort *v)
2927
 
{
2928
 
   GET_CURRENT_CONTEXT(ctx);
2929
 
   GLint i;
2930
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2931
 
   for (i = n - 1; i >= 0; i--)
2932
 
      ATTR4F(index + i, (GLfloat) v[4 * i], (GLfloat) v[4 * i + 1], (GLfloat) v[4 * i + 2], (GLfloat) v[4 * i + 3]);
2933
 
}
2934
 
 
2935
 
static void GLAPIENTRY
2936
 
TAG(VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat *v)
2937
 
{
2938
 
   GET_CURRENT_CONTEXT(ctx);
2939
 
   GLint i;
2940
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2941
 
   for (i = n - 1; i >= 0; i--)
2942
 
      ATTR4F(index + i, v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3]);
2943
 
}
2944
 
 
2945
 
static void GLAPIENTRY
2946
 
TAG(VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble *v)
2947
 
{
2948
 
   GET_CURRENT_CONTEXT(ctx);
2949
 
   GLint i;
2950
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2951
 
   for (i = n - 1; i >= 0; i--)
2952
 
      ATTR4F(index + i, (GLfloat) v[4 * i], (GLfloat) v[4 * i + 1], (GLfloat) v[4 * i + 2], (GLfloat) v[4 * i + 3]);
2953
 
}
2954
 
 
2955
 
static void GLAPIENTRY
2956
 
TAG(VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte *v)
2957
 
{
2958
 
   GET_CURRENT_CONTEXT(ctx);
2959
 
   GLint i;
2960
 
   n = MIN2(n, VBO_ATTRIB_MAX - index);
2961
 
   for (i = n - 1; i >= 0; i--)
2962
 
      ATTR4F(index + i, UBYTE_TO_FLOAT(v[4 * i]), UBYTE_TO_FLOAT(v[4 * i + 1]),
2963
 
             UBYTE_TO_FLOAT(v[4 * i + 2]), UBYTE_TO_FLOAT(v[4 * i + 3]));
2964
 
}
2965
 
 
2966
 
 
2967
 
/*
2968
 
 * GL_ARB_vertex_program
2969
 
 * Note that attribute indexes do NOT alias conventional attributes.
2970
 
 */
2971
 
 
2972
 
static void GLAPIENTRY
2973
 
TAG(VertexAttrib1s)(GLuint index, GLshort x)
2974
 
{
2975
 
   GET_CURRENT_CONTEXT(ctx);
2976
 
   if (is_vertex_position(ctx, index))
2977
 
      ATTR1F(0, (GLfloat) x);
2978
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
2979
 
      ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x);
2980
 
   else
2981
 
      ERROR(GL_INVALID_VALUE);
2982
 
}
2983
 
 
2984
 
static void GLAPIENTRY
2985
 
TAG(VertexAttrib1d)(GLuint index, GLdouble x)
2986
 
{
2987
 
   GET_CURRENT_CONTEXT(ctx);
2988
 
   if (is_vertex_position(ctx, index))
2989
 
      ATTR1F(0, (GLfloat) x);
2990
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
2991
 
      ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x);
2992
 
   else
2993
 
      ERROR(GL_INVALID_VALUE);
2994
 
}
2995
 
 
2996
 
static void GLAPIENTRY
2997
 
TAG(VertexAttrib2s)(GLuint index, GLshort x, GLshort y)
2998
 
{
2999
 
   GET_CURRENT_CONTEXT(ctx);
3000
 
   if (is_vertex_position(ctx, index))
3001
 
      ATTR2F(0, (GLfloat) x, (GLfloat) y);
3002
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3003
 
      ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y);
3004
 
   else
3005
 
      ERROR(GL_INVALID_VALUE);
3006
 
}
3007
 
 
3008
 
static void GLAPIENTRY
3009
 
TAG(VertexAttrib2d)(GLuint index, GLdouble x, GLdouble y)
3010
 
{
3011
 
   GET_CURRENT_CONTEXT(ctx);
3012
 
   if (is_vertex_position(ctx, index))
3013
 
      ATTR2F(0, (GLfloat) x, (GLfloat) y);
3014
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3015
 
      ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y);
3016
 
   else
3017
 
      ERROR(GL_INVALID_VALUE);
3018
 
}
3019
 
 
3020
 
static void GLAPIENTRY
3021
 
TAG(VertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z)
3022
 
{
3023
 
   GET_CURRENT_CONTEXT(ctx);
3024
 
   if (is_vertex_position(ctx, index))
3025
 
      ATTR3F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z);
3026
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3027
 
      ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z);
3028
 
   else
3029
 
      ERROR(GL_INVALID_VALUE);
3030
 
}
3031
 
 
3032
 
static void GLAPIENTRY
3033
 
TAG(VertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
3034
 
{
3035
 
   GET_CURRENT_CONTEXT(ctx);
3036
 
   if (is_vertex_position(ctx, index))
3037
 
      ATTR3F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z);
3038
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3039
 
      ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z);
3040
 
   else
3041
 
      ERROR(GL_INVALID_VALUE);
3042
 
}
3043
 
 
3044
 
static void GLAPIENTRY
3045
 
TAG(VertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
3046
 
{
3047
 
   GET_CURRENT_CONTEXT(ctx);
3048
 
   if (is_vertex_position(ctx, index))
3049
 
      ATTR4F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
3050
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3051
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
3052
 
   else
3053
 
      ERROR(GL_INVALID_VALUE);
3054
 
}
3055
 
 
3056
 
static void GLAPIENTRY
3057
 
TAG(VertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
3058
 
{
3059
 
   GET_CURRENT_CONTEXT(ctx);
3060
 
   if (is_vertex_position(ctx, index))
3061
 
      ATTR4F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
3062
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3063
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
3064
 
   else
3065
 
      ERROR(GL_INVALID_VALUE);
3066
 
}
3067
 
 
3068
 
static void GLAPIENTRY
3069
 
TAG(VertexAttrib1sv)(GLuint index, const GLshort *v)
3070
 
{
3071
 
   GET_CURRENT_CONTEXT(ctx);
3072
 
   if (is_vertex_position(ctx, index))
3073
 
      ATTR1F(0, (GLfloat) v[0]);
3074
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3075
 
      ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0]);
3076
 
   else
3077
 
      ERROR(GL_INVALID_VALUE);
3078
 
}
3079
 
 
3080
 
static void GLAPIENTRY
3081
 
TAG(VertexAttrib1dv)(GLuint index, const GLdouble *v)
3082
 
{
3083
 
   GET_CURRENT_CONTEXT(ctx);
3084
 
   if (is_vertex_position(ctx, index))
3085
 
      ATTR1F(0, (GLfloat) v[0]);
3086
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3087
 
      ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0]);
3088
 
   else
3089
 
      ERROR(GL_INVALID_VALUE);
3090
 
}
3091
 
 
3092
 
static void GLAPIENTRY
3093
 
TAG(VertexAttrib2sv)(GLuint index, const GLshort *v)
3094
 
{
3095
 
   GET_CURRENT_CONTEXT(ctx);
3096
 
   if (is_vertex_position(ctx, index))
3097
 
      ATTR2F(0, (GLfloat) v[0], (GLfloat) v[1]);
3098
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3099
 
      ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1]);
3100
 
   else
3101
 
      ERROR(GL_INVALID_VALUE);
3102
 
}
3103
 
 
3104
 
static void GLAPIENTRY
3105
 
TAG(VertexAttrib2dv)(GLuint index, const GLdouble *v)
3106
 
{
3107
 
   GET_CURRENT_CONTEXT(ctx);
3108
 
   if (is_vertex_position(ctx, index))
3109
 
      ATTR2F(0, (GLfloat) v[0], (GLfloat) v[1]);
3110
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3111
 
      ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1]);
3112
 
   else
3113
 
      ERROR(GL_INVALID_VALUE);
3114
 
}
3115
 
 
3116
 
static void GLAPIENTRY
3117
 
TAG(VertexAttrib3sv)(GLuint index, const GLshort *v)
3118
 
{
3119
 
   GET_CURRENT_CONTEXT(ctx);
3120
 
   if (is_vertex_position(ctx, index))
3121
 
      ATTR3F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
3122
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3123
 
      ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
3124
 
   else
3125
 
      ERROR(GL_INVALID_VALUE);
3126
 
}
3127
 
 
3128
 
static void GLAPIENTRY
3129
 
TAG(VertexAttrib3dv)(GLuint index, const GLdouble *v)
3130
 
{
3131
 
   GET_CURRENT_CONTEXT(ctx);
3132
 
   if (is_vertex_position(ctx, index))
3133
 
      ATTR3F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
3134
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3135
 
      ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
3136
 
   else
3137
 
      ERROR(GL_INVALID_VALUE);
3138
 
}
3139
 
 
3140
 
static void GLAPIENTRY
3141
 
TAG(VertexAttrib4sv)(GLuint index, const GLshort *v)
3142
 
{
3143
 
   GET_CURRENT_CONTEXT(ctx);
3144
 
   if (is_vertex_position(ctx, index))
3145
 
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3146
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3147
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3148
 
   else
3149
 
      ERROR(GL_INVALID_VALUE);
3150
 
}
3151
 
 
3152
 
static void GLAPIENTRY
3153
 
TAG(VertexAttrib4dv)(GLuint index, const GLdouble *v)
3154
 
{
3155
 
   GET_CURRENT_CONTEXT(ctx);
3156
 
   if (is_vertex_position(ctx, index))
3157
 
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3158
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3159
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3160
 
   else
3161
 
      ERROR(GL_INVALID_VALUE);
3162
 
}
3163
 
 
3164
 
static void GLAPIENTRY
3165
 
TAG(VertexAttrib4bv)(GLuint index, const GLbyte * v)
3166
 
{
3167
 
   GET_CURRENT_CONTEXT(ctx);
3168
 
   if (is_vertex_position(ctx, index))
3169
 
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3170
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3171
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3172
 
   else
3173
 
      ERROR(GL_INVALID_VALUE);
3174
 
}
3175
 
 
3176
 
static void GLAPIENTRY
3177
 
TAG(VertexAttrib4iv)(GLuint index, const GLint * v)
3178
 
{
3179
 
   GET_CURRENT_CONTEXT(ctx);
3180
 
   if (is_vertex_position(ctx, index))
3181
 
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3182
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3183
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3184
 
   else
3185
 
      ERROR(GL_INVALID_VALUE);
3186
 
}
3187
 
 
3188
 
static void GLAPIENTRY
3189
 
TAG(VertexAttrib4ubv)(GLuint index, const GLubyte * v)
3190
 
{
3191
 
   GET_CURRENT_CONTEXT(ctx);
3192
 
   if (is_vertex_position(ctx, index))
3193
 
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3194
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3195
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3196
 
   else
3197
 
      ERROR(GL_INVALID_VALUE);
3198
 
}
3199
 
 
3200
 
static void GLAPIENTRY
3201
 
TAG(VertexAttrib4usv)(GLuint index, const GLushort * v)
3202
 
{
3203
 
   GET_CURRENT_CONTEXT(ctx);
3204
 
   if (is_vertex_position(ctx, index))
3205
 
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3206
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3207
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3208
 
   else
3209
 
      ERROR(GL_INVALID_VALUE);
3210
 
}
3211
 
 
3212
 
static void GLAPIENTRY
3213
 
TAG(VertexAttrib4uiv)(GLuint index, const GLuint * v)
3214
 
{
3215
 
   GET_CURRENT_CONTEXT(ctx);
3216
 
   if (is_vertex_position(ctx, index))
3217
 
      ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3218
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3219
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
3220
 
   else
3221
 
      ERROR(GL_INVALID_VALUE);
3222
 
}
3223
 
 
3224
 
static void GLAPIENTRY
3225
 
TAG(VertexAttrib4Nbv)(GLuint index, const GLbyte * v)
3226
 
{
3227
 
   GET_CURRENT_CONTEXT(ctx);
3228
 
   if (is_vertex_position(ctx, index))
3229
 
      ATTR4F(0, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]));
3230
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3231
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]));
3232
 
   else
3233
 
      ERROR(GL_INVALID_VALUE);
3234
 
}
3235
 
 
3236
 
static void GLAPIENTRY
3237
 
TAG(VertexAttrib4Nsv)(GLuint index, const GLshort * v)
3238
 
{
3239
 
   GET_CURRENT_CONTEXT(ctx);
3240
 
   if (is_vertex_position(ctx, index))
3241
 
      ATTR4F(0, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]));
3242
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3243
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]));
3244
 
   else
3245
 
      ERROR(GL_INVALID_VALUE);
3246
 
}
3247
 
 
3248
 
static void GLAPIENTRY
3249
 
TAG(VertexAttrib4Niv)(GLuint index, const GLint * v)
3250
 
{
3251
 
   GET_CURRENT_CONTEXT(ctx);
3252
 
   if (is_vertex_position(ctx, index))
3253
 
      ATTR4F(0, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]));
3254
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3255
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]));
3256
 
   else
3257
 
      ERROR(GL_INVALID_VALUE);
3258
 
}
3259
 
 
3260
 
static void GLAPIENTRY
3261
 
TAG(VertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
3262
 
{
3263
 
   GET_CURRENT_CONTEXT(ctx);
3264
 
   if (is_vertex_position(ctx, index))
3265
 
      ATTR4F(0, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y), UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w));
3266
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3267
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y), UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w));
3268
 
   else
3269
 
      ERROR(GL_INVALID_VALUE);
3270
 
}
3271
 
 
3272
 
static void GLAPIENTRY
3273
 
TAG(VertexAttrib4Nubv)(GLuint index, const GLubyte * v)
3274
 
{
3275
 
   GET_CURRENT_CONTEXT(ctx);
3276
 
   if (is_vertex_position(ctx, index))
3277
 
      ATTR4F(0, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
3278
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3279
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
3280
 
   else
3281
 
      ERROR(GL_INVALID_VALUE);
3282
 
}
3283
 
 
3284
 
static void GLAPIENTRY
3285
 
TAG(VertexAttrib4Nusv)(GLuint index, const GLushort * v)
3286
 
{
3287
 
   GET_CURRENT_CONTEXT(ctx);
3288
 
   if (is_vertex_position(ctx, index))
3289
 
      ATTR4F(0, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]), USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]));
3290
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3291
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]), USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]));
3292
 
   else
3293
 
      ERROR(GL_INVALID_VALUE);
3294
 
}
3295
 
 
3296
 
static void GLAPIENTRY
3297
 
TAG(VertexAttrib4Nuiv)(GLuint index, const GLuint * v)
3298
 
{
3299
 
   GET_CURRENT_CONTEXT(ctx);
3300
 
   if (is_vertex_position(ctx, index))
3301
 
      ATTR4F(0, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]), UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]));
3302
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3303
 
      ATTR4F(VBO_ATTRIB_GENERIC0 + index, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]), UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]));
3304
 
   else
3305
 
      ERROR(GL_INVALID_VALUE);
3306
 
}
3307
 
 
3308
 
 
3309
 
 
3310
 
/**
3311
 
 * GL_EXT_gpu_shader / GL 3.0 signed/unsigned integer-valued attributes.
3312
 
 * Note that attribute indexes do NOT alias conventional attributes.
3313
 
 */
3314
 
 
3315
 
static void GLAPIENTRY
3316
 
TAG(VertexAttribI1iv)(GLuint index, const GLint *v)
3317
 
{
3318
 
   GET_CURRENT_CONTEXT(ctx);
3319
 
   if (is_vertex_position(ctx, index))
3320
 
      ATTR1I(0, v[0]);
3321
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3322
 
      ATTR1I(VBO_ATTRIB_GENERIC0 + index, v[0]);
3323
 
   else
3324
 
      ERROR(GL_INVALID_VALUE);
3325
 
}
3326
 
 
3327
 
static void GLAPIENTRY
3328
 
TAG(VertexAttribI1uiv)(GLuint index, const GLuint *v)
3329
 
{
3330
 
   GET_CURRENT_CONTEXT(ctx);
3331
 
   if (is_vertex_position(ctx, index))
3332
 
      ATTR1UI(0, v[0]);
3333
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3334
 
      ATTR1UI(VBO_ATTRIB_GENERIC0 + index, v[0]);
3335
 
   else
3336
 
      ERROR(GL_INVALID_VALUE);
3337
 
}
3338
 
 
3339
 
static void GLAPIENTRY
3340
 
TAG(VertexAttribI4bv)(GLuint index, const GLbyte *v)
3341
 
{
3342
 
   GET_CURRENT_CONTEXT(ctx);
3343
 
   if (is_vertex_position(ctx, index))
3344
 
      ATTR4I(0, v[0], v[1], v[2], v[3]);
3345
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3346
 
      ATTR4I(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
3347
 
   else
3348
 
      ERROR(GL_INVALID_VALUE);
3349
 
}
3350
 
 
3351
 
static void GLAPIENTRY
3352
 
TAG(VertexAttribI4sv)(GLuint index, const GLshort *v)
3353
 
{
3354
 
   GET_CURRENT_CONTEXT(ctx);
3355
 
   if (is_vertex_position(ctx, index))
3356
 
      ATTR4I(0, v[0], v[1], v[2], v[3]);
3357
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3358
 
      ATTR4I(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
3359
 
   else
3360
 
      ERROR(GL_INVALID_VALUE);
3361
 
}
3362
 
 
3363
 
static void GLAPIENTRY
3364
 
TAG(VertexAttribI4ubv)(GLuint index, const GLubyte *v)
3365
 
{
3366
 
   GET_CURRENT_CONTEXT(ctx);
3367
 
   if (is_vertex_position(ctx, index))
3368
 
      ATTR4UI(0, v[0], v[1], v[2], v[3]);
3369
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3370
 
      ATTR4UI(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
3371
 
   else
3372
 
      ERROR(GL_INVALID_VALUE);
3373
 
}
3374
 
 
3375
 
static void GLAPIENTRY
3376
 
TAG(VertexAttribI4usv)(GLuint index, const GLushort *v)
3377
 
{
3378
 
   GET_CURRENT_CONTEXT(ctx);
3379
 
   if (is_vertex_position(ctx, index))
3380
 
      ATTR4UI(0, v[0], v[1], v[2], v[3]);
3381
 
   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
3382
 
      ATTR4UI(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
3383
 
   else
3384
 
      ERROR(GL_INVALID_VALUE);
3385
 
}
 
3379
#endif /* HW_SELECT_MODE */
3386
3380
 
3387
3381
#undef ATTR1FV
3388
3382
#undef ATTR2FV