2 * Mesa 3-D graphics library
5 * Copyright (C) 2004-2008 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * Implementation of GLSL-related API functions
33 * 1. Check that the right error code is generated for all _mesa_error() calls.
34 * 2. Insert FLUSH_VERTICES calls in various places
38 #include "main/glheader.h"
39 #include "main/context.h"
40 #include "main/hash.h"
41 #include "main/macros.h"
42 #include "shader/program.h"
43 #include "shader/prog_parameter.h"
44 #include "shader/prog_print.h"
45 #include "shader/prog_statevars.h"
46 #include "shader/prog_uniform.h"
47 #include "shader/shader_api.h"
48 #include "shader/slang/slang_compile.h"
49 #include "shader/slang/slang_link.h"
50 #include "glapi/dispatch.h"
53 #ifndef GL_PROGRAM_BINARY_LENGTH_OES
54 #define GL_PROGRAM_BINARY_LENGTH_OES 0x8741
59 * Allocate a new gl_shader_program object, initialize it.
61 static struct gl_shader_program
*
62 _mesa_new_shader_program(GLcontext
*ctx
, GLuint name
)
64 struct gl_shader_program
*shProg
;
65 shProg
= CALLOC_STRUCT(gl_shader_program
);
67 shProg
->Type
= GL_SHADER_PROGRAM_MESA
;
70 shProg
->Attributes
= _mesa_new_parameter_list();
77 * Clear (free) the shader program state that gets produced by linking.
80 _mesa_clear_shader_program_data(GLcontext
*ctx
,
81 struct gl_shader_program
*shProg
)
83 _mesa_reference_vertprog(ctx
, &shProg
->VertexProgram
, NULL
);
84 _mesa_reference_fragprog(ctx
, &shProg
->FragmentProgram
, NULL
);
86 if (shProg
->Uniforms
) {
87 _mesa_free_uniform_list(shProg
->Uniforms
);
88 shProg
->Uniforms
= NULL
;
91 if (shProg
->Varying
) {
92 _mesa_free_parameter_list(shProg
->Varying
);
93 shProg
->Varying
= NULL
;
99 * Free all the data that hangs off a shader program object, but not the
103 _mesa_free_shader_program_data(GLcontext
*ctx
,
104 struct gl_shader_program
*shProg
)
108 assert(shProg
->Type
== GL_SHADER_PROGRAM_MESA
);
110 _mesa_clear_shader_program_data(ctx
, shProg
);
112 if (shProg
->Attributes
) {
113 _mesa_free_parameter_list(shProg
->Attributes
);
114 shProg
->Attributes
= NULL
;
118 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
119 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
121 shProg
->NumShaders
= 0;
123 if (shProg
->Shaders
) {
124 _mesa_free(shProg
->Shaders
);
125 shProg
->Shaders
= NULL
;
128 if (shProg
->InfoLog
) {
129 _mesa_free(shProg
->InfoLog
);
130 shProg
->InfoLog
= NULL
;
136 * Free/delete a shader program object.
139 _mesa_free_shader_program(GLcontext
*ctx
, struct gl_shader_program
*shProg
)
141 _mesa_free_shader_program_data(ctx
, shProg
);
148 * Set ptr to point to shProg.
149 * If ptr is pointing to another object, decrement its refcount (and delete
150 * if refcount hits zero).
151 * Then set ptr to point to shProg, incrementing its refcount.
153 /* XXX this could be static */
155 _mesa_reference_shader_program(GLcontext
*ctx
,
156 struct gl_shader_program
**ptr
,
157 struct gl_shader_program
*shProg
)
160 if (*ptr
== shProg
) {
165 /* Unreference the old shader program */
166 GLboolean deleteFlag
= GL_FALSE
;
167 struct gl_shader_program
*old
= *ptr
;
169 ASSERT(old
->RefCount
> 0);
172 printf("ShaderProgram %p ID=%u RefCount-- to %d\n",
173 (void *) old
, old
->Name
, old
->RefCount
);
175 deleteFlag
= (old
->RefCount
== 0);
178 _mesa_HashRemove(ctx
->Shared
->ShaderObjects
, old
->Name
);
179 _mesa_free_shader_program(ctx
, old
);
189 printf("ShaderProgram %p ID=%u RefCount++ to %d\n",
190 (void *) shProg
, shProg
->Name
, shProg
->RefCount
);
198 * Lookup a GLSL program object.
200 struct gl_shader_program
*
201 _mesa_lookup_shader_program(GLcontext
*ctx
, GLuint name
)
203 struct gl_shader_program
*shProg
;
205 shProg
= (struct gl_shader_program
*)
206 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
207 /* Note that both gl_shader and gl_shader_program objects are kept
208 * in the same hash table. Check the object's type to be sure it's
209 * what we're expecting.
211 if (shProg
&& shProg
->Type
!= GL_SHADER_PROGRAM_MESA
) {
221 * As above, but record an error if program is not found.
223 static struct gl_shader_program
*
224 _mesa_lookup_shader_program_err(GLcontext
*ctx
, GLuint name
,
228 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
232 struct gl_shader_program
*shProg
= (struct gl_shader_program
*)
233 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
235 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
238 if (shProg
->Type
!= GL_SHADER_PROGRAM_MESA
) {
239 _mesa_error(ctx
, GL_INVALID_OPERATION
, caller
);
250 * Allocate a new gl_shader object, initialize it.
253 _mesa_new_shader(GLcontext
*ctx
, GLuint name
, GLenum type
)
255 struct gl_shader
*shader
;
256 assert(type
== GL_FRAGMENT_SHADER
|| type
== GL_VERTEX_SHADER
);
257 shader
= CALLOC_STRUCT(gl_shader
);
261 shader
->RefCount
= 1;
268 _mesa_free_shader(GLcontext
*ctx
, struct gl_shader
*sh
)
271 _mesa_free((void *) sh
->Source
);
273 _mesa_free(sh
->InfoLog
);
274 _mesa_reference_program(ctx
, &sh
->Program
, NULL
);
280 * Set ptr to point to sh.
281 * If ptr is pointing to another shader, decrement its refcount (and delete
282 * if refcount hits zero).
283 * Then set ptr to point to sh, incrementing its refcount.
285 /* XXX this could be static */
287 _mesa_reference_shader(GLcontext
*ctx
, struct gl_shader
**ptr
,
288 struct gl_shader
*sh
)
296 /* Unreference the old shader */
297 GLboolean deleteFlag
= GL_FALSE
;
298 struct gl_shader
*old
= *ptr
;
300 ASSERT(old
->RefCount
> 0);
302 /*printf("SHADER DECR %p (%d) to %d\n",
303 (void*) old, old->Name, old->RefCount);*/
304 deleteFlag
= (old
->RefCount
== 0);
307 _mesa_HashRemove(ctx
->Shared
->ShaderObjects
, old
->Name
);
308 _mesa_free_shader(ctx
, old
);
318 /*printf("SHADER INCR %p (%d) to %d\n",
319 (void*) sh, sh->Name, sh->RefCount);*/
326 * Lookup a GLSL shader object.
329 _mesa_lookup_shader(GLcontext
*ctx
, GLuint name
)
332 struct gl_shader
*sh
= (struct gl_shader
*)
333 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
334 /* Note that both gl_shader and gl_shader_program objects are kept
335 * in the same hash table. Check the object's type to be sure it's
336 * what we're expecting.
338 if (sh
&& sh
->Type
== GL_SHADER_PROGRAM_MESA
) {
348 * As above, but record an error if shader is not found.
350 static struct gl_shader
*
351 _mesa_lookup_shader_err(GLcontext
*ctx
, GLuint name
, const char *caller
)
354 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
358 struct gl_shader
*sh
= (struct gl_shader
*)
359 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
361 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
364 if (sh
->Type
== GL_SHADER_PROGRAM_MESA
) {
365 _mesa_error(ctx
, GL_INVALID_OPERATION
, caller
);
375 * Initialize context's shader state.
378 _mesa_init_shader_state(GLcontext
* ctx
)
380 /* Device drivers may override these to control what kind of instructions
381 * are generated by the GLSL compiler.
383 ctx
->Shader
.EmitHighLevelInstructions
= GL_TRUE
;
384 ctx
->Shader
.EmitCondCodes
= GL_FALSE
;/*GL_TRUE;*/ /* XXX probably want GL_FALSE... */
385 ctx
->Shader
.EmitComments
= GL_FALSE
;
390 * Free the per-context shader-related state.
393 _mesa_free_shader_state(GLcontext
*ctx
)
395 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, NULL
);
400 * Copy string from <src> to <dst>, up to maxLength characters, returning
401 * length of <dst> in <length>.
402 * \param src the strings source
403 * \param maxLength max chars to copy
404 * \param length returns number of chars copied
405 * \param dst the string destination
408 copy_string(GLchar
*dst
, GLsizei maxLength
, GLsizei
*length
, const GLchar
*src
)
411 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
421 _mesa_is_program(GLcontext
*ctx
, GLuint name
)
423 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
424 return shProg
? GL_TRUE
: GL_FALSE
;
429 _mesa_is_shader(GLcontext
*ctx
, GLuint name
)
431 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
432 return shader
? GL_TRUE
: GL_FALSE
;
437 * Called via ctx->Driver.AttachShader()
440 _mesa_attach_shader(GLcontext
*ctx
, GLuint program
, GLuint shader
)
442 struct gl_shader_program
*shProg
;
443 struct gl_shader
*sh
;
446 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glAttachShader");
450 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glAttachShader");
455 n
= shProg
->NumShaders
;
456 for (i
= 0; i
< n
; i
++) {
457 if (shProg
->Shaders
[i
] == sh
) {
458 /* The shader is already attched to this program. The
459 * GL_ARB_shader_objects spec says:
461 * "The error INVALID_OPERATION is generated by AttachObjectARB
462 * if <obj> is already attached to <containerObj>."
464 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
470 shProg
->Shaders
= (struct gl_shader
**)
471 _mesa_realloc(shProg
->Shaders
,
472 n
* sizeof(struct gl_shader
*),
473 (n
+ 1) * sizeof(struct gl_shader
*));
474 if (!shProg
->Shaders
) {
475 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
480 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
481 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
482 shProg
->NumShaders
++;
487 _mesa_get_attrib_location(GLcontext
*ctx
, GLuint program
,
490 struct gl_shader_program
*shProg
491 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttribLocation");
497 if (!shProg
->LinkStatus
) {
498 _mesa_error(ctx
, GL_INVALID_OPERATION
,
499 "glGetAttribLocation(program not linked)");
506 if (shProg
->VertexProgram
) {
507 const struct gl_program_parameter_list
*attribs
=
508 shProg
->VertexProgram
->Base
.Attributes
;
510 GLint i
= _mesa_lookup_parameter_index(attribs
, -1, name
);
512 return attribs
->Parameters
[i
].StateIndexes
[0];
521 _mesa_bind_attrib_location(GLcontext
*ctx
, GLuint program
, GLuint index
,
524 struct gl_shader_program
*shProg
;
525 const GLint size
= -1; /* unknown size */
527 GLenum datatype
= GL_FLOAT_VEC4
;
529 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
530 "glBindAttribLocation");
538 if (strncmp(name
, "gl_", 3) == 0) {
539 _mesa_error(ctx
, GL_INVALID_OPERATION
,
540 "glBindAttribLocation(illegal name)");
544 if (index
>= ctx
->Const
.VertexProgram
.MaxAttribs
) {
545 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBindAttribLocation(index)");
549 if (shProg
->LinkStatus
) {
550 /* get current index/location for the attribute */
551 oldIndex
= _mesa_get_attrib_location(ctx
, program
, name
);
557 /* this will replace the current value if it's already in the list */
558 i
= _mesa_add_attribute(shProg
->Attributes
, name
, size
, datatype
, index
);
560 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glBindAttribLocation");
565 * Note that this attribute binding won't go into effect until
566 * glLinkProgram is called again.
572 _mesa_create_shader(GLcontext
*ctx
, GLenum type
)
574 struct gl_shader
*sh
;
577 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
580 case GL_FRAGMENT_SHADER
:
581 case GL_VERTEX_SHADER
:
582 sh
= _mesa_new_shader(ctx
, name
, type
);
585 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(type)");
589 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, sh
);
596 _mesa_create_program(GLcontext
*ctx
)
599 struct gl_shader_program
*shProg
;
601 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
602 shProg
= _mesa_new_shader_program(ctx
, name
);
604 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, shProg
);
606 assert(shProg
->RefCount
== 1);
613 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
617 _mesa_delete_program2(GLcontext
*ctx
, GLuint name
)
620 * NOTE: deleting shaders/programs works a bit differently than
621 * texture objects (and buffer objects, etc). Shader/program
622 * handles/IDs exist in the hash table until the object is really
623 * deleted (refcount==0). With texture objects, the handle/ID is
624 * removed from the hash table in glDeleteTextures() while the tex
625 * object itself might linger until its refcount goes to zero.
627 struct gl_shader_program
*shProg
;
629 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
633 shProg
->DeletePending
= GL_TRUE
;
635 /* effectively, decr shProg's refcount */
636 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
641 _mesa_delete_shader(GLcontext
*ctx
, GLuint shader
)
643 struct gl_shader
*sh
;
645 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
649 sh
->DeletePending
= GL_TRUE
;
651 /* effectively, decr sh's refcount */
652 _mesa_reference_shader(ctx
, &sh
, NULL
);
657 _mesa_detach_shader(GLcontext
*ctx
, GLuint program
, GLuint shader
)
659 struct gl_shader_program
*shProg
;
663 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
667 n
= shProg
->NumShaders
;
669 for (i
= 0; i
< n
; i
++) {
670 if (shProg
->Shaders
[i
]->Name
== shader
) {
672 struct gl_shader
**newList
;
675 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
677 /* alloc new, smaller array */
678 newList
= (struct gl_shader
**)
679 _mesa_malloc((n
- 1) * sizeof(struct gl_shader
*));
681 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
684 for (j
= 0; j
< i
; j
++) {
685 newList
[j
] = shProg
->Shaders
[j
];
688 newList
[j
++] = shProg
->Shaders
[i
];
689 _mesa_free(shProg
->Shaders
);
691 shProg
->Shaders
= newList
;
692 shProg
->NumShaders
= n
- 1;
697 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
698 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
699 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
700 assert(shProg
->Shaders
[j
]->RefCount
> 0);
712 if (_mesa_is_shader(ctx
, shader
))
713 err
= GL_INVALID_OPERATION
;
714 else if (_mesa_is_program(ctx
, shader
))
715 err
= GL_INVALID_OPERATION
;
717 err
= GL_INVALID_VALUE
;
718 _mesa_error(ctx
, err
, "glDetachProgram(shader)");
725 sizeof_glsl_type(GLenum type
)
734 case GL_SAMPLER_CUBE
:
735 case GL_SAMPLER_1D_SHADOW
:
736 case GL_SAMPLER_2D_SHADOW
:
737 case GL_SAMPLER_2D_RECT_ARB
:
738 case GL_SAMPLER_2D_RECT_SHADOW_ARB
:
739 case GL_SAMPLER_1D_ARRAY_SHADOW_EXT
:
740 case GL_SAMPLER_2D_ARRAY_SHADOW_EXT
:
741 case GL_SAMPLER_CUBE_SHADOW_EXT
:
756 case GL_FLOAT_MAT2x3
:
757 case GL_FLOAT_MAT2x4
:
758 return 8; /* two float[4] vectors */
760 case GL_FLOAT_MAT3x2
:
761 case GL_FLOAT_MAT3x4
:
762 return 12; /* three float[4] vectors */
764 case GL_FLOAT_MAT4x2
:
765 case GL_FLOAT_MAT4x3
:
766 return 16; /* four float[4] vectors */
768 _mesa_problem(NULL
, "Invalid type in sizeof_glsl_type()");
775 is_boolean_type(GLenum type
)
790 is_integer_type(GLenum type
)
805 _mesa_get_active_attrib(GLcontext
*ctx
, GLuint program
, GLuint index
,
806 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
807 GLenum
*type
, GLchar
*nameOut
)
809 const struct gl_program_parameter_list
*attribs
= NULL
;
810 struct gl_shader_program
*shProg
;
812 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetActiveAttrib");
816 if (shProg
->VertexProgram
)
817 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
819 if (!attribs
|| index
>= attribs
->NumParameters
) {
820 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveAttrib(index)");
824 copy_string(nameOut
, maxLength
, length
, attribs
->Parameters
[index
].Name
);
827 *size
= attribs
->Parameters
[index
].Size
828 / sizeof_glsl_type(attribs
->Parameters
[index
].DataType
);
831 *type
= attribs
->Parameters
[index
].DataType
;
835 static struct gl_program_parameter
*
836 get_uniform_parameter(const struct gl_shader_program
*shProg
, GLuint index
)
838 const struct gl_program
*prog
;
841 progPos
= shProg
->Uniforms
->Uniforms
[index
].VertPos
;
843 prog
= &shProg
->VertexProgram
->Base
;
846 progPos
= shProg
->Uniforms
->Uniforms
[index
].FragPos
;
848 prog
= &shProg
->FragmentProgram
->Base
;
852 if (!prog
|| progPos
< 0)
853 return NULL
; /* should never happen */
855 return &prog
->Parameters
->Parameters
[progPos
];
860 * Called via ctx->Driver.GetActiveUniform().
863 _mesa_get_active_uniform(GLcontext
*ctx
, GLuint program
, GLuint index
,
864 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
865 GLenum
*type
, GLchar
*nameOut
)
867 const struct gl_shader_program
*shProg
;
868 const struct gl_program
*prog
;
871 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetActiveUniform");
875 if (!shProg
->Uniforms
|| index
>= shProg
->Uniforms
->NumUniforms
) {
876 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveUniform(index)");
880 progPos
= shProg
->Uniforms
->Uniforms
[index
].VertPos
;
882 prog
= &shProg
->VertexProgram
->Base
;
885 progPos
= shProg
->Uniforms
->Uniforms
[index
].FragPos
;
887 prog
= &shProg
->FragmentProgram
->Base
;
891 if (!prog
|| progPos
< 0)
892 return; /* should never happen */
895 copy_string(nameOut
, maxLength
, length
,
896 prog
->Parameters
->Parameters
[progPos
].Name
);
898 *size
= prog
->Parameters
->Parameters
[progPos
].Size
899 / sizeof_glsl_type(prog
->Parameters
->Parameters
[progPos
].DataType
);
901 *type
= prog
->Parameters
->Parameters
[progPos
].DataType
;
906 * Called via ctx->Driver.GetAttachedShaders().
909 _mesa_get_attached_shaders(GLcontext
*ctx
, GLuint program
, GLsizei maxCount
,
910 GLsizei
*count
, GLuint
*obj
)
912 struct gl_shader_program
*shProg
=
913 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
916 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
917 obj
[i
] = shProg
->Shaders
[i
]->Name
;
926 _mesa_get_handle(GLcontext
*ctx
, GLenum pname
)
930 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
931 CALL_GetIntegerv(ctx
->Exec
, (GL_CURRENT_PROGRAM
, &handle
));
933 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
941 _mesa_get_programiv(GLcontext
*ctx
, GLuint program
,
942 GLenum pname
, GLint
*params
)
944 const struct gl_program_parameter_list
*attribs
;
945 struct gl_shader_program
*shProg
946 = _mesa_lookup_shader_program(ctx
, program
);
949 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
953 if (shProg
->VertexProgram
)
954 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
959 case GL_DELETE_STATUS
:
960 *params
= shProg
->DeletePending
;
963 *params
= shProg
->LinkStatus
;
965 case GL_VALIDATE_STATUS
:
966 *params
= shProg
->Validated
;
968 case GL_INFO_LOG_LENGTH
:
969 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
971 case GL_ATTACHED_SHADERS
:
972 *params
= shProg
->NumShaders
;
974 case GL_ACTIVE_ATTRIBUTES
:
975 *params
= attribs
? attribs
->NumParameters
: 0;
977 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
978 *params
= _mesa_longest_parameter_name(attribs
, PROGRAM_INPUT
) + 1;
980 case GL_ACTIVE_UNIFORMS
:
981 *params
= shProg
->Uniforms
? shProg
->Uniforms
->NumUniforms
: 0;
983 case GL_ACTIVE_UNIFORM_MAX_LENGTH
:
984 *params
= _mesa_longest_uniform_name(shProg
->Uniforms
);
986 (*params
)++; /* add one for terminating zero */
988 case GL_PROGRAM_BINARY_LENGTH_OES
:
992 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname)");
999 _mesa_get_shaderiv(GLcontext
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
1001 struct gl_shader
*shader
= _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
1008 case GL_SHADER_TYPE
:
1009 *params
= shader
->Type
;
1011 case GL_DELETE_STATUS
:
1012 *params
= shader
->DeletePending
;
1014 case GL_COMPILE_STATUS
:
1015 *params
= shader
->CompileStatus
;
1017 case GL_INFO_LOG_LENGTH
:
1018 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
1020 case GL_SHADER_SOURCE_LENGTH
:
1021 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
1024 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
1031 _mesa_get_program_info_log(GLcontext
*ctx
, GLuint program
, GLsizei bufSize
,
1032 GLsizei
*length
, GLchar
*infoLog
)
1034 struct gl_shader_program
*shProg
1035 = _mesa_lookup_shader_program(ctx
, program
);
1037 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
1040 copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
1045 _mesa_get_shader_info_log(GLcontext
*ctx
, GLuint shader
, GLsizei bufSize
,
1046 GLsizei
*length
, GLchar
*infoLog
)
1048 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
1050 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
1053 copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
1058 * Called via ctx->Driver.GetShaderSource().
1061 _mesa_get_shader_source(GLcontext
*ctx
, GLuint shader
, GLsizei maxLength
,
1062 GLsizei
*length
, GLchar
*sourceOut
)
1064 struct gl_shader
*sh
;
1065 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
1069 copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
1074 get_matrix_dims(GLenum type
, GLint
*rows
, GLint
*cols
)
1080 case GL_FLOAT_MAT2x3
:
1084 case GL_FLOAT_MAT2x4
:
1092 case GL_FLOAT_MAT3x2
:
1096 case GL_FLOAT_MAT3x4
:
1104 case GL_FLOAT_MAT4x2
:
1108 case GL_FLOAT_MAT4x3
:
1119 * Determine the number of rows and columns occupied by a uniform
1120 * according to its datatype. For non-matrix types (such as GL_FLOAT_VEC4),
1121 * the number of rows = 1 and cols = number of elements in the vector.
1124 get_uniform_rows_cols(const struct gl_program_parameter
*p
,
1125 GLint
*rows
, GLint
*cols
)
1127 get_matrix_dims(p
->DataType
, rows
, cols
);
1128 if (*rows
== 0 && *cols
== 0) {
1129 /* not a matrix type, probably a float or vector */
1135 *rows
= p
->Size
/ 4 + 1;
1136 if (p
->Size
% 4 == 0)
1139 *cols
= p
->Size
% 4;
1145 #define MAX_UNIFORM_ELEMENTS 16
1148 * Helper for GetUniformfv(), GetUniformiv()
1149 * Returns number of elements written to 'params' output.
1152 get_uniformfv(GLcontext
*ctx
, GLuint program
, GLint location
,
1155 struct gl_shader_program
*shProg
1156 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetUniform[if]v");
1158 if (shProg
->Uniforms
&&
1159 location
>= 0 && location
< (GLint
) shProg
->Uniforms
->NumUniforms
) {
1161 const struct gl_program
*prog
= NULL
;
1163 progPos
= shProg
->Uniforms
->Uniforms
[location
].VertPos
;
1165 prog
= &shProg
->VertexProgram
->Base
;
1168 progPos
= shProg
->Uniforms
->Uniforms
[location
].FragPos
;
1170 prog
= &shProg
->FragmentProgram
->Base
;
1176 const struct gl_program_parameter
*p
=
1177 &prog
->Parameters
->Parameters
[progPos
];
1178 GLint rows
, cols
, i
, j
, k
;
1180 /* See uniformiv() below */
1181 assert(p
->Size
<= MAX_UNIFORM_ELEMENTS
);
1183 get_uniform_rows_cols(p
, &rows
, &cols
);
1186 for (i
= 0; i
< rows
; i
++) {
1187 for (j
= 0; j
< cols
; j
++ ) {
1188 params
[k
++] = prog
->Parameters
->ParameterValues
[progPos
+i
][j
];
1196 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetUniformfv(location)");
1204 * Called via ctx->Driver.GetUniformfv().
1207 _mesa_get_uniformfv(GLcontext
*ctx
, GLuint program
, GLint location
,
1210 (void) get_uniformfv(ctx
, program
, location
, params
);
1215 * Called via ctx->Driver.GetUniformiv().
1218 _mesa_get_uniformiv(GLcontext
*ctx
, GLuint program
, GLint location
,
1221 GLfloat fparams
[MAX_UNIFORM_ELEMENTS
];
1222 GLuint n
= get_uniformfv(ctx
, program
, location
, fparams
);
1224 assert(n
<= MAX_UNIFORM_ELEMENTS
);
1225 for (i
= 0; i
< n
; i
++) {
1226 params
[i
] = (GLint
) fparams
[i
];
1232 * The value returned by GetUniformLocation actually encodes two things:
1233 * 1. the index into the prog->Uniforms[] array for the uniform
1234 * 2. an offset in the prog->ParameterValues[] array for specifying array
1235 * elements or structure fields.
1236 * This function merges those two values.
1239 merge_location_offset(GLint
*location
, GLint offset
)
1241 *location
= *location
| (offset
<< 16);
1246 * Seperate the uniform location and parameter offset. See above.
1249 split_location_offset(GLint
*location
, GLint
*offset
)
1251 *offset
= (*location
>> 16);
1252 *location
= *location
& 0xffff;
1257 * Called via ctx->Driver.GetUniformLocation().
1259 * The return value will encode two values, the uniform location and an
1260 * offset (used for arrays, structs).
1263 _mesa_get_uniform_location(GLcontext
*ctx
, GLuint program
, const GLchar
*name
)
1265 GLint offset
= 0, location
= -1;
1267 struct gl_shader_program
*shProg
=
1268 _mesa_lookup_shader_program_err(ctx
, program
, "glGetUniformLocation");
1273 if (shProg
->LinkStatus
== GL_FALSE
) {
1274 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetUniformfv(program)");
1278 /* XXX we should return -1 if the uniform was declared, but not
1282 /* XXX we need to be able to parse uniform names for structs and arrays
1289 /* handle 1-dimension arrays here... */
1290 char *c
= strchr(name
, '[');
1292 /* truncate name at [ */
1293 const GLint len
= c
- name
;
1294 GLchar
*newName
= _mesa_malloc(len
+ 1);
1296 return -1; /* out of mem */
1297 _mesa_memcpy(newName
, name
, len
);
1300 location
= _mesa_lookup_uniform(shProg
->Uniforms
, newName
);
1301 if (location
>= 0) {
1302 const GLint element
= _mesa_atoi(c
+ 1);
1304 /* get type of the uniform array element */
1305 struct gl_program_parameter
*p
;
1306 p
= get_uniform_parameter(shProg
, location
);
1309 get_matrix_dims(p
->DataType
, &rows
, &cols
);
1312 offset
= element
* rows
;
1317 _mesa_free(newName
);
1322 location
= _mesa_lookup_uniform(shProg
->Uniforms
, name
);
1325 if (location
>= 0) {
1326 merge_location_offset(&location
, offset
);
1335 * Called via ctx->Driver.ShaderSource()
1338 _mesa_shader_source(GLcontext
*ctx
, GLuint shader
, const GLchar
*source
)
1340 struct gl_shader
*sh
;
1342 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glShaderSource");
1346 /* free old shader source string and install new one */
1348 _mesa_free((void *) sh
->Source
);
1350 sh
->Source
= source
;
1351 sh
->CompileStatus
= GL_FALSE
;
1356 * Called via ctx->Driver.CompileShader()
1359 _mesa_compile_shader(GLcontext
*ctx
, GLuint shaderObj
)
1361 struct gl_shader
*sh
;
1363 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glCompileShader");
1367 sh
->CompileStatus
= _slang_compile(ctx
, sh
);
1372 * Called via ctx->Driver.LinkProgram()
1375 _mesa_link_program(GLcontext
*ctx
, GLuint program
)
1377 struct gl_shader_program
*shProg
;
1379 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glLinkProgram");
1383 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1385 _slang_link(ctx
, program
, shProg
);
1390 * Called via ctx->Driver.UseProgram()
1393 _mesa_use_program(GLcontext
*ctx
, GLuint program
)
1395 struct gl_shader_program
*shProg
;
1397 if (ctx
->Shader
.CurrentProgram
&&
1398 ctx
->Shader
.CurrentProgram
->Name
== program
) {
1403 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1406 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1410 if (!shProg
->LinkStatus
) {
1411 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUseProgram");
1419 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, shProg
);
1425 * Update the vertex/fragment program's TexturesUsed array.
1427 * This needs to be called after glUniform(set sampler var) is called.
1428 * A call to glUniform(samplerVar, value) causes a sampler to point to a
1429 * particular texture unit. We know the sampler's texture target
1430 * (1D/2D/3D/etc) from compile time but the sampler's texture unit is
1431 * set by glUniform() calls.
1433 * So, scan the program->SamplerUnits[] and program->SamplerTargets[]
1434 * information to update the prog->TexturesUsed[] values.
1435 * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,
1436 * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.
1437 * We'll use that info for state validation before rendering.
1440 _mesa_update_shader_textures_used(struct gl_program
*prog
)
1444 memset(prog
->TexturesUsed
, 0, sizeof(prog
->TexturesUsed
));
1446 for (s
= 0; s
< MAX_SAMPLERS
; s
++) {
1447 if (prog
->SamplersUsed
& (1 << s
)) {
1448 GLuint u
= prog
->SamplerUnits
[s
];
1449 GLuint t
= prog
->SamplerTargets
[s
];
1450 assert(u
< MAX_TEXTURE_IMAGE_UNITS
);
1451 prog
->TexturesUsed
[u
] |= (1 << t
);
1458 is_sampler_type(GLenum type
)
1464 case GL_SAMPLER_CUBE
:
1465 case GL_SAMPLER_1D_SHADOW
:
1466 case GL_SAMPLER_2D_SHADOW
:
1467 case GL_SAMPLER_2D_RECT_ARB
:
1468 case GL_SAMPLER_2D_RECT_SHADOW_ARB
:
1469 case GL_SAMPLER_1D_ARRAY_EXT
:
1470 case GL_SAMPLER_2D_ARRAY_EXT
:
1479 * Check if the type given by userType is allowed to set a uniform of the
1480 * target type. Generally, equivalence is required, but setting Boolean
1481 * uniforms can be done with glUniformiv or glUniformfv.
1484 compatible_types(GLenum userType
, GLenum targetType
)
1486 if (userType
== targetType
)
1489 if (targetType
== GL_BOOL
&& (userType
== GL_FLOAT
|| userType
== GL_INT
))
1492 if (targetType
== GL_BOOL_VEC2
&& (userType
== GL_FLOAT_VEC2
||
1493 userType
== GL_INT_VEC2
))
1496 if (targetType
== GL_BOOL_VEC3
&& (userType
== GL_FLOAT_VEC3
||
1497 userType
== GL_INT_VEC3
))
1500 if (targetType
== GL_BOOL_VEC4
&& (userType
== GL_FLOAT_VEC4
||
1501 userType
== GL_INT_VEC4
))
1504 if (is_sampler_type(targetType
) && userType
== GL_INT
)
1512 * Set the value of a program's uniform variable.
1513 * \param program the program whose uniform to update
1514 * \param index the index of the program parameter for the uniform
1515 * \param offset additional parameter slot offset (for arrays)
1516 * \param type the datatype of the uniform
1517 * \param count the number of uniforms to set
1518 * \param elems number of elements per uniform
1519 * \param values the new values
1522 set_program_uniform(GLcontext
*ctx
, struct gl_program
*program
,
1523 GLint index
, GLint offset
,
1524 GLenum type
, GLsizei count
, GLint elems
,
1527 struct gl_program_parameter
*param
=
1528 &program
->Parameters
->Parameters
[index
];
1530 assert(offset
>= 0);
1532 if (!compatible_types(type
, param
->DataType
)) {
1533 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(type mismatch)");
1537 if (index
+ offset
> (GLint
) program
->Parameters
->Size
) {
1538 /* out of bounds! */
1542 if (param
->Type
== PROGRAM_SAMPLER
) {
1543 /* This controls which texture unit which is used by a sampler */
1544 GLuint texUnit
, sampler
;
1546 /* data type for setting samplers must be int */
1547 if (type
!= GL_INT
|| count
!= 1) {
1548 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1549 "glUniform(only glUniform1i can be used "
1550 "to set sampler uniforms)");
1554 sampler
= (GLuint
) program
->Parameters
->ParameterValues
[index
][0];
1555 texUnit
= ((GLuint
*) values
)[0];
1557 /* check that the sampler (tex unit index) is legal */
1558 if (texUnit
>= ctx
->Const
.MaxTextureImageUnits
) {
1559 _mesa_error(ctx
, GL_INVALID_VALUE
,
1560 "glUniform1(invalid sampler/tex unit index)");
1564 /* This maps a sampler to a texture unit: */
1565 program
->SamplerUnits
[sampler
] = texUnit
;
1566 _mesa_update_shader_textures_used(program
);
1568 FLUSH_VERTICES(ctx
, _NEW_TEXTURE
);
1571 /* ordinary uniform variable */
1573 GLint slots
= (param
->Size
+ 3) / 4;
1575 if (count
* elems
> (GLint
) param
->Size
) {
1576 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(count too large)");
1583 for (k
= 0; k
< count
; k
++) {
1584 GLfloat
*uniformVal
=
1585 program
->Parameters
->ParameterValues
[index
+ offset
+ k
];
1586 if (is_integer_type(type
)) {
1587 const GLint
*iValues
= ((const GLint
*) values
) + k
* elems
;
1588 for (i
= 0; i
< elems
; i
++) {
1589 uniformVal
[i
] = (GLfloat
) iValues
[i
];
1593 const GLfloat
*fValues
= ((const GLfloat
*) values
) + k
* elems
;
1594 for (i
= 0; i
< elems
; i
++) {
1595 uniformVal
[i
] = fValues
[i
];
1599 /* if the uniform is bool-valued, convert to 1.0 or 0.0 */
1600 if (is_boolean_type(param
->DataType
)) {
1601 for (i
= 0; i
< elems
; i
++) {
1602 uniformVal
[i
] = uniformVal
[i
] ? 1.0f
: 0.0f
;
1611 * Called via ctx->Driver.Uniform().
1614 _mesa_uniform(GLcontext
*ctx
, GLint location
, GLsizei count
,
1615 const GLvoid
*values
, GLenum type
)
1617 struct gl_shader_program
*shProg
= ctx
->Shader
.CurrentProgram
;
1618 struct gl_uniform
*uniform
;
1619 GLint elems
, offset
;
1621 if (!shProg
|| !shProg
->LinkStatus
) {
1622 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(program not linked)");
1627 return; /* The standard specifies this as a no-op */
1629 split_location_offset(&location
, &offset
);
1631 if (location
< 0 || location
>= (GLint
) shProg
->Uniforms
->NumUniforms
) {
1632 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniform(location)");
1637 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniform(count < 0)");
1659 _mesa_problem(ctx
, "Invalid type in _mesa_uniform");
1663 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1665 uniform
= &shProg
->Uniforms
->Uniforms
[location
];
1667 /* A uniform var may be used by both a vertex shader and a fragment
1668 * shader. We may need to update one or both shader's uniform here:
1670 if (shProg
->VertexProgram
) {
1671 /* convert uniform location to program parameter index */
1672 GLint index
= uniform
->VertPos
;
1674 set_program_uniform(ctx
, &shProg
->VertexProgram
->Base
,
1675 index
, offset
, type
, count
, elems
, values
);
1679 if (shProg
->FragmentProgram
) {
1680 /* convert uniform location to program parameter index */
1681 GLint index
= uniform
->FragPos
;
1683 set_program_uniform(ctx
, &shProg
->FragmentProgram
->Base
,
1684 index
, offset
, type
, count
, elems
, values
);
1688 uniform
->Initialized
= GL_TRUE
;
1693 * Set a matrix-valued program parameter.
1696 set_program_uniform_matrix(GLcontext
*ctx
, struct gl_program
*program
,
1697 GLuint index
, GLuint offset
,
1698 GLuint count
, GLuint rows
, GLuint cols
,
1699 GLboolean transpose
, const GLfloat
*values
)
1701 GLuint mat
, row
, col
;
1702 GLuint dst
= index
+ offset
, src
= 0;
1705 /* check that the number of rows, columns is correct */
1706 get_matrix_dims(program
->Parameters
->Parameters
[index
].DataType
, &nr
, &nc
);
1707 if (rows
!= nr
|| cols
!= nc
) {
1708 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1709 "glUniformMatrix(matrix size mismatch)");
1713 if (index
+ offset
> program
->Parameters
->Size
) {
1714 /* out of bounds! */
1719 * Note: the _columns_ of a matrix are stored in program registers, not
1720 * the rows. So, the loops below look a little funny.
1721 * XXX could optimize this a bit...
1724 /* loop over matrices */
1725 for (mat
= 0; mat
< count
; mat
++) {
1728 for (col
= 0; col
< cols
; col
++) {
1729 GLfloat
*v
= program
->Parameters
->ParameterValues
[dst
];
1730 for (row
= 0; row
< rows
; row
++) {
1732 v
[row
] = values
[src
+ row
* cols
+ col
];
1735 v
[row
] = values
[src
+ col
* rows
+ row
];
1741 src
+= rows
* cols
; /* next matrix */
1747 * Called by ctx->Driver.UniformMatrix().
1748 * Note: cols=2, rows=4 ==> array[2] of vec4
1751 _mesa_uniform_matrix(GLcontext
*ctx
, GLint cols
, GLint rows
,
1752 GLenum matrixType
, GLint location
, GLsizei count
,
1753 GLboolean transpose
, const GLfloat
*values
)
1755 struct gl_shader_program
*shProg
= ctx
->Shader
.CurrentProgram
;
1756 struct gl_uniform
*uniform
;
1759 if (!shProg
|| !shProg
->LinkStatus
) {
1760 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1761 "glUniformMatrix(program not linked)");
1766 return; /* The standard specifies this as a no-op */
1768 split_location_offset(&location
, &offset
);
1770 if (location
< 0 || location
>= (GLint
) shProg
->Uniforms
->NumUniforms
) {
1771 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniformMatrix(location)");
1774 if (values
== NULL
) {
1775 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniformMatrix");
1779 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1781 uniform
= &shProg
->Uniforms
->Uniforms
[location
];
1783 if (shProg
->VertexProgram
) {
1784 /* convert uniform location to program parameter index */
1785 GLint index
= uniform
->VertPos
;
1787 set_program_uniform_matrix(ctx
, &shProg
->VertexProgram
->Base
,
1789 count
, rows
, cols
, transpose
, values
);
1793 if (shProg
->FragmentProgram
) {
1794 /* convert uniform location to program parameter index */
1795 GLint index
= uniform
->FragPos
;
1797 set_program_uniform_matrix(ctx
, &shProg
->FragmentProgram
->Base
,
1799 count
, rows
, cols
, transpose
, values
);
1803 uniform
->Initialized
= GL_TRUE
;
1808 _mesa_validate_program(GLcontext
*ctx
, GLuint program
)
1810 struct gl_shader_program
*shProg
;
1812 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1817 if (!shProg
->LinkStatus
) {
1818 shProg
->Validated
= GL_FALSE
;
1822 /* From the GL spec, a program is invalid if any of these are true:
1824 any two active samplers in the current program object are of
1825 different types, but refer to the same texture image unit,
1827 any active sampler in the current program object refers to a texture
1828 image unit where fixed-function fragment processing accesses a
1829 texture target that does not match the sampler type, or
1831 the sum of the number of active samplers in the program and the
1832 number of texture image units enabled for fixed-function fragment
1833 processing exceeds the combined limit on the total number of texture
1834 image units allowed.
1837 shProg
->Validated
= GL_TRUE
;
1842 * Plug in Mesa's GLSL functions into the device driver function table.
1845 _mesa_init_glsl_driver_functions(struct dd_function_table
*driver
)
1847 driver
->AttachShader
= _mesa_attach_shader
;
1848 driver
->BindAttribLocation
= _mesa_bind_attrib_location
;
1849 driver
->CompileShader
= _mesa_compile_shader
;
1850 driver
->CreateProgram
= _mesa_create_program
;
1851 driver
->CreateShader
= _mesa_create_shader
;
1852 driver
->DeleteProgram2
= _mesa_delete_program2
;
1853 driver
->DeleteShader
= _mesa_delete_shader
;
1854 driver
->DetachShader
= _mesa_detach_shader
;
1855 driver
->GetActiveAttrib
= _mesa_get_active_attrib
;
1856 driver
->GetActiveUniform
= _mesa_get_active_uniform
;
1857 driver
->GetAttachedShaders
= _mesa_get_attached_shaders
;
1858 driver
->GetAttribLocation
= _mesa_get_attrib_location
;
1859 driver
->GetHandle
= _mesa_get_handle
;
1860 driver
->GetProgramiv
= _mesa_get_programiv
;
1861 driver
->GetProgramInfoLog
= _mesa_get_program_info_log
;
1862 driver
->GetShaderiv
= _mesa_get_shaderiv
;
1863 driver
->GetShaderInfoLog
= _mesa_get_shader_info_log
;
1864 driver
->GetShaderSource
= _mesa_get_shader_source
;
1865 driver
->GetUniformfv
= _mesa_get_uniformfv
;
1866 driver
->GetUniformiv
= _mesa_get_uniformiv
;
1867 driver
->GetUniformLocation
= _mesa_get_uniform_location
;
1868 driver
->IsProgram
= _mesa_is_program
;
1869 driver
->IsShader
= _mesa_is_shader
;
1870 driver
->LinkProgram
= _mesa_link_program
;
1871 driver
->ShaderSource
= _mesa_shader_source
;
1872 driver
->Uniform
= _mesa_uniform
;
1873 driver
->UniformMatrix
= _mesa_uniform_matrix
;
1874 driver
->UseProgram
= _mesa_use_program
;
1875 driver
->ValidateProgram
= _mesa_validate_program
;