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.
518 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
519 GLsizei
*count
, GLuint
*obj
)
521 struct gl_shader_program
*shProg
;
524 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetAttachedShaders(maxCount < 0)");
529 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
533 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
534 obj
[i
] = shProg
->Shaders
[i
]->Name
;
543 * glGetHandleARB() - return ID/name of currently bound shader program.
546 get_handle(struct gl_context
*ctx
, GLenum pname
)
548 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
549 if (ctx
->_Shader
->ActiveProgram
)
550 return ctx
->_Shader
->ActiveProgram
->Name
;
555 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
562 * Check if a geometry shader query is valid at this time. If not, report an
563 * error and return false.
565 * From GL 3.2 section 6.1.16 (Shader and Program Queries):
567 * "If GEOMETRY_VERTICES_OUT, GEOMETRY_INPUT_TYPE, or GEOMETRY_OUTPUT_TYPE
568 * are queried for a program which has not been linked successfully, or
569 * which does not contain objects to form a geometry shader, then an
570 * INVALID_OPERATION error is generated."
573 check_gs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
575 if (shProg
->data
->LinkStatus
&&
576 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] != NULL
) {
580 _mesa_error(ctx
, GL_INVALID_OPERATION
,
581 "glGetProgramv(linked geometry shader required)");
587 * Check if a tessellation control shader query is valid at this time.
588 * If not, report an error and return false.
590 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
592 * "If TESS_CONTROL_OUTPUT_VERTICES is queried for a program which has
593 * not been linked successfully, or which does not contain objects to
594 * form a tessellation control shader, then an INVALID_OPERATION error is
598 check_tcs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
600 if (shProg
->data
->LinkStatus
&&
601 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
] != NULL
) {
605 _mesa_error(ctx
, GL_INVALID_OPERATION
,
606 "glGetProgramv(linked tessellation control shader required)");
612 * Check if a tessellation evaluation shader query is valid at this time.
613 * If not, report an error and return false.
615 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
617 * "If any of the pname values in this paragraph are queried for a program
618 * which has not been linked successfully, or which does not contain
619 * objects to form a tessellation evaluation shader, then an
620 * INVALID_OPERATION error is generated."
624 check_tes_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
626 if (shProg
->data
->LinkStatus
&&
627 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
] != NULL
) {
631 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramv(linked tessellation "
632 "evaluation shader required)");
638 * glGetProgramiv() - get shader program state.
639 * Note that this is for GLSL shader programs, not ARB vertex/fragment
640 * programs (see glGetProgramivARB).
643 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
,
646 struct gl_shader_program
*shProg
647 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramiv(program)");
649 /* Is transform feedback available in this context?
652 (ctx
->API
== API_OPENGL_COMPAT
&& ctx
->Extensions
.EXT_transform_feedback
)
653 || ctx
->API
== API_OPENGL_CORE
654 || _mesa_is_gles3(ctx
);
656 /* True if geometry shaders (of the form that was adopted into GLSL 1.50
657 * and GL 3.2) are available in this context
659 const bool has_core_gs
= _mesa_has_geometry_shaders(ctx
);
660 const bool has_tess
= _mesa_has_tessellation(ctx
);
662 /* Are uniform buffer objects available in this context?
665 (ctx
->API
== API_OPENGL_COMPAT
&&
666 ctx
->Extensions
.ARB_uniform_buffer_object
)
667 || ctx
->API
== API_OPENGL_CORE
668 || _mesa_is_gles3(ctx
);
675 case GL_DELETE_STATUS
:
676 *params
= shProg
->DeletePending
;
679 *params
= shProg
->data
->LinkStatus
? GL_TRUE
: GL_FALSE
;
681 case GL_VALIDATE_STATUS
:
682 *params
= shProg
->data
->Validated
;
684 case GL_INFO_LOG_LENGTH
:
685 *params
= (shProg
->data
->InfoLog
&& shProg
->data
->InfoLog
[0] != '\0') ?
686 strlen(shProg
->data
->InfoLog
) + 1 : 0;
688 case GL_ATTACHED_SHADERS
:
689 *params
= shProg
->NumShaders
;
691 case GL_ACTIVE_ATTRIBUTES
:
692 *params
= _mesa_count_active_attribs(shProg
);
694 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
695 *params
= _mesa_longest_attribute_name_length(shProg
);
697 case GL_ACTIVE_UNIFORMS
: {
699 const unsigned num_uniforms
=
700 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
701 for (*params
= 0, i
= 0; i
< num_uniforms
; i
++) {
702 if (!shProg
->data
->UniformStorage
[i
].is_shader_storage
)
707 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
710 const unsigned num_uniforms
=
711 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
713 for (i
= 0; i
< num_uniforms
; i
++) {
714 if (shProg
->data
->UniformStorage
[i
].is_shader_storage
)
717 /* Add one for the terminating NUL character for a non-array, and
718 * 4 for the "[0]" and the NUL for an array.
720 const GLint len
= strlen(shProg
->data
->UniformStorage
[i
].name
) + 1 +
721 ((shProg
->data
->UniformStorage
[i
].array_elements
!= 0) ? 3 : 0);
730 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
733 *params
= shProg
->TransformFeedback
.NumVarying
;
735 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
: {
741 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
742 /* Add one for the terminating NUL character.
745 strlen(shProg
->TransformFeedback
.VaryingNames
[i
]) + 1;
754 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
757 *params
= shProg
->TransformFeedback
.BufferMode
;
759 case GL_GEOMETRY_VERTICES_OUT
:
762 if (check_gs_query(ctx
, shProg
)) {
763 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
764 Program
->info
.gs
.vertices_out
;
767 case GL_GEOMETRY_SHADER_INVOCATIONS
:
768 if (!has_core_gs
|| !ctx
->Extensions
.ARB_gpu_shader5
)
770 if (check_gs_query(ctx
, shProg
)) {
771 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
772 Program
->info
.gs
.invocations
;
775 case GL_GEOMETRY_INPUT_TYPE
:
778 if (check_gs_query(ctx
, shProg
)) {
779 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
780 Program
->info
.gs
.input_primitive
;
783 case GL_GEOMETRY_OUTPUT_TYPE
:
786 if (check_gs_query(ctx
, shProg
)) {
787 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
788 Program
->info
.gs
.output_primitive
;
791 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
: {
798 for (i
= 0; i
< shProg
->data
->NumUniformBlocks
; i
++) {
799 /* Add one for the terminating NUL character.
801 const GLint len
= strlen(shProg
->data
->UniformBlocks
[i
].Name
) + 1;
810 case GL_ACTIVE_UNIFORM_BLOCKS
:
814 *params
= shProg
->data
->NumUniformBlocks
;
816 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
817 /* This enum isn't part of the OES extension for OpenGL ES 2.0. It is
818 * only available with desktop OpenGL 3.0+ with the
819 * GL_ARB_get_program_binary extension or OpenGL ES 3.0.
821 * On desktop, we ignore the 3.0+ requirement because it is silly.
823 if (!_mesa_is_desktop_gl(ctx
) && !_mesa_is_gles3(ctx
))
826 *params
= shProg
->BinaryRetreivableHint
;
828 case GL_PROGRAM_BINARY_LENGTH
:
831 case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS
:
832 if (!ctx
->Extensions
.ARB_shader_atomic_counters
)
835 *params
= shProg
->data
->NumAtomicBuffers
;
837 case GL_COMPUTE_WORK_GROUP_SIZE
: {
839 if (!_mesa_has_compute_shaders(ctx
))
841 if (!shProg
->data
->LinkStatus
) {
842 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(program not "
846 if (shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
] == NULL
) {
847 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(no compute "
851 for (i
= 0; i
< 3; i
++)
852 params
[i
] = shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
]->
853 Program
->info
.cs
.local_size
[i
];
856 case GL_PROGRAM_SEPARABLE
:
857 /* If the program has not been linked, return initial value 0. */
858 *params
= (shProg
->data
->LinkStatus
== linking_failure
) ? 0 : shProg
->SeparateShader
;
861 /* ARB_tessellation_shader */
862 case GL_TESS_CONTROL_OUTPUT_VERTICES
:
865 if (check_tcs_query(ctx
, shProg
)) {
866 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->
867 Program
->info
.tess
.tcs_vertices_out
;
870 case GL_TESS_GEN_MODE
:
873 if (check_tes_query(ctx
, shProg
)) {
874 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
875 Program
->info
.tess
.primitive_mode
;
878 case GL_TESS_GEN_SPACING
:
881 if (check_tes_query(ctx
, shProg
)) {
882 const struct gl_linked_shader
*tes
=
883 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
];
884 switch (tes
->Program
->info
.tess
.spacing
) {
885 case TESS_SPACING_EQUAL
:
888 case TESS_SPACING_FRACTIONAL_ODD
:
889 *params
= GL_FRACTIONAL_ODD
;
891 case TESS_SPACING_FRACTIONAL_EVEN
:
892 *params
= GL_FRACTIONAL_EVEN
;
894 case TESS_SPACING_UNSPECIFIED
:
900 case GL_TESS_GEN_VERTEX_ORDER
:
903 if (check_tes_query(ctx
, shProg
)) {
904 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
905 Program
->info
.tess
.ccw
? GL_CCW
: GL_CW
;
908 case GL_TESS_GEN_POINT_MODE
:
911 if (check_tes_query(ctx
, shProg
)) {
912 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
913 Program
->info
.tess
.point_mode
? GL_TRUE
: GL_FALSE
;
920 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname=%s)",
921 _mesa_enum_to_string(pname
));
926 * glGetShaderiv() - get GLSL shader state
929 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
931 struct gl_shader
*shader
=
932 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
940 *params
= shader
->Type
;
942 case GL_DELETE_STATUS
:
943 *params
= shader
->DeletePending
;
945 case GL_COMPILE_STATUS
:
946 *params
= shader
->CompileStatus
? GL_TRUE
: GL_FALSE
;
948 case GL_INFO_LOG_LENGTH
:
949 *params
= (shader
->InfoLog
&& shader
->InfoLog
[0] != '\0') ?
950 strlen(shader
->InfoLog
) + 1 : 0;
952 case GL_SHADER_SOURCE_LENGTH
:
953 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
956 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
963 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
964 GLsizei
*length
, GLchar
*infoLog
)
966 struct gl_shader_program
*shProg
;
968 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
969 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
971 * "If a negative number is provided where an argument of type sizei or
972 * sizeiptr is specified, an INVALID_VALUE error is generated."
975 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(bufSize < 0)");
979 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
980 "glGetProgramInfoLog(program)");
985 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->data
->InfoLog
);
990 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
991 GLsizei
*length
, GLchar
*infoLog
)
993 struct gl_shader
*sh
;
995 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
996 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
998 * "If a negative number is provided where an argument of type sizei or
999 * sizeiptr is specified, an INVALID_VALUE error is generated."
1002 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(bufSize < 0)");
1006 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderInfoLog(shader)");
1011 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
1016 * Return shader source code.
1019 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
1020 GLsizei
*length
, GLchar
*sourceOut
)
1022 struct gl_shader
*sh
;
1024 if (maxLength
< 0) {
1025 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderSource(bufSize < 0)");
1029 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
1033 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
1038 * Set/replace shader source code. A helper function used by
1039 * glShaderSource[ARB].
1042 set_shader_source(struct gl_shader
*sh
, const GLchar
*source
)
1046 if (sh
->CompileStatus
== compile_skipped
&& !sh
->FallbackSource
) {
1047 /* If shader was previously compiled back-up the source in case of cache
1050 sh
->FallbackSource
= sh
->Source
;
1051 sh
->Source
= source
;
1053 /* free old shader source string and install new one */
1054 free((void *)sh
->Source
);
1055 sh
->Source
= source
;
1059 sh
->SourceChecksum
= util_hash_crc32(sh
->Source
, strlen(sh
->Source
));
1068 _mesa_compile_shader(struct gl_context
*ctx
, struct gl_shader
*sh
)
1074 /* If the user called glCompileShader without first calling
1075 * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
1077 sh
->CompileStatus
= compile_failure
;
1079 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1080 _mesa_log("GLSL source for %s shader %d:\n",
1081 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1082 _mesa_log("%s\n", sh
->Source
);
1085 /* this call will set the shader->CompileStatus field to indicate if
1086 * compilation was successful.
1088 _mesa_glsl_compile_shader(ctx
, sh
, false, false, false);
1090 if (ctx
->_Shader
->Flags
& GLSL_LOG
) {
1091 _mesa_write_shader_to_file(sh
);
1094 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1095 if (sh
->CompileStatus
) {
1097 _mesa_log("GLSL IR for shader %d:\n", sh
->Name
);
1098 _mesa_print_ir(_mesa_get_log_file(), sh
->ir
, NULL
);
1100 _mesa_log("No GLSL IR for shader %d (shader may be from "
1101 "cache)\n", sh
->Name
);
1105 _mesa_log("GLSL shader %d failed to compile.\n", sh
->Name
);
1107 if (sh
->InfoLog
&& sh
->InfoLog
[0] != 0) {
1108 _mesa_log("GLSL shader %d info log:\n", sh
->Name
);
1109 _mesa_log("%s\n", sh
->InfoLog
);
1114 if (!sh
->CompileStatus
) {
1115 if (ctx
->_Shader
->Flags
& GLSL_DUMP_ON_ERROR
) {
1116 _mesa_log("GLSL source for %s shader %d:\n",
1117 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1118 _mesa_log("%s\n", sh
->Source
);
1119 _mesa_log("Info Log:\n%s\n", sh
->InfoLog
);
1122 if (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
) {
1123 _mesa_debug(ctx
, "Error compiling shader %u:\n%s\n",
1124 sh
->Name
, sh
->InfoLog
);
1131 * Link a program's shaders.
1133 static ALWAYS_INLINE
void
1134 link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1141 /* From the ARB_transform_feedback2 specification:
1142 * "The error INVALID_OPERATION is generated by LinkProgram if <program>
1143 * is the name of a program being used by one or more transform feedback
1144 * objects, even if the objects are not currently bound or are paused."
1146 if (_mesa_transform_feedback_is_using_program(ctx
, shProg
)) {
1147 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1148 "glLinkProgram(transform feedback is using the program)");
1153 unsigned programs_in_use
= 0;
1155 for (unsigned stage
= 0; stage
< MESA_SHADER_STAGES
; stage
++) {
1156 if (ctx
->_Shader
->CurrentProgram
[stage
] &&
1157 ctx
->_Shader
->CurrentProgram
[stage
]->Id
== shProg
->Name
) {
1158 programs_in_use
|= 1 << stage
;
1162 FLUSH_VERTICES(ctx
, 0);
1163 _mesa_glsl_link_shader(ctx
, shProg
);
1165 /* From section 7.3 (Program Objects) of the OpenGL 4.5 spec:
1167 * "If LinkProgram or ProgramBinary successfully re-links a program
1168 * object that is active for any shader stage, then the newly generated
1169 * executable code will be installed as part of the current rendering
1170 * state for all shader stages where the program is active.
1171 * Additionally, the newly generated executable code is made part of
1172 * the state of any program pipeline for all stages where the program
1175 if (shProg
->data
->LinkStatus
&& programs_in_use
) {
1176 while (programs_in_use
) {
1177 const int stage
= u_bit_scan(&programs_in_use
);
1179 struct gl_program
*prog
= NULL
;
1180 if (shProg
->_LinkedShaders
[stage
])
1181 prog
= shProg
->_LinkedShaders
[stage
]->Program
;
1183 _mesa_use_program(ctx
, stage
, shProg
, prog
, ctx
->_Shader
);
1187 /* Capture .shader_test files. */
1188 const char *capture_path
= _mesa_get_shader_capture_path();
1189 if (shProg
->Name
!= 0 && shProg
->Name
!= ~0 && capture_path
!= NULL
) {
1191 char *filename
= ralloc_asprintf(NULL
, "%s/%u.shader_test",
1192 capture_path
, shProg
->Name
);
1193 file
= fopen(filename
, "w");
1195 fprintf(file
, "[require]\nGLSL%s >= %u.%02u\n",
1196 shProg
->IsES
? " ES" : "",
1197 shProg
->data
->Version
/ 100, shProg
->data
->Version
% 100);
1198 if (shProg
->SeparateShader
)
1199 fprintf(file
, "GL_ARB_separate_shader_objects\nSSO ENABLED\n");
1200 fprintf(file
, "\n");
1202 for (unsigned i
= 0; i
< shProg
->NumShaders
; i
++) {
1203 fprintf(file
, "[%s shader]\n%s\n",
1204 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1205 shProg
->Shaders
[i
]->Source
);
1209 _mesa_warning(ctx
, "Failed to open %s", filename
);
1212 ralloc_free(filename
);
1215 if (shProg
->data
->LinkStatus
== linking_failure
&&
1216 (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
)) {
1217 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
1218 shProg
->Name
, shProg
->data
->InfoLog
);
1225 printf("Link %u shaders in program %u: %s\n",
1226 shProg
->NumShaders
, shProg
->Name
,
1227 shProg
->data
->LinkStatus
? "Success" : "Failed");
1229 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1230 printf(" shader %u, stage %u\n",
1231 shProg
->Shaders
[i
]->Name
,
1232 shProg
->Shaders
[i
]->Stage
);
1239 link_program_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1241 link_program(ctx
, shProg
, false);
1246 link_program_no_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1248 link_program(ctx
, shProg
, true);
1253 _mesa_link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1255 link_program_error(ctx
, shProg
);
1260 * Print basic shader info (for debug).
1263 print_shader_info(const struct gl_shader_program
*shProg
)
1267 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
1268 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1270 printf(" %s shader %u, checksum %u\n",
1271 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1272 shProg
->Shaders
[i
]->Name
,
1273 shProg
->Shaders
[i
]->SourceChecksum
);
1275 printf(" %s shader %u\n",
1276 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1277 shProg
->Shaders
[i
]->Name
);
1280 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
1281 printf(" vert prog %u\n",
1282 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
1283 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
1284 printf(" frag prog %u\n",
1285 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
1286 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
1287 printf(" geom prog %u\n",
1288 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
1289 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
])
1290 printf(" tesc prog %u\n",
1291 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->Program
->Id
);
1292 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
])
1293 printf(" tese prog %u\n",
1294 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->Program
->Id
);
1299 * Use the named shader program for subsequent glUniform calls
1302 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1305 if ((shProg
!= NULL
) && !shProg
->data
->LinkStatus
) {
1306 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1307 "%s(program %u not linked)", caller
, shProg
->Name
);
1311 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
1312 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
1318 * Use the named shader program for subsequent rendering.
1321 _mesa_use_shader_program(struct gl_context
*ctx
,
1322 struct gl_shader_program
*shProg
)
1324 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1325 struct gl_program
*new_prog
= NULL
;
1326 if (shProg
&& shProg
->_LinkedShaders
[i
])
1327 new_prog
= shProg
->_LinkedShaders
[i
]->Program
;
1328 _mesa_use_program(ctx
, i
, shProg
, new_prog
, &ctx
->Shader
);
1330 _mesa_active_program(ctx
, shProg
, "glUseProgram");
1335 * Do validation of the given shader program.
1336 * \param errMsg returns error message if validation fails.
1337 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1340 validate_shader_program(const struct gl_shader_program
*shProg
,
1343 if (!shProg
->data
->LinkStatus
) {
1347 /* From the GL spec, a program is invalid if any of these are true:
1349 any two active samplers in the current program object are of
1350 different types, but refer to the same texture image unit,
1352 any active sampler in the current program object refers to a texture
1353 image unit where fixed-function fragment processing accesses a
1354 texture target that does not match the sampler type, or
1356 the sum of the number of active samplers in the program and the
1357 number of texture image units enabled for fixed-function fragment
1358 processing exceeds the combined limit on the total number of texture
1359 image units allowed.
1363 * Check: any two active samplers in the current program object are of
1364 * different types, but refer to the same texture image unit,
1366 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
1374 * Called via glValidateProgram()
1377 validate_program(struct gl_context
*ctx
, GLuint program
)
1379 struct gl_shader_program
*shProg
;
1380 char errMsg
[100] = "";
1382 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1387 shProg
->data
->Validated
= validate_shader_program(shProg
, errMsg
);
1388 if (!shProg
->data
->Validated
) {
1389 /* update info log */
1390 if (shProg
->data
->InfoLog
) {
1391 ralloc_free(shProg
->data
->InfoLog
);
1393 shProg
->data
->InfoLog
= ralloc_strdup(shProg
->data
, errMsg
);
1399 _mesa_AttachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1401 GET_CURRENT_CONTEXT(ctx
);
1402 attach_shader_no_error(ctx
, program
, shader
);
1407 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1409 GET_CURRENT_CONTEXT(ctx
);
1410 attach_shader_err(ctx
, program
, shader
, "glAttachObjectARB");
1415 _mesa_AttachShader_no_error(GLuint program
, GLuint shader
)
1417 GET_CURRENT_CONTEXT(ctx
);
1418 attach_shader_no_error(ctx
, program
, shader
);
1423 _mesa_AttachShader(GLuint program
, GLuint shader
)
1425 GET_CURRENT_CONTEXT(ctx
);
1426 attach_shader_err(ctx
, program
, shader
, "glAttachShader");
1431 _mesa_CompileShader(GLuint shaderObj
)
1433 GET_CURRENT_CONTEXT(ctx
);
1434 if (MESA_VERBOSE
& VERBOSE_API
)
1435 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1436 _mesa_compile_shader(ctx
, _mesa_lookup_shader_err(ctx
, shaderObj
,
1437 "glCompileShader"));
1442 _mesa_CreateShader_no_error(GLenum type
)
1444 GET_CURRENT_CONTEXT(ctx
);
1445 return create_shader(ctx
, type
);
1450 _mesa_CreateShader(GLenum type
)
1452 GET_CURRENT_CONTEXT(ctx
);
1454 if (MESA_VERBOSE
& VERBOSE_API
)
1455 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_enum_to_string(type
));
1457 return create_shader_err(ctx
, type
, "glCreateShader");
1461 GLhandleARB GLAPIENTRY
1462 _mesa_CreateShaderObjectARB_no_error(GLenum type
)
1464 GET_CURRENT_CONTEXT(ctx
);
1465 return create_shader(ctx
, type
);
1469 GLhandleARB GLAPIENTRY
1470 _mesa_CreateShaderObjectARB(GLenum type
)
1472 GET_CURRENT_CONTEXT(ctx
);
1473 return create_shader_err(ctx
, type
, "glCreateShaderObjectARB");
1478 _mesa_CreateProgram(void)
1480 GET_CURRENT_CONTEXT(ctx
);
1481 if (MESA_VERBOSE
& VERBOSE_API
)
1482 _mesa_debug(ctx
, "glCreateProgram\n");
1483 return create_shader_program(ctx
);
1487 GLhandleARB GLAPIENTRY
1488 _mesa_CreateProgramObjectARB(void)
1490 GET_CURRENT_CONTEXT(ctx
);
1491 return create_shader_program(ctx
);
1496 _mesa_DeleteObjectARB(GLhandleARB obj
)
1498 if (MESA_VERBOSE
& VERBOSE_API
) {
1499 GET_CURRENT_CONTEXT(ctx
);
1500 _mesa_debug(ctx
, "glDeleteObjectARB(%lu)\n", (unsigned long)obj
);
1504 GET_CURRENT_CONTEXT(ctx
);
1505 FLUSH_VERTICES(ctx
, 0);
1506 if (is_program(ctx
, obj
)) {
1507 delete_shader_program(ctx
, obj
);
1509 else if (is_shader(ctx
, obj
)) {
1510 delete_shader(ctx
, obj
);
1520 _mesa_DeleteProgram(GLuint name
)
1523 GET_CURRENT_CONTEXT(ctx
);
1524 FLUSH_VERTICES(ctx
, 0);
1525 delete_shader_program(ctx
, name
);
1531 _mesa_DeleteShader(GLuint name
)
1534 GET_CURRENT_CONTEXT(ctx
);
1535 FLUSH_VERTICES(ctx
, 0);
1536 delete_shader(ctx
, name
);
1542 _mesa_DetachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1544 GET_CURRENT_CONTEXT(ctx
);
1545 detach_shader_no_error(ctx
, program
, shader
);
1550 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1552 GET_CURRENT_CONTEXT(ctx
);
1553 detach_shader_error(ctx
, program
, shader
);
1558 _mesa_DetachShader_no_error(GLuint program
, GLuint shader
)
1560 GET_CURRENT_CONTEXT(ctx
);
1561 detach_shader_no_error(ctx
, program
, shader
);
1566 _mesa_DetachShader(GLuint program
, GLuint shader
)
1568 GET_CURRENT_CONTEXT(ctx
);
1569 detach_shader_error(ctx
, program
, shader
);
1574 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1575 GLsizei
* count
, GLhandleARB
* obj
)
1577 GET_CURRENT_CONTEXT(ctx
);
1578 get_attached_shaders(ctx
, container
, maxCount
, count
, obj
);
1583 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1584 GLsizei
*count
, GLuint
*obj
)
1586 GET_CURRENT_CONTEXT(ctx
);
1587 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
);
1592 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1593 GLcharARB
* infoLog
)
1595 GET_CURRENT_CONTEXT(ctx
);
1596 if (is_program(ctx
, object
)) {
1597 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1599 else if (is_shader(ctx
, object
)) {
1600 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1603 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1609 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1611 GET_CURRENT_CONTEXT(ctx
);
1612 /* Implement in terms of GetProgramiv, GetShaderiv */
1613 if (is_program(ctx
, object
)) {
1614 if (pname
== GL_OBJECT_TYPE_ARB
) {
1615 *params
= GL_PROGRAM_OBJECT_ARB
;
1618 get_programiv(ctx
, object
, pname
, params
);
1621 else if (is_shader(ctx
, object
)) {
1622 if (pname
== GL_OBJECT_TYPE_ARB
) {
1623 *params
= GL_SHADER_OBJECT_ARB
;
1626 get_shaderiv(ctx
, object
, pname
, params
);
1630 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1636 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1639 GLint iparams
[1] = {0}; /* XXX is one element enough? */
1640 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1641 params
[0] = (GLfloat
) iparams
[0];
1646 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1648 GET_CURRENT_CONTEXT(ctx
);
1649 get_programiv(ctx
, program
, pname
, params
);
1654 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1656 GET_CURRENT_CONTEXT(ctx
);
1657 get_shaderiv(ctx
, shader
, pname
, params
);
1662 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1663 GLsizei
*length
, GLchar
*infoLog
)
1665 GET_CURRENT_CONTEXT(ctx
);
1666 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1671 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1672 GLsizei
*length
, GLchar
*infoLog
)
1674 GET_CURRENT_CONTEXT(ctx
);
1675 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1680 _mesa_GetShaderSource(GLuint shader
, GLsizei maxLength
,
1681 GLsizei
*length
, GLchar
*sourceOut
)
1683 GET_CURRENT_CONTEXT(ctx
);
1684 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1688 GLhandleARB GLAPIENTRY
1689 _mesa_GetHandleARB(GLenum pname
)
1691 GET_CURRENT_CONTEXT(ctx
);
1692 return get_handle(ctx
, pname
);
1696 GLboolean GLAPIENTRY
1697 _mesa_IsProgram(GLuint name
)
1699 GET_CURRENT_CONTEXT(ctx
);
1700 return is_program(ctx
, name
);
1704 GLboolean GLAPIENTRY
1705 _mesa_IsShader(GLuint name
)
1707 GET_CURRENT_CONTEXT(ctx
);
1708 return is_shader(ctx
, name
);
1713 _mesa_LinkProgram_no_error(GLuint programObj
)
1715 GET_CURRENT_CONTEXT(ctx
);
1717 struct gl_shader_program
*shProg
=
1718 _mesa_lookup_shader_program(ctx
, programObj
);
1719 link_program_no_error(ctx
, shProg
);
1724 _mesa_LinkProgram(GLuint programObj
)
1726 GET_CURRENT_CONTEXT(ctx
);
1728 if (MESA_VERBOSE
& VERBOSE_API
)
1729 _mesa_debug(ctx
, "glLinkProgram %u\n", programObj
);
1731 struct gl_shader_program
*shProg
=
1732 _mesa_lookup_shader_program_err(ctx
, programObj
, "glLinkProgram");
1733 link_program_error(ctx
, shProg
);
1736 #ifdef ENABLE_SHADER_CACHE
1738 * Generate a SHA-1 hash value string for given source string.
1741 generate_sha1(const char *source
, char sha_str
[64])
1743 unsigned char sha
[20];
1744 _mesa_sha1_compute(source
, strlen(source
), sha
);
1745 _mesa_sha1_format(sha_str
, sha
);
1749 * Construct a full path for shader replacement functionality using
1752 * <path>/<stage prefix>_<CHECKSUM>.glsl
1755 construct_name(const gl_shader_stage stage
, const char *source
,
1759 static const char *types
[] = {
1760 "VS", "TC", "TE", "GS", "FS", "CS",
1763 generate_sha1(source
, sha
);
1764 return ralloc_asprintf(NULL
, "%s/%s_%s.glsl", path
, types
[stage
], sha
);
1768 * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1771 dump_shader(const gl_shader_stage stage
, const char *source
)
1773 static bool path_exists
= true;
1780 dump_path
= getenv("MESA_SHADER_DUMP_PATH");
1782 path_exists
= false;
1786 char *name
= construct_name(stage
, source
, dump_path
);
1788 f
= fopen(name
, "w");
1793 GET_CURRENT_CONTEXT(ctx
);
1794 _mesa_warning(ctx
, "could not open %s for dumping shader (%s)", name
,
1801 * Read shader source code from a file.
1802 * Useful for debugging to override an app's shader.
1805 read_shader(const gl_shader_stage stage
, const char *source
)
1808 static bool path_exists
= true;
1809 int len
, shader_size
= 0;
1816 read_path
= getenv("MESA_SHADER_READ_PATH");
1818 path_exists
= false;
1822 char *name
= construct_name(stage
, source
, read_path
);
1823 f
= fopen(name
, "r");
1828 /* allocate enough room for the entire shader */
1829 fseek(f
, 0, SEEK_END
);
1830 shader_size
= ftell(f
);
1832 assert(shader_size
);
1834 /* add one for terminating zero */
1837 buffer
= malloc(shader_size
);
1840 len
= fread(buffer
, 1, shader_size
, f
);
1848 #endif /* ENABLE_SHADER_CACHE */
1851 * Called via glShaderSource() and glShaderSourceARB() API functions.
1852 * Basically, concatenate the source code strings into one long string
1853 * and pass it to _mesa_shader_source().
1855 static ALWAYS_INLINE
void
1856 shader_source(struct gl_context
*ctx
, GLuint shaderObj
, GLsizei count
,
1857 const GLchar
*const *string
, const GLint
*length
, bool no_error
)
1860 GLsizei i
, totalLength
;
1862 struct gl_shader
*sh
;
1865 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glShaderSourceARB");
1869 if (string
== NULL
) {
1870 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1874 sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1878 * This array holds offsets of where the appropriate string ends, thus the
1879 * last element will be set to the total length of the source code.
1881 offsets
= malloc(count
* sizeof(GLint
));
1882 if (offsets
== NULL
) {
1883 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1887 for (i
= 0; i
< count
; i
++) {
1888 if (!no_error
&& string
[i
] == NULL
) {
1889 free((GLvoid
*) offsets
);
1890 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1891 "glShaderSourceARB(null string)");
1894 if (length
== NULL
|| length
[i
] < 0)
1895 offsets
[i
] = strlen(string
[i
]);
1897 offsets
[i
] = length
[i
];
1898 /* accumulate string lengths */
1900 offsets
[i
] += offsets
[i
- 1];
1903 /* Total length of source string is sum off all strings plus two.
1904 * One extra byte for terminating zero, another extra byte to silence
1905 * valgrind warnings in the parser/grammer code.
1907 totalLength
= offsets
[count
- 1] + 2;
1908 source
= malloc(totalLength
* sizeof(GLcharARB
));
1909 if (source
== NULL
) {
1910 free((GLvoid
*) offsets
);
1911 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1915 for (i
= 0; i
< count
; i
++) {
1916 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1917 memcpy(source
+ start
, string
[i
],
1918 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1920 source
[totalLength
- 1] = '\0';
1921 source
[totalLength
- 2] = '\0';
1923 #ifdef ENABLE_SHADER_CACHE
1924 GLcharARB
*replacement
;
1926 /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
1927 * if corresponding entry found from MESA_SHADER_READ_PATH.
1929 dump_shader(sh
->Stage
, source
);
1931 replacement
= read_shader(sh
->Stage
, source
);
1934 source
= replacement
;
1936 #endif /* ENABLE_SHADER_CACHE */
1938 set_shader_source(sh
, source
);
1945 _mesa_ShaderSource_no_error(GLuint shaderObj
, GLsizei count
,
1946 const GLchar
*const *string
, const GLint
*length
)
1948 GET_CURRENT_CONTEXT(ctx
);
1949 shader_source(ctx
, shaderObj
, count
, string
, length
, true);
1954 _mesa_ShaderSource(GLuint shaderObj
, GLsizei count
,
1955 const GLchar
*const *string
, const GLint
*length
)
1957 GET_CURRENT_CONTEXT(ctx
);
1958 shader_source(ctx
, shaderObj
, count
, string
, length
, false);
1962 static ALWAYS_INLINE
void
1963 use_program(GLuint program
, bool no_error
)
1965 GET_CURRENT_CONTEXT(ctx
);
1966 struct gl_shader_program
*shProg
= NULL
;
1968 if (MESA_VERBOSE
& VERBOSE_API
)
1969 _mesa_debug(ctx
, "glUseProgram %u\n", program
);
1973 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1976 if (_mesa_is_xfb_active_and_unpaused(ctx
)) {
1977 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1978 "glUseProgram(transform feedback active)");
1984 _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1988 if (!shProg
->data
->LinkStatus
) {
1989 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1990 "glUseProgram(program %u not linked)", program
);
1995 if (ctx
->_Shader
->Flags
& GLSL_USE_PROG
) {
1996 print_shader_info(shProg
);
2001 /* The ARB_separate_shader_object spec says:
2003 * "The executable code for an individual shader stage is taken from
2004 * the current program for that stage. If there is a current program
2005 * object established by UseProgram, that program is considered current
2006 * for all stages. Otherwise, if there is a bound program pipeline
2007 * object (section 2.14.PPO), the program bound to the appropriate
2008 * stage of the pipeline object is considered current."
2011 /* Attach shader state to the binding point */
2012 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, &ctx
->Shader
);
2013 /* Update the program */
2014 _mesa_use_shader_program(ctx
, shProg
);
2016 /* Must be done first: detach the progam */
2017 _mesa_use_shader_program(ctx
, shProg
);
2018 /* Unattach shader_state binding point */
2019 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
,
2020 ctx
->Pipeline
.Default
);
2021 /* If a pipeline was bound, rebind it */
2022 if (ctx
->Pipeline
.Current
) {
2024 _mesa_BindProgramPipeline_no_error(ctx
->Pipeline
.Current
->Name
);
2026 _mesa_BindProgramPipeline(ctx
->Pipeline
.Current
->Name
);
2033 _mesa_UseProgram_no_error(GLuint program
)
2035 use_program(program
, true);
2040 _mesa_UseProgram(GLuint program
)
2042 use_program(program
, false);
2047 _mesa_ValidateProgram(GLuint program
)
2049 GET_CURRENT_CONTEXT(ctx
);
2050 validate_program(ctx
, program
);
2055 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2058 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
2059 GLint
* range
, GLint
* precision
)
2061 const struct gl_program_constants
*limits
;
2062 const struct gl_precision
*p
;
2063 GET_CURRENT_CONTEXT(ctx
);
2065 switch (shadertype
) {
2066 case GL_VERTEX_SHADER
:
2067 limits
= &ctx
->Const
.Program
[MESA_SHADER_VERTEX
];
2069 case GL_FRAGMENT_SHADER
:
2070 limits
= &ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
];
2073 _mesa_error(ctx
, GL_INVALID_ENUM
,
2074 "glGetShaderPrecisionFormat(shadertype)");
2078 switch (precisiontype
) {
2080 p
= &limits
->LowFloat
;
2082 case GL_MEDIUM_FLOAT
:
2083 p
= &limits
->MediumFloat
;
2086 p
= &limits
->HighFloat
;
2089 p
= &limits
->LowInt
;
2092 p
= &limits
->MediumInt
;
2095 p
= &limits
->HighInt
;
2098 _mesa_error(ctx
, GL_INVALID_ENUM
,
2099 "glGetShaderPrecisionFormat(precisiontype)");
2103 range
[0] = p
->RangeMin
;
2104 range
[1] = p
->RangeMax
;
2105 precision
[0] = p
->Precision
;
2110 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2113 _mesa_ReleaseShaderCompiler(void)
2115 _mesa_destroy_shader_compiler_caches();
2120 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2123 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
2124 const void* binary
, GLint length
)
2126 GET_CURRENT_CONTEXT(ctx
);
2128 (void) binaryformat
;
2131 /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
2132 * page 88 of the OpenGL 4.5 specs state:
2134 * "An INVALID_VALUE error is generated if count or length is negative.
2135 * An INVALID_ENUM error is generated if binaryformat is not a supported
2136 * format returned in SHADER_BINARY_FORMATS."
2138 if (n
< 0 || length
< 0) {
2139 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderBinary(count or length < 0)");
2143 _mesa_error(ctx
, GL_INVALID_ENUM
, "glShaderBinary(format)");
2148 _mesa_GetProgramBinary(GLuint program
, GLsizei bufSize
, GLsizei
*length
,
2149 GLenum
*binaryFormat
, GLvoid
*binary
)
2151 struct gl_shader_program
*shProg
;
2152 GLsizei length_dummy
;
2153 GET_CURRENT_CONTEXT(ctx
);
2156 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramBinary(bufSize < 0)");
2160 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramBinary");
2164 /* The ARB_get_program_binary spec says:
2166 * "If <length> is NULL, then no length is returned."
2168 * Ensure that length always points to valid storage to avoid multiple NULL
2169 * pointer checks below.
2172 length
= &length_dummy
;
2175 /* The ARB_get_program_binary spec says:
2177 * "When a program object's LINK_STATUS is FALSE, its program binary
2178 * length is zero, and a call to GetProgramBinary will generate an
2179 * INVALID_OPERATION error.
2181 if (!shProg
->data
->LinkStatus
) {
2182 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2183 "glGetProgramBinary(program %u not linked)",
2190 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2191 "glGetProgramBinary(driver supports zero binary formats)");
2193 (void) binaryFormat
;
2198 _mesa_ProgramBinary(GLuint program
, GLenum binaryFormat
,
2199 const GLvoid
*binary
, GLsizei length
)
2201 struct gl_shader_program
*shProg
;
2202 GET_CURRENT_CONTEXT(ctx
);
2204 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glProgramBinary");
2208 (void) binaryFormat
;
2211 /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
2213 * "If a negative number is provided where an argument of type sizei or
2214 * sizeiptr is specified, an INVALID_VALUE error is generated."
2217 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramBinary(length < 0)");
2221 /* The ARB_get_program_binary spec says:
2223 * "<binaryFormat> and <binary> must be those returned by a previous
2224 * call to GetProgramBinary, and <length> must be the length of the
2225 * program binary as returned by GetProgramBinary or GetProgramiv with
2226 * <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
2227 * setting the LINK_STATUS of <program> to FALSE, if these conditions
2230 * Since any value of binaryFormat passed "is not one of those specified as
2231 * allowable for [this] command, an INVALID_ENUM error is generated."
2233 shProg
->data
->LinkStatus
= linking_failure
;
2234 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramBinary");
2238 static ALWAYS_INLINE
void
2239 program_parameteri(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
2240 GLuint pname
, GLint value
, bool no_error
)
2243 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
2244 /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
2245 * is part of OpenGL ES 3.0. For the ES2 case, this function shouldn't
2246 * even be in the dispatch table, so we shouldn't need to expclicitly
2249 * On desktop, we ignore the 3.0+ requirement because it is silly.
2252 /* The ARB_get_program_binary extension spec says:
2254 * "An INVALID_VALUE error is generated if the <value> argument to
2255 * ProgramParameteri is not TRUE or FALSE."
2257 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2261 /* No need to notify the driver. Any changes will actually take effect
2262 * the next time the shader is linked.
2264 * The ARB_get_program_binary extension spec says:
2266 * "To indicate that a program binary is likely to be retrieved,
2267 * ProgramParameteri should be called with <pname>
2268 * PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2269 * will not be in effect until the next time LinkProgram or
2270 * ProgramBinary has been called successfully."
2272 * The resloution of issue 9 in the extension spec also says:
2274 * "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2275 * to indicate to the GL implementation that this program will
2276 * likely be saved with GetProgramBinary at some point. This will
2277 * give the GL implementation the opportunity to track any state
2278 * changes made to the program before being saved such that when it
2279 * is loaded again a recompile can be avoided."
2281 shProg
->BinaryRetreivableHint
= value
;
2284 case GL_PROGRAM_SEPARABLE
:
2285 /* Spec imply that the behavior is the same as ARB_get_program_binary
2286 * Chapter 7.3 Program Objects
2288 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2291 shProg
->SeparateShader
= value
;
2296 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteri(pname=%s)",
2297 _mesa_enum_to_string(pname
));
2303 _mesa_error(ctx
, GL_INVALID_VALUE
,
2304 "glProgramParameteri(pname=%s, value=%d): "
2305 "value must be 0 or 1.",
2306 _mesa_enum_to_string(pname
),
2312 _mesa_ProgramParameteri_no_error(GLuint program
, GLenum pname
, GLint value
)
2314 GET_CURRENT_CONTEXT(ctx
);
2316 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, program
);
2317 program_parameteri(ctx
, shProg
, pname
, value
, true);
2322 _mesa_ProgramParameteri(GLuint program
, GLenum pname
, GLint value
)
2324 struct gl_shader_program
*shProg
;
2325 GET_CURRENT_CONTEXT(ctx
);
2327 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
2328 "glProgramParameteri");
2332 program_parameteri(ctx
, shProg
, pname
, value
, false);
2337 _mesa_use_program(struct gl_context
*ctx
, gl_shader_stage stage
,
2338 struct gl_shader_program
*shProg
, struct gl_program
*prog
,
2339 struct gl_pipeline_object
*shTarget
)
2341 struct gl_program
**target
;
2343 target
= &shTarget
->CurrentProgram
[stage
];
2345 _mesa_program_init_subroutine_defaults(ctx
, prog
);
2348 if (*target
!= prog
) {
2349 /* Program is current, flush it */
2350 if (shTarget
== ctx
->_Shader
) {
2351 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
2354 _mesa_reference_shader_program(ctx
,
2355 &shTarget
->ReferencedPrograms
[stage
],
2357 _mesa_reference_program(ctx
, target
, prog
);
2365 * Copy program-specific data generated by linking from the gl_shader_program
2366 * object to the gl_program object referred to by the gl_linked_shader.
2368 * This function expects _mesa_reference_program() to have been previously
2369 * called setting the gl_linked_shaders program reference.
2372 _mesa_copy_linked_program_data(const struct gl_shader_program
*src
,
2373 struct gl_linked_shader
*dst_sh
)
2375 assert(dst_sh
->Program
);
2377 struct gl_program
*dst
= dst_sh
->Program
;
2379 dst
->info
.separate_shader
= src
->SeparateShader
;
2381 switch (dst_sh
->Stage
) {
2382 case MESA_SHADER_GEOMETRY
: {
2383 dst
->info
.gs
.vertices_in
= src
->Geom
.VerticesIn
;
2384 dst
->info
.gs
.uses_end_primitive
= src
->Geom
.UsesEndPrimitive
;
2385 dst
->info
.gs
.uses_streams
= src
->Geom
.UsesStreams
;
2388 case MESA_SHADER_FRAGMENT
: {
2389 dst
->info
.fs
.depth_layout
= src
->FragDepthLayout
;
2392 case MESA_SHADER_COMPUTE
: {
2393 dst
->info
.cs
.shared_size
= src
->Comp
.SharedSize
;
2402 * ARB_separate_shader_objects: Compile & Link Program
2405 _mesa_CreateShaderProgramv(GLenum type
, GLsizei count
,
2406 const GLchar
* const *strings
)
2408 GET_CURRENT_CONTEXT(ctx
);
2410 const GLuint shader
= create_shader_err(ctx
, type
, "glCreateShaderProgramv");
2414 * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2415 * GL_INVALID_VALUE should be generated if count < 0
2418 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCreateShaderProgram (count < 0)");
2423 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
2425 _mesa_ShaderSource(shader
, count
, strings
, NULL
);
2426 _mesa_compile_shader(ctx
, sh
);
2428 program
= create_shader_program(ctx
);
2430 struct gl_shader_program
*shProg
;
2431 GLint compiled
= GL_FALSE
;
2433 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2435 shProg
->SeparateShader
= GL_TRUE
;
2437 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
2439 attach_shader_err(ctx
, program
, shader
, "glCreateShaderProgramv");
2440 _mesa_link_program(ctx
, shProg
);
2441 detach_shader_error(ctx
, program
, shader
);
2445 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
2446 append
-error
-to
-info
-log
;
2447 shProg
->data
->LinkStatus
= linking_failure
;
2452 ralloc_strcat(&shProg
->data
->InfoLog
, sh
->InfoLog
);
2455 delete_shader(ctx
, shader
);
2463 * For GL_ARB_tessellation_shader
2466 _mesa_PatchParameteri_no_error(GLenum pname
, GLint value
)
2468 GET_CURRENT_CONTEXT(ctx
);
2469 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2473 extern void GLAPIENTRY
2474 _mesa_PatchParameteri(GLenum pname
, GLint value
)
2476 GET_CURRENT_CONTEXT(ctx
);
2478 if (!_mesa_has_tessellation(ctx
)) {
2479 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameteri");
2483 if (pname
!= GL_PATCH_VERTICES
) {
2484 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameteri");
2488 if (value
<= 0 || value
> ctx
->Const
.MaxPatchVertices
) {
2489 _mesa_error(ctx
, GL_INVALID_VALUE
, "glPatchParameteri");
2493 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2497 extern void GLAPIENTRY
2498 _mesa_PatchParameterfv(GLenum pname
, const GLfloat
*values
)
2500 GET_CURRENT_CONTEXT(ctx
);
2502 if (!_mesa_has_tessellation(ctx
)) {
2503 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameterfv");
2508 case GL_PATCH_DEFAULT_OUTER_LEVEL
:
2509 FLUSH_VERTICES(ctx
, 0);
2510 memcpy(ctx
->TessCtrlProgram
.patch_default_outer_level
, values
,
2511 4 * sizeof(GLfloat
));
2512 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2514 case GL_PATCH_DEFAULT_INNER_LEVEL
:
2515 FLUSH_VERTICES(ctx
, 0);
2516 memcpy(ctx
->TessCtrlProgram
.patch_default_inner_level
, values
,
2517 2 * sizeof(GLfloat
));
2518 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2521 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameterfv");
2527 * ARB_shader_subroutine
2530 _mesa_GetSubroutineUniformLocation(GLuint program
, GLenum shadertype
,
2533 GET_CURRENT_CONTEXT(ctx
);
2534 const char *api_name
= "glGetSubroutineUniformLocation";
2535 struct gl_shader_program
*shProg
;
2536 GLenum resource_type
;
2537 gl_shader_stage stage
;
2539 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2540 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2544 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2548 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2549 if (!shProg
->_LinkedShaders
[stage
]) {
2550 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2554 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2555 return _mesa_program_resource_location(shProg
, resource_type
, name
);
2559 _mesa_GetSubroutineIndex(GLuint program
, GLenum shadertype
,
2562 GET_CURRENT_CONTEXT(ctx
);
2563 const char *api_name
= "glGetSubroutineIndex";
2564 struct gl_shader_program
*shProg
;
2565 struct gl_program_resource
*res
;
2566 GLenum resource_type
;
2567 gl_shader_stage stage
;
2569 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2570 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2574 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2578 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2579 if (!shProg
->_LinkedShaders
[stage
]) {
2580 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2584 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2585 res
= _mesa_program_resource_find_name(shProg
, resource_type
, name
, NULL
);
2590 return _mesa_program_resource_index(shProg
, res
);
2595 _mesa_GetActiveSubroutineUniformiv(GLuint program
, GLenum shadertype
,
2596 GLuint index
, GLenum pname
, GLint
*values
)
2598 GET_CURRENT_CONTEXT(ctx
);
2599 const char *api_name
= "glGetActiveSubroutineUniformiv";
2600 struct gl_shader_program
*shProg
;
2601 struct gl_linked_shader
*sh
;
2602 gl_shader_stage stage
;
2603 struct gl_program_resource
*res
;
2604 const struct gl_uniform_storage
*uni
;
2605 GLenum resource_type
;
2608 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2609 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2613 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2617 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2618 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2620 sh
= shProg
->_LinkedShaders
[stage
];
2622 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2626 struct gl_program
*p
= shProg
->_LinkedShaders
[stage
]->Program
;
2627 if (index
>= p
->sh
.NumSubroutineUniforms
) {
2628 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name
);
2633 case GL_NUM_COMPATIBLE_SUBROUTINES
: {
2634 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2637 values
[0] = uni
->num_compatible_subroutines
;
2641 case GL_COMPATIBLE_SUBROUTINES
: {
2642 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2646 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2647 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2648 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2649 if (fn
->types
[j
] == uni
->type
) {
2650 values
[count
++] = i
;
2658 case GL_UNIFORM_SIZE
:
2659 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2662 values
[0] = uni
->array_elements
? uni
->array_elements
: 1;
2665 case GL_UNIFORM_NAME_LENGTH
:
2666 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2668 values
[0] = strlen(_mesa_program_resource_name(res
)) + 1
2669 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2673 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2680 _mesa_GetActiveSubroutineUniformName(GLuint program
, GLenum shadertype
,
2681 GLuint index
, GLsizei bufsize
,
2682 GLsizei
*length
, GLchar
*name
)
2684 GET_CURRENT_CONTEXT(ctx
);
2685 const char *api_name
= "glGetActiveSubroutineUniformName";
2686 struct gl_shader_program
*shProg
;
2687 GLenum resource_type
;
2688 gl_shader_stage stage
;
2690 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2691 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2695 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2699 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2700 if (!shProg
->_LinkedShaders
[stage
]) {
2701 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2705 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2706 /* get program resource name */
2707 _mesa_get_program_resource_name(shProg
, resource_type
,
2709 length
, name
, api_name
);
2714 _mesa_GetActiveSubroutineName(GLuint program
, GLenum shadertype
,
2715 GLuint index
, GLsizei bufsize
,
2716 GLsizei
*length
, GLchar
*name
)
2718 GET_CURRENT_CONTEXT(ctx
);
2719 const char *api_name
= "glGetActiveSubroutineName";
2720 struct gl_shader_program
*shProg
;
2721 GLenum resource_type
;
2722 gl_shader_stage stage
;
2724 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2725 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2729 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2733 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2734 if (!shProg
->_LinkedShaders
[stage
]) {
2735 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2738 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2739 _mesa_get_program_resource_name(shProg
, resource_type
,
2741 length
, name
, api_name
);
2745 _mesa_UniformSubroutinesuiv(GLenum shadertype
, GLsizei count
,
2746 const GLuint
*indices
)
2748 GET_CURRENT_CONTEXT(ctx
);
2749 const char *api_name
= "glUniformSubroutinesuiv";
2750 gl_shader_stage stage
;
2753 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2754 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2758 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2759 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2761 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2765 if (count
!= p
->sh
.NumSubroutineUniformRemapTable
) {
2766 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2771 bool flushed
= false;
2773 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2780 _mesa_flush_vertices_for_uniforms(ctx
, uni
);
2784 int uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2787 for (j
= i
; j
< i
+ uni_count
; j
++) {
2788 struct gl_subroutine_function
*subfn
= NULL
;
2789 if (indices
[j
] > p
->sh
.MaxSubroutineFunctionIndex
) {
2790 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2794 for (f
= 0; f
< p
->sh
.NumSubroutineFunctions
; f
++) {
2795 if (p
->sh
.SubroutineFunctions
[f
].index
== indices
[j
])
2796 subfn
= &p
->sh
.SubroutineFunctions
[f
];
2803 for (k
= 0; k
< subfn
->num_compat_types
; k
++) {
2804 if (subfn
->types
[k
] == uni
->type
)
2807 if (k
== subfn
->num_compat_types
) {
2808 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2812 ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[j
] = indices
[j
];
2820 _mesa_GetUniformSubroutineuiv(GLenum shadertype
, GLint location
,
2823 GET_CURRENT_CONTEXT(ctx
);
2824 const char *api_name
= "glGetUniformSubroutineuiv";
2825 gl_shader_stage stage
;
2827 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2828 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2832 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2833 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2835 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2839 if (location
>= p
->sh
.NumSubroutineUniformRemapTable
) {
2840 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2844 *params
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[location
];
2849 _mesa_GetProgramStageiv(GLuint program
, GLenum shadertype
,
2850 GLenum pname
, GLint
*values
)
2852 GET_CURRENT_CONTEXT(ctx
);
2853 const char *api_name
= "glGetProgramStageiv";
2854 struct gl_shader_program
*shProg
;
2855 struct gl_linked_shader
*sh
;
2856 gl_shader_stage stage
;
2858 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2859 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2863 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2867 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2868 sh
= shProg
->_LinkedShaders
[stage
];
2870 /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
2871 * INVALID_OPERATION in the case of not be linked.
2873 * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
2874 * same info using other specs (ARB_program_interface_query), without the
2875 * need of the program to be linked, being the value for that case 0.
2877 * But at the same time, some other methods require the program to be
2878 * linked for pname related to locations, so it would be inconsistent to
2879 * not do the same here. So we are:
2880 * * Return GL_INVALID_OPERATION if not linked only for locations.
2881 * * Setting a default value of 0, to be returned if not linked.
2885 if (pname
== GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
) {
2886 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2891 struct gl_program
*p
= sh
->Program
;
2893 case GL_ACTIVE_SUBROUTINES
:
2894 values
[0] = p
->sh
.NumSubroutineFunctions
;
2896 case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
:
2897 values
[0] = p
->sh
.NumSubroutineUniformRemapTable
;
2899 case GL_ACTIVE_SUBROUTINE_UNIFORMS
:
2900 values
[0] = p
->sh
.NumSubroutineUniforms
;
2902 case GL_ACTIVE_SUBROUTINE_MAX_LENGTH
:
2906 GLenum resource_type
;
2907 struct gl_program_resource
*res
;
2909 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2910 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2911 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2913 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1;
2918 values
[0] = max_len
;
2921 case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
:
2925 GLenum resource_type
;
2926 struct gl_program_resource
*res
;
2928 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2929 for (i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
2930 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2932 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1
2933 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2939 values
[0] = max_len
;
2943 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s", api_name
);
2950 find_compat_subroutine(struct gl_program
*p
, const struct glsl_type
*type
)
2954 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2955 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2956 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2957 if (fn
->types
[j
] == type
)
2965 _mesa_shader_write_subroutine_index(struct gl_context
*ctx
,
2966 struct gl_program
*p
)
2970 if (p
->sh
.NumSubroutineUniformRemapTable
== 0)
2975 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2984 uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2985 for (j
= 0; j
< uni_count
; j
++) {
2986 val
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[i
+ j
];
2987 memcpy(&uni
->storage
[j
], &val
, sizeof(int));
2990 _mesa_propagate_uniforms_to_driver_storage(uni
, 0, uni_count
);
2992 } while(i
< p
->sh
.NumSubroutineUniformRemapTable
);
2996 _mesa_shader_write_subroutine_indices(struct gl_context
*ctx
,
2997 gl_shader_stage stage
)
2999 if (ctx
->_Shader
->CurrentProgram
[stage
])
3000 _mesa_shader_write_subroutine_index(ctx
,
3001 ctx
->_Shader
->CurrentProgram
[stage
]);
3005 _mesa_program_init_subroutine_defaults(struct gl_context
*ctx
,
3006 struct gl_program
*p
)
3010 struct gl_subroutine_index_binding
*binding
= &ctx
->SubroutineIndex
[p
->info
.stage
];
3011 if (binding
->NumIndex
!= p
->sh
.NumSubroutineUniformRemapTable
) {
3012 binding
->IndexPtr
= realloc(binding
->IndexPtr
,
3013 p
->sh
.NumSubroutineUniformRemapTable
* (sizeof(GLuint
)));
3014 binding
->NumIndex
= p
->sh
.NumSubroutineUniformRemapTable
;
3017 for (int i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3018 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3023 binding
->IndexPtr
[i
] = find_compat_subroutine(p
, uni
->type
);