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/shaderapi.h"
45 #include "main/shaderobj.h"
46 #include "program/program.h"
47 #include "program/prog_parameter.h"
48 #include "program/prog_uniform.h"
52 /** Define this to enable shader substitution (see below) */
53 #define SHADER_SUBST 0
57 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
60 get_shader_flags(void)
62 GLbitfield flags
= 0x0;
63 const char *env
= _mesa_getenv("MESA_GLSL");
66 if (strstr(env
, "dump"))
68 if (strstr(env
, "log"))
70 if (strstr(env
, "nopvert"))
71 flags
|= GLSL_NOP_VERT
;
72 if (strstr(env
, "nopfrag"))
73 flags
|= GLSL_NOP_FRAG
;
74 if (strstr(env
, "nopt"))
76 else if (strstr(env
, "opt"))
78 if (strstr(env
, "uniform"))
79 flags
|= GLSL_UNIFORMS
;
80 if (strstr(env
, "useprog"))
81 flags
|= GLSL_USE_PROG
;
89 * Initialize context's shader state.
92 _mesa_init_shader_state(struct gl_context
*ctx
)
94 /* Device drivers may override these to control what kind of instructions
95 * are generated by the GLSL compiler.
97 struct gl_shader_compiler_options options
;
100 memset(&options
, 0, sizeof(options
));
101 options
.MaxUnrollIterations
= 32;
103 /* Default pragma settings */
104 options
.DefaultPragmas
.Optimize
= GL_TRUE
;
106 for(i
= 0; i
< MESA_SHADER_TYPES
; ++i
)
107 memcpy(&ctx
->ShaderCompilerOptions
[i
], &options
, sizeof(options
));
109 ctx
->Shader
.Flags
= get_shader_flags();
114 * Free the per-context shader-related state.
117 _mesa_free_shader_state(struct gl_context
*ctx
)
119 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, NULL
);
124 * Return the size of the given GLSL datatype, in floats (components).
127 _mesa_sizeof_glsl_type(GLenum type
)
136 case GL_SAMPLER_CUBE
:
137 case GL_SAMPLER_1D_SHADOW
:
138 case GL_SAMPLER_2D_SHADOW
:
139 case GL_SAMPLER_2D_RECT_ARB
:
140 case GL_SAMPLER_2D_RECT_SHADOW_ARB
:
141 case GL_SAMPLER_1D_ARRAY_EXT
:
142 case GL_SAMPLER_2D_ARRAY_EXT
:
143 case GL_SAMPLER_1D_ARRAY_SHADOW_EXT
:
144 case GL_SAMPLER_2D_ARRAY_SHADOW_EXT
:
145 case GL_SAMPLER_CUBE_SHADOW_EXT
:
149 case GL_UNSIGNED_INT_VEC2
:
154 case GL_UNSIGNED_INT_VEC3
:
159 case GL_UNSIGNED_INT_VEC4
:
163 case GL_FLOAT_MAT2x3
:
164 case GL_FLOAT_MAT2x4
:
165 return 8; /* two float[4] vectors */
167 case GL_FLOAT_MAT3x2
:
168 case GL_FLOAT_MAT3x4
:
169 return 12; /* three float[4] vectors */
171 case GL_FLOAT_MAT4x2
:
172 case GL_FLOAT_MAT4x3
:
173 return 16; /* four float[4] vectors */
175 _mesa_problem(NULL
, "Invalid type in _mesa_sizeof_glsl_type()");
182 * Copy string from <src> to <dst>, up to maxLength characters, returning
183 * length of <dst> in <length>.
184 * \param src the strings source
185 * \param maxLength max chars to copy
186 * \param length returns number of chars copied
187 * \param dst the string destination
190 _mesa_copy_string(GLchar
*dst
, GLsizei maxLength
,
191 GLsizei
*length
, const GLchar
*src
)
194 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
205 * Find the length of the longest transform feedback varying name
206 * which was specified with glTransformFeedbackVaryings().
209 longest_feedback_varying_name(const struct gl_shader_program
*shProg
)
213 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
214 GLint len
= strlen(shProg
->TransformFeedback
.VaryingNames
[i
]);
224 is_program(struct gl_context
*ctx
, GLuint name
)
226 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
227 return shProg
? GL_TRUE
: GL_FALSE
;
232 is_shader(struct gl_context
*ctx
, GLuint name
)
234 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
235 return shader
? GL_TRUE
: GL_FALSE
;
240 * Attach shader to a shader program.
243 attach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
245 struct gl_shader_program
*shProg
;
246 struct gl_shader
*sh
;
249 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glAttachShader");
253 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glAttachShader");
258 n
= shProg
->NumShaders
;
259 for (i
= 0; i
< n
; i
++) {
260 if (shProg
->Shaders
[i
] == sh
) {
261 /* The shader is already attched to this program. The
262 * GL_ARB_shader_objects spec says:
264 * "The error INVALID_OPERATION is generated by AttachObjectARB
265 * if <obj> is already attached to <containerObj>."
267 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
273 shProg
->Shaders
= (struct gl_shader
**)
274 _mesa_realloc(shProg
->Shaders
,
275 n
* sizeof(struct gl_shader
*),
276 (n
+ 1) * sizeof(struct gl_shader
*));
277 if (!shProg
->Shaders
) {
278 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
283 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
284 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
285 shProg
->NumShaders
++;
290 get_attrib_location(struct gl_context
*ctx
, GLuint program
, const GLchar
*name
)
292 struct gl_shader_program
*shProg
293 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttribLocation");
299 if (!shProg
->LinkStatus
) {
300 _mesa_error(ctx
, GL_INVALID_OPERATION
,
301 "glGetAttribLocation(program not linked)");
308 if (shProg
->VertexProgram
) {
309 const struct gl_program_parameter_list
*attribs
=
310 shProg
->VertexProgram
->Base
.Attributes
;
312 GLint i
= _mesa_lookup_parameter_index(attribs
, -1, name
);
314 return attribs
->Parameters
[i
].StateIndexes
[0];
323 bind_attrib_location(struct gl_context
*ctx
, GLuint program
, GLuint index
,
326 struct gl_shader_program
*shProg
;
327 const GLint size
= -1; /* unknown size */
329 GLenum datatype
= GL_FLOAT_VEC4
;
331 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
332 "glBindAttribLocation");
340 if (strncmp(name
, "gl_", 3) == 0) {
341 _mesa_error(ctx
, GL_INVALID_OPERATION
,
342 "glBindAttribLocation(illegal name)");
346 if (index
>= ctx
->Const
.VertexProgram
.MaxAttribs
) {
347 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBindAttribLocation(index)");
351 if (shProg
->LinkStatus
) {
352 /* get current index/location for the attribute */
353 oldIndex
= get_attrib_location(ctx
, program
, name
);
359 /* this will replace the current value if it's already in the list */
360 i
= _mesa_add_attribute(shProg
->Attributes
, name
, size
, datatype
, index
);
362 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glBindAttribLocation");
367 * Note that this attribute binding won't go into effect until
368 * glLinkProgram is called again.
374 create_shader(struct gl_context
*ctx
, GLenum type
)
376 struct gl_shader
*sh
;
379 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
382 case GL_FRAGMENT_SHADER
:
383 case GL_VERTEX_SHADER
:
384 case GL_GEOMETRY_SHADER_ARB
:
385 sh
= ctx
->Driver
.NewShader(ctx
, name
, type
);
388 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(type)");
392 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, sh
);
399 create_shader_program(struct gl_context
*ctx
)
402 struct gl_shader_program
*shProg
;
404 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
406 shProg
= ctx
->Driver
.NewShaderProgram(ctx
, name
);
408 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, shProg
);
410 assert(shProg
->RefCount
== 1);
417 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
421 delete_shader_program(struct gl_context
*ctx
, GLuint name
)
424 * NOTE: deleting shaders/programs works a bit differently than
425 * texture objects (and buffer objects, etc). Shader/program
426 * handles/IDs exist in the hash table until the object is really
427 * deleted (refcount==0). With texture objects, the handle/ID is
428 * removed from the hash table in glDeleteTextures() while the tex
429 * object itself might linger until its refcount goes to zero.
431 struct gl_shader_program
*shProg
;
433 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
437 shProg
->DeletePending
= GL_TRUE
;
439 /* effectively, decr shProg's refcount */
440 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
445 delete_shader(struct gl_context
*ctx
, GLuint shader
)
447 struct gl_shader
*sh
;
449 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
453 sh
->DeletePending
= GL_TRUE
;
455 /* effectively, decr sh's refcount */
456 _mesa_reference_shader(ctx
, &sh
, NULL
);
461 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
463 struct gl_shader_program
*shProg
;
467 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
471 n
= shProg
->NumShaders
;
473 for (i
= 0; i
< n
; i
++) {
474 if (shProg
->Shaders
[i
]->Name
== shader
) {
476 struct gl_shader
**newList
;
479 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
481 /* alloc new, smaller array */
482 newList
= (struct gl_shader
**)
483 malloc((n
- 1) * sizeof(struct gl_shader
*));
485 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
488 for (j
= 0; j
< i
; j
++) {
489 newList
[j
] = shProg
->Shaders
[j
];
492 newList
[j
++] = shProg
->Shaders
[i
];
493 free(shProg
->Shaders
);
495 shProg
->Shaders
= newList
;
496 shProg
->NumShaders
= n
- 1;
501 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
502 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
503 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
504 assert(shProg
->Shaders
[j
]->RefCount
> 0);
516 if (is_shader(ctx
, shader
))
517 err
= GL_INVALID_OPERATION
;
518 else if (is_program(ctx
, shader
))
519 err
= GL_INVALID_OPERATION
;
521 err
= GL_INVALID_VALUE
;
522 _mesa_error(ctx
, err
, "glDetachProgram(shader)");
529 get_active_attrib(struct gl_context
*ctx
, GLuint program
, GLuint index
,
530 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
531 GLenum
*type
, GLchar
*nameOut
)
533 const struct gl_program_parameter_list
*attribs
= NULL
;
534 struct gl_shader_program
*shProg
;
536 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetActiveAttrib");
540 if (shProg
->VertexProgram
)
541 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
543 if (!attribs
|| index
>= attribs
->NumParameters
) {
544 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveAttrib(index)");
548 _mesa_copy_string(nameOut
, maxLength
, length
,
549 attribs
->Parameters
[index
].Name
);
552 *size
= attribs
->Parameters
[index
].Size
553 / _mesa_sizeof_glsl_type(attribs
->Parameters
[index
].DataType
);
556 *type
= attribs
->Parameters
[index
].DataType
;
561 * Return list of shaders attached to shader program.
564 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
565 GLsizei
*count
, GLuint
*obj
)
567 struct gl_shader_program
*shProg
=
568 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
571 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
572 obj
[i
] = shProg
->Shaders
[i
]->Name
;
581 * glGetHandleARB() - return ID/name of currently bound shader program.
584 get_handle(struct gl_context
*ctx
, GLenum pname
)
586 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
587 if (ctx
->Shader
.CurrentProgram
)
588 return ctx
->Shader
.CurrentProgram
->Name
;
593 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
600 * glGetProgramiv() - get shader program state.
601 * Note that this is for GLSL shader programs, not ARB vertex/fragment
602 * programs (see glGetProgramivARB).
605 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
, GLint
*params
)
607 const struct gl_program_parameter_list
*attribs
;
608 struct gl_shader_program
*shProg
609 = _mesa_lookup_shader_program(ctx
, program
);
612 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
616 if (shProg
->VertexProgram
)
617 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
622 case GL_DELETE_STATUS
:
623 *params
= shProg
->DeletePending
;
626 *params
= shProg
->LinkStatus
;
628 case GL_VALIDATE_STATUS
:
629 *params
= shProg
->Validated
;
631 case GL_INFO_LOG_LENGTH
:
632 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
634 case GL_ATTACHED_SHADERS
:
635 *params
= shProg
->NumShaders
;
637 case GL_ACTIVE_ATTRIBUTES
:
638 *params
= attribs
? attribs
->NumParameters
: 0;
640 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
641 *params
= _mesa_longest_parameter_name(attribs
, PROGRAM_INPUT
) + 1;
643 case GL_ACTIVE_UNIFORMS
:
644 *params
= shProg
->Uniforms
? shProg
->Uniforms
->NumUniforms
: 0;
646 case GL_ACTIVE_UNIFORM_MAX_LENGTH
:
647 *params
= _mesa_longest_uniform_name(shProg
->Uniforms
);
649 (*params
)++; /* add one for terminating zero */
651 case GL_PROGRAM_BINARY_LENGTH_OES
:
654 #if FEATURE_EXT_transform_feedback
655 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
656 *params
= shProg
->TransformFeedback
.NumVarying
;
658 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
:
659 *params
= longest_feedback_varying_name(shProg
) + 1;
661 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
662 *params
= shProg
->TransformFeedback
.BufferMode
;
665 #if FEATURE_ARB_geometry_shader4
666 case GL_GEOMETRY_VERTICES_OUT_ARB
:
667 *params
= shProg
->Geom
.VerticesOut
;
669 case GL_GEOMETRY_INPUT_TYPE_ARB
:
670 *params
= shProg
->Geom
.InputType
;
672 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
673 *params
= shProg
->Geom
.OutputType
;
677 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname)");
684 * glGetShaderiv() - get GLSL shader state
687 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
689 struct gl_shader
*shader
=
690 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
698 *params
= shader
->Type
;
700 case GL_DELETE_STATUS
:
701 *params
= shader
->DeletePending
;
703 case GL_COMPILE_STATUS
:
704 *params
= shader
->CompileStatus
;
706 case GL_INFO_LOG_LENGTH
:
707 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
709 case GL_SHADER_SOURCE_LENGTH
:
710 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
713 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
720 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
721 GLsizei
*length
, GLchar
*infoLog
)
723 struct gl_shader_program
*shProg
724 = _mesa_lookup_shader_program(ctx
, program
);
726 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
729 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
734 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
735 GLsizei
*length
, GLchar
*infoLog
)
737 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
739 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
742 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
747 * Return shader source code.
750 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
751 GLsizei
*length
, GLchar
*sourceOut
)
753 struct gl_shader
*sh
;
754 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
758 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
763 * Set/replace shader source code.
766 shader_source(struct gl_context
*ctx
, GLuint shader
, const GLchar
*source
)
768 struct gl_shader
*sh
;
770 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glShaderSource");
774 /* free old shader source string and install new one */
776 free((void *) sh
->Source
);
779 sh
->CompileStatus
= GL_FALSE
;
781 sh
->SourceChecksum
= _mesa_str_checksum(sh
->Source
);
790 compile_shader(struct gl_context
*ctx
, GLuint shaderObj
)
792 struct gl_shader
*sh
;
793 struct gl_shader_compiler_options
*options
;
795 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glCompileShader");
799 options
= &ctx
->ShaderCompilerOptions
[_mesa_shader_type_to_index(sh
->Type
)];
801 /* set default pragma state for shader */
802 sh
->Pragmas
= options
->DefaultPragmas
;
804 /* this call will set the sh->CompileStatus field to indicate if
805 * compilation was successful.
807 _mesa_glsl_compile_shader(ctx
, sh
);
812 * Link a program's shaders.
815 link_program(struct gl_context
*ctx
, GLuint program
)
817 struct gl_shader_program
*shProg
;
818 struct gl_transform_feedback_object
*obj
=
819 ctx
->TransformFeedback
.CurrentObject
;
821 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glLinkProgram");
825 if (obj
->Active
&& shProg
== ctx
->Shader
.CurrentProgram
) {
826 _mesa_error(ctx
, GL_INVALID_OPERATION
,
827 "glLinkProgram(transform feedback active");
831 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
833 _mesa_glsl_link_shader(ctx
, shProg
);
839 printf("Link %u shaders in program %u: %s\n",
840 shProg
->NumShaders
, shProg
->Name
,
841 shProg
->LinkStatus
? "Success" : "Failed");
843 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
844 printf(" shader %u, type 0x%x\n",
845 shProg
->Shaders
[i
]->Name
,
846 shProg
->Shaders
[i
]->Type
);
853 * Print basic shader info (for debug).
856 print_shader_info(const struct gl_shader_program
*shProg
)
860 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
861 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
863 switch (shProg
->Shaders
[i
]->Type
) {
864 case GL_VERTEX_SHADER
:
867 case GL_FRAGMENT_SHADER
:
870 case GL_GEOMETRY_SHADER
:
876 printf(" %s shader %u, checksum %u\n", s
,
877 shProg
->Shaders
[i
]->Name
,
878 shProg
->Shaders
[i
]->SourceChecksum
);
880 if (shProg
->VertexProgram
)
881 printf(" vert prog %u\n", shProg
->VertexProgram
->Base
.Id
);
882 if (shProg
->FragmentProgram
)
883 printf(" frag prog %u\n", shProg
->FragmentProgram
->Base
.Id
);
888 * Use the named shader program for subsequent rendering.
891 _mesa_use_program(struct gl_context
*ctx
, GLuint program
)
893 struct gl_shader_program
*shProg
;
894 struct gl_transform_feedback_object
*obj
=
895 ctx
->TransformFeedback
.CurrentObject
;
898 _mesa_error(ctx
, GL_INVALID_OPERATION
,
899 "glUseProgram(transform feedback active)");
903 if (ctx
->Shader
.CurrentProgram
&&
904 ctx
->Shader
.CurrentProgram
->Name
== program
) {
910 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
914 if (!shProg
->LinkStatus
) {
915 _mesa_error(ctx
, GL_INVALID_OPERATION
,
916 "glUseProgram(program %u not linked)", program
);
921 if (ctx
->Shader
.Flags
& GLSL_USE_PROG
) {
922 print_shader_info(shProg
);
929 if (ctx
->Shader
.CurrentProgram
!= shProg
) {
930 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
931 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, shProg
);
934 if (ctx
->Driver
.UseProgram
)
935 ctx
->Driver
.UseProgram(ctx
, shProg
);
940 * Validate a program's samplers.
941 * Specifically, check that there aren't two samplers of different types
942 * pointing to the same texture unit.
943 * \return GL_TRUE if valid, GL_FALSE if invalid
946 validate_samplers(struct gl_context
*ctx
, const struct gl_program
*prog
, char *errMsg
)
948 static const char *targetName
[] = {
957 GLint targetUsed
[MAX_TEXTURE_IMAGE_UNITS
];
958 GLbitfield samplersUsed
= prog
->SamplersUsed
;
961 assert(Elements(targetName
) == NUM_TEXTURE_TARGETS
);
963 if (samplersUsed
== 0x0)
966 for (i
= 0; i
< Elements(targetUsed
); i
++)
969 /* walk over bits which are set in 'samplers' */
970 while (samplersUsed
) {
972 gl_texture_index target
;
973 GLint sampler
= _mesa_ffs(samplersUsed
) - 1;
974 assert(sampler
>= 0);
975 assert(sampler
< MAX_TEXTURE_IMAGE_UNITS
);
976 unit
= prog
->SamplerUnits
[sampler
];
977 target
= prog
->SamplerTargets
[sampler
];
978 if (targetUsed
[unit
] != -1 && targetUsed
[unit
] != target
) {
979 _mesa_snprintf(errMsg
, 100,
980 "Texture unit %d is accessed both as %s and %s",
981 unit
, targetName
[targetUsed
[unit
]], targetName
[target
]);
984 targetUsed
[unit
] = target
;
985 samplersUsed
^= (1 << sampler
);
993 * Do validation of the given shader program.
994 * \param errMsg returns error message if validation fails.
995 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
998 validate_shader_program(struct gl_context
*ctx
,
999 const struct gl_shader_program
*shProg
,
1002 const struct gl_vertex_program
*vp
= shProg
->VertexProgram
;
1003 const struct gl_fragment_program
*fp
= shProg
->FragmentProgram
;
1005 if (!shProg
->LinkStatus
) {
1009 /* From the GL spec, a program is invalid if any of these are true:
1011 any two active samplers in the current program object are of
1012 different types, but refer to the same texture image unit,
1014 any active sampler in the current program object refers to a texture
1015 image unit where fixed-function fragment processing accesses a
1016 texture target that does not match the sampler type, or
1018 the sum of the number of active samplers in the program and the
1019 number of texture image units enabled for fixed-function fragment
1020 processing exceeds the combined limit on the total number of texture
1021 image units allowed.
1026 * Check: any two active samplers in the current program object are of
1027 * different types, but refer to the same texture image unit,
1029 if (vp
&& !validate_samplers(ctx
, &vp
->Base
, errMsg
)) {
1032 if (fp
&& !validate_samplers(ctx
, &fp
->Base
, errMsg
)) {
1041 * Called via glValidateProgram()
1044 validate_program(struct gl_context
*ctx
, GLuint program
)
1046 struct gl_shader_program
*shProg
;
1049 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1054 shProg
->Validated
= validate_shader_program(ctx
, shProg
, errMsg
);
1055 if (!shProg
->Validated
) {
1056 /* update info log */
1057 if (shProg
->InfoLog
) {
1058 talloc_free(shProg
->InfoLog
);
1060 shProg
->InfoLog
= talloc_strdup(shProg
, errMsg
);
1067 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1069 GET_CURRENT_CONTEXT(ctx
);
1070 attach_shader(ctx
, program
, shader
);
1075 _mesa_AttachShader(GLuint program
, GLuint shader
)
1077 GET_CURRENT_CONTEXT(ctx
);
1078 attach_shader(ctx
, program
, shader
);
1083 _mesa_BindAttribLocationARB(GLhandleARB program
, GLuint index
,
1084 const GLcharARB
*name
)
1086 GET_CURRENT_CONTEXT(ctx
);
1087 bind_attrib_location(ctx
, program
, index
, name
);
1092 _mesa_CompileShaderARB(GLhandleARB shaderObj
)
1094 GET_CURRENT_CONTEXT(ctx
);
1095 compile_shader(ctx
, shaderObj
);
1100 _mesa_CreateShader(GLenum type
)
1102 GET_CURRENT_CONTEXT(ctx
);
1103 return create_shader(ctx
, type
);
1107 GLhandleARB GLAPIENTRY
1108 _mesa_CreateShaderObjectARB(GLenum type
)
1110 GET_CURRENT_CONTEXT(ctx
);
1111 return create_shader(ctx
, type
);
1116 _mesa_CreateProgram(void)
1118 GET_CURRENT_CONTEXT(ctx
);
1119 return create_shader_program(ctx
);
1123 GLhandleARB GLAPIENTRY
1124 _mesa_CreateProgramObjectARB(void)
1126 GET_CURRENT_CONTEXT(ctx
);
1127 return create_shader_program(ctx
);
1132 _mesa_DeleteObjectARB(GLhandleARB obj
)
1135 GET_CURRENT_CONTEXT(ctx
);
1136 if (is_program(ctx
, obj
)) {
1137 delete_shader_program(ctx
, obj
);
1139 else if (is_shader(ctx
, obj
)) {
1140 delete_shader(ctx
, obj
);
1150 _mesa_DeleteProgram(GLuint name
)
1153 GET_CURRENT_CONTEXT(ctx
);
1154 delete_shader_program(ctx
, name
);
1160 _mesa_DeleteShader(GLuint name
)
1163 GET_CURRENT_CONTEXT(ctx
);
1164 delete_shader(ctx
, name
);
1170 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1172 GET_CURRENT_CONTEXT(ctx
);
1173 detach_shader(ctx
, program
, shader
);
1178 _mesa_DetachShader(GLuint program
, GLuint shader
)
1180 GET_CURRENT_CONTEXT(ctx
);
1181 detach_shader(ctx
, program
, shader
);
1186 _mesa_GetActiveAttribARB(GLhandleARB program
, GLuint index
,
1187 GLsizei maxLength
, GLsizei
* length
, GLint
* size
,
1188 GLenum
* type
, GLcharARB
* name
)
1190 GET_CURRENT_CONTEXT(ctx
);
1191 get_active_attrib(ctx
, program
, index
, maxLength
, length
, size
, type
, name
);
1196 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1197 GLsizei
* count
, GLhandleARB
* obj
)
1199 GET_CURRENT_CONTEXT(ctx
);
1200 get_attached_shaders(ctx
, container
, maxCount
, count
, obj
);
1205 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1206 GLsizei
*count
, GLuint
*obj
)
1208 GET_CURRENT_CONTEXT(ctx
);
1209 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
);
1214 _mesa_GetAttribLocationARB(GLhandleARB program
, const GLcharARB
* name
)
1216 GET_CURRENT_CONTEXT(ctx
);
1217 return get_attrib_location(ctx
, program
, name
);
1222 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1223 GLcharARB
* infoLog
)
1225 GET_CURRENT_CONTEXT(ctx
);
1226 if (is_program(ctx
, object
)) {
1227 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1229 else if (is_shader(ctx
, object
)) {
1230 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1233 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1239 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1241 GET_CURRENT_CONTEXT(ctx
);
1242 /* Implement in terms of GetProgramiv, GetShaderiv */
1243 if (is_program(ctx
, object
)) {
1244 if (pname
== GL_OBJECT_TYPE_ARB
) {
1245 *params
= GL_PROGRAM_OBJECT_ARB
;
1248 get_programiv(ctx
, object
, pname
, params
);
1251 else if (is_shader(ctx
, object
)) {
1252 if (pname
== GL_OBJECT_TYPE_ARB
) {
1253 *params
= GL_SHADER_OBJECT_ARB
;
1256 get_shaderiv(ctx
, object
, pname
, params
);
1260 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1266 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1269 GLint iparams
[1]; /* XXX is one element enough? */
1270 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1271 params
[0] = (GLfloat
) iparams
[0];
1276 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1278 GET_CURRENT_CONTEXT(ctx
);
1279 get_programiv(ctx
, program
, pname
, params
);
1284 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1286 GET_CURRENT_CONTEXT(ctx
);
1287 get_shaderiv(ctx
, shader
, pname
, params
);
1292 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1293 GLsizei
*length
, GLchar
*infoLog
)
1295 GET_CURRENT_CONTEXT(ctx
);
1296 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1301 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1302 GLsizei
*length
, GLchar
*infoLog
)
1304 GET_CURRENT_CONTEXT(ctx
);
1305 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1310 _mesa_GetShaderSourceARB(GLhandleARB shader
, GLsizei maxLength
,
1311 GLsizei
*length
, GLcharARB
*sourceOut
)
1313 GET_CURRENT_CONTEXT(ctx
);
1314 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1318 GLhandleARB GLAPIENTRY
1319 _mesa_GetHandleARB(GLenum pname
)
1321 GET_CURRENT_CONTEXT(ctx
);
1322 return get_handle(ctx
, pname
);
1326 GLboolean GLAPIENTRY
1327 _mesa_IsProgram(GLuint name
)
1329 GET_CURRENT_CONTEXT(ctx
);
1330 return is_program(ctx
, name
);
1334 GLboolean GLAPIENTRY
1335 _mesa_IsShader(GLuint name
)
1337 GET_CURRENT_CONTEXT(ctx
);
1338 return is_shader(ctx
, name
);
1343 _mesa_LinkProgramARB(GLhandleARB programObj
)
1345 GET_CURRENT_CONTEXT(ctx
);
1346 link_program(ctx
, programObj
);
1352 * Read shader source code from a file.
1353 * Useful for debugging to override an app's shader.
1356 read_shader(const char *fname
)
1358 const int max
= 50*1000;
1359 FILE *f
= fopen(fname
, "r");
1360 GLcharARB
*buffer
, *shader
;
1367 buffer
= (char *) malloc(max
);
1368 len
= fread(buffer
, 1, max
, f
);
1373 shader
= _mesa_strdup(buffer
);
1381 * Called via glShaderSource() and glShaderSourceARB() API functions.
1382 * Basically, concatenate the source code strings into one long string
1383 * and pass it to _mesa_shader_source().
1386 _mesa_ShaderSourceARB(GLhandleARB shaderObj
, GLsizei count
,
1387 const GLcharARB
** string
, const GLint
* length
)
1389 GET_CURRENT_CONTEXT(ctx
);
1391 GLsizei i
, totalLength
;
1395 if (!shaderObj
|| string
== NULL
) {
1396 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1401 * This array holds offsets of where the appropriate string ends, thus the
1402 * last element will be set to the total length of the source code.
1404 offsets
= (GLint
*) malloc(count
* sizeof(GLint
));
1405 if (offsets
== NULL
) {
1406 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1410 for (i
= 0; i
< count
; i
++) {
1411 if (string
[i
] == NULL
) {
1412 free((GLvoid
*) offsets
);
1413 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glShaderSourceARB(null string)");
1416 if (length
== NULL
|| length
[i
] < 0)
1417 offsets
[i
] = strlen(string
[i
]);
1419 offsets
[i
] = length
[i
];
1420 /* accumulate string lengths */
1422 offsets
[i
] += offsets
[i
- 1];
1425 /* Total length of source string is sum off all strings plus two.
1426 * One extra byte for terminating zero, another extra byte to silence
1427 * valgrind warnings in the parser/grammer code.
1429 totalLength
= offsets
[count
- 1] + 2;
1430 source
= (GLcharARB
*) malloc(totalLength
* sizeof(GLcharARB
));
1431 if (source
== NULL
) {
1432 free((GLvoid
*) offsets
);
1433 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1437 for (i
= 0; i
< count
; i
++) {
1438 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1439 memcpy(source
+ start
, string
[i
],
1440 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1442 source
[totalLength
- 1] = '\0';
1443 source
[totalLength
- 2] = '\0';
1446 /* Compute the shader's source code checksum then try to open a file
1447 * named newshader_<CHECKSUM>. If it exists, use it in place of the
1448 * original shader source code. For debugging.
1451 GLcharARB
*newSource
;
1453 checksum
= _mesa_str_checksum(source
);
1455 _mesa_snprintf(filename
, sizeof(filename
), "newshader_%d", checksum
);
1457 newSource
= read_shader(filename
);
1459 fprintf(stderr
, "Mesa: Replacing shader %u chksum=%d with %s\n",
1460 shaderObj
, checksum
, filename
);
1466 shader_source(ctx
, shaderObj
, source
);
1469 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1471 sh
->SourceChecksum
= checksum
; /* save original checksum */
1479 _mesa_UseProgramObjectARB(GLhandleARB program
)
1481 GET_CURRENT_CONTEXT(ctx
);
1482 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1483 _mesa_use_program(ctx
, program
);
1488 _mesa_ValidateProgramARB(GLhandleARB program
)
1490 GET_CURRENT_CONTEXT(ctx
);
1491 validate_program(ctx
, program
);
1497 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
1498 GLint
* range
, GLint
* precision
)
1500 GET_CURRENT_CONTEXT(ctx
);
1501 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1506 _mesa_ReleaseShaderCompiler(void)
1508 GET_CURRENT_CONTEXT(ctx
);
1509 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1514 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
1515 const void* binary
, GLint length
)
1517 GET_CURRENT_CONTEXT(ctx
);
1518 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1521 #endif /* FEATURE_ES2 */
1524 #if FEATURE_ARB_geometry_shader4
1527 _mesa_ProgramParameteriARB(GLuint program
, GLenum pname
,
1530 struct gl_shader_program
*shProg
;
1531 GET_CURRENT_CONTEXT(ctx
);
1533 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1535 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1536 "glProgramParameteri");
1541 case GL_GEOMETRY_VERTICES_OUT_ARB
:
1543 value
> ctx
->Const
.GeometryProgram
.MaxGeometryOutputVertices
) {
1544 _mesa_error(ctx
, GL_INVALID_VALUE
,
1545 "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1549 shProg
->Geom
.VerticesOut
= value
;
1551 case GL_GEOMETRY_INPUT_TYPE_ARB
:
1555 case GL_LINES_ADJACENCY_ARB
:
1557 case GL_TRIANGLES_ADJACENCY_ARB
:
1558 shProg
->Geom
.InputType
= value
;
1561 _mesa_error(ctx
, GL_INVALID_VALUE
,
1562 "glProgramParameteri(geometry input type = %s",
1563 _mesa_lookup_enum_by_nr(value
));
1567 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
1571 case GL_TRIANGLE_STRIP
:
1572 shProg
->Geom
.OutputType
= value
;
1575 _mesa_error(ctx
, GL_INVALID_VALUE
,
1576 "glProgramParameteri(geometry output type = %s",
1577 _mesa_lookup_enum_by_nr(value
));
1582 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteriARB(pname=%s)",
1583 _mesa_lookup_enum_by_nr(pname
));
1592 * Plug in shader-related functions into API dispatch table.
1595 _mesa_init_shader_dispatch(struct _glapi_table
*exec
)
1598 /* GL_ARB_vertex/fragment_shader */
1599 SET_DeleteObjectARB(exec
, _mesa_DeleteObjectARB
);
1600 SET_GetHandleARB(exec
, _mesa_GetHandleARB
);
1601 SET_DetachObjectARB(exec
, _mesa_DetachObjectARB
);
1602 SET_CreateShaderObjectARB(exec
, _mesa_CreateShaderObjectARB
);
1603 SET_ShaderSourceARB(exec
, _mesa_ShaderSourceARB
);
1604 SET_CompileShaderARB(exec
, _mesa_CompileShaderARB
);
1605 SET_CreateProgramObjectARB(exec
, _mesa_CreateProgramObjectARB
);
1606 SET_AttachObjectARB(exec
, _mesa_AttachObjectARB
);
1607 SET_LinkProgramARB(exec
, _mesa_LinkProgramARB
);
1608 SET_UseProgramObjectARB(exec
, _mesa_UseProgramObjectARB
);
1609 SET_ValidateProgramARB(exec
, _mesa_ValidateProgramARB
);
1610 SET_GetObjectParameterfvARB(exec
, _mesa_GetObjectParameterfvARB
);
1611 SET_GetObjectParameterivARB(exec
, _mesa_GetObjectParameterivARB
);
1612 SET_GetInfoLogARB(exec
, _mesa_GetInfoLogARB
);
1613 SET_GetAttachedObjectsARB(exec
, _mesa_GetAttachedObjectsARB
);
1614 SET_GetShaderSourceARB(exec
, _mesa_GetShaderSourceARB
);
1617 SET_AttachShader(exec
, _mesa_AttachShader
);
1618 SET_CreateProgram(exec
, _mesa_CreateProgram
);
1619 SET_CreateShader(exec
, _mesa_CreateShader
);
1620 SET_DeleteProgram(exec
, _mesa_DeleteProgram
);
1621 SET_DeleteShader(exec
, _mesa_DeleteShader
);
1622 SET_DetachShader(exec
, _mesa_DetachShader
);
1623 SET_GetAttachedShaders(exec
, _mesa_GetAttachedShaders
);
1624 SET_GetProgramiv(exec
, _mesa_GetProgramiv
);
1625 SET_GetProgramInfoLog(exec
, _mesa_GetProgramInfoLog
);
1626 SET_GetShaderiv(exec
, _mesa_GetShaderiv
);
1627 SET_GetShaderInfoLog(exec
, _mesa_GetShaderInfoLog
);
1628 SET_IsProgram(exec
, _mesa_IsProgram
);
1629 SET_IsShader(exec
, _mesa_IsShader
);
1631 #if FEATURE_ARB_vertex_shader
1632 SET_BindAttribLocationARB(exec
, _mesa_BindAttribLocationARB
);
1633 SET_GetActiveAttribARB(exec
, _mesa_GetActiveAttribARB
);
1634 SET_GetAttribLocationARB(exec
, _mesa_GetAttribLocationARB
);
1637 #if FEATURE_ARB_geometry_shader4
1638 SET_ProgramParameteriARB(exec
, _mesa_ProgramParameteriARB
);
1640 #endif /* FEATURE_GL */