2 * Mesa 3-D graphics library
4 * Copyright (C) 2004-2008 Brian Paul All Rights Reserved.
5 * Copyright (C) 2009-2010 VMware, Inc. 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.
29 * Implementation of GLSL-related API functions.
30 * The glUniform* functions are in uniforms.c
34 * 1. Check that the right error code is generated for all _mesa_error() calls.
35 * 2. Insert FLUSH_VERTICES calls in various places
39 #include "main/glheader.h"
40 #include "main/context.h"
41 #include "main/dispatch.h"
42 #include "main/enums.h"
43 #include "main/hash.h"
44 #include "main/mfeatures.h"
45 #include "main/mtypes.h"
46 #include "main/shaderapi.h"
47 #include "main/shaderobj.h"
48 #include "main/uniforms.h"
49 #include "program/program.h"
50 #include "program/prog_parameter.h"
53 #include "../glsl/glsl_parser_extras.h"
54 #include "../glsl/ir_uniform.h"
56 /** Define this to enable shader substitution (see below) */
57 #define SHADER_SUBST 0
61 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
64 get_shader_flags(void)
66 GLbitfield flags
= 0x0;
67 const char *env
= _mesa_getenv("MESA_GLSL");
70 if (strstr(env
, "dump"))
72 if (strstr(env
, "log"))
74 if (strstr(env
, "nopvert"))
75 flags
|= GLSL_NOP_VERT
;
76 if (strstr(env
, "nopfrag"))
77 flags
|= GLSL_NOP_FRAG
;
78 if (strstr(env
, "nopt"))
80 else if (strstr(env
, "opt"))
82 if (strstr(env
, "uniform"))
83 flags
|= GLSL_UNIFORMS
;
84 if (strstr(env
, "useprog"))
85 flags
|= GLSL_USE_PROG
;
93 * Initialize context's shader state.
96 _mesa_init_shader_state(struct gl_context
*ctx
)
98 /* Device drivers may override these to control what kind of instructions
99 * are generated by the GLSL compiler.
101 struct gl_shader_compiler_options options
;
104 memset(&options
, 0, sizeof(options
));
105 options
.MaxUnrollIterations
= 32;
107 /* Default pragma settings */
108 options
.DefaultPragmas
.Optimize
= GL_TRUE
;
110 for (sh
= 0; sh
< MESA_SHADER_TYPES
; ++sh
)
111 memcpy(&ctx
->ShaderCompilerOptions
[sh
], &options
, sizeof(options
));
113 ctx
->Shader
.Flags
= get_shader_flags();
118 * Free the per-context shader-related state.
121 _mesa_free_shader_state(struct gl_context
*ctx
)
123 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentVertexProgram
, NULL
);
124 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentGeometryProgram
,
126 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentFragmentProgram
,
128 _mesa_reference_shader_program(ctx
, &ctx
->Shader
._CurrentFragmentProgram
,
130 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, NULL
);
135 * Return the size of the given GLSL datatype, in floats (components).
138 _mesa_sizeof_glsl_type(GLenum type
)
143 case GL_UNSIGNED_INT
:
148 case GL_SAMPLER_CUBE
:
149 case GL_SAMPLER_1D_SHADOW
:
150 case GL_SAMPLER_2D_SHADOW
:
151 case GL_SAMPLER_2D_RECT_ARB
:
152 case GL_SAMPLER_2D_RECT_SHADOW_ARB
:
153 case GL_SAMPLER_1D_ARRAY_EXT
:
154 case GL_SAMPLER_2D_ARRAY_EXT
:
155 case GL_SAMPLER_1D_ARRAY_SHADOW_EXT
:
156 case GL_SAMPLER_2D_ARRAY_SHADOW_EXT
:
157 case GL_SAMPLER_CUBE_SHADOW_EXT
:
158 case GL_SAMPLER_EXTERNAL_OES
:
162 case GL_UNSIGNED_INT_VEC2
:
167 case GL_UNSIGNED_INT_VEC3
:
172 case GL_UNSIGNED_INT_VEC4
:
176 case GL_FLOAT_MAT2x3
:
177 case GL_FLOAT_MAT2x4
:
178 return 8; /* two float[4] vectors */
180 case GL_FLOAT_MAT3x2
:
181 case GL_FLOAT_MAT3x4
:
182 return 12; /* three float[4] vectors */
184 case GL_FLOAT_MAT4x2
:
185 case GL_FLOAT_MAT4x3
:
186 return 16; /* four float[4] vectors */
188 _mesa_problem(NULL
, "Invalid type in _mesa_sizeof_glsl_type()");
195 * Copy string from <src> to <dst>, up to maxLength characters, returning
196 * length of <dst> in <length>.
197 * \param src the strings source
198 * \param maxLength max chars to copy
199 * \param length returns number of chars copied
200 * \param dst the string destination
203 _mesa_copy_string(GLchar
*dst
, GLsizei maxLength
,
204 GLsizei
*length
, const GLchar
*src
)
207 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
218 * Confirm that the a shader type is valid and supported by the implementation
220 * \param ctx Current GL context
221 * \param type Shader target
225 validate_shader_target(const struct gl_context
*ctx
, GLenum type
)
228 #if FEATURE_ARB_fragment_shader
229 case GL_FRAGMENT_SHADER
:
230 return ctx
->Extensions
.ARB_fragment_shader
;
232 #if FEATURE_ARB_vertex_shader
233 case GL_VERTEX_SHADER
:
234 return ctx
->Extensions
.ARB_vertex_shader
;
236 #if FEATURE_ARB_geometry_shader4
237 case GL_GEOMETRY_SHADER_ARB
:
238 return ctx
->Extensions
.ARB_geometry_shader4
;
247 * Find the length of the longest transform feedback varying name
248 * which was specified with glTransformFeedbackVaryings().
251 longest_feedback_varying_name(const struct gl_shader_program
*shProg
)
255 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
256 GLint len
= strlen(shProg
->TransformFeedback
.VaryingNames
[i
]);
266 is_program(struct gl_context
*ctx
, GLuint name
)
268 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
269 return shProg
? GL_TRUE
: GL_FALSE
;
274 is_shader(struct gl_context
*ctx
, GLuint name
)
276 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
277 return shader
? GL_TRUE
: GL_FALSE
;
282 * Attach shader to a shader program.
285 attach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
287 struct gl_shader_program
*shProg
;
288 struct gl_shader
*sh
;
291 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glAttachShader");
295 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glAttachShader");
300 n
= shProg
->NumShaders
;
301 for (i
= 0; i
< n
; i
++) {
302 if (shProg
->Shaders
[i
] == sh
) {
303 /* The shader is already attched to this program. The
304 * GL_ARB_shader_objects spec says:
306 * "The error INVALID_OPERATION is generated by AttachObjectARB
307 * if <obj> is already attached to <containerObj>."
309 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
315 shProg
->Shaders
= (struct gl_shader
**)
316 _mesa_realloc(shProg
->Shaders
,
317 n
* sizeof(struct gl_shader
*),
318 (n
+ 1) * sizeof(struct gl_shader
*));
319 if (!shProg
->Shaders
) {
320 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
325 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
326 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
327 shProg
->NumShaders
++;
332 create_shader(struct gl_context
*ctx
, GLenum type
)
334 struct gl_shader
*sh
;
337 if (!validate_shader_target(ctx
, type
)) {
338 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(type)");
342 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
343 sh
= ctx
->Driver
.NewShader(ctx
, name
, type
);
344 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, sh
);
351 create_shader_program(struct gl_context
*ctx
)
354 struct gl_shader_program
*shProg
;
356 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
358 shProg
= ctx
->Driver
.NewShaderProgram(ctx
, name
);
360 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, shProg
);
362 assert(shProg
->RefCount
== 1);
369 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
373 delete_shader_program(struct gl_context
*ctx
, GLuint name
)
376 * NOTE: deleting shaders/programs works a bit differently than
377 * texture objects (and buffer objects, etc). Shader/program
378 * handles/IDs exist in the hash table until the object is really
379 * deleted (refcount==0). With texture objects, the handle/ID is
380 * removed from the hash table in glDeleteTextures() while the tex
381 * object itself might linger until its refcount goes to zero.
383 struct gl_shader_program
*shProg
;
385 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
389 if (!shProg
->DeletePending
) {
390 shProg
->DeletePending
= GL_TRUE
;
392 /* effectively, decr shProg's refcount */
393 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
399 delete_shader(struct gl_context
*ctx
, GLuint shader
)
401 struct gl_shader
*sh
;
403 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
407 sh
->DeletePending
= GL_TRUE
;
409 /* effectively, decr sh's refcount */
410 _mesa_reference_shader(ctx
, &sh
, NULL
);
415 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
417 struct gl_shader_program
*shProg
;
421 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
425 n
= shProg
->NumShaders
;
427 for (i
= 0; i
< n
; i
++) {
428 if (shProg
->Shaders
[i
]->Name
== shader
) {
430 struct gl_shader
**newList
;
433 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
435 /* alloc new, smaller array */
436 newList
= (struct gl_shader
**)
437 malloc((n
- 1) * sizeof(struct gl_shader
*));
439 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
442 for (j
= 0; j
< i
; j
++) {
443 newList
[j
] = shProg
->Shaders
[j
];
446 newList
[j
++] = shProg
->Shaders
[i
];
447 free(shProg
->Shaders
);
449 shProg
->Shaders
= newList
;
450 shProg
->NumShaders
= n
- 1;
455 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
456 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
457 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
458 assert(shProg
->Shaders
[j
]->RefCount
> 0);
470 if (is_shader(ctx
, shader
))
471 err
= GL_INVALID_OPERATION
;
472 else if (is_program(ctx
, shader
))
473 err
= GL_INVALID_OPERATION
;
475 err
= GL_INVALID_VALUE
;
476 _mesa_error(ctx
, err
, "glDetachProgram(shader)");
483 * Return list of shaders attached to shader program.
486 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
487 GLsizei
*count
, GLuint
*obj
)
489 struct gl_shader_program
*shProg
=
490 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
493 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
494 obj
[i
] = shProg
->Shaders
[i
]->Name
;
503 * glGetHandleARB() - return ID/name of currently bound shader program.
506 get_handle(struct gl_context
*ctx
, GLenum pname
)
508 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
509 if (ctx
->Shader
.ActiveProgram
)
510 return ctx
->Shader
.ActiveProgram
->Name
;
515 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
522 * glGetProgramiv() - get shader program state.
523 * Note that this is for GLSL shader programs, not ARB vertex/fragment
524 * programs (see glGetProgramivARB).
527 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
, GLint
*params
)
529 struct gl_shader_program
*shProg
530 = _mesa_lookup_shader_program(ctx
, program
);
533 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
538 case GL_DELETE_STATUS
:
539 *params
= shProg
->DeletePending
;
542 *params
= shProg
->LinkStatus
;
544 case GL_VALIDATE_STATUS
:
545 *params
= shProg
->Validated
;
547 case GL_INFO_LOG_LENGTH
:
548 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
550 case GL_ATTACHED_SHADERS
:
551 *params
= shProg
->NumShaders
;
553 case GL_ACTIVE_ATTRIBUTES
:
554 *params
= _mesa_count_active_attribs(shProg
);
556 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
557 *params
= _mesa_longest_attribute_name_length(shProg
);
559 case GL_ACTIVE_UNIFORMS
:
560 *params
= shProg
->NumUserUniformStorage
;
562 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
566 for (i
= 0; i
< shProg
->NumUserUniformStorage
; i
++) {
567 /* Add one for the terminating NUL character.
569 const GLint len
= strlen(shProg
->UniformStorage
[i
].name
) + 1;
578 case GL_PROGRAM_BINARY_LENGTH_OES
:
581 #if FEATURE_EXT_transform_feedback
582 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
583 *params
= shProg
->TransformFeedback
.NumVarying
;
585 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
:
586 *params
= longest_feedback_varying_name(shProg
) + 1;
588 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
589 *params
= shProg
->TransformFeedback
.BufferMode
;
592 #if FEATURE_ARB_geometry_shader4
593 case GL_GEOMETRY_VERTICES_OUT_ARB
:
594 *params
= shProg
->Geom
.VerticesOut
;
596 case GL_GEOMETRY_INPUT_TYPE_ARB
:
597 *params
= shProg
->Geom
.InputType
;
599 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
600 *params
= shProg
->Geom
.OutputType
;
604 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname)");
611 * glGetShaderiv() - get GLSL shader state
614 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
616 struct gl_shader
*shader
=
617 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
625 *params
= shader
->Type
;
627 case GL_DELETE_STATUS
:
628 *params
= shader
->DeletePending
;
630 case GL_COMPILE_STATUS
:
631 *params
= shader
->CompileStatus
;
633 case GL_INFO_LOG_LENGTH
:
634 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
636 case GL_SHADER_SOURCE_LENGTH
:
637 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
640 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
647 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
648 GLsizei
*length
, GLchar
*infoLog
)
650 struct gl_shader_program
*shProg
651 = _mesa_lookup_shader_program(ctx
, program
);
653 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
656 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
661 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
662 GLsizei
*length
, GLchar
*infoLog
)
664 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
666 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
669 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
674 * Return shader source code.
677 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
678 GLsizei
*length
, GLchar
*sourceOut
)
680 struct gl_shader
*sh
;
681 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
685 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
690 * Set/replace shader source code.
693 shader_source(struct gl_context
*ctx
, GLuint shader
, const GLchar
*source
)
695 struct gl_shader
*sh
;
697 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glShaderSource");
701 /* free old shader source string and install new one */
703 free((void *) sh
->Source
);
706 sh
->CompileStatus
= GL_FALSE
;
708 sh
->SourceChecksum
= _mesa_str_checksum(sh
->Source
);
717 compile_shader(struct gl_context
*ctx
, GLuint shaderObj
)
719 struct gl_shader
*sh
;
720 struct gl_shader_compiler_options
*options
;
722 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glCompileShader");
726 options
= &ctx
->ShaderCompilerOptions
[_mesa_shader_type_to_index(sh
->Type
)];
728 /* set default pragma state for shader */
729 sh
->Pragmas
= options
->DefaultPragmas
;
731 /* this call will set the sh->CompileStatus field to indicate if
732 * compilation was successful.
734 _mesa_glsl_compile_shader(ctx
, sh
);
739 * Link a program's shaders.
742 link_program(struct gl_context
*ctx
, GLuint program
)
744 struct gl_shader_program
*shProg
;
745 struct gl_transform_feedback_object
*obj
=
746 ctx
->TransformFeedback
.CurrentObject
;
748 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glLinkProgram");
753 && (shProg
== ctx
->Shader
.CurrentVertexProgram
754 || shProg
== ctx
->Shader
.CurrentGeometryProgram
755 || shProg
== ctx
->Shader
.CurrentFragmentProgram
)) {
756 _mesa_error(ctx
, GL_INVALID_OPERATION
,
757 "glLinkProgram(transform feedback active)");
761 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
763 _mesa_glsl_link_shader(ctx
, shProg
);
769 printf("Link %u shaders in program %u: %s\n",
770 shProg
->NumShaders
, shProg
->Name
,
771 shProg
->LinkStatus
? "Success" : "Failed");
773 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
774 printf(" shader %u, type 0x%x\n",
775 shProg
->Shaders
[i
]->Name
,
776 shProg
->Shaders
[i
]->Type
);
783 * Print basic shader info (for debug).
786 print_shader_info(const struct gl_shader_program
*shProg
)
790 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
791 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
793 switch (shProg
->Shaders
[i
]->Type
) {
794 case GL_VERTEX_SHADER
:
797 case GL_FRAGMENT_SHADER
:
800 case GL_GEOMETRY_SHADER
:
806 printf(" %s shader %u, checksum %u\n", s
,
807 shProg
->Shaders
[i
]->Name
,
808 shProg
->Shaders
[i
]->SourceChecksum
);
810 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
811 printf(" vert prog %u\n",
812 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
813 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
814 printf(" frag prog %u\n",
815 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
816 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
817 printf(" geom prog %u\n",
818 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
823 * Use the named shader program for subsequent glUniform calls
826 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
829 if ((shProg
!= NULL
) && !shProg
->LinkStatus
) {
830 _mesa_error(ctx
, GL_INVALID_OPERATION
,
831 "%s(program %u not linked)", caller
, shProg
->Name
);
835 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
836 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
843 use_shader_program(struct gl_context
*ctx
, GLenum type
,
844 struct gl_shader_program
*shProg
)
846 struct gl_shader_program
**target
;
849 #if FEATURE_ARB_vertex_shader
850 case GL_VERTEX_SHADER
:
851 target
= &ctx
->Shader
.CurrentVertexProgram
;
853 || (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
] == NULL
)) {
858 #if FEATURE_ARB_geometry_shader4
859 case GL_GEOMETRY_SHADER_ARB
:
860 target
= &ctx
->Shader
.CurrentGeometryProgram
;
862 || (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] == NULL
)) {
867 #if FEATURE_ARB_fragment_shader
868 case GL_FRAGMENT_SHADER
:
869 target
= &ctx
->Shader
.CurrentFragmentProgram
;
871 || (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
] == NULL
)) {
880 if (*target
!= shProg
) {
881 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
883 /* If the shader is also bound as the current rendering shader, unbind
884 * it from that binding point as well. This ensures that the correct
885 * semantics of glDeleteProgram are maintained.
888 #if FEATURE_ARB_vertex_shader
889 case GL_VERTEX_SHADER
:
893 #if FEATURE_ARB_geometry_shader4
894 case GL_GEOMETRY_SHADER_ARB
:
898 #if FEATURE_ARB_fragment_shader
899 case GL_FRAGMENT_SHADER
:
900 if (*target
== ctx
->Shader
._CurrentFragmentProgram
) {
901 _mesa_reference_shader_program(ctx
,
902 &ctx
->Shader
._CurrentFragmentProgram
,
909 _mesa_reference_shader_program(ctx
, target
, shProg
);
917 * Use the named shader program for subsequent rendering.
920 _mesa_use_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
922 use_shader_program(ctx
, GL_VERTEX_SHADER
, shProg
);
923 use_shader_program(ctx
, GL_GEOMETRY_SHADER_ARB
, shProg
);
924 use_shader_program(ctx
, GL_FRAGMENT_SHADER
, shProg
);
925 _mesa_active_program(ctx
, shProg
, "glUseProgram");
927 if (ctx
->Driver
.UseProgram
)
928 ctx
->Driver
.UseProgram(ctx
, shProg
);
932 * Do validation of the given shader program.
933 * \param errMsg returns error message if validation fails.
934 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
937 validate_shader_program(const struct gl_shader_program
*shProg
,
940 if (!shProg
->LinkStatus
) {
944 /* From the GL spec, a program is invalid if any of these are true:
946 any two active samplers in the current program object are of
947 different types, but refer to the same texture image unit,
949 any active sampler in the current program object refers to a texture
950 image unit where fixed-function fragment processing accesses a
951 texture target that does not match the sampler type, or
953 the sum of the number of active samplers in the program and the
954 number of texture image units enabled for fixed-function fragment
955 processing exceeds the combined limit on the total number of texture
961 * Check: any two active samplers in the current program object are of
962 * different types, but refer to the same texture image unit,
964 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
972 * Called via glValidateProgram()
975 validate_program(struct gl_context
*ctx
, GLuint program
)
977 struct gl_shader_program
*shProg
;
978 char errMsg
[100] = "";
980 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
985 shProg
->Validated
= validate_shader_program(shProg
, errMsg
);
986 if (!shProg
->Validated
) {
987 /* update info log */
988 if (shProg
->InfoLog
) {
989 ralloc_free(shProg
->InfoLog
);
991 shProg
->InfoLog
= ralloc_strdup(shProg
, errMsg
);
998 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1000 GET_CURRENT_CONTEXT(ctx
);
1001 attach_shader(ctx
, program
, shader
);
1006 _mesa_AttachShader(GLuint program
, GLuint shader
)
1008 GET_CURRENT_CONTEXT(ctx
);
1009 attach_shader(ctx
, program
, shader
);
1014 _mesa_CompileShaderARB(GLhandleARB shaderObj
)
1016 GET_CURRENT_CONTEXT(ctx
);
1017 if (MESA_VERBOSE
& VERBOSE_API
)
1018 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1019 compile_shader(ctx
, shaderObj
);
1024 _mesa_CreateShader(GLenum type
)
1026 GET_CURRENT_CONTEXT(ctx
);
1027 if (MESA_VERBOSE
& VERBOSE_API
)
1028 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type
));
1029 return create_shader(ctx
, type
);
1033 GLhandleARB GLAPIENTRY
1034 _mesa_CreateShaderObjectARB(GLenum type
)
1036 GET_CURRENT_CONTEXT(ctx
);
1037 return create_shader(ctx
, type
);
1042 _mesa_CreateProgram(void)
1044 GET_CURRENT_CONTEXT(ctx
);
1045 if (MESA_VERBOSE
& VERBOSE_API
)
1046 _mesa_debug(ctx
, "glCreateProgram\n");
1047 return create_shader_program(ctx
);
1051 GLhandleARB GLAPIENTRY
1052 _mesa_CreateProgramObjectARB(void)
1054 GET_CURRENT_CONTEXT(ctx
);
1055 return create_shader_program(ctx
);
1060 _mesa_DeleteObjectARB(GLhandleARB obj
)
1062 if (MESA_VERBOSE
& VERBOSE_API
) {
1063 GET_CURRENT_CONTEXT(ctx
);
1064 _mesa_debug(ctx
, "glDeleteObjectARB(%u)\n", obj
);
1068 GET_CURRENT_CONTEXT(ctx
);
1069 FLUSH_VERTICES(ctx
, 0);
1070 if (is_program(ctx
, obj
)) {
1071 delete_shader_program(ctx
, obj
);
1073 else if (is_shader(ctx
, obj
)) {
1074 delete_shader(ctx
, obj
);
1084 _mesa_DeleteProgram(GLuint name
)
1087 GET_CURRENT_CONTEXT(ctx
);
1088 FLUSH_VERTICES(ctx
, 0);
1089 delete_shader_program(ctx
, name
);
1095 _mesa_DeleteShader(GLuint name
)
1098 GET_CURRENT_CONTEXT(ctx
);
1099 FLUSH_VERTICES(ctx
, 0);
1100 delete_shader(ctx
, name
);
1106 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1108 GET_CURRENT_CONTEXT(ctx
);
1109 detach_shader(ctx
, program
, shader
);
1114 _mesa_DetachShader(GLuint program
, GLuint shader
)
1116 GET_CURRENT_CONTEXT(ctx
);
1117 detach_shader(ctx
, program
, shader
);
1122 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1123 GLsizei
* count
, GLhandleARB
* obj
)
1125 GET_CURRENT_CONTEXT(ctx
);
1126 get_attached_shaders(ctx
, container
, maxCount
, count
, obj
);
1131 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1132 GLsizei
*count
, GLuint
*obj
)
1134 GET_CURRENT_CONTEXT(ctx
);
1135 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
);
1140 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1141 GLcharARB
* infoLog
)
1143 GET_CURRENT_CONTEXT(ctx
);
1144 if (is_program(ctx
, object
)) {
1145 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1147 else if (is_shader(ctx
, object
)) {
1148 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1151 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1157 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1159 GET_CURRENT_CONTEXT(ctx
);
1160 /* Implement in terms of GetProgramiv, GetShaderiv */
1161 if (is_program(ctx
, object
)) {
1162 if (pname
== GL_OBJECT_TYPE_ARB
) {
1163 *params
= GL_PROGRAM_OBJECT_ARB
;
1166 get_programiv(ctx
, object
, pname
, params
);
1169 else if (is_shader(ctx
, object
)) {
1170 if (pname
== GL_OBJECT_TYPE_ARB
) {
1171 *params
= GL_SHADER_OBJECT_ARB
;
1174 get_shaderiv(ctx
, object
, pname
, params
);
1178 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1184 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1187 GLint iparams
[1]; /* XXX is one element enough? */
1188 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1189 params
[0] = (GLfloat
) iparams
[0];
1194 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1196 GET_CURRENT_CONTEXT(ctx
);
1197 get_programiv(ctx
, program
, pname
, params
);
1202 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1204 GET_CURRENT_CONTEXT(ctx
);
1205 get_shaderiv(ctx
, shader
, pname
, params
);
1210 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1211 GLsizei
*length
, GLchar
*infoLog
)
1213 GET_CURRENT_CONTEXT(ctx
);
1214 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1219 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1220 GLsizei
*length
, GLchar
*infoLog
)
1222 GET_CURRENT_CONTEXT(ctx
);
1223 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1228 _mesa_GetShaderSourceARB(GLhandleARB shader
, GLsizei maxLength
,
1229 GLsizei
*length
, GLcharARB
*sourceOut
)
1231 GET_CURRENT_CONTEXT(ctx
);
1232 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1236 GLhandleARB GLAPIENTRY
1237 _mesa_GetHandleARB(GLenum pname
)
1239 GET_CURRENT_CONTEXT(ctx
);
1240 return get_handle(ctx
, pname
);
1244 GLboolean GLAPIENTRY
1245 _mesa_IsProgram(GLuint name
)
1247 GET_CURRENT_CONTEXT(ctx
);
1248 return is_program(ctx
, name
);
1252 GLboolean GLAPIENTRY
1253 _mesa_IsShader(GLuint name
)
1255 GET_CURRENT_CONTEXT(ctx
);
1256 return is_shader(ctx
, name
);
1261 _mesa_LinkProgramARB(GLhandleARB programObj
)
1263 GET_CURRENT_CONTEXT(ctx
);
1264 link_program(ctx
, programObj
);
1270 * Read shader source code from a file.
1271 * Useful for debugging to override an app's shader.
1274 read_shader(const char *fname
)
1276 const int max
= 50*1000;
1277 FILE *f
= fopen(fname
, "r");
1278 GLcharARB
*buffer
, *shader
;
1285 buffer
= (char *) malloc(max
);
1286 len
= fread(buffer
, 1, max
, f
);
1291 shader
= _mesa_strdup(buffer
);
1299 * Called via glShaderSource() and glShaderSourceARB() API functions.
1300 * Basically, concatenate the source code strings into one long string
1301 * and pass it to _mesa_shader_source().
1304 _mesa_ShaderSourceARB(GLhandleARB shaderObj
, GLsizei count
,
1305 const GLcharARB
** string
, const GLint
* length
)
1307 GET_CURRENT_CONTEXT(ctx
);
1309 GLsizei i
, totalLength
;
1313 if (!shaderObj
|| string
== NULL
) {
1314 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1319 * This array holds offsets of where the appropriate string ends, thus the
1320 * last element will be set to the total length of the source code.
1322 offsets
= (GLint
*) malloc(count
* sizeof(GLint
));
1323 if (offsets
== NULL
) {
1324 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1328 for (i
= 0; i
< count
; i
++) {
1329 if (string
[i
] == NULL
) {
1330 free((GLvoid
*) offsets
);
1331 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1332 "glShaderSourceARB(null string)");
1335 if (length
== NULL
|| length
[i
] < 0)
1336 offsets
[i
] = strlen(string
[i
]);
1338 offsets
[i
] = length
[i
];
1339 /* accumulate string lengths */
1341 offsets
[i
] += offsets
[i
- 1];
1344 /* Total length of source string is sum off all strings plus two.
1345 * One extra byte for terminating zero, another extra byte to silence
1346 * valgrind warnings in the parser/grammer code.
1348 totalLength
= offsets
[count
- 1] + 2;
1349 source
= (GLcharARB
*) malloc(totalLength
* sizeof(GLcharARB
));
1350 if (source
== NULL
) {
1351 free((GLvoid
*) offsets
);
1352 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1356 for (i
= 0; i
< count
; i
++) {
1357 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1358 memcpy(source
+ start
, string
[i
],
1359 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1361 source
[totalLength
- 1] = '\0';
1362 source
[totalLength
- 2] = '\0';
1365 /* Compute the shader's source code checksum then try to open a file
1366 * named newshader_<CHECKSUM>. If it exists, use it in place of the
1367 * original shader source code. For debugging.
1370 GLcharARB
*newSource
;
1372 checksum
= _mesa_str_checksum(source
);
1374 _mesa_snprintf(filename
, sizeof(filename
), "newshader_%d", checksum
);
1376 newSource
= read_shader(filename
);
1378 fprintf(stderr
, "Mesa: Replacing shader %u chksum=%d with %s\n",
1379 shaderObj
, checksum
, filename
);
1385 shader_source(ctx
, shaderObj
, source
);
1388 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1390 sh
->SourceChecksum
= checksum
; /* save original checksum */
1398 _mesa_UseProgramObjectARB(GLhandleARB program
)
1400 GET_CURRENT_CONTEXT(ctx
);
1401 struct gl_shader_program
*shProg
;
1402 struct gl_transform_feedback_object
*obj
=
1403 ctx
->TransformFeedback
.CurrentObject
;
1405 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1407 if (obj
->Active
&& !obj
->Paused
) {
1408 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1409 "glUseProgram(transform feedback active)");
1414 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1418 if (!shProg
->LinkStatus
) {
1419 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1420 "glUseProgram(program %u not linked)", program
);
1425 if (ctx
->Shader
.Flags
& GLSL_USE_PROG
) {
1426 print_shader_info(shProg
);
1433 _mesa_use_program(ctx
, shProg
);
1438 _mesa_ValidateProgramARB(GLhandleARB program
)
1440 GET_CURRENT_CONTEXT(ctx
);
1441 validate_program(ctx
, program
);
1447 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
1448 GLint
* range
, GLint
* precision
)
1450 const struct gl_program_constants
*limits
;
1451 const struct gl_precision
*p
;
1452 GET_CURRENT_CONTEXT(ctx
);
1454 switch (shadertype
) {
1455 case GL_VERTEX_SHADER
:
1456 limits
= &ctx
->Const
.VertexProgram
;
1458 case GL_FRAGMENT_SHADER
:
1459 limits
= &ctx
->Const
.FragmentProgram
;
1462 _mesa_error(ctx
, GL_INVALID_ENUM
,
1463 "glGetShaderPrecisionFormat(shadertype)");
1467 switch (precisiontype
) {
1469 p
= &limits
->LowFloat
;
1471 case GL_MEDIUM_FLOAT
:
1472 p
= &limits
->MediumFloat
;
1475 p
= &limits
->HighFloat
;
1478 p
= &limits
->LowInt
;
1481 p
= &limits
->MediumInt
;
1484 p
= &limits
->HighInt
;
1487 _mesa_error(ctx
, GL_INVALID_ENUM
,
1488 "glGetShaderPrecisionFormat(precisiontype)");
1492 range
[0] = p
->RangeMin
;
1493 range
[1] = p
->RangeMax
;
1494 precision
[0] = p
->Precision
;
1499 _mesa_ReleaseShaderCompiler(void)
1501 _mesa_destroy_shader_compiler_caches();
1506 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
1507 const void* binary
, GLint length
)
1509 GET_CURRENT_CONTEXT(ctx
);
1512 (void) binaryformat
;
1515 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1518 #endif /* FEATURE_ES2 */
1521 #if FEATURE_ARB_geometry_shader4
1524 _mesa_ProgramParameteriARB(GLuint program
, GLenum pname
, GLint value
)
1526 struct gl_shader_program
*shProg
;
1527 GET_CURRENT_CONTEXT(ctx
);
1529 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1531 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1532 "glProgramParameteri");
1537 case GL_GEOMETRY_VERTICES_OUT_ARB
:
1539 (unsigned) value
> ctx
->Const
.MaxGeometryOutputVertices
) {
1540 _mesa_error(ctx
, GL_INVALID_VALUE
,
1541 "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1545 shProg
->Geom
.VerticesOut
= value
;
1547 case GL_GEOMETRY_INPUT_TYPE_ARB
:
1551 case GL_LINES_ADJACENCY_ARB
:
1553 case GL_TRIANGLES_ADJACENCY_ARB
:
1554 shProg
->Geom
.InputType
= value
;
1557 _mesa_error(ctx
, GL_INVALID_VALUE
,
1558 "glProgramParameteri(geometry input type = %s",
1559 _mesa_lookup_enum_by_nr(value
));
1563 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
1567 case GL_TRIANGLE_STRIP
:
1568 shProg
->Geom
.OutputType
= value
;
1571 _mesa_error(ctx
, GL_INVALID_VALUE
,
1572 "glProgramParameteri(geometry output type = %s",
1573 _mesa_lookup_enum_by_nr(value
));
1578 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteriARB(pname=%s)",
1579 _mesa_lookup_enum_by_nr(pname
));
1587 _mesa_use_shader_program(struct gl_context
*ctx
, GLenum type
,
1588 struct gl_shader_program
*shProg
)
1590 use_shader_program(ctx
, type
, shProg
);
1592 if (ctx
->Driver
.UseProgram
)
1593 ctx
->Driver
.UseProgram(ctx
, shProg
);
1597 _mesa_UseShaderProgramEXT(GLenum type
, GLuint program
)
1599 GET_CURRENT_CONTEXT(ctx
);
1600 struct gl_shader_program
*shProg
= NULL
;
1602 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1604 if (!validate_shader_target(ctx
, type
)) {
1605 _mesa_error(ctx
, GL_INVALID_ENUM
, "glUseShaderProgramEXT(type)");
1609 if (ctx
->TransformFeedback
.CurrentObject
->Active
&&
1610 !ctx
->TransformFeedback
.CurrentObject
->Paused
) {
1611 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1612 "glUseShaderProgramEXT(transform feedback is active)");
1617 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1618 "glUseShaderProgramEXT");
1622 if (!shProg
->LinkStatus
) {
1623 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1624 "glUseShaderProgramEXT(program not linked)");
1629 _mesa_use_shader_program(ctx
, type
, shProg
);
1633 _mesa_ActiveProgramEXT(GLuint program
)
1635 GET_CURRENT_CONTEXT(ctx
);
1636 struct gl_shader_program
*shProg
= (program
!= 0)
1637 ? _mesa_lookup_shader_program_err(ctx
, program
, "glActiveProgramEXT")
1640 _mesa_active_program(ctx
, shProg
, "glActiveProgramEXT");
1645 _mesa_CreateShaderProgramEXT(GLenum type
, const GLchar
*string
)
1647 GET_CURRENT_CONTEXT(ctx
);
1648 const GLuint shader
= create_shader(ctx
, type
);
1652 shader_source(ctx
, shader
, _mesa_strdup(string
));
1653 compile_shader(ctx
, shader
);
1655 program
= create_shader_program(ctx
);
1657 struct gl_shader_program
*shProg
;
1658 struct gl_shader
*sh
;
1659 GLint compiled
= GL_FALSE
;
1661 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1662 sh
= _mesa_lookup_shader(ctx
, shader
);
1664 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
1666 attach_shader(ctx
, program
, shader
);
1667 link_program(ctx
, program
);
1668 detach_shader(ctx
, program
, shader
);
1672 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
1673 append
-error
-to
-info
-log
;
1674 shProg
->LinkStatus
= GL_FALSE
;
1679 ralloc_strcat(&shProg
->InfoLog
, sh
->InfoLog
);
1682 delete_shader(ctx
, shader
);
1689 * Plug in shader-related functions into API dispatch table.
1692 _mesa_init_shader_dispatch(struct _glapi_table
*exec
)
1695 /* GL_ARB_vertex/fragment_shader */
1696 SET_DeleteObjectARB(exec
, _mesa_DeleteObjectARB
);
1697 SET_GetHandleARB(exec
, _mesa_GetHandleARB
);
1698 SET_DetachObjectARB(exec
, _mesa_DetachObjectARB
);
1699 SET_CreateShaderObjectARB(exec
, _mesa_CreateShaderObjectARB
);
1700 SET_ShaderSourceARB(exec
, _mesa_ShaderSourceARB
);
1701 SET_CompileShaderARB(exec
, _mesa_CompileShaderARB
);
1702 SET_CreateProgramObjectARB(exec
, _mesa_CreateProgramObjectARB
);
1703 SET_AttachObjectARB(exec
, _mesa_AttachObjectARB
);
1704 SET_LinkProgramARB(exec
, _mesa_LinkProgramARB
);
1705 SET_UseProgramObjectARB(exec
, _mesa_UseProgramObjectARB
);
1706 SET_ValidateProgramARB(exec
, _mesa_ValidateProgramARB
);
1707 SET_GetObjectParameterfvARB(exec
, _mesa_GetObjectParameterfvARB
);
1708 SET_GetObjectParameterivARB(exec
, _mesa_GetObjectParameterivARB
);
1709 SET_GetInfoLogARB(exec
, _mesa_GetInfoLogARB
);
1710 SET_GetAttachedObjectsARB(exec
, _mesa_GetAttachedObjectsARB
);
1711 SET_GetShaderSourceARB(exec
, _mesa_GetShaderSourceARB
);
1714 SET_AttachShader(exec
, _mesa_AttachShader
);
1715 SET_CreateProgram(exec
, _mesa_CreateProgram
);
1716 SET_CreateShader(exec
, _mesa_CreateShader
);
1717 SET_DeleteProgram(exec
, _mesa_DeleteProgram
);
1718 SET_DeleteShader(exec
, _mesa_DeleteShader
);
1719 SET_DetachShader(exec
, _mesa_DetachShader
);
1720 SET_GetAttachedShaders(exec
, _mesa_GetAttachedShaders
);
1721 SET_GetProgramiv(exec
, _mesa_GetProgramiv
);
1722 SET_GetProgramInfoLog(exec
, _mesa_GetProgramInfoLog
);
1723 SET_GetShaderiv(exec
, _mesa_GetShaderiv
);
1724 SET_GetShaderInfoLog(exec
, _mesa_GetShaderInfoLog
);
1725 SET_IsProgram(exec
, _mesa_IsProgram
);
1726 SET_IsShader(exec
, _mesa_IsShader
);
1728 #if FEATURE_ARB_vertex_shader
1729 SET_BindAttribLocationARB(exec
, _mesa_BindAttribLocationARB
);
1730 SET_GetActiveAttribARB(exec
, _mesa_GetActiveAttribARB
);
1731 SET_GetAttribLocationARB(exec
, _mesa_GetAttribLocationARB
);
1734 #if FEATURE_ARB_geometry_shader4
1735 SET_ProgramParameteriARB(exec
, _mesa_ProgramParameteriARB
);
1738 SET_UseShaderProgramEXT(exec
, _mesa_UseShaderProgramEXT
);
1739 SET_ActiveProgramEXT(exec
, _mesa_ActiveProgramEXT
);
1740 SET_CreateShaderProgramEXT(exec
, _mesa_CreateShaderProgramEXT
);
1742 /* GL_EXT_gpu_shader4 / GL 3.0 */
1743 SET_BindFragDataLocationEXT(exec
, _mesa_BindFragDataLocation
);
1744 SET_GetFragDataLocationEXT(exec
, _mesa_GetFragDataLocation
);
1746 /* GL_ARB_ES2_compatibility */
1747 SET_ReleaseShaderCompiler(exec
, _mesa_ReleaseShaderCompiler
);
1748 SET_GetShaderPrecisionFormat(exec
, _mesa_GetShaderPrecisionFormat
);
1750 #endif /* FEATURE_GL */