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 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 * OTHER DEALINGS IN THE SOFTWARE.
30 * Implementation of GLSL-related API functions.
31 * The glUniform* functions are in uniforms.c
35 * 1. Check that the right error code is generated for all _mesa_error() calls.
36 * 2. Insert FLUSH_VERTICES calls in various places
41 #include "main/glheader.h"
42 #include "main/context.h"
43 #include "main/dispatch.h"
44 #include "main/enums.h"
45 #include "main/hash.h"
46 #include "main/mtypes.h"
47 #include "main/pipelineobj.h"
48 #include "main/shaderapi.h"
49 #include "main/shaderobj.h"
50 #include "main/transformfeedback.h"
51 #include "main/uniforms.h"
52 #include "compiler/glsl/glsl_parser_extras.h"
53 #include "compiler/glsl/ir.h"
54 #include "compiler/glsl/ir_uniform.h"
55 #include "compiler/glsl/program.h"
56 #include "program/program.h"
57 #include "program/prog_print.h"
58 #include "program/prog_parameter.h"
59 #include "util/ralloc.h"
60 #include "util/hash_table.h"
61 #include "util/mesa-sha1.h"
62 #include "util/crc32.h"
65 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
68 _mesa_get_shader_flags(void)
70 GLbitfield flags
= 0x0;
71 const char *env
= getenv("MESA_GLSL");
74 if (strstr(env
, "dump_on_error"))
75 flags
|= GLSL_DUMP_ON_ERROR
;
76 else if (strstr(env
, "dump"))
78 if (strstr(env
, "log"))
80 if (strstr(env
, "cache_fb"))
81 flags
|= GLSL_CACHE_FALLBACK
;
82 if (strstr(env
, "cache_info"))
83 flags
|= GLSL_CACHE_INFO
;
84 if (strstr(env
, "nopvert"))
85 flags
|= GLSL_NOP_VERT
;
86 if (strstr(env
, "nopfrag"))
87 flags
|= GLSL_NOP_FRAG
;
88 if (strstr(env
, "uniform"))
89 flags
|= GLSL_UNIFORMS
;
90 if (strstr(env
, "useprog"))
91 flags
|= GLSL_USE_PROG
;
92 if (strstr(env
, "errors"))
93 flags
|= GLSL_REPORT_ERRORS
;
100 * Memoized version of getenv("MESA_SHADER_CAPTURE_PATH").
103 _mesa_get_shader_capture_path(void)
105 static bool read_env_var
= false;
106 static const char *path
= NULL
;
109 path
= getenv("MESA_SHADER_CAPTURE_PATH");
117 * Initialize context's shader state.
120 _mesa_init_shader_state(struct gl_context
*ctx
)
122 /* Device drivers may override these to control what kind of instructions
123 * are generated by the GLSL compiler.
125 struct gl_shader_compiler_options options
;
129 memset(&options
, 0, sizeof(options
));
130 options
.MaxUnrollIterations
= 32;
131 options
.MaxIfDepth
= UINT_MAX
;
133 for (sh
= 0; sh
< MESA_SHADER_STAGES
; ++sh
)
134 memcpy(&ctx
->Const
.ShaderCompilerOptions
[sh
], &options
, sizeof(options
));
136 ctx
->Shader
.Flags
= _mesa_get_shader_flags();
138 if (ctx
->Shader
.Flags
!= 0)
139 ctx
->Const
.GenerateTemporaryNames
= true;
141 /* Extended for ARB_separate_shader_objects */
142 ctx
->Shader
.RefCount
= 1;
143 ctx
->TessCtrlProgram
.patch_vertices
= 3;
144 for (i
= 0; i
< 4; ++i
)
145 ctx
->TessCtrlProgram
.patch_default_outer_level
[i
] = 1.0;
146 for (i
= 0; i
< 2; ++i
)
147 ctx
->TessCtrlProgram
.patch_default_inner_level
[i
] = 1.0;
152 * Free the per-context shader-related state.
155 _mesa_free_shader_state(struct gl_context
*ctx
)
157 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
158 _mesa_reference_program(ctx
, &ctx
->Shader
.CurrentProgram
[i
], NULL
);
160 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, NULL
);
162 /* Extended for ARB_separate_shader_objects */
163 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, NULL
);
165 assert(ctx
->Shader
.RefCount
== 1);
170 * Copy string from <src> to <dst>, up to maxLength characters, returning
171 * length of <dst> in <length>.
172 * \param src the strings source
173 * \param maxLength max chars to copy
174 * \param length returns number of chars copied
175 * \param dst the string destination
178 _mesa_copy_string(GLchar
*dst
, GLsizei maxLength
,
179 GLsizei
*length
, const GLchar
*src
)
182 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
193 * Confirm that the a shader type is valid and supported by the implementation
195 * \param ctx Current GL context
196 * \param type Shader target
200 _mesa_validate_shader_target(const struct gl_context
*ctx
, GLenum type
)
202 /* Note: when building built-in GLSL functions, this function may be
203 * invoked with ctx == NULL. In that case, we can only validate that it's
204 * a shader target we recognize, not that it's supported in the current
205 * context. But that's fine--we don't need any further validation than
206 * that when building built-in GLSL functions.
210 case GL_FRAGMENT_SHADER
:
211 return ctx
== NULL
|| ctx
->Extensions
.ARB_fragment_shader
;
212 case GL_VERTEX_SHADER
:
213 return ctx
== NULL
|| ctx
->Extensions
.ARB_vertex_shader
;
214 case GL_GEOMETRY_SHADER_ARB
:
215 return ctx
== NULL
|| _mesa_has_geometry_shaders(ctx
);
216 case GL_TESS_CONTROL_SHADER
:
217 case GL_TESS_EVALUATION_SHADER
:
218 return ctx
== NULL
|| _mesa_has_tessellation(ctx
);
219 case GL_COMPUTE_SHADER
:
220 return ctx
== NULL
|| _mesa_has_compute_shaders(ctx
);
228 is_program(struct gl_context
*ctx
, GLuint name
)
230 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
231 return shProg
? GL_TRUE
: GL_FALSE
;
236 is_shader(struct gl_context
*ctx
, GLuint name
)
238 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
239 return shader
? GL_TRUE
: GL_FALSE
;
244 * Attach shader to a shader program.
247 attach_shader(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
248 struct gl_shader
*sh
)
250 GLuint n
= shProg
->NumShaders
;
252 shProg
->Shaders
= realloc(shProg
->Shaders
,
253 (n
+ 1) * sizeof(struct gl_shader
*));
254 if (!shProg
->Shaders
) {
255 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
260 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
261 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
262 shProg
->NumShaders
++;
266 attach_shader_err(struct gl_context
*ctx
, GLuint program
, GLuint shader
,
269 struct gl_shader_program
*shProg
;
270 struct gl_shader
*sh
;
273 const bool same_type_disallowed
= _mesa_is_gles(ctx
);
275 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, caller
);
279 sh
= _mesa_lookup_shader_err(ctx
, shader
, caller
);
284 n
= shProg
->NumShaders
;
285 for (i
= 0; i
< n
; i
++) {
286 if (shProg
->Shaders
[i
] == sh
) {
287 /* The shader is already attched to this program. The
288 * GL_ARB_shader_objects spec says:
290 * "The error INVALID_OPERATION is generated by AttachObjectARB
291 * if <obj> is already attached to <containerObj>."
293 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", caller
);
295 } else if (same_type_disallowed
&&
296 shProg
->Shaders
[i
]->Stage
== sh
->Stage
) {
297 /* Shader with the same type is already attached to this program,
298 * OpenGL ES 2.0 and 3.0 specs say:
300 * "Multiple shader objects of the same type may not be attached
301 * to a single program object. [...] The error INVALID_OPERATION
302 * is generated if [...] another shader object of the same type
303 * as shader is already attached to program."
305 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", caller
);
310 attach_shader(ctx
, shProg
, sh
);
314 attach_shader_no_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
316 struct gl_shader_program
*shProg
;
317 struct gl_shader
*sh
;
319 shProg
= _mesa_lookup_shader_program(ctx
, program
);
320 sh
= _mesa_lookup_shader(ctx
, shader
);
322 attach_shader(ctx
, shProg
, sh
);
326 create_shader(struct gl_context
*ctx
, GLenum type
)
328 struct gl_shader
*sh
;
331 _mesa_HashLockMutex(ctx
->Shared
->ShaderObjects
);
332 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
333 sh
= _mesa_new_shader(name
, _mesa_shader_enum_to_shader_stage(type
));
335 _mesa_HashInsertLocked(ctx
->Shared
->ShaderObjects
, name
, sh
);
336 _mesa_HashUnlockMutex(ctx
->Shared
->ShaderObjects
);
343 create_shader_err(struct gl_context
*ctx
, GLenum type
, const char *caller
)
345 if (!_mesa_validate_shader_target(ctx
, type
)) {
346 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s(%s)",
347 caller
, _mesa_enum_to_string(type
));
351 return create_shader(ctx
, type
);
356 create_shader_program(struct gl_context
*ctx
)
359 struct gl_shader_program
*shProg
;
361 _mesa_HashLockMutex(ctx
->Shared
->ShaderObjects
);
363 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
365 shProg
= _mesa_new_shader_program(name
);
367 _mesa_HashInsertLocked(ctx
->Shared
->ShaderObjects
, name
, shProg
);
369 assert(shProg
->RefCount
== 1);
371 _mesa_HashUnlockMutex(ctx
->Shared
->ShaderObjects
);
378 * Delete a shader program. Actually, just decrement the program's
379 * reference count and mark it as DeletePending.
380 * Used to implement glDeleteProgram() and glDeleteObjectARB().
383 delete_shader_program(struct gl_context
*ctx
, GLuint name
)
386 * NOTE: deleting shaders/programs works a bit differently than
387 * texture objects (and buffer objects, etc). Shader/program
388 * handles/IDs exist in the hash table until the object is really
389 * deleted (refcount==0). With texture objects, the handle/ID is
390 * removed from the hash table in glDeleteTextures() while the tex
391 * object itself might linger until its refcount goes to zero.
393 struct gl_shader_program
*shProg
;
395 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
399 if (!shProg
->DeletePending
) {
400 shProg
->DeletePending
= GL_TRUE
;
402 /* effectively, decr shProg's refcount */
403 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
409 delete_shader(struct gl_context
*ctx
, GLuint shader
)
411 struct gl_shader
*sh
;
413 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
417 if (!sh
->DeletePending
) {
418 sh
->DeletePending
= GL_TRUE
;
420 /* effectively, decr sh's refcount */
421 _mesa_reference_shader(ctx
, &sh
, NULL
);
426 static ALWAYS_INLINE
void
427 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
,
430 struct gl_shader_program
*shProg
;
435 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
439 shProg
= _mesa_lookup_shader_program(ctx
, program
);
442 n
= shProg
->NumShaders
;
444 for (i
= 0; i
< n
; i
++) {
445 if (shProg
->Shaders
[i
]->Name
== shader
) {
447 struct gl_shader
**newList
;
450 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
452 /* alloc new, smaller array */
453 newList
= malloc((n
- 1) * sizeof(struct gl_shader
*));
455 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
458 /* Copy old list entries to new list, skipping removed entry at [i] */
459 for (j
= 0; j
< i
; j
++) {
460 newList
[j
] = shProg
->Shaders
[j
];
463 newList
[j
++] = shProg
->Shaders
[i
];
466 /* Free old list and install new one */
467 free(shProg
->Shaders
);
468 shProg
->Shaders
= newList
;
469 shProg
->NumShaders
= n
- 1;
472 /* sanity check - make sure the new list's entries are sensible */
473 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
474 assert(shProg
->Shaders
[j
]->Stage
== MESA_SHADER_VERTEX
||
475 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_TESS_CTRL
||
476 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_TESS_EVAL
||
477 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_GEOMETRY
||
478 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_FRAGMENT
);
479 assert(shProg
->Shaders
[j
]->RefCount
> 0);
490 if (is_shader(ctx
, shader
) || is_program(ctx
, shader
))
491 err
= GL_INVALID_OPERATION
;
493 err
= GL_INVALID_VALUE
;
494 _mesa_error(ctx
, err
, "glDetachShader(shader)");
501 detach_shader_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
503 detach_shader(ctx
, program
, shader
, false);
508 detach_shader_no_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
510 detach_shader(ctx
, program
, shader
, true);
515 * Return list of shaders attached to shader program.
516 * \param objOut returns GLuint ids
517 * \param handleOut returns GLhandleARB handles
520 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
521 GLsizei
*countOut
, GLuint
*objOut
, GLhandleARB
*handleOut
)
523 struct gl_shader_program
*shProg
;
526 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetAttachedShaders(maxCount < 0)");
531 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
535 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
537 objOut
[i
] = shProg
->Shaders
[i
]->Name
;
541 handleOut
[i
] = (GLhandleARB
) shProg
->Shaders
[i
]->Name
;
551 * glGetHandleARB() - return ID/name of currently bound shader program.
554 get_handle(struct gl_context
*ctx
, GLenum pname
)
556 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
557 if (ctx
->_Shader
->ActiveProgram
)
558 return ctx
->_Shader
->ActiveProgram
->Name
;
563 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
570 * Check if a geometry shader query is valid at this time. If not, report an
571 * error and return false.
573 * From GL 3.2 section 6.1.16 (Shader and Program Queries):
575 * "If GEOMETRY_VERTICES_OUT, GEOMETRY_INPUT_TYPE, or GEOMETRY_OUTPUT_TYPE
576 * are queried for a program which has not been linked successfully, or
577 * which does not contain objects to form a geometry shader, then an
578 * INVALID_OPERATION error is generated."
581 check_gs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
583 if (shProg
->data
->LinkStatus
&&
584 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] != NULL
) {
588 _mesa_error(ctx
, GL_INVALID_OPERATION
,
589 "glGetProgramv(linked geometry shader required)");
595 * Check if a tessellation control shader query is valid at this time.
596 * If not, report an error and return false.
598 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
600 * "If TESS_CONTROL_OUTPUT_VERTICES is queried for a program which has
601 * not been linked successfully, or which does not contain objects to
602 * form a tessellation control shader, then an INVALID_OPERATION error is
606 check_tcs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
608 if (shProg
->data
->LinkStatus
&&
609 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
] != NULL
) {
613 _mesa_error(ctx
, GL_INVALID_OPERATION
,
614 "glGetProgramv(linked tessellation control shader required)");
620 * Check if a tessellation evaluation shader query is valid at this time.
621 * If not, report an error and return false.
623 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
625 * "If any of the pname values in this paragraph are queried for a program
626 * which has not been linked successfully, or which does not contain
627 * objects to form a tessellation evaluation shader, then an
628 * INVALID_OPERATION error is generated."
632 check_tes_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
634 if (shProg
->data
->LinkStatus
&&
635 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
] != NULL
) {
639 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramv(linked tessellation "
640 "evaluation shader required)");
646 * glGetProgramiv() - get shader program state.
647 * Note that this is for GLSL shader programs, not ARB vertex/fragment
648 * programs (see glGetProgramivARB).
651 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
,
654 struct gl_shader_program
*shProg
655 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramiv(program)");
657 /* Is transform feedback available in this context?
660 (ctx
->API
== API_OPENGL_COMPAT
&& ctx
->Extensions
.EXT_transform_feedback
)
661 || ctx
->API
== API_OPENGL_CORE
662 || _mesa_is_gles3(ctx
);
664 /* True if geometry shaders (of the form that was adopted into GLSL 1.50
665 * and GL 3.2) are available in this context
667 const bool has_core_gs
= _mesa_has_geometry_shaders(ctx
);
668 const bool has_tess
= _mesa_has_tessellation(ctx
);
670 /* Are uniform buffer objects available in this context?
673 (ctx
->API
== API_OPENGL_COMPAT
&&
674 ctx
->Extensions
.ARB_uniform_buffer_object
)
675 || ctx
->API
== API_OPENGL_CORE
676 || _mesa_is_gles3(ctx
);
683 case GL_DELETE_STATUS
:
684 *params
= shProg
->DeletePending
;
687 *params
= shProg
->data
->LinkStatus
? GL_TRUE
: GL_FALSE
;
689 case GL_VALIDATE_STATUS
:
690 *params
= shProg
->data
->Validated
;
692 case GL_INFO_LOG_LENGTH
:
693 *params
= (shProg
->data
->InfoLog
&& shProg
->data
->InfoLog
[0] != '\0') ?
694 strlen(shProg
->data
->InfoLog
) + 1 : 0;
696 case GL_ATTACHED_SHADERS
:
697 *params
= shProg
->NumShaders
;
699 case GL_ACTIVE_ATTRIBUTES
:
700 *params
= _mesa_count_active_attribs(shProg
);
702 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
703 *params
= _mesa_longest_attribute_name_length(shProg
);
705 case GL_ACTIVE_UNIFORMS
: {
707 const unsigned num_uniforms
=
708 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
709 for (*params
= 0, i
= 0; i
< num_uniforms
; i
++) {
710 if (!shProg
->data
->UniformStorage
[i
].is_shader_storage
)
715 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
718 const unsigned num_uniforms
=
719 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
721 for (i
= 0; i
< num_uniforms
; i
++) {
722 if (shProg
->data
->UniformStorage
[i
].is_shader_storage
)
725 /* Add one for the terminating NUL character for a non-array, and
726 * 4 for the "[0]" and the NUL for an array.
728 const GLint len
= strlen(shProg
->data
->UniformStorage
[i
].name
) + 1 +
729 ((shProg
->data
->UniformStorage
[i
].array_elements
!= 0) ? 3 : 0);
738 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
741 *params
= shProg
->TransformFeedback
.NumVarying
;
743 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
: {
749 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
750 /* Add one for the terminating NUL character.
753 strlen(shProg
->TransformFeedback
.VaryingNames
[i
]) + 1;
762 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
765 *params
= shProg
->TransformFeedback
.BufferMode
;
767 case GL_GEOMETRY_VERTICES_OUT
:
770 if (check_gs_query(ctx
, shProg
)) {
771 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
772 Program
->info
.gs
.vertices_out
;
775 case GL_GEOMETRY_SHADER_INVOCATIONS
:
776 if (!has_core_gs
|| !ctx
->Extensions
.ARB_gpu_shader5
)
778 if (check_gs_query(ctx
, shProg
)) {
779 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
780 Program
->info
.gs
.invocations
;
783 case GL_GEOMETRY_INPUT_TYPE
:
786 if (check_gs_query(ctx
, shProg
)) {
787 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
788 Program
->info
.gs
.input_primitive
;
791 case GL_GEOMETRY_OUTPUT_TYPE
:
794 if (check_gs_query(ctx
, shProg
)) {
795 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
796 Program
->info
.gs
.output_primitive
;
799 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
: {
806 for (i
= 0; i
< shProg
->data
->NumUniformBlocks
; i
++) {
807 /* Add one for the terminating NUL character.
809 const GLint len
= strlen(shProg
->data
->UniformBlocks
[i
].Name
) + 1;
818 case GL_ACTIVE_UNIFORM_BLOCKS
:
822 *params
= shProg
->data
->NumUniformBlocks
;
824 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
825 /* This enum isn't part of the OES extension for OpenGL ES 2.0. It is
826 * only available with desktop OpenGL 3.0+ with the
827 * GL_ARB_get_program_binary extension or OpenGL ES 3.0.
829 * On desktop, we ignore the 3.0+ requirement because it is silly.
831 if (!_mesa_is_desktop_gl(ctx
) && !_mesa_is_gles3(ctx
))
834 *params
= shProg
->BinaryRetreivableHint
;
836 case GL_PROGRAM_BINARY_LENGTH
:
839 case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS
:
840 if (!ctx
->Extensions
.ARB_shader_atomic_counters
)
843 *params
= shProg
->data
->NumAtomicBuffers
;
845 case GL_COMPUTE_WORK_GROUP_SIZE
: {
847 if (!_mesa_has_compute_shaders(ctx
))
849 if (!shProg
->data
->LinkStatus
) {
850 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(program not "
854 if (shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
] == NULL
) {
855 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(no compute "
859 for (i
= 0; i
< 3; i
++)
860 params
[i
] = shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
]->
861 Program
->info
.cs
.local_size
[i
];
864 case GL_PROGRAM_SEPARABLE
:
865 /* If the program has not been linked, return initial value 0. */
866 *params
= (shProg
->data
->LinkStatus
== linking_failure
) ? 0 : shProg
->SeparateShader
;
869 /* ARB_tessellation_shader */
870 case GL_TESS_CONTROL_OUTPUT_VERTICES
:
873 if (check_tcs_query(ctx
, shProg
)) {
874 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->
875 Program
->info
.tess
.tcs_vertices_out
;
878 case GL_TESS_GEN_MODE
:
881 if (check_tes_query(ctx
, shProg
)) {
882 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
883 Program
->info
.tess
.primitive_mode
;
886 case GL_TESS_GEN_SPACING
:
889 if (check_tes_query(ctx
, shProg
)) {
890 const struct gl_linked_shader
*tes
=
891 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
];
892 switch (tes
->Program
->info
.tess
.spacing
) {
893 case TESS_SPACING_EQUAL
:
896 case TESS_SPACING_FRACTIONAL_ODD
:
897 *params
= GL_FRACTIONAL_ODD
;
899 case TESS_SPACING_FRACTIONAL_EVEN
:
900 *params
= GL_FRACTIONAL_EVEN
;
902 case TESS_SPACING_UNSPECIFIED
:
908 case GL_TESS_GEN_VERTEX_ORDER
:
911 if (check_tes_query(ctx
, shProg
)) {
912 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
913 Program
->info
.tess
.ccw
? GL_CCW
: GL_CW
;
916 case GL_TESS_GEN_POINT_MODE
:
919 if (check_tes_query(ctx
, shProg
)) {
920 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
921 Program
->info
.tess
.point_mode
? GL_TRUE
: GL_FALSE
;
928 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname=%s)",
929 _mesa_enum_to_string(pname
));
934 * glGetShaderiv() - get GLSL shader state
937 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
939 struct gl_shader
*shader
=
940 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
948 *params
= shader
->Type
;
950 case GL_DELETE_STATUS
:
951 *params
= shader
->DeletePending
;
953 case GL_COMPILE_STATUS
:
954 *params
= shader
->CompileStatus
? GL_TRUE
: GL_FALSE
;
956 case GL_INFO_LOG_LENGTH
:
957 *params
= (shader
->InfoLog
&& shader
->InfoLog
[0] != '\0') ?
958 strlen(shader
->InfoLog
) + 1 : 0;
960 case GL_SHADER_SOURCE_LENGTH
:
961 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
964 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
971 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
972 GLsizei
*length
, GLchar
*infoLog
)
974 struct gl_shader_program
*shProg
;
976 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
977 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
979 * "If a negative number is provided where an argument of type sizei or
980 * sizeiptr is specified, an INVALID_VALUE error is generated."
983 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(bufSize < 0)");
987 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
988 "glGetProgramInfoLog(program)");
993 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->data
->InfoLog
);
998 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
999 GLsizei
*length
, GLchar
*infoLog
)
1001 struct gl_shader
*sh
;
1003 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
1004 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
1006 * "If a negative number is provided where an argument of type sizei or
1007 * sizeiptr is specified, an INVALID_VALUE error is generated."
1010 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(bufSize < 0)");
1014 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderInfoLog(shader)");
1019 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
1024 * Return shader source code.
1027 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
1028 GLsizei
*length
, GLchar
*sourceOut
)
1030 struct gl_shader
*sh
;
1032 if (maxLength
< 0) {
1033 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderSource(bufSize < 0)");
1037 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
1041 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
1046 * Set/replace shader source code. A helper function used by
1047 * glShaderSource[ARB].
1050 set_shader_source(struct gl_shader
*sh
, const GLchar
*source
)
1054 if (sh
->CompileStatus
== compile_skipped
&& !sh
->FallbackSource
) {
1055 /* If shader was previously compiled back-up the source in case of cache
1058 sh
->FallbackSource
= sh
->Source
;
1059 sh
->Source
= source
;
1061 /* free old shader source string and install new one */
1062 free((void *)sh
->Source
);
1063 sh
->Source
= source
;
1067 sh
->SourceChecksum
= util_hash_crc32(sh
->Source
, strlen(sh
->Source
));
1076 _mesa_compile_shader(struct gl_context
*ctx
, struct gl_shader
*sh
)
1082 /* If the user called glCompileShader without first calling
1083 * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
1085 sh
->CompileStatus
= compile_failure
;
1087 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1088 _mesa_log("GLSL source for %s shader %d:\n",
1089 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1090 _mesa_log("%s\n", sh
->Source
);
1093 /* this call will set the shader->CompileStatus field to indicate if
1094 * compilation was successful.
1096 _mesa_glsl_compile_shader(ctx
, sh
, false, false, false);
1098 if (ctx
->_Shader
->Flags
& GLSL_LOG
) {
1099 _mesa_write_shader_to_file(sh
);
1102 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1103 if (sh
->CompileStatus
) {
1105 _mesa_log("GLSL IR for shader %d:\n", sh
->Name
);
1106 _mesa_print_ir(_mesa_get_log_file(), sh
->ir
, NULL
);
1108 _mesa_log("No GLSL IR for shader %d (shader may be from "
1109 "cache)\n", sh
->Name
);
1113 _mesa_log("GLSL shader %d failed to compile.\n", sh
->Name
);
1115 if (sh
->InfoLog
&& sh
->InfoLog
[0] != 0) {
1116 _mesa_log("GLSL shader %d info log:\n", sh
->Name
);
1117 _mesa_log("%s\n", sh
->InfoLog
);
1122 if (!sh
->CompileStatus
) {
1123 if (ctx
->_Shader
->Flags
& GLSL_DUMP_ON_ERROR
) {
1124 _mesa_log("GLSL source for %s shader %d:\n",
1125 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1126 _mesa_log("%s\n", sh
->Source
);
1127 _mesa_log("Info Log:\n%s\n", sh
->InfoLog
);
1130 if (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
) {
1131 _mesa_debug(ctx
, "Error compiling shader %u:\n%s\n",
1132 sh
->Name
, sh
->InfoLog
);
1139 * Link a program's shaders.
1141 static ALWAYS_INLINE
void
1142 link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1149 /* From the ARB_transform_feedback2 specification:
1150 * "The error INVALID_OPERATION is generated by LinkProgram if <program>
1151 * is the name of a program being used by one or more transform feedback
1152 * objects, even if the objects are not currently bound or are paused."
1154 if (_mesa_transform_feedback_is_using_program(ctx
, shProg
)) {
1155 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1156 "glLinkProgram(transform feedback is using the program)");
1161 unsigned programs_in_use
= 0;
1163 for (unsigned stage
= 0; stage
< MESA_SHADER_STAGES
; stage
++) {
1164 if (ctx
->_Shader
->CurrentProgram
[stage
] &&
1165 ctx
->_Shader
->CurrentProgram
[stage
]->Id
== shProg
->Name
) {
1166 programs_in_use
|= 1 << stage
;
1170 FLUSH_VERTICES(ctx
, 0);
1171 _mesa_glsl_link_shader(ctx
, shProg
);
1173 /* From section 7.3 (Program Objects) of the OpenGL 4.5 spec:
1175 * "If LinkProgram or ProgramBinary successfully re-links a program
1176 * object that is active for any shader stage, then the newly generated
1177 * executable code will be installed as part of the current rendering
1178 * state for all shader stages where the program is active.
1179 * Additionally, the newly generated executable code is made part of
1180 * the state of any program pipeline for all stages where the program
1183 if (shProg
->data
->LinkStatus
&& programs_in_use
) {
1184 while (programs_in_use
) {
1185 const int stage
= u_bit_scan(&programs_in_use
);
1187 struct gl_program
*prog
= NULL
;
1188 if (shProg
->_LinkedShaders
[stage
])
1189 prog
= shProg
->_LinkedShaders
[stage
]->Program
;
1191 _mesa_use_program(ctx
, stage
, shProg
, prog
, ctx
->_Shader
);
1195 /* Capture .shader_test files. */
1196 const char *capture_path
= _mesa_get_shader_capture_path();
1197 if (shProg
->Name
!= 0 && shProg
->Name
!= ~0 && capture_path
!= NULL
) {
1199 char *filename
= ralloc_asprintf(NULL
, "%s/%u.shader_test",
1200 capture_path
, shProg
->Name
);
1201 file
= fopen(filename
, "w");
1203 fprintf(file
, "[require]\nGLSL%s >= %u.%02u\n",
1204 shProg
->IsES
? " ES" : "",
1205 shProg
->data
->Version
/ 100, shProg
->data
->Version
% 100);
1206 if (shProg
->SeparateShader
)
1207 fprintf(file
, "GL_ARB_separate_shader_objects\nSSO ENABLED\n");
1208 fprintf(file
, "\n");
1210 for (unsigned i
= 0; i
< shProg
->NumShaders
; i
++) {
1211 fprintf(file
, "[%s shader]\n%s\n",
1212 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1213 shProg
->Shaders
[i
]->Source
);
1217 _mesa_warning(ctx
, "Failed to open %s", filename
);
1220 ralloc_free(filename
);
1223 if (shProg
->data
->LinkStatus
== linking_failure
&&
1224 (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
)) {
1225 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
1226 shProg
->Name
, shProg
->data
->InfoLog
);
1233 printf("Link %u shaders in program %u: %s\n",
1234 shProg
->NumShaders
, shProg
->Name
,
1235 shProg
->data
->LinkStatus
? "Success" : "Failed");
1237 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1238 printf(" shader %u, stage %u\n",
1239 shProg
->Shaders
[i
]->Name
,
1240 shProg
->Shaders
[i
]->Stage
);
1247 link_program_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1249 link_program(ctx
, shProg
, false);
1254 link_program_no_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1256 link_program(ctx
, shProg
, true);
1261 _mesa_link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1263 link_program_error(ctx
, shProg
);
1268 * Print basic shader info (for debug).
1271 print_shader_info(const struct gl_shader_program
*shProg
)
1275 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
1276 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1278 printf(" %s shader %u, checksum %u\n",
1279 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1280 shProg
->Shaders
[i
]->Name
,
1281 shProg
->Shaders
[i
]->SourceChecksum
);
1283 printf(" %s shader %u\n",
1284 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1285 shProg
->Shaders
[i
]->Name
);
1288 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
1289 printf(" vert prog %u\n",
1290 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
1291 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
1292 printf(" frag prog %u\n",
1293 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
1294 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
1295 printf(" geom prog %u\n",
1296 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
1297 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
])
1298 printf(" tesc prog %u\n",
1299 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->Program
->Id
);
1300 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
])
1301 printf(" tese prog %u\n",
1302 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->Program
->Id
);
1307 * Use the named shader program for subsequent glUniform calls
1310 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1313 if ((shProg
!= NULL
) && !shProg
->data
->LinkStatus
) {
1314 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1315 "%s(program %u not linked)", caller
, shProg
->Name
);
1319 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
1320 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
1326 * Use the named shader program for subsequent rendering.
1329 _mesa_use_shader_program(struct gl_context
*ctx
,
1330 struct gl_shader_program
*shProg
)
1332 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1333 struct gl_program
*new_prog
= NULL
;
1334 if (shProg
&& shProg
->_LinkedShaders
[i
])
1335 new_prog
= shProg
->_LinkedShaders
[i
]->Program
;
1336 _mesa_use_program(ctx
, i
, shProg
, new_prog
, &ctx
->Shader
);
1338 _mesa_active_program(ctx
, shProg
, "glUseProgram");
1343 * Do validation of the given shader program.
1344 * \param errMsg returns error message if validation fails.
1345 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1348 validate_shader_program(const struct gl_shader_program
*shProg
,
1351 if (!shProg
->data
->LinkStatus
) {
1355 /* From the GL spec, a program is invalid if any of these are true:
1357 any two active samplers in the current program object are of
1358 different types, but refer to the same texture image unit,
1360 any active sampler in the current program object refers to a texture
1361 image unit where fixed-function fragment processing accesses a
1362 texture target that does not match the sampler type, or
1364 the sum of the number of active samplers in the program and the
1365 number of texture image units enabled for fixed-function fragment
1366 processing exceeds the combined limit on the total number of texture
1367 image units allowed.
1371 * Check: any two active samplers in the current program object are of
1372 * different types, but refer to the same texture image unit,
1374 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
1382 * Called via glValidateProgram()
1385 validate_program(struct gl_context
*ctx
, GLuint program
)
1387 struct gl_shader_program
*shProg
;
1388 char errMsg
[100] = "";
1390 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1395 shProg
->data
->Validated
= validate_shader_program(shProg
, errMsg
);
1396 if (!shProg
->data
->Validated
) {
1397 /* update info log */
1398 if (shProg
->data
->InfoLog
) {
1399 ralloc_free(shProg
->data
->InfoLog
);
1401 shProg
->data
->InfoLog
= ralloc_strdup(shProg
->data
, errMsg
);
1407 _mesa_AttachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1409 GET_CURRENT_CONTEXT(ctx
);
1410 attach_shader_no_error(ctx
, program
, shader
);
1415 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1417 GET_CURRENT_CONTEXT(ctx
);
1418 attach_shader_err(ctx
, program
, shader
, "glAttachObjectARB");
1423 _mesa_AttachShader_no_error(GLuint program
, GLuint shader
)
1425 GET_CURRENT_CONTEXT(ctx
);
1426 attach_shader_no_error(ctx
, program
, shader
);
1431 _mesa_AttachShader(GLuint program
, GLuint shader
)
1433 GET_CURRENT_CONTEXT(ctx
);
1434 attach_shader_err(ctx
, program
, shader
, "glAttachShader");
1439 _mesa_CompileShader(GLuint shaderObj
)
1441 GET_CURRENT_CONTEXT(ctx
);
1442 if (MESA_VERBOSE
& VERBOSE_API
)
1443 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1444 _mesa_compile_shader(ctx
, _mesa_lookup_shader_err(ctx
, shaderObj
,
1445 "glCompileShader"));
1450 _mesa_CreateShader_no_error(GLenum type
)
1452 GET_CURRENT_CONTEXT(ctx
);
1453 return create_shader(ctx
, type
);
1458 _mesa_CreateShader(GLenum type
)
1460 GET_CURRENT_CONTEXT(ctx
);
1462 if (MESA_VERBOSE
& VERBOSE_API
)
1463 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_enum_to_string(type
));
1465 return create_shader_err(ctx
, type
, "glCreateShader");
1469 GLhandleARB GLAPIENTRY
1470 _mesa_CreateShaderObjectARB_no_error(GLenum type
)
1472 GET_CURRENT_CONTEXT(ctx
);
1473 return create_shader(ctx
, type
);
1477 GLhandleARB GLAPIENTRY
1478 _mesa_CreateShaderObjectARB(GLenum type
)
1480 GET_CURRENT_CONTEXT(ctx
);
1481 return create_shader_err(ctx
, type
, "glCreateShaderObjectARB");
1486 _mesa_CreateProgram(void)
1488 GET_CURRENT_CONTEXT(ctx
);
1489 if (MESA_VERBOSE
& VERBOSE_API
)
1490 _mesa_debug(ctx
, "glCreateProgram\n");
1491 return create_shader_program(ctx
);
1495 GLhandleARB GLAPIENTRY
1496 _mesa_CreateProgramObjectARB(void)
1498 GET_CURRENT_CONTEXT(ctx
);
1499 return create_shader_program(ctx
);
1504 _mesa_DeleteObjectARB(GLhandleARB obj
)
1506 if (MESA_VERBOSE
& VERBOSE_API
) {
1507 GET_CURRENT_CONTEXT(ctx
);
1508 _mesa_debug(ctx
, "glDeleteObjectARB(%lu)\n", (unsigned long)obj
);
1512 GET_CURRENT_CONTEXT(ctx
);
1513 FLUSH_VERTICES(ctx
, 0);
1514 if (is_program(ctx
, obj
)) {
1515 delete_shader_program(ctx
, obj
);
1517 else if (is_shader(ctx
, obj
)) {
1518 delete_shader(ctx
, obj
);
1528 _mesa_DeleteProgram(GLuint name
)
1531 GET_CURRENT_CONTEXT(ctx
);
1532 FLUSH_VERTICES(ctx
, 0);
1533 delete_shader_program(ctx
, name
);
1539 _mesa_DeleteShader(GLuint name
)
1542 GET_CURRENT_CONTEXT(ctx
);
1543 FLUSH_VERTICES(ctx
, 0);
1544 delete_shader(ctx
, name
);
1550 _mesa_DetachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1552 GET_CURRENT_CONTEXT(ctx
);
1553 detach_shader_no_error(ctx
, program
, shader
);
1558 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1560 GET_CURRENT_CONTEXT(ctx
);
1561 detach_shader_error(ctx
, program
, shader
);
1566 _mesa_DetachShader_no_error(GLuint program
, GLuint shader
)
1568 GET_CURRENT_CONTEXT(ctx
);
1569 detach_shader_no_error(ctx
, program
, shader
);
1574 _mesa_DetachShader(GLuint program
, GLuint shader
)
1576 GET_CURRENT_CONTEXT(ctx
);
1577 detach_shader_error(ctx
, program
, shader
);
1582 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1583 GLsizei
* count
, GLhandleARB
* obj
)
1585 GET_CURRENT_CONTEXT(ctx
);
1586 get_attached_shaders(ctx
, (GLuint
)container
, maxCount
, count
, NULL
, obj
);
1591 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1592 GLsizei
*count
, GLuint
*obj
)
1594 GET_CURRENT_CONTEXT(ctx
);
1595 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
, NULL
);
1600 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1601 GLcharARB
* infoLog
)
1603 GET_CURRENT_CONTEXT(ctx
);
1604 if (is_program(ctx
, object
)) {
1605 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1607 else if (is_shader(ctx
, object
)) {
1608 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1611 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1617 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1619 GET_CURRENT_CONTEXT(ctx
);
1620 /* Implement in terms of GetProgramiv, GetShaderiv */
1621 if (is_program(ctx
, object
)) {
1622 if (pname
== GL_OBJECT_TYPE_ARB
) {
1623 *params
= GL_PROGRAM_OBJECT_ARB
;
1626 get_programiv(ctx
, object
, pname
, params
);
1629 else if (is_shader(ctx
, object
)) {
1630 if (pname
== GL_OBJECT_TYPE_ARB
) {
1631 *params
= GL_SHADER_OBJECT_ARB
;
1634 get_shaderiv(ctx
, object
, pname
, params
);
1638 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1644 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1647 GLint iparams
[1] = {0}; /* XXX is one element enough? */
1648 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1649 params
[0] = (GLfloat
) iparams
[0];
1654 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1656 GET_CURRENT_CONTEXT(ctx
);
1657 get_programiv(ctx
, program
, pname
, params
);
1662 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1664 GET_CURRENT_CONTEXT(ctx
);
1665 get_shaderiv(ctx
, shader
, pname
, params
);
1670 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1671 GLsizei
*length
, GLchar
*infoLog
)
1673 GET_CURRENT_CONTEXT(ctx
);
1674 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1679 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1680 GLsizei
*length
, GLchar
*infoLog
)
1682 GET_CURRENT_CONTEXT(ctx
);
1683 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1688 _mesa_GetShaderSource(GLuint shader
, GLsizei maxLength
,
1689 GLsizei
*length
, GLchar
*sourceOut
)
1691 GET_CURRENT_CONTEXT(ctx
);
1692 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1696 GLhandleARB GLAPIENTRY
1697 _mesa_GetHandleARB(GLenum pname
)
1699 GET_CURRENT_CONTEXT(ctx
);
1700 return get_handle(ctx
, pname
);
1704 GLboolean GLAPIENTRY
1705 _mesa_IsProgram(GLuint name
)
1707 GET_CURRENT_CONTEXT(ctx
);
1708 return is_program(ctx
, name
);
1712 GLboolean GLAPIENTRY
1713 _mesa_IsShader(GLuint name
)
1715 GET_CURRENT_CONTEXT(ctx
);
1716 return is_shader(ctx
, name
);
1721 _mesa_LinkProgram_no_error(GLuint programObj
)
1723 GET_CURRENT_CONTEXT(ctx
);
1725 struct gl_shader_program
*shProg
=
1726 _mesa_lookup_shader_program(ctx
, programObj
);
1727 link_program_no_error(ctx
, shProg
);
1732 _mesa_LinkProgram(GLuint programObj
)
1734 GET_CURRENT_CONTEXT(ctx
);
1736 if (MESA_VERBOSE
& VERBOSE_API
)
1737 _mesa_debug(ctx
, "glLinkProgram %u\n", programObj
);
1739 struct gl_shader_program
*shProg
=
1740 _mesa_lookup_shader_program_err(ctx
, programObj
, "glLinkProgram");
1741 link_program_error(ctx
, shProg
);
1744 #ifdef ENABLE_SHADER_CACHE
1746 * Generate a SHA-1 hash value string for given source string.
1749 generate_sha1(const char *source
, char sha_str
[64])
1751 unsigned char sha
[20];
1752 _mesa_sha1_compute(source
, strlen(source
), sha
);
1753 _mesa_sha1_format(sha_str
, sha
);
1757 * Construct a full path for shader replacement functionality using
1760 * <path>/<stage prefix>_<CHECKSUM>.glsl
1763 construct_name(const gl_shader_stage stage
, const char *source
,
1767 static const char *types
[] = {
1768 "VS", "TC", "TE", "GS", "FS", "CS",
1771 generate_sha1(source
, sha
);
1772 return ralloc_asprintf(NULL
, "%s/%s_%s.glsl", path
, types
[stage
], sha
);
1776 * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1779 dump_shader(const gl_shader_stage stage
, const char *source
)
1781 static bool path_exists
= true;
1788 dump_path
= getenv("MESA_SHADER_DUMP_PATH");
1790 path_exists
= false;
1794 char *name
= construct_name(stage
, source
, dump_path
);
1796 f
= fopen(name
, "w");
1801 GET_CURRENT_CONTEXT(ctx
);
1802 _mesa_warning(ctx
, "could not open %s for dumping shader (%s)", name
,
1809 * Read shader source code from a file.
1810 * Useful for debugging to override an app's shader.
1813 read_shader(const gl_shader_stage stage
, const char *source
)
1816 static bool path_exists
= true;
1817 int len
, shader_size
= 0;
1824 read_path
= getenv("MESA_SHADER_READ_PATH");
1826 path_exists
= false;
1830 char *name
= construct_name(stage
, source
, read_path
);
1831 f
= fopen(name
, "r");
1836 /* allocate enough room for the entire shader */
1837 fseek(f
, 0, SEEK_END
);
1838 shader_size
= ftell(f
);
1840 assert(shader_size
);
1842 /* add one for terminating zero */
1845 buffer
= malloc(shader_size
);
1848 len
= fread(buffer
, 1, shader_size
, f
);
1856 #endif /* ENABLE_SHADER_CACHE */
1859 * Called via glShaderSource() and glShaderSourceARB() API functions.
1860 * Basically, concatenate the source code strings into one long string
1861 * and pass it to _mesa_shader_source().
1863 static ALWAYS_INLINE
void
1864 shader_source(struct gl_context
*ctx
, GLuint shaderObj
, GLsizei count
,
1865 const GLchar
*const *string
, const GLint
*length
, bool no_error
)
1868 GLsizei i
, totalLength
;
1870 struct gl_shader
*sh
;
1873 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glShaderSourceARB");
1877 if (string
== NULL
) {
1878 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1882 sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1886 * This array holds offsets of where the appropriate string ends, thus the
1887 * last element will be set to the total length of the source code.
1889 offsets
= malloc(count
* sizeof(GLint
));
1890 if (offsets
== NULL
) {
1891 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1895 for (i
= 0; i
< count
; i
++) {
1896 if (!no_error
&& string
[i
] == NULL
) {
1897 free((GLvoid
*) offsets
);
1898 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1899 "glShaderSourceARB(null string)");
1902 if (length
== NULL
|| length
[i
] < 0)
1903 offsets
[i
] = strlen(string
[i
]);
1905 offsets
[i
] = length
[i
];
1906 /* accumulate string lengths */
1908 offsets
[i
] += offsets
[i
- 1];
1911 /* Total length of source string is sum off all strings plus two.
1912 * One extra byte for terminating zero, another extra byte to silence
1913 * valgrind warnings in the parser/grammer code.
1915 totalLength
= offsets
[count
- 1] + 2;
1916 source
= malloc(totalLength
* sizeof(GLcharARB
));
1917 if (source
== NULL
) {
1918 free((GLvoid
*) offsets
);
1919 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1923 for (i
= 0; i
< count
; i
++) {
1924 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1925 memcpy(source
+ start
, string
[i
],
1926 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1928 source
[totalLength
- 1] = '\0';
1929 source
[totalLength
- 2] = '\0';
1931 #ifdef ENABLE_SHADER_CACHE
1932 GLcharARB
*replacement
;
1934 /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
1935 * if corresponding entry found from MESA_SHADER_READ_PATH.
1937 dump_shader(sh
->Stage
, source
);
1939 replacement
= read_shader(sh
->Stage
, source
);
1942 source
= replacement
;
1944 #endif /* ENABLE_SHADER_CACHE */
1946 set_shader_source(sh
, source
);
1953 _mesa_ShaderSource_no_error(GLuint shaderObj
, GLsizei count
,
1954 const GLchar
*const *string
, const GLint
*length
)
1956 GET_CURRENT_CONTEXT(ctx
);
1957 shader_source(ctx
, shaderObj
, count
, string
, length
, true);
1962 _mesa_ShaderSource(GLuint shaderObj
, GLsizei count
,
1963 const GLchar
*const *string
, const GLint
*length
)
1965 GET_CURRENT_CONTEXT(ctx
);
1966 shader_source(ctx
, shaderObj
, count
, string
, length
, false);
1970 static ALWAYS_INLINE
void
1971 use_program(GLuint program
, bool no_error
)
1973 GET_CURRENT_CONTEXT(ctx
);
1974 struct gl_shader_program
*shProg
= NULL
;
1976 if (MESA_VERBOSE
& VERBOSE_API
)
1977 _mesa_debug(ctx
, "glUseProgram %u\n", program
);
1981 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1984 if (_mesa_is_xfb_active_and_unpaused(ctx
)) {
1985 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1986 "glUseProgram(transform feedback active)");
1992 _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1996 if (!shProg
->data
->LinkStatus
) {
1997 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1998 "glUseProgram(program %u not linked)", program
);
2003 if (ctx
->_Shader
->Flags
& GLSL_USE_PROG
) {
2004 print_shader_info(shProg
);
2009 /* The ARB_separate_shader_object spec says:
2011 * "The executable code for an individual shader stage is taken from
2012 * the current program for that stage. If there is a current program
2013 * object established by UseProgram, that program is considered current
2014 * for all stages. Otherwise, if there is a bound program pipeline
2015 * object (section 2.14.PPO), the program bound to the appropriate
2016 * stage of the pipeline object is considered current."
2019 /* Attach shader state to the binding point */
2020 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, &ctx
->Shader
);
2021 /* Update the program */
2022 _mesa_use_shader_program(ctx
, shProg
);
2024 /* Must be done first: detach the progam */
2025 _mesa_use_shader_program(ctx
, shProg
);
2026 /* Unattach shader_state binding point */
2027 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
,
2028 ctx
->Pipeline
.Default
);
2029 /* If a pipeline was bound, rebind it */
2030 if (ctx
->Pipeline
.Current
) {
2032 _mesa_BindProgramPipeline_no_error(ctx
->Pipeline
.Current
->Name
);
2034 _mesa_BindProgramPipeline(ctx
->Pipeline
.Current
->Name
);
2041 _mesa_UseProgram_no_error(GLuint program
)
2043 use_program(program
, true);
2048 _mesa_UseProgram(GLuint program
)
2050 use_program(program
, false);
2055 _mesa_ValidateProgram(GLuint program
)
2057 GET_CURRENT_CONTEXT(ctx
);
2058 validate_program(ctx
, program
);
2063 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2066 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
2067 GLint
* range
, GLint
* precision
)
2069 const struct gl_program_constants
*limits
;
2070 const struct gl_precision
*p
;
2071 GET_CURRENT_CONTEXT(ctx
);
2073 switch (shadertype
) {
2074 case GL_VERTEX_SHADER
:
2075 limits
= &ctx
->Const
.Program
[MESA_SHADER_VERTEX
];
2077 case GL_FRAGMENT_SHADER
:
2078 limits
= &ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
];
2081 _mesa_error(ctx
, GL_INVALID_ENUM
,
2082 "glGetShaderPrecisionFormat(shadertype)");
2086 switch (precisiontype
) {
2088 p
= &limits
->LowFloat
;
2090 case GL_MEDIUM_FLOAT
:
2091 p
= &limits
->MediumFloat
;
2094 p
= &limits
->HighFloat
;
2097 p
= &limits
->LowInt
;
2100 p
= &limits
->MediumInt
;
2103 p
= &limits
->HighInt
;
2106 _mesa_error(ctx
, GL_INVALID_ENUM
,
2107 "glGetShaderPrecisionFormat(precisiontype)");
2111 range
[0] = p
->RangeMin
;
2112 range
[1] = p
->RangeMax
;
2113 precision
[0] = p
->Precision
;
2118 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2121 _mesa_ReleaseShaderCompiler(void)
2123 _mesa_destroy_shader_compiler_caches();
2128 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2131 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
2132 const void* binary
, GLint length
)
2134 GET_CURRENT_CONTEXT(ctx
);
2136 (void) binaryformat
;
2139 /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
2140 * page 88 of the OpenGL 4.5 specs state:
2142 * "An INVALID_VALUE error is generated if count or length is negative.
2143 * An INVALID_ENUM error is generated if binaryformat is not a supported
2144 * format returned in SHADER_BINARY_FORMATS."
2146 if (n
< 0 || length
< 0) {
2147 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderBinary(count or length < 0)");
2151 _mesa_error(ctx
, GL_INVALID_ENUM
, "glShaderBinary(format)");
2156 _mesa_GetProgramBinary(GLuint program
, GLsizei bufSize
, GLsizei
*length
,
2157 GLenum
*binaryFormat
, GLvoid
*binary
)
2159 struct gl_shader_program
*shProg
;
2160 GLsizei length_dummy
;
2161 GET_CURRENT_CONTEXT(ctx
);
2164 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramBinary(bufSize < 0)");
2168 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramBinary");
2172 /* The ARB_get_program_binary spec says:
2174 * "If <length> is NULL, then no length is returned."
2176 * Ensure that length always points to valid storage to avoid multiple NULL
2177 * pointer checks below.
2180 length
= &length_dummy
;
2183 /* The ARB_get_program_binary spec says:
2185 * "When a program object's LINK_STATUS is FALSE, its program binary
2186 * length is zero, and a call to GetProgramBinary will generate an
2187 * INVALID_OPERATION error.
2189 if (!shProg
->data
->LinkStatus
) {
2190 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2191 "glGetProgramBinary(program %u not linked)",
2198 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2199 "glGetProgramBinary(driver supports zero binary formats)");
2201 (void) binaryFormat
;
2206 _mesa_ProgramBinary(GLuint program
, GLenum binaryFormat
,
2207 const GLvoid
*binary
, GLsizei length
)
2209 struct gl_shader_program
*shProg
;
2210 GET_CURRENT_CONTEXT(ctx
);
2212 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glProgramBinary");
2216 (void) binaryFormat
;
2219 /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
2221 * "If a negative number is provided where an argument of type sizei or
2222 * sizeiptr is specified, an INVALID_VALUE error is generated."
2225 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramBinary(length < 0)");
2229 /* The ARB_get_program_binary spec says:
2231 * "<binaryFormat> and <binary> must be those returned by a previous
2232 * call to GetProgramBinary, and <length> must be the length of the
2233 * program binary as returned by GetProgramBinary or GetProgramiv with
2234 * <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
2235 * setting the LINK_STATUS of <program> to FALSE, if these conditions
2238 * Since any value of binaryFormat passed "is not one of those specified as
2239 * allowable for [this] command, an INVALID_ENUM error is generated."
2241 shProg
->data
->LinkStatus
= linking_failure
;
2242 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramBinary");
2246 static ALWAYS_INLINE
void
2247 program_parameteri(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
2248 GLuint pname
, GLint value
, bool no_error
)
2251 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
2252 /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
2253 * is part of OpenGL ES 3.0. For the ES2 case, this function shouldn't
2254 * even be in the dispatch table, so we shouldn't need to expclicitly
2257 * On desktop, we ignore the 3.0+ requirement because it is silly.
2260 /* The ARB_get_program_binary extension spec says:
2262 * "An INVALID_VALUE error is generated if the <value> argument to
2263 * ProgramParameteri is not TRUE or FALSE."
2265 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2269 /* No need to notify the driver. Any changes will actually take effect
2270 * the next time the shader is linked.
2272 * The ARB_get_program_binary extension spec says:
2274 * "To indicate that a program binary is likely to be retrieved,
2275 * ProgramParameteri should be called with <pname>
2276 * PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2277 * will not be in effect until the next time LinkProgram or
2278 * ProgramBinary has been called successfully."
2280 * The resloution of issue 9 in the extension spec also says:
2282 * "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2283 * to indicate to the GL implementation that this program will
2284 * likely be saved with GetProgramBinary at some point. This will
2285 * give the GL implementation the opportunity to track any state
2286 * changes made to the program before being saved such that when it
2287 * is loaded again a recompile can be avoided."
2289 shProg
->BinaryRetreivableHint
= value
;
2292 case GL_PROGRAM_SEPARABLE
:
2293 /* Spec imply that the behavior is the same as ARB_get_program_binary
2294 * Chapter 7.3 Program Objects
2296 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2299 shProg
->SeparateShader
= value
;
2304 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteri(pname=%s)",
2305 _mesa_enum_to_string(pname
));
2311 _mesa_error(ctx
, GL_INVALID_VALUE
,
2312 "glProgramParameteri(pname=%s, value=%d): "
2313 "value must be 0 or 1.",
2314 _mesa_enum_to_string(pname
),
2320 _mesa_ProgramParameteri_no_error(GLuint program
, GLenum pname
, GLint value
)
2322 GET_CURRENT_CONTEXT(ctx
);
2324 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, program
);
2325 program_parameteri(ctx
, shProg
, pname
, value
, true);
2330 _mesa_ProgramParameteri(GLuint program
, GLenum pname
, GLint value
)
2332 struct gl_shader_program
*shProg
;
2333 GET_CURRENT_CONTEXT(ctx
);
2335 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
2336 "glProgramParameteri");
2340 program_parameteri(ctx
, shProg
, pname
, value
, false);
2345 _mesa_use_program(struct gl_context
*ctx
, gl_shader_stage stage
,
2346 struct gl_shader_program
*shProg
, struct gl_program
*prog
,
2347 struct gl_pipeline_object
*shTarget
)
2349 struct gl_program
**target
;
2351 target
= &shTarget
->CurrentProgram
[stage
];
2353 _mesa_program_init_subroutine_defaults(ctx
, prog
);
2356 if (*target
!= prog
) {
2357 /* Program is current, flush it */
2358 if (shTarget
== ctx
->_Shader
) {
2359 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
2362 _mesa_reference_shader_program(ctx
,
2363 &shTarget
->ReferencedPrograms
[stage
],
2365 _mesa_reference_program(ctx
, target
, prog
);
2373 * Copy program-specific data generated by linking from the gl_shader_program
2374 * object to the gl_program object referred to by the gl_linked_shader.
2376 * This function expects _mesa_reference_program() to have been previously
2377 * called setting the gl_linked_shaders program reference.
2380 _mesa_copy_linked_program_data(const struct gl_shader_program
*src
,
2381 struct gl_linked_shader
*dst_sh
)
2383 assert(dst_sh
->Program
);
2385 struct gl_program
*dst
= dst_sh
->Program
;
2387 dst
->info
.separate_shader
= src
->SeparateShader
;
2389 switch (dst_sh
->Stage
) {
2390 case MESA_SHADER_GEOMETRY
: {
2391 dst
->info
.gs
.vertices_in
= src
->Geom
.VerticesIn
;
2392 dst
->info
.gs
.uses_end_primitive
= src
->Geom
.UsesEndPrimitive
;
2393 dst
->info
.gs
.uses_streams
= src
->Geom
.UsesStreams
;
2396 case MESA_SHADER_FRAGMENT
: {
2397 dst
->info
.fs
.depth_layout
= src
->FragDepthLayout
;
2400 case MESA_SHADER_COMPUTE
: {
2401 dst
->info
.cs
.shared_size
= src
->Comp
.SharedSize
;
2410 * ARB_separate_shader_objects: Compile & Link Program
2413 _mesa_CreateShaderProgramv(GLenum type
, GLsizei count
,
2414 const GLchar
* const *strings
)
2416 GET_CURRENT_CONTEXT(ctx
);
2418 const GLuint shader
= create_shader_err(ctx
, type
, "glCreateShaderProgramv");
2422 * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2423 * GL_INVALID_VALUE should be generated if count < 0
2426 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCreateShaderProgram (count < 0)");
2431 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
2433 _mesa_ShaderSource(shader
, count
, strings
, NULL
);
2434 _mesa_compile_shader(ctx
, sh
);
2436 program
= create_shader_program(ctx
);
2438 struct gl_shader_program
*shProg
;
2439 GLint compiled
= GL_FALSE
;
2441 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2443 shProg
->SeparateShader
= GL_TRUE
;
2445 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
2447 attach_shader_err(ctx
, program
, shader
, "glCreateShaderProgramv");
2448 _mesa_link_program(ctx
, shProg
);
2449 detach_shader_error(ctx
, program
, shader
);
2453 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
2454 append
-error
-to
-info
-log
;
2455 shProg
->data
->LinkStatus
= linking_failure
;
2460 ralloc_strcat(&shProg
->data
->InfoLog
, sh
->InfoLog
);
2463 delete_shader(ctx
, shader
);
2471 * For GL_ARB_tessellation_shader
2474 _mesa_PatchParameteri_no_error(GLenum pname
, GLint value
)
2476 GET_CURRENT_CONTEXT(ctx
);
2477 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2481 extern void GLAPIENTRY
2482 _mesa_PatchParameteri(GLenum pname
, GLint value
)
2484 GET_CURRENT_CONTEXT(ctx
);
2486 if (!_mesa_has_tessellation(ctx
)) {
2487 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameteri");
2491 if (pname
!= GL_PATCH_VERTICES
) {
2492 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameteri");
2496 if (value
<= 0 || value
> ctx
->Const
.MaxPatchVertices
) {
2497 _mesa_error(ctx
, GL_INVALID_VALUE
, "glPatchParameteri");
2501 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2505 extern void GLAPIENTRY
2506 _mesa_PatchParameterfv(GLenum pname
, const GLfloat
*values
)
2508 GET_CURRENT_CONTEXT(ctx
);
2510 if (!_mesa_has_tessellation(ctx
)) {
2511 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameterfv");
2516 case GL_PATCH_DEFAULT_OUTER_LEVEL
:
2517 FLUSH_VERTICES(ctx
, 0);
2518 memcpy(ctx
->TessCtrlProgram
.patch_default_outer_level
, values
,
2519 4 * sizeof(GLfloat
));
2520 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2522 case GL_PATCH_DEFAULT_INNER_LEVEL
:
2523 FLUSH_VERTICES(ctx
, 0);
2524 memcpy(ctx
->TessCtrlProgram
.patch_default_inner_level
, values
,
2525 2 * sizeof(GLfloat
));
2526 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2529 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameterfv");
2535 * ARB_shader_subroutine
2538 _mesa_GetSubroutineUniformLocation(GLuint program
, GLenum shadertype
,
2541 GET_CURRENT_CONTEXT(ctx
);
2542 const char *api_name
= "glGetSubroutineUniformLocation";
2543 struct gl_shader_program
*shProg
;
2544 GLenum resource_type
;
2545 gl_shader_stage stage
;
2547 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2548 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2552 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2556 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2557 if (!shProg
->_LinkedShaders
[stage
]) {
2558 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2562 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2563 return _mesa_program_resource_location(shProg
, resource_type
, name
);
2567 _mesa_GetSubroutineIndex(GLuint program
, GLenum shadertype
,
2570 GET_CURRENT_CONTEXT(ctx
);
2571 const char *api_name
= "glGetSubroutineIndex";
2572 struct gl_shader_program
*shProg
;
2573 struct gl_program_resource
*res
;
2574 GLenum resource_type
;
2575 gl_shader_stage stage
;
2577 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2578 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2582 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2586 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2587 if (!shProg
->_LinkedShaders
[stage
]) {
2588 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2592 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2593 res
= _mesa_program_resource_find_name(shProg
, resource_type
, name
, NULL
);
2598 return _mesa_program_resource_index(shProg
, res
);
2603 _mesa_GetActiveSubroutineUniformiv(GLuint program
, GLenum shadertype
,
2604 GLuint index
, GLenum pname
, GLint
*values
)
2606 GET_CURRENT_CONTEXT(ctx
);
2607 const char *api_name
= "glGetActiveSubroutineUniformiv";
2608 struct gl_shader_program
*shProg
;
2609 struct gl_linked_shader
*sh
;
2610 gl_shader_stage stage
;
2611 struct gl_program_resource
*res
;
2612 const struct gl_uniform_storage
*uni
;
2613 GLenum resource_type
;
2616 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2617 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2621 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2625 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2626 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2628 sh
= shProg
->_LinkedShaders
[stage
];
2630 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2634 struct gl_program
*p
= shProg
->_LinkedShaders
[stage
]->Program
;
2635 if (index
>= p
->sh
.NumSubroutineUniforms
) {
2636 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name
);
2641 case GL_NUM_COMPATIBLE_SUBROUTINES
: {
2642 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2645 values
[0] = uni
->num_compatible_subroutines
;
2649 case GL_COMPATIBLE_SUBROUTINES
: {
2650 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2654 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2655 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2656 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2657 if (fn
->types
[j
] == uni
->type
) {
2658 values
[count
++] = i
;
2666 case GL_UNIFORM_SIZE
:
2667 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2670 values
[0] = uni
->array_elements
? uni
->array_elements
: 1;
2673 case GL_UNIFORM_NAME_LENGTH
:
2674 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2676 values
[0] = strlen(_mesa_program_resource_name(res
)) + 1
2677 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2681 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2688 _mesa_GetActiveSubroutineUniformName(GLuint program
, GLenum shadertype
,
2689 GLuint index
, GLsizei bufsize
,
2690 GLsizei
*length
, GLchar
*name
)
2692 GET_CURRENT_CONTEXT(ctx
);
2693 const char *api_name
= "glGetActiveSubroutineUniformName";
2694 struct gl_shader_program
*shProg
;
2695 GLenum resource_type
;
2696 gl_shader_stage stage
;
2698 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2699 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2703 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2707 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2708 if (!shProg
->_LinkedShaders
[stage
]) {
2709 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2713 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2714 /* get program resource name */
2715 _mesa_get_program_resource_name(shProg
, resource_type
,
2717 length
, name
, api_name
);
2722 _mesa_GetActiveSubroutineName(GLuint program
, GLenum shadertype
,
2723 GLuint index
, GLsizei bufsize
,
2724 GLsizei
*length
, GLchar
*name
)
2726 GET_CURRENT_CONTEXT(ctx
);
2727 const char *api_name
= "glGetActiveSubroutineName";
2728 struct gl_shader_program
*shProg
;
2729 GLenum resource_type
;
2730 gl_shader_stage stage
;
2732 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2733 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2737 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2741 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2742 if (!shProg
->_LinkedShaders
[stage
]) {
2743 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2746 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2747 _mesa_get_program_resource_name(shProg
, resource_type
,
2749 length
, name
, api_name
);
2753 _mesa_UniformSubroutinesuiv(GLenum shadertype
, GLsizei count
,
2754 const GLuint
*indices
)
2756 GET_CURRENT_CONTEXT(ctx
);
2757 const char *api_name
= "glUniformSubroutinesuiv";
2758 gl_shader_stage stage
;
2761 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2762 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2766 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2767 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2769 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2773 if (count
!= p
->sh
.NumSubroutineUniformRemapTable
) {
2774 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2779 bool flushed
= false;
2781 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2788 _mesa_flush_vertices_for_uniforms(ctx
, uni
);
2792 int uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2795 for (j
= i
; j
< i
+ uni_count
; j
++) {
2796 struct gl_subroutine_function
*subfn
= NULL
;
2797 if (indices
[j
] > p
->sh
.MaxSubroutineFunctionIndex
) {
2798 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2802 for (f
= 0; f
< p
->sh
.NumSubroutineFunctions
; f
++) {
2803 if (p
->sh
.SubroutineFunctions
[f
].index
== indices
[j
])
2804 subfn
= &p
->sh
.SubroutineFunctions
[f
];
2811 for (k
= 0; k
< subfn
->num_compat_types
; k
++) {
2812 if (subfn
->types
[k
] == uni
->type
)
2815 if (k
== subfn
->num_compat_types
) {
2816 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2820 ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[j
] = indices
[j
];
2828 _mesa_GetUniformSubroutineuiv(GLenum shadertype
, GLint location
,
2831 GET_CURRENT_CONTEXT(ctx
);
2832 const char *api_name
= "glGetUniformSubroutineuiv";
2833 gl_shader_stage stage
;
2835 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2836 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2840 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2841 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2843 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2847 if (location
>= p
->sh
.NumSubroutineUniformRemapTable
) {
2848 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2852 *params
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[location
];
2857 _mesa_GetProgramStageiv(GLuint program
, GLenum shadertype
,
2858 GLenum pname
, GLint
*values
)
2860 GET_CURRENT_CONTEXT(ctx
);
2861 const char *api_name
= "glGetProgramStageiv";
2862 struct gl_shader_program
*shProg
;
2863 struct gl_linked_shader
*sh
;
2864 gl_shader_stage stage
;
2866 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2867 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2871 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2875 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2876 sh
= shProg
->_LinkedShaders
[stage
];
2878 /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
2879 * INVALID_OPERATION in the case of not be linked.
2881 * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
2882 * same info using other specs (ARB_program_interface_query), without the
2883 * need of the program to be linked, being the value for that case 0.
2885 * But at the same time, some other methods require the program to be
2886 * linked for pname related to locations, so it would be inconsistent to
2887 * not do the same here. So we are:
2888 * * Return GL_INVALID_OPERATION if not linked only for locations.
2889 * * Setting a default value of 0, to be returned if not linked.
2893 if (pname
== GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
) {
2894 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2899 struct gl_program
*p
= sh
->Program
;
2901 case GL_ACTIVE_SUBROUTINES
:
2902 values
[0] = p
->sh
.NumSubroutineFunctions
;
2904 case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
:
2905 values
[0] = p
->sh
.NumSubroutineUniformRemapTable
;
2907 case GL_ACTIVE_SUBROUTINE_UNIFORMS
:
2908 values
[0] = p
->sh
.NumSubroutineUniforms
;
2910 case GL_ACTIVE_SUBROUTINE_MAX_LENGTH
:
2914 GLenum resource_type
;
2915 struct gl_program_resource
*res
;
2917 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2918 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2919 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2921 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1;
2926 values
[0] = max_len
;
2929 case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
:
2933 GLenum resource_type
;
2934 struct gl_program_resource
*res
;
2936 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2937 for (i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
2938 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2940 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1
2941 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2947 values
[0] = max_len
;
2951 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s", api_name
);
2958 find_compat_subroutine(struct gl_program
*p
, const struct glsl_type
*type
)
2962 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2963 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2964 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2965 if (fn
->types
[j
] == type
)
2973 _mesa_shader_write_subroutine_index(struct gl_context
*ctx
,
2974 struct gl_program
*p
)
2978 if (p
->sh
.NumSubroutineUniformRemapTable
== 0)
2983 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2992 uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2993 for (j
= 0; j
< uni_count
; j
++) {
2994 val
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[i
+ j
];
2995 memcpy(&uni
->storage
[j
], &val
, sizeof(int));
2998 _mesa_propagate_uniforms_to_driver_storage(uni
, 0, uni_count
);
3000 } while(i
< p
->sh
.NumSubroutineUniformRemapTable
);
3004 _mesa_shader_write_subroutine_indices(struct gl_context
*ctx
,
3005 gl_shader_stage stage
)
3007 if (ctx
->_Shader
->CurrentProgram
[stage
])
3008 _mesa_shader_write_subroutine_index(ctx
,
3009 ctx
->_Shader
->CurrentProgram
[stage
]);
3013 _mesa_program_init_subroutine_defaults(struct gl_context
*ctx
,
3014 struct gl_program
*p
)
3018 struct gl_subroutine_index_binding
*binding
= &ctx
->SubroutineIndex
[p
->info
.stage
];
3019 if (binding
->NumIndex
!= p
->sh
.NumSubroutineUniformRemapTable
) {
3020 binding
->IndexPtr
= realloc(binding
->IndexPtr
,
3021 p
->sh
.NumSubroutineUniformRemapTable
* (sizeof(GLuint
)));
3022 binding
->NumIndex
= p
->sh
.NumSubroutineUniformRemapTable
;
3025 for (int i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3026 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3031 binding
->IndexPtr
[i
] = find_compat_subroutine(p
, uni
->type
);