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 "program/program.h"
49 #include "program/prog_parameter.h"
50 #include "program/prog_uniform.h"
53 #include "../glsl/glsl_parser_extras.h"
55 /** Define this to enable shader substitution (see below) */
56 #define SHADER_SUBST 0
60 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
63 get_shader_flags(void)
65 GLbitfield flags
= 0x0;
66 const char *env
= _mesa_getenv("MESA_GLSL");
69 if (strstr(env
, "dump"))
71 if (strstr(env
, "log"))
73 if (strstr(env
, "nopvert"))
74 flags
|= GLSL_NOP_VERT
;
75 if (strstr(env
, "nopfrag"))
76 flags
|= GLSL_NOP_FRAG
;
77 if (strstr(env
, "nopt"))
79 else if (strstr(env
, "opt"))
81 if (strstr(env
, "uniform"))
82 flags
|= GLSL_UNIFORMS
;
83 if (strstr(env
, "useprog"))
84 flags
|= GLSL_USE_PROG
;
92 * Initialize context's shader state.
95 _mesa_init_shader_state(struct gl_context
*ctx
)
97 /* Device drivers may override these to control what kind of instructions
98 * are generated by the GLSL compiler.
100 struct gl_shader_compiler_options options
;
103 memset(&options
, 0, sizeof(options
));
104 options
.MaxUnrollIterations
= 32;
106 /* Default pragma settings */
107 options
.DefaultPragmas
.Optimize
= GL_TRUE
;
109 for (sh
= 0; sh
< MESA_SHADER_TYPES
; ++sh
)
110 memcpy(&ctx
->ShaderCompilerOptions
[sh
], &options
, sizeof(options
));
112 ctx
->Shader
.Flags
= get_shader_flags();
117 * Free the per-context shader-related state.
120 _mesa_free_shader_state(struct gl_context
*ctx
)
122 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentVertexProgram
, NULL
);
123 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentGeometryProgram
,
125 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentFragmentProgram
,
127 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, NULL
);
132 * Return the size of the given GLSL datatype, in floats (components).
135 _mesa_sizeof_glsl_type(GLenum type
)
144 case GL_SAMPLER_CUBE
:
145 case GL_SAMPLER_1D_SHADOW
:
146 case GL_SAMPLER_2D_SHADOW
:
147 case GL_SAMPLER_2D_RECT_ARB
:
148 case GL_SAMPLER_2D_RECT_SHADOW_ARB
:
149 case GL_SAMPLER_1D_ARRAY_EXT
:
150 case GL_SAMPLER_2D_ARRAY_EXT
:
151 case GL_SAMPLER_1D_ARRAY_SHADOW_EXT
:
152 case GL_SAMPLER_2D_ARRAY_SHADOW_EXT
:
153 case GL_SAMPLER_CUBE_SHADOW_EXT
:
157 case GL_UNSIGNED_INT_VEC2
:
162 case GL_UNSIGNED_INT_VEC3
:
167 case GL_UNSIGNED_INT_VEC4
:
171 case GL_FLOAT_MAT2x3
:
172 case GL_FLOAT_MAT2x4
:
173 return 8; /* two float[4] vectors */
175 case GL_FLOAT_MAT3x2
:
176 case GL_FLOAT_MAT3x4
:
177 return 12; /* three float[4] vectors */
179 case GL_FLOAT_MAT4x2
:
180 case GL_FLOAT_MAT4x3
:
181 return 16; /* four float[4] vectors */
183 _mesa_problem(NULL
, "Invalid type in _mesa_sizeof_glsl_type()");
190 * Copy string from <src> to <dst>, up to maxLength characters, returning
191 * length of <dst> in <length>.
192 * \param src the strings source
193 * \param maxLength max chars to copy
194 * \param length returns number of chars copied
195 * \param dst the string destination
198 _mesa_copy_string(GLchar
*dst
, GLsizei maxLength
,
199 GLsizei
*length
, const GLchar
*src
)
202 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
213 * Confirm that the a shader type is valid and supported by the implementation
215 * \param ctx Current GL context
216 * \param type Shader target
220 validate_shader_target(const struct gl_context
*ctx
, GLenum type
)
223 #if FEATURE_ARB_fragment_shader
224 case GL_FRAGMENT_SHADER
:
225 return ctx
->Extensions
.ARB_fragment_shader
;
227 #if FEATURE_ARB_vertex_shader
228 case GL_VERTEX_SHADER
:
229 return ctx
->Extensions
.ARB_vertex_shader
;
231 #if FEATURE_ARB_geometry_shader4
232 case GL_GEOMETRY_SHADER_ARB
:
233 return ctx
->Extensions
.ARB_geometry_shader4
;
242 * Find the length of the longest transform feedback varying name
243 * which was specified with glTransformFeedbackVaryings().
246 longest_feedback_varying_name(const struct gl_shader_program
*shProg
)
250 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
251 GLint len
= strlen(shProg
->TransformFeedback
.VaryingNames
[i
]);
261 is_program(struct gl_context
*ctx
, GLuint name
)
263 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
264 return shProg
? GL_TRUE
: GL_FALSE
;
269 is_shader(struct gl_context
*ctx
, GLuint name
)
271 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
272 return shader
? GL_TRUE
: GL_FALSE
;
277 * Attach shader to a shader program.
280 attach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
282 struct gl_shader_program
*shProg
;
283 struct gl_shader
*sh
;
286 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glAttachShader");
290 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glAttachShader");
295 n
= shProg
->NumShaders
;
296 for (i
= 0; i
< n
; i
++) {
297 if (shProg
->Shaders
[i
] == sh
) {
298 /* The shader is already attched to this program. The
299 * GL_ARB_shader_objects spec says:
301 * "The error INVALID_OPERATION is generated by AttachObjectARB
302 * if <obj> is already attached to <containerObj>."
304 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
310 shProg
->Shaders
= (struct gl_shader
**)
311 _mesa_realloc(shProg
->Shaders
,
312 n
* sizeof(struct gl_shader
*),
313 (n
+ 1) * sizeof(struct gl_shader
*));
314 if (!shProg
->Shaders
) {
315 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
320 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
321 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
322 shProg
->NumShaders
++;
327 get_attrib_location(struct gl_context
*ctx
, GLuint program
, const GLchar
*name
)
329 struct gl_shader_program
*shProg
330 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttribLocation");
336 if (!shProg
->LinkStatus
) {
337 _mesa_error(ctx
, GL_INVALID_OPERATION
,
338 "glGetAttribLocation(program not linked)");
345 if (shProg
->VertexProgram
) {
346 const struct gl_program_parameter_list
*attribs
=
347 shProg
->VertexProgram
->Base
.Attributes
;
349 GLint i
= _mesa_lookup_parameter_index(attribs
, -1, name
);
351 return attribs
->Parameters
[i
].StateIndexes
[0];
360 bind_attrib_location(struct gl_context
*ctx
, GLuint program
, GLuint index
,
363 struct gl_shader_program
*shProg
;
364 const GLint size
= -1; /* unknown size */
366 GLenum datatype
= GL_FLOAT_VEC4
;
368 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
369 "glBindAttribLocation");
377 if (strncmp(name
, "gl_", 3) == 0) {
378 _mesa_error(ctx
, GL_INVALID_OPERATION
,
379 "glBindAttribLocation(illegal name)");
383 if (index
>= ctx
->Const
.VertexProgram
.MaxAttribs
) {
384 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBindAttribLocation(index)");
388 if (shProg
->LinkStatus
) {
389 /* get current index/location for the attribute */
390 oldIndex
= get_attrib_location(ctx
, program
, name
);
396 /* this will replace the current value if it's already in the list */
397 i
= _mesa_add_attribute(shProg
->Attributes
, name
, size
, datatype
, index
);
399 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glBindAttribLocation");
404 * Note that this attribute binding won't go into effect until
405 * glLinkProgram is called again.
411 bind_frag_data_location(struct gl_context
*ctx
, GLuint program
,
412 GLuint colorNumber
, const GLchar
*name
)
414 _mesa_problem(ctx
, "bind_frag_data_location() not implemented yet");
419 create_shader(struct gl_context
*ctx
, GLenum type
)
421 struct gl_shader
*sh
;
424 if (!validate_shader_target(ctx
, type
)) {
425 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(type)");
429 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
430 sh
= ctx
->Driver
.NewShader(ctx
, name
, type
);
431 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, sh
);
438 create_shader_program(struct gl_context
*ctx
)
441 struct gl_shader_program
*shProg
;
443 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
445 shProg
= ctx
->Driver
.NewShaderProgram(ctx
, name
);
447 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, shProg
);
449 assert(shProg
->RefCount
== 1);
456 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
460 delete_shader_program(struct gl_context
*ctx
, GLuint name
)
463 * NOTE: deleting shaders/programs works a bit differently than
464 * texture objects (and buffer objects, etc). Shader/program
465 * handles/IDs exist in the hash table until the object is really
466 * deleted (refcount==0). With texture objects, the handle/ID is
467 * removed from the hash table in glDeleteTextures() while the tex
468 * object itself might linger until its refcount goes to zero.
470 struct gl_shader_program
*shProg
;
472 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
476 shProg
->DeletePending
= GL_TRUE
;
478 /* effectively, decr shProg's refcount */
479 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
484 delete_shader(struct gl_context
*ctx
, GLuint shader
)
486 struct gl_shader
*sh
;
488 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
492 sh
->DeletePending
= GL_TRUE
;
494 /* effectively, decr sh's refcount */
495 _mesa_reference_shader(ctx
, &sh
, NULL
);
500 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
502 struct gl_shader_program
*shProg
;
506 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
510 n
= shProg
->NumShaders
;
512 for (i
= 0; i
< n
; i
++) {
513 if (shProg
->Shaders
[i
]->Name
== shader
) {
515 struct gl_shader
**newList
;
518 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
520 /* alloc new, smaller array */
521 newList
= (struct gl_shader
**)
522 malloc((n
- 1) * sizeof(struct gl_shader
*));
524 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
527 for (j
= 0; j
< i
; j
++) {
528 newList
[j
] = shProg
->Shaders
[j
];
531 newList
[j
++] = shProg
->Shaders
[i
];
532 free(shProg
->Shaders
);
534 shProg
->Shaders
= newList
;
535 shProg
->NumShaders
= n
- 1;
540 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
541 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
542 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
543 assert(shProg
->Shaders
[j
]->RefCount
> 0);
555 if (is_shader(ctx
, shader
))
556 err
= GL_INVALID_OPERATION
;
557 else if (is_program(ctx
, shader
))
558 err
= GL_INVALID_OPERATION
;
560 err
= GL_INVALID_VALUE
;
561 _mesa_error(ctx
, err
, "glDetachProgram(shader)");
568 get_active_attrib(struct gl_context
*ctx
, GLuint program
, GLuint index
,
569 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
570 GLenum
*type
, GLchar
*nameOut
)
572 const struct gl_program_parameter_list
*attribs
= NULL
;
573 struct gl_shader_program
*shProg
;
575 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetActiveAttrib");
579 if (shProg
->VertexProgram
)
580 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
582 if (!attribs
|| index
>= attribs
->NumParameters
) {
583 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveAttrib(index)");
587 _mesa_copy_string(nameOut
, maxLength
, length
,
588 attribs
->Parameters
[index
].Name
);
591 *size
= attribs
->Parameters
[index
].Size
592 / _mesa_sizeof_glsl_type(attribs
->Parameters
[index
].DataType
);
595 *type
= attribs
->Parameters
[index
].DataType
;
600 * Return list of shaders attached to shader program.
603 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
604 GLsizei
*count
, GLuint
*obj
)
606 struct gl_shader_program
*shProg
=
607 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
610 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
611 obj
[i
] = shProg
->Shaders
[i
]->Name
;
620 get_frag_data_location(struct gl_context
*ctx
, GLuint program
,
623 _mesa_problem(ctx
, "get_frag_data_location() not implemented yet");
630 * glGetHandleARB() - return ID/name of currently bound shader program.
633 get_handle(struct gl_context
*ctx
, GLenum pname
)
635 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
636 if (ctx
->Shader
.ActiveProgram
)
637 return ctx
->Shader
.ActiveProgram
->Name
;
642 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
649 * glGetProgramiv() - get shader program state.
650 * Note that this is for GLSL shader programs, not ARB vertex/fragment
651 * programs (see glGetProgramivARB).
654 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
, GLint
*params
)
656 const struct gl_program_parameter_list
*attribs
;
657 struct gl_shader_program
*shProg
658 = _mesa_lookup_shader_program(ctx
, program
);
661 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
665 if (shProg
->VertexProgram
)
666 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
671 case GL_DELETE_STATUS
:
672 *params
= shProg
->DeletePending
;
675 *params
= shProg
->LinkStatus
;
677 case GL_VALIDATE_STATUS
:
678 *params
= shProg
->Validated
;
680 case GL_INFO_LOG_LENGTH
:
681 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
683 case GL_ATTACHED_SHADERS
:
684 *params
= shProg
->NumShaders
;
686 case GL_ACTIVE_ATTRIBUTES
:
687 *params
= attribs
? attribs
->NumParameters
: 0;
689 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
690 *params
= _mesa_longest_parameter_name(attribs
, PROGRAM_INPUT
) + 1;
692 case GL_ACTIVE_UNIFORMS
:
693 *params
= shProg
->Uniforms
? shProg
->Uniforms
->NumUniforms
: 0;
695 case GL_ACTIVE_UNIFORM_MAX_LENGTH
:
696 *params
= _mesa_longest_uniform_name(shProg
->Uniforms
);
698 (*params
)++; /* add one for terminating zero */
700 case GL_PROGRAM_BINARY_LENGTH_OES
:
703 #if FEATURE_EXT_transform_feedback
704 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
705 *params
= shProg
->TransformFeedback
.NumVarying
;
707 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
:
708 *params
= longest_feedback_varying_name(shProg
) + 1;
710 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
711 *params
= shProg
->TransformFeedback
.BufferMode
;
714 #if FEATURE_ARB_geometry_shader4
715 case GL_GEOMETRY_VERTICES_OUT_ARB
:
716 *params
= shProg
->Geom
.VerticesOut
;
718 case GL_GEOMETRY_INPUT_TYPE_ARB
:
719 *params
= shProg
->Geom
.InputType
;
721 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
722 *params
= shProg
->Geom
.OutputType
;
726 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname)");
733 * glGetShaderiv() - get GLSL shader state
736 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
738 struct gl_shader
*shader
=
739 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
747 *params
= shader
->Type
;
749 case GL_DELETE_STATUS
:
750 *params
= shader
->DeletePending
;
752 case GL_COMPILE_STATUS
:
753 *params
= shader
->CompileStatus
;
755 case GL_INFO_LOG_LENGTH
:
756 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
758 case GL_SHADER_SOURCE_LENGTH
:
759 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
762 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
769 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
770 GLsizei
*length
, GLchar
*infoLog
)
772 struct gl_shader_program
*shProg
773 = _mesa_lookup_shader_program(ctx
, program
);
775 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
778 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
783 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
784 GLsizei
*length
, GLchar
*infoLog
)
786 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
788 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
791 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
796 * Return shader source code.
799 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
800 GLsizei
*length
, GLchar
*sourceOut
)
802 struct gl_shader
*sh
;
803 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
807 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
812 * Set/replace shader source code.
815 shader_source(struct gl_context
*ctx
, GLuint shader
, const GLchar
*source
)
817 struct gl_shader
*sh
;
819 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glShaderSource");
823 /* free old shader source string and install new one */
825 free((void *) sh
->Source
);
828 sh
->CompileStatus
= GL_FALSE
;
830 sh
->SourceChecksum
= _mesa_str_checksum(sh
->Source
);
839 compile_shader(struct gl_context
*ctx
, GLuint shaderObj
)
841 struct gl_shader
*sh
;
842 struct gl_shader_compiler_options
*options
;
844 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glCompileShader");
848 options
= &ctx
->ShaderCompilerOptions
[_mesa_shader_type_to_index(sh
->Type
)];
850 /* set default pragma state for shader */
851 sh
->Pragmas
= options
->DefaultPragmas
;
853 /* this call will set the sh->CompileStatus field to indicate if
854 * compilation was successful.
856 _mesa_glsl_compile_shader(ctx
, sh
);
861 * Link a program's shaders.
864 link_program(struct gl_context
*ctx
, GLuint program
)
866 struct gl_shader_program
*shProg
;
867 struct gl_transform_feedback_object
*obj
=
868 ctx
->TransformFeedback
.CurrentObject
;
870 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glLinkProgram");
875 && (shProg
== ctx
->Shader
.CurrentVertexProgram
876 || shProg
== ctx
->Shader
.CurrentGeometryProgram
877 || shProg
== ctx
->Shader
.CurrentFragmentProgram
)) {
878 _mesa_error(ctx
, GL_INVALID_OPERATION
,
879 "glLinkProgram(transform feedback active");
883 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
885 _mesa_glsl_link_shader(ctx
, shProg
);
891 printf("Link %u shaders in program %u: %s\n",
892 shProg
->NumShaders
, shProg
->Name
,
893 shProg
->LinkStatus
? "Success" : "Failed");
895 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
896 printf(" shader %u, type 0x%x\n",
897 shProg
->Shaders
[i
]->Name
,
898 shProg
->Shaders
[i
]->Type
);
905 * Print basic shader info (for debug).
908 print_shader_info(const struct gl_shader_program
*shProg
)
912 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
913 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
915 switch (shProg
->Shaders
[i
]->Type
) {
916 case GL_VERTEX_SHADER
:
919 case GL_FRAGMENT_SHADER
:
922 case GL_GEOMETRY_SHADER
:
928 printf(" %s shader %u, checksum %u\n", s
,
929 shProg
->Shaders
[i
]->Name
,
930 shProg
->Shaders
[i
]->SourceChecksum
);
932 if (shProg
->VertexProgram
)
933 printf(" vert prog %u\n", shProg
->VertexProgram
->Base
.Id
);
934 if (shProg
->FragmentProgram
)
935 printf(" frag prog %u\n", shProg
->FragmentProgram
->Base
.Id
);
940 * Use the named shader program for subsequent glUniform calls
943 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
946 if ((shProg
!= NULL
) && !shProg
->LinkStatus
) {
947 _mesa_error(ctx
, GL_INVALID_OPERATION
,
948 "%s(program %u not linked)", caller
, shProg
->Name
);
952 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
953 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
960 use_shader_program(struct gl_context
*ctx
, GLenum type
,
961 struct gl_shader_program
*shProg
)
963 struct gl_shader_program
**target
;
966 #if FEATURE_ARB_vertex_shader
967 case GL_VERTEX_SHADER
:
968 target
= &ctx
->Shader
.CurrentVertexProgram
;
970 || (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
] == NULL
)) {
975 #if FEATURE_ARB_geometry_shader4
976 case GL_GEOMETRY_SHADER_ARB
:
977 target
= &ctx
->Shader
.CurrentGeometryProgram
;
979 || (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] == NULL
)) {
984 #if FEATURE_ARB_fragment_shader
985 case GL_FRAGMENT_SHADER
:
986 target
= &ctx
->Shader
.CurrentFragmentProgram
;
988 || (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
] == NULL
)) {
997 if (*target
!= shProg
) {
998 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
999 _mesa_reference_shader_program(ctx
, target
, shProg
);
1007 * Use the named shader program for subsequent rendering.
1010 _mesa_use_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1012 use_shader_program(ctx
, GL_VERTEX_SHADER
, shProg
);
1013 use_shader_program(ctx
, GL_GEOMETRY_SHADER_ARB
, shProg
);
1014 use_shader_program(ctx
, GL_FRAGMENT_SHADER
, shProg
);
1015 _mesa_active_program(ctx
, shProg
, "glUseProgram");
1017 if (ctx
->Driver
.UseProgram
)
1018 ctx
->Driver
.UseProgram(ctx
, shProg
);
1023 * Validate a program's samplers.
1024 * Specifically, check that there aren't two samplers of different types
1025 * pointing to the same texture unit.
1026 * \return GL_TRUE if valid, GL_FALSE if invalid
1029 validate_samplers(const struct gl_program
*prog
, char *errMsg
)
1031 static const char *targetName
[] = {
1040 GLint targetUsed
[MAX_TEXTURE_IMAGE_UNITS
];
1041 GLbitfield samplersUsed
= prog
->SamplersUsed
;
1044 assert(Elements(targetName
) == NUM_TEXTURE_TARGETS
);
1046 if (samplersUsed
== 0x0)
1049 for (i
= 0; i
< Elements(targetUsed
); i
++)
1052 /* walk over bits which are set in 'samplers' */
1053 while (samplersUsed
) {
1055 gl_texture_index target
;
1056 GLint sampler
= _mesa_ffs(samplersUsed
) - 1;
1057 assert(sampler
>= 0);
1058 assert(sampler
< MAX_TEXTURE_IMAGE_UNITS
);
1059 unit
= prog
->SamplerUnits
[sampler
];
1060 target
= prog
->SamplerTargets
[sampler
];
1061 if (targetUsed
[unit
] != -1 && targetUsed
[unit
] != (int) target
) {
1062 _mesa_snprintf(errMsg
, 100,
1063 "Texture unit %d is accessed both as %s and %s",
1064 unit
, targetName
[targetUsed
[unit
]], targetName
[target
]);
1067 targetUsed
[unit
] = target
;
1068 samplersUsed
^= (1 << sampler
);
1076 * Do validation of the given shader program.
1077 * \param errMsg returns error message if validation fails.
1078 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1081 validate_shader_program(const struct gl_shader_program
*shProg
,
1084 const struct gl_vertex_program
*vp
= shProg
->VertexProgram
;
1085 const struct gl_fragment_program
*fp
= shProg
->FragmentProgram
;
1087 if (!shProg
->LinkStatus
) {
1091 /* From the GL spec, a program is invalid if any of these are true:
1093 any two active samplers in the current program object are of
1094 different types, but refer to the same texture image unit,
1096 any active sampler in the current program object refers to a texture
1097 image unit where fixed-function fragment processing accesses a
1098 texture target that does not match the sampler type, or
1100 the sum of the number of active samplers in the program and the
1101 number of texture image units enabled for fixed-function fragment
1102 processing exceeds the combined limit on the total number of texture
1103 image units allowed.
1108 * Check: any two active samplers in the current program object are of
1109 * different types, but refer to the same texture image unit,
1111 if (vp
&& !validate_samplers(&vp
->Base
, errMsg
)) {
1114 if (fp
&& !validate_samplers(&fp
->Base
, errMsg
)) {
1123 * Called via glValidateProgram()
1126 validate_program(struct gl_context
*ctx
, GLuint program
)
1128 struct gl_shader_program
*shProg
;
1131 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1136 shProg
->Validated
= validate_shader_program(shProg
, errMsg
);
1137 if (!shProg
->Validated
) {
1138 /* update info log */
1139 if (shProg
->InfoLog
) {
1140 talloc_free(shProg
->InfoLog
);
1142 shProg
->InfoLog
= talloc_strdup(shProg
, errMsg
);
1149 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1151 GET_CURRENT_CONTEXT(ctx
);
1152 attach_shader(ctx
, program
, shader
);
1157 _mesa_AttachShader(GLuint program
, GLuint shader
)
1159 GET_CURRENT_CONTEXT(ctx
);
1160 attach_shader(ctx
, program
, shader
);
1165 _mesa_BindAttribLocationARB(GLhandleARB program
, GLuint index
,
1166 const GLcharARB
*name
)
1168 GET_CURRENT_CONTEXT(ctx
);
1169 bind_attrib_location(ctx
, program
, index
, name
);
1173 /* GL_EXT_gpu_shader4, GL3 */
1175 _mesa_BindFragDataLocation(GLuint program
, GLuint colorNumber
,
1178 GET_CURRENT_CONTEXT(ctx
);
1179 bind_frag_data_location(ctx
, program
, colorNumber
, name
);
1184 _mesa_CompileShaderARB(GLhandleARB shaderObj
)
1186 GET_CURRENT_CONTEXT(ctx
);
1187 compile_shader(ctx
, shaderObj
);
1192 _mesa_CreateShader(GLenum type
)
1194 GET_CURRENT_CONTEXT(ctx
);
1195 return create_shader(ctx
, type
);
1199 GLhandleARB GLAPIENTRY
1200 _mesa_CreateShaderObjectARB(GLenum type
)
1202 GET_CURRENT_CONTEXT(ctx
);
1203 return create_shader(ctx
, type
);
1208 _mesa_CreateProgram(void)
1210 GET_CURRENT_CONTEXT(ctx
);
1211 return create_shader_program(ctx
);
1215 GLhandleARB GLAPIENTRY
1216 _mesa_CreateProgramObjectARB(void)
1218 GET_CURRENT_CONTEXT(ctx
);
1219 return create_shader_program(ctx
);
1224 _mesa_DeleteObjectARB(GLhandleARB obj
)
1227 GET_CURRENT_CONTEXT(ctx
);
1228 if (is_program(ctx
, obj
)) {
1229 delete_shader_program(ctx
, obj
);
1231 else if (is_shader(ctx
, obj
)) {
1232 delete_shader(ctx
, obj
);
1242 _mesa_DeleteProgram(GLuint name
)
1245 GET_CURRENT_CONTEXT(ctx
);
1246 delete_shader_program(ctx
, name
);
1252 _mesa_DeleteShader(GLuint name
)
1255 GET_CURRENT_CONTEXT(ctx
);
1256 delete_shader(ctx
, name
);
1262 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1264 GET_CURRENT_CONTEXT(ctx
);
1265 detach_shader(ctx
, program
, shader
);
1270 _mesa_DetachShader(GLuint program
, GLuint shader
)
1272 GET_CURRENT_CONTEXT(ctx
);
1273 detach_shader(ctx
, program
, shader
);
1278 _mesa_GetActiveAttribARB(GLhandleARB program
, GLuint index
,
1279 GLsizei maxLength
, GLsizei
* length
, GLint
* size
,
1280 GLenum
* type
, GLcharARB
* name
)
1282 GET_CURRENT_CONTEXT(ctx
);
1283 get_active_attrib(ctx
, program
, index
, maxLength
, length
, size
, type
, name
);
1288 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1289 GLsizei
* count
, GLhandleARB
* obj
)
1291 GET_CURRENT_CONTEXT(ctx
);
1292 get_attached_shaders(ctx
, container
, maxCount
, count
, obj
);
1297 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1298 GLsizei
*count
, GLuint
*obj
)
1300 GET_CURRENT_CONTEXT(ctx
);
1301 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
);
1306 _mesa_GetAttribLocationARB(GLhandleARB program
, const GLcharARB
* name
)
1308 GET_CURRENT_CONTEXT(ctx
);
1309 return get_attrib_location(ctx
, program
, name
);
1313 /* GL_EXT_gpu_shader4, GL3 */
1315 _mesa_GetFragDataLocation(GLuint program
, const GLchar
*name
)
1317 GET_CURRENT_CONTEXT(ctx
);
1318 return get_frag_data_location(ctx
, program
, name
);
1324 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1325 GLcharARB
* infoLog
)
1327 GET_CURRENT_CONTEXT(ctx
);
1328 if (is_program(ctx
, object
)) {
1329 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1331 else if (is_shader(ctx
, object
)) {
1332 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1335 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1341 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1343 GET_CURRENT_CONTEXT(ctx
);
1344 /* Implement in terms of GetProgramiv, GetShaderiv */
1345 if (is_program(ctx
, object
)) {
1346 if (pname
== GL_OBJECT_TYPE_ARB
) {
1347 *params
= GL_PROGRAM_OBJECT_ARB
;
1350 get_programiv(ctx
, object
, pname
, params
);
1353 else if (is_shader(ctx
, object
)) {
1354 if (pname
== GL_OBJECT_TYPE_ARB
) {
1355 *params
= GL_SHADER_OBJECT_ARB
;
1358 get_shaderiv(ctx
, object
, pname
, params
);
1362 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1368 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1371 GLint iparams
[1]; /* XXX is one element enough? */
1372 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1373 params
[0] = (GLfloat
) iparams
[0];
1378 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1380 GET_CURRENT_CONTEXT(ctx
);
1381 get_programiv(ctx
, program
, pname
, params
);
1386 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1388 GET_CURRENT_CONTEXT(ctx
);
1389 get_shaderiv(ctx
, shader
, pname
, params
);
1394 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1395 GLsizei
*length
, GLchar
*infoLog
)
1397 GET_CURRENT_CONTEXT(ctx
);
1398 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1403 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1404 GLsizei
*length
, GLchar
*infoLog
)
1406 GET_CURRENT_CONTEXT(ctx
);
1407 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1412 _mesa_GetShaderSourceARB(GLhandleARB shader
, GLsizei maxLength
,
1413 GLsizei
*length
, GLcharARB
*sourceOut
)
1415 GET_CURRENT_CONTEXT(ctx
);
1416 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1420 GLhandleARB GLAPIENTRY
1421 _mesa_GetHandleARB(GLenum pname
)
1423 GET_CURRENT_CONTEXT(ctx
);
1424 return get_handle(ctx
, pname
);
1428 GLboolean GLAPIENTRY
1429 _mesa_IsProgram(GLuint name
)
1431 GET_CURRENT_CONTEXT(ctx
);
1432 return is_program(ctx
, name
);
1436 GLboolean GLAPIENTRY
1437 _mesa_IsShader(GLuint name
)
1439 GET_CURRENT_CONTEXT(ctx
);
1440 return is_shader(ctx
, name
);
1445 _mesa_LinkProgramARB(GLhandleARB programObj
)
1447 GET_CURRENT_CONTEXT(ctx
);
1448 link_program(ctx
, programObj
);
1454 * Read shader source code from a file.
1455 * Useful for debugging to override an app's shader.
1458 read_shader(const char *fname
)
1460 const int max
= 50*1000;
1461 FILE *f
= fopen(fname
, "r");
1462 GLcharARB
*buffer
, *shader
;
1469 buffer
= (char *) malloc(max
);
1470 len
= fread(buffer
, 1, max
, f
);
1475 shader
= _mesa_strdup(buffer
);
1483 * Called via glShaderSource() and glShaderSourceARB() API functions.
1484 * Basically, concatenate the source code strings into one long string
1485 * and pass it to _mesa_shader_source().
1488 _mesa_ShaderSourceARB(GLhandleARB shaderObj
, GLsizei count
,
1489 const GLcharARB
** string
, const GLint
* length
)
1491 GET_CURRENT_CONTEXT(ctx
);
1493 GLsizei i
, totalLength
;
1497 if (!shaderObj
|| string
== NULL
) {
1498 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1503 * This array holds offsets of where the appropriate string ends, thus the
1504 * last element will be set to the total length of the source code.
1506 offsets
= (GLint
*) malloc(count
* sizeof(GLint
));
1507 if (offsets
== NULL
) {
1508 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1512 for (i
= 0; i
< count
; i
++) {
1513 if (string
[i
] == NULL
) {
1514 free((GLvoid
*) offsets
);
1515 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glShaderSourceARB(null string)");
1518 if (length
== NULL
|| length
[i
] < 0)
1519 offsets
[i
] = strlen(string
[i
]);
1521 offsets
[i
] = length
[i
];
1522 /* accumulate string lengths */
1524 offsets
[i
] += offsets
[i
- 1];
1527 /* Total length of source string is sum off all strings plus two.
1528 * One extra byte for terminating zero, another extra byte to silence
1529 * valgrind warnings in the parser/grammer code.
1531 totalLength
= offsets
[count
- 1] + 2;
1532 source
= (GLcharARB
*) malloc(totalLength
* sizeof(GLcharARB
));
1533 if (source
== NULL
) {
1534 free((GLvoid
*) offsets
);
1535 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1539 for (i
= 0; i
< count
; i
++) {
1540 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1541 memcpy(source
+ start
, string
[i
],
1542 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1544 source
[totalLength
- 1] = '\0';
1545 source
[totalLength
- 2] = '\0';
1548 /* Compute the shader's source code checksum then try to open a file
1549 * named newshader_<CHECKSUM>. If it exists, use it in place of the
1550 * original shader source code. For debugging.
1553 GLcharARB
*newSource
;
1555 checksum
= _mesa_str_checksum(source
);
1557 _mesa_snprintf(filename
, sizeof(filename
), "newshader_%d", checksum
);
1559 newSource
= read_shader(filename
);
1561 fprintf(stderr
, "Mesa: Replacing shader %u chksum=%d with %s\n",
1562 shaderObj
, checksum
, filename
);
1568 shader_source(ctx
, shaderObj
, source
);
1571 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1573 sh
->SourceChecksum
= checksum
; /* save original checksum */
1581 _mesa_UseProgramObjectARB(GLhandleARB program
)
1583 GET_CURRENT_CONTEXT(ctx
);
1584 struct gl_shader_program
*shProg
;
1585 struct gl_transform_feedback_object
*obj
=
1586 ctx
->TransformFeedback
.CurrentObject
;
1589 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1590 "glUseProgram(transform feedback active)");
1595 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1599 if (!shProg
->LinkStatus
) {
1600 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1601 "glUseProgram(program %u not linked)", program
);
1606 if (ctx
->Shader
.Flags
& GLSL_USE_PROG
) {
1607 print_shader_info(shProg
);
1614 _mesa_use_program(ctx
, shProg
);
1619 _mesa_ValidateProgramARB(GLhandleARB program
)
1621 GET_CURRENT_CONTEXT(ctx
);
1622 validate_program(ctx
, program
);
1628 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
1629 GLint
* range
, GLint
* precision
)
1631 const struct gl_program_constants
*limits
;
1632 const struct gl_precision
*p
;
1633 GET_CURRENT_CONTEXT(ctx
);
1635 switch (shadertype
) {
1636 case GL_VERTEX_SHADER
:
1637 limits
= &ctx
->Const
.VertexProgram
;
1639 case GL_FRAGMENT_SHADER
:
1640 limits
= &ctx
->Const
.FragmentProgram
;
1643 _mesa_error(ctx
, GL_INVALID_ENUM
,
1644 "glGetShaderPrecisionFormat(shadertype)");
1648 switch (precisiontype
) {
1650 p
= &limits
->LowFloat
;
1652 case GL_MEDIUM_FLOAT
:
1653 p
= &limits
->MediumFloat
;
1656 p
= &limits
->HighFloat
;
1659 p
= &limits
->LowInt
;
1662 p
= &limits
->MediumInt
;
1665 p
= &limits
->HighInt
;
1668 _mesa_error(ctx
, GL_INVALID_ENUM
,
1669 "glGetShaderPrecisionFormat(precisiontype)");
1673 range
[0] = p
->RangeMin
;
1674 range
[1] = p
->RangeMax
;
1675 precision
[0] = p
->Precision
;
1680 _mesa_ReleaseShaderCompiler(void)
1682 _mesa_destroy_shader_compiler_caches();
1687 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
1688 const void* binary
, GLint length
)
1690 GET_CURRENT_CONTEXT(ctx
);
1693 (void) binaryformat
;
1696 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1699 #endif /* FEATURE_ES2 */
1702 #if FEATURE_ARB_geometry_shader4
1705 _mesa_ProgramParameteriARB(GLuint program
, GLenum pname
,
1708 struct gl_shader_program
*shProg
;
1709 GET_CURRENT_CONTEXT(ctx
);
1711 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1713 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1714 "glProgramParameteri");
1719 case GL_GEOMETRY_VERTICES_OUT_ARB
:
1721 (unsigned) value
> ctx
->Const
.GeometryProgram
.MaxGeometryOutputVertices
) {
1722 _mesa_error(ctx
, GL_INVALID_VALUE
,
1723 "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1727 shProg
->Geom
.VerticesOut
= value
;
1729 case GL_GEOMETRY_INPUT_TYPE_ARB
:
1733 case GL_LINES_ADJACENCY_ARB
:
1735 case GL_TRIANGLES_ADJACENCY_ARB
:
1736 shProg
->Geom
.InputType
= value
;
1739 _mesa_error(ctx
, GL_INVALID_VALUE
,
1740 "glProgramParameteri(geometry input type = %s",
1741 _mesa_lookup_enum_by_nr(value
));
1745 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
1749 case GL_TRIANGLE_STRIP
:
1750 shProg
->Geom
.OutputType
= value
;
1753 _mesa_error(ctx
, GL_INVALID_VALUE
,
1754 "glProgramParameteri(geometry output type = %s",
1755 _mesa_lookup_enum_by_nr(value
));
1760 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteriARB(pname=%s)",
1761 _mesa_lookup_enum_by_nr(pname
));
1769 _mesa_use_shader_program(struct gl_context
*ctx
, GLenum type
,
1770 struct gl_shader_program
*shProg
)
1772 use_shader_program(ctx
, type
, shProg
);
1774 if (ctx
->Driver
.UseProgram
)
1775 ctx
->Driver
.UseProgram(ctx
, shProg
);
1779 _mesa_UseShaderProgramEXT(GLenum type
, GLuint program
)
1781 GET_CURRENT_CONTEXT(ctx
);
1782 struct gl_shader_program
*shProg
= NULL
;
1784 if (!validate_shader_target(ctx
, type
)) {
1785 _mesa_error(ctx
, GL_INVALID_ENUM
, "glUseShaderProgramEXT(type)");
1789 if (ctx
->TransformFeedback
.CurrentObject
->Active
) {
1790 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1791 "glUseShaderProgramEXT(transform feedback is active)");
1796 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1797 "glUseShaderProgramEXT");
1801 if (!shProg
->LinkStatus
) {
1802 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1803 "glUseShaderProgramEXT(program not linked)");
1808 _mesa_use_shader_program(ctx
, type
, shProg
);
1812 _mesa_ActiveProgramEXT(GLuint program
)
1814 GET_CURRENT_CONTEXT(ctx
);
1815 struct gl_shader_program
*shProg
= (program
!= 0)
1816 ? _mesa_lookup_shader_program_err(ctx
, program
, "glActiveProgramEXT")
1819 _mesa_active_program(ctx
, shProg
, "glActiveProgramEXT");
1824 _mesa_CreateShaderProgramEXT(GLenum type
, const GLchar
*string
)
1826 GET_CURRENT_CONTEXT(ctx
);
1827 const GLuint shader
= create_shader(ctx
, type
);
1831 shader_source(ctx
, shader
, _mesa_strdup(string
));
1832 compile_shader(ctx
, shader
);
1834 program
= create_shader_program(ctx
);
1836 struct gl_shader_program
*shProg
;
1837 struct gl_shader
*sh
;
1838 GLint compiled
= GL_FALSE
;
1840 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1841 sh
= _mesa_lookup_shader(ctx
, shader
);
1843 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
1845 attach_shader(ctx
, program
, shader
);
1846 link_program(ctx
, program
);
1847 detach_shader(ctx
, program
, shader
);
1851 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
1852 append
-error
-to
-info
-log
;
1853 shProg
->LinkStatus
= GL_FALSE
;
1858 shProg
->InfoLog
= talloc_strdup_append(shProg
->InfoLog
, sh
->InfoLog
);
1861 delete_shader(ctx
, shader
);
1868 * Plug in shader-related functions into API dispatch table.
1871 _mesa_init_shader_dispatch(struct _glapi_table
*exec
)
1874 /* GL_ARB_vertex/fragment_shader */
1875 SET_DeleteObjectARB(exec
, _mesa_DeleteObjectARB
);
1876 SET_GetHandleARB(exec
, _mesa_GetHandleARB
);
1877 SET_DetachObjectARB(exec
, _mesa_DetachObjectARB
);
1878 SET_CreateShaderObjectARB(exec
, _mesa_CreateShaderObjectARB
);
1879 SET_ShaderSourceARB(exec
, _mesa_ShaderSourceARB
);
1880 SET_CompileShaderARB(exec
, _mesa_CompileShaderARB
);
1881 SET_CreateProgramObjectARB(exec
, _mesa_CreateProgramObjectARB
);
1882 SET_AttachObjectARB(exec
, _mesa_AttachObjectARB
);
1883 SET_LinkProgramARB(exec
, _mesa_LinkProgramARB
);
1884 SET_UseProgramObjectARB(exec
, _mesa_UseProgramObjectARB
);
1885 SET_ValidateProgramARB(exec
, _mesa_ValidateProgramARB
);
1886 SET_GetObjectParameterfvARB(exec
, _mesa_GetObjectParameterfvARB
);
1887 SET_GetObjectParameterivARB(exec
, _mesa_GetObjectParameterivARB
);
1888 SET_GetInfoLogARB(exec
, _mesa_GetInfoLogARB
);
1889 SET_GetAttachedObjectsARB(exec
, _mesa_GetAttachedObjectsARB
);
1890 SET_GetShaderSourceARB(exec
, _mesa_GetShaderSourceARB
);
1893 SET_AttachShader(exec
, _mesa_AttachShader
);
1894 SET_CreateProgram(exec
, _mesa_CreateProgram
);
1895 SET_CreateShader(exec
, _mesa_CreateShader
);
1896 SET_DeleteProgram(exec
, _mesa_DeleteProgram
);
1897 SET_DeleteShader(exec
, _mesa_DeleteShader
);
1898 SET_DetachShader(exec
, _mesa_DetachShader
);
1899 SET_GetAttachedShaders(exec
, _mesa_GetAttachedShaders
);
1900 SET_GetProgramiv(exec
, _mesa_GetProgramiv
);
1901 SET_GetProgramInfoLog(exec
, _mesa_GetProgramInfoLog
);
1902 SET_GetShaderiv(exec
, _mesa_GetShaderiv
);
1903 SET_GetShaderInfoLog(exec
, _mesa_GetShaderInfoLog
);
1904 SET_IsProgram(exec
, _mesa_IsProgram
);
1905 SET_IsShader(exec
, _mesa_IsShader
);
1907 #if FEATURE_ARB_vertex_shader
1908 SET_BindAttribLocationARB(exec
, _mesa_BindAttribLocationARB
);
1909 SET_GetActiveAttribARB(exec
, _mesa_GetActiveAttribARB
);
1910 SET_GetAttribLocationARB(exec
, _mesa_GetAttribLocationARB
);
1913 #if FEATURE_ARB_geometry_shader4
1914 SET_ProgramParameteriARB(exec
, _mesa_ProgramParameteriARB
);
1917 SET_UseShaderProgramEXT(exec
, _mesa_UseShaderProgramEXT
);
1918 SET_ActiveProgramEXT(exec
, _mesa_ActiveProgramEXT
);
1919 SET_CreateShaderProgramEXT(exec
, _mesa_CreateShaderProgramEXT
);
1921 /* GL_EXT_gpu_shader4 / GL 3.0 */
1922 SET_BindFragDataLocationEXT(exec
, _mesa_BindFragDataLocation
);
1923 SET_GetFragDataLocationEXT(exec
, _mesa_GetFragDataLocation
);
1925 /* GL_ARB_ES2_compatibility */
1926 SET_ReleaseShaderCompiler(exec
, _mesa_ReleaseShaderCompiler
);
1927 SET_GetShaderPrecisionFormat(exec
, _mesa_GetShaderPrecisionFormat
);
1929 #endif /* FEATURE_GL */