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 <c99_alloca.h>
42 #include "main/glheader.h"
43 #include "main/context.h"
44 #include "main/dispatch.h"
45 #include "main/enums.h"
46 #include "main/glspirv.h"
47 #include "main/hash.h"
48 #include "main/mtypes.h"
49 #include "main/pipelineobj.h"
50 #include "main/program_binary.h"
51 #include "main/shaderapi.h"
52 #include "main/shaderobj.h"
53 #include "main/state.h"
54 #include "main/transformfeedback.h"
55 #include "main/uniforms.h"
56 #include "compiler/glsl/glsl_parser_extras.h"
57 #include "compiler/glsl/ir.h"
58 #include "compiler/glsl/ir_uniform.h"
59 #include "compiler/glsl/program.h"
60 #include "program/program.h"
61 #include "program/prog_print.h"
62 #include "program/prog_parameter.h"
63 #include "util/ralloc.h"
64 #include "util/hash_table.h"
65 #include "util/mesa-sha1.h"
66 #include "util/crc32.h"
69 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
72 _mesa_get_shader_flags(void)
74 GLbitfield flags
= 0x0;
75 const char *env
= getenv("MESA_GLSL");
78 if (strstr(env
, "dump_on_error"))
79 flags
|= GLSL_DUMP_ON_ERROR
;
80 else if (strstr(env
, "dump"))
82 if (strstr(env
, "log"))
84 if (strstr(env
, "cache_fb"))
85 flags
|= GLSL_CACHE_FALLBACK
;
86 if (strstr(env
, "cache_info"))
87 flags
|= GLSL_CACHE_INFO
;
88 if (strstr(env
, "nopvert"))
89 flags
|= GLSL_NOP_VERT
;
90 if (strstr(env
, "nopfrag"))
91 flags
|= GLSL_NOP_FRAG
;
92 if (strstr(env
, "uniform"))
93 flags
|= GLSL_UNIFORMS
;
94 if (strstr(env
, "useprog"))
95 flags
|= GLSL_USE_PROG
;
96 if (strstr(env
, "errors"))
97 flags
|= GLSL_REPORT_ERRORS
;
104 * Memoized version of getenv("MESA_SHADER_CAPTURE_PATH").
107 _mesa_get_shader_capture_path(void)
109 static bool read_env_var
= false;
110 static const char *path
= NULL
;
113 path
= getenv("MESA_SHADER_CAPTURE_PATH");
121 * Initialize context's shader state.
124 _mesa_init_shader_state(struct gl_context
*ctx
)
126 /* Device drivers may override these to control what kind of instructions
127 * are generated by the GLSL compiler.
129 struct gl_shader_compiler_options options
;
133 memset(&options
, 0, sizeof(options
));
134 options
.MaxUnrollIterations
= 32;
135 options
.MaxIfDepth
= UINT_MAX
;
137 for (sh
= 0; sh
< MESA_SHADER_STAGES
; ++sh
)
138 memcpy(&ctx
->Const
.ShaderCompilerOptions
[sh
], &options
, sizeof(options
));
140 ctx
->Shader
.Flags
= _mesa_get_shader_flags();
142 if (ctx
->Shader
.Flags
!= 0)
143 ctx
->Const
.GenerateTemporaryNames
= true;
145 /* Extended for ARB_separate_shader_objects */
146 ctx
->Shader
.RefCount
= 1;
147 ctx
->TessCtrlProgram
.patch_vertices
= 3;
148 for (i
= 0; i
< 4; ++i
)
149 ctx
->TessCtrlProgram
.patch_default_outer_level
[i
] = 1.0;
150 for (i
= 0; i
< 2; ++i
)
151 ctx
->TessCtrlProgram
.patch_default_inner_level
[i
] = 1.0;
156 * Free the per-context shader-related state.
159 _mesa_free_shader_state(struct gl_context
*ctx
)
161 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
162 _mesa_reference_program(ctx
, &ctx
->Shader
.CurrentProgram
[i
], NULL
);
164 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, NULL
);
166 /* Extended for ARB_separate_shader_objects */
167 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, NULL
);
169 assert(ctx
->Shader
.RefCount
== 1);
174 * Copy string from <src> to <dst>, up to maxLength characters, returning
175 * length of <dst> in <length>.
176 * \param src the strings source
177 * \param maxLength max chars to copy
178 * \param length returns number of chars copied
179 * \param dst the string destination
182 _mesa_copy_string(GLchar
*dst
, GLsizei maxLength
,
183 GLsizei
*length
, const GLchar
*src
)
186 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
197 * Confirm that the a shader type is valid and supported by the implementation
199 * \param ctx Current GL context
200 * \param type Shader target
204 _mesa_validate_shader_target(const struct gl_context
*ctx
, GLenum type
)
206 /* Note: when building built-in GLSL functions, this function may be
207 * invoked with ctx == NULL. In that case, we can only validate that it's
208 * a shader target we recognize, not that it's supported in the current
209 * context. But that's fine--we don't need any further validation than
210 * that when building built-in GLSL functions.
214 case GL_FRAGMENT_SHADER
:
215 return ctx
== NULL
|| ctx
->Extensions
.ARB_fragment_shader
;
216 case GL_VERTEX_SHADER
:
217 return ctx
== NULL
|| ctx
->Extensions
.ARB_vertex_shader
;
218 case GL_GEOMETRY_SHADER_ARB
:
219 return ctx
== NULL
|| _mesa_has_geometry_shaders(ctx
);
220 case GL_TESS_CONTROL_SHADER
:
221 case GL_TESS_EVALUATION_SHADER
:
222 return ctx
== NULL
|| _mesa_has_tessellation(ctx
);
223 case GL_COMPUTE_SHADER
:
224 return ctx
== NULL
|| _mesa_has_compute_shaders(ctx
);
232 is_program(struct gl_context
*ctx
, GLuint name
)
234 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
235 return shProg
? GL_TRUE
: GL_FALSE
;
240 is_shader(struct gl_context
*ctx
, GLuint name
)
242 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
243 return shader
? GL_TRUE
: GL_FALSE
;
248 * Attach shader to a shader program.
251 attach_shader(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
252 struct gl_shader
*sh
)
254 GLuint n
= shProg
->NumShaders
;
256 shProg
->Shaders
= realloc(shProg
->Shaders
,
257 (n
+ 1) * sizeof(struct gl_shader
*));
258 if (!shProg
->Shaders
) {
259 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
264 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
265 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
266 shProg
->NumShaders
++;
270 attach_shader_err(struct gl_context
*ctx
, GLuint program
, GLuint shader
,
273 struct gl_shader_program
*shProg
;
274 struct gl_shader
*sh
;
277 const bool same_type_disallowed
= _mesa_is_gles(ctx
);
279 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, caller
);
283 sh
= _mesa_lookup_shader_err(ctx
, shader
, caller
);
288 n
= shProg
->NumShaders
;
289 for (i
= 0; i
< n
; i
++) {
290 if (shProg
->Shaders
[i
] == sh
) {
291 /* The shader is already attched to this program. The
292 * GL_ARB_shader_objects spec says:
294 * "The error INVALID_OPERATION is generated by AttachObjectARB
295 * if <obj> is already attached to <containerObj>."
297 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", caller
);
299 } else if (same_type_disallowed
&&
300 shProg
->Shaders
[i
]->Stage
== sh
->Stage
) {
301 /* Shader with the same type is already attached to this program,
302 * OpenGL ES 2.0 and 3.0 specs say:
304 * "Multiple shader objects of the same type may not be attached
305 * to a single program object. [...] The error INVALID_OPERATION
306 * is generated if [...] another shader object of the same type
307 * as shader is already attached to program."
309 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", caller
);
314 attach_shader(ctx
, shProg
, sh
);
318 attach_shader_no_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
320 struct gl_shader_program
*shProg
;
321 struct gl_shader
*sh
;
323 shProg
= _mesa_lookup_shader_program(ctx
, program
);
324 sh
= _mesa_lookup_shader(ctx
, shader
);
326 attach_shader(ctx
, shProg
, sh
);
330 create_shader(struct gl_context
*ctx
, GLenum type
)
332 struct gl_shader
*sh
;
335 _mesa_HashLockMutex(ctx
->Shared
->ShaderObjects
);
336 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
337 sh
= _mesa_new_shader(name
, _mesa_shader_enum_to_shader_stage(type
));
339 _mesa_HashInsertLocked(ctx
->Shared
->ShaderObjects
, name
, sh
);
340 _mesa_HashUnlockMutex(ctx
->Shared
->ShaderObjects
);
347 create_shader_err(struct gl_context
*ctx
, GLenum type
, const char *caller
)
349 if (!_mesa_validate_shader_target(ctx
, type
)) {
350 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s(%s)",
351 caller
, _mesa_enum_to_string(type
));
355 return create_shader(ctx
, type
);
360 create_shader_program(struct gl_context
*ctx
)
363 struct gl_shader_program
*shProg
;
365 _mesa_HashLockMutex(ctx
->Shared
->ShaderObjects
);
367 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
369 shProg
= _mesa_new_shader_program(name
);
371 _mesa_HashInsertLocked(ctx
->Shared
->ShaderObjects
, name
, shProg
);
373 assert(shProg
->RefCount
== 1);
375 _mesa_HashUnlockMutex(ctx
->Shared
->ShaderObjects
);
382 * Delete a shader program. Actually, just decrement the program's
383 * reference count and mark it as DeletePending.
384 * Used to implement glDeleteProgram() and glDeleteObjectARB().
387 delete_shader_program(struct gl_context
*ctx
, GLuint name
)
390 * NOTE: deleting shaders/programs works a bit differently than
391 * texture objects (and buffer objects, etc). Shader/program
392 * handles/IDs exist in the hash table until the object is really
393 * deleted (refcount==0). With texture objects, the handle/ID is
394 * removed from the hash table in glDeleteTextures() while the tex
395 * object itself might linger until its refcount goes to zero.
397 struct gl_shader_program
*shProg
;
399 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
403 if (!shProg
->DeletePending
) {
404 shProg
->DeletePending
= GL_TRUE
;
406 /* effectively, decr shProg's refcount */
407 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
413 delete_shader(struct gl_context
*ctx
, GLuint shader
)
415 struct gl_shader
*sh
;
417 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
421 if (!sh
->DeletePending
) {
422 sh
->DeletePending
= GL_TRUE
;
424 /* effectively, decr sh's refcount */
425 _mesa_reference_shader(ctx
, &sh
, NULL
);
430 static ALWAYS_INLINE
void
431 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
,
434 struct gl_shader_program
*shProg
;
439 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
443 shProg
= _mesa_lookup_shader_program(ctx
, program
);
446 n
= shProg
->NumShaders
;
448 for (i
= 0; i
< n
; i
++) {
449 if (shProg
->Shaders
[i
]->Name
== shader
) {
451 struct gl_shader
**newList
;
454 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
456 /* alloc new, smaller array */
457 newList
= malloc((n
- 1) * sizeof(struct gl_shader
*));
459 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
462 /* Copy old list entries to new list, skipping removed entry at [i] */
463 for (j
= 0; j
< i
; j
++) {
464 newList
[j
] = shProg
->Shaders
[j
];
467 newList
[j
++] = shProg
->Shaders
[i
];
470 /* Free old list and install new one */
471 free(shProg
->Shaders
);
472 shProg
->Shaders
= newList
;
473 shProg
->NumShaders
= n
- 1;
476 /* sanity check - make sure the new list's entries are sensible */
477 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
478 assert(shProg
->Shaders
[j
]->Stage
== MESA_SHADER_VERTEX
||
479 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_TESS_CTRL
||
480 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_TESS_EVAL
||
481 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_GEOMETRY
||
482 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_FRAGMENT
);
483 assert(shProg
->Shaders
[j
]->RefCount
> 0);
494 if (is_shader(ctx
, shader
) || is_program(ctx
, shader
))
495 err
= GL_INVALID_OPERATION
;
497 err
= GL_INVALID_VALUE
;
498 _mesa_error(ctx
, err
, "glDetachShader(shader)");
505 detach_shader_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
507 detach_shader(ctx
, program
, shader
, false);
512 detach_shader_no_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
514 detach_shader(ctx
, program
, shader
, true);
519 * Return list of shaders attached to shader program.
520 * \param objOut returns GLuint ids
521 * \param handleOut returns GLhandleARB handles
524 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
525 GLsizei
*countOut
, GLuint
*objOut
, GLhandleARB
*handleOut
)
527 struct gl_shader_program
*shProg
;
530 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetAttachedShaders(maxCount < 0)");
535 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
539 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
541 objOut
[i
] = shProg
->Shaders
[i
]->Name
;
545 handleOut
[i
] = (GLhandleARB
) shProg
->Shaders
[i
]->Name
;
555 * glGetHandleARB() - return ID/name of currently bound shader program.
558 get_handle(struct gl_context
*ctx
, GLenum pname
)
560 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
561 if (ctx
->_Shader
->ActiveProgram
)
562 return ctx
->_Shader
->ActiveProgram
->Name
;
567 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
574 * Check if a geometry shader query is valid at this time. If not, report an
575 * error and return false.
577 * From GL 3.2 section 6.1.16 (Shader and Program Queries):
579 * "If GEOMETRY_VERTICES_OUT, GEOMETRY_INPUT_TYPE, or GEOMETRY_OUTPUT_TYPE
580 * are queried for a program which has not been linked successfully, or
581 * which does not contain objects to form a geometry shader, then an
582 * INVALID_OPERATION error is generated."
585 check_gs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
587 if (shProg
->data
->LinkStatus
&&
588 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] != NULL
) {
592 _mesa_error(ctx
, GL_INVALID_OPERATION
,
593 "glGetProgramv(linked geometry shader required)");
599 * Check if a tessellation control shader query is valid at this time.
600 * If not, report an error and return false.
602 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
604 * "If TESS_CONTROL_OUTPUT_VERTICES is queried for a program which has
605 * not been linked successfully, or which does not contain objects to
606 * form a tessellation control shader, then an INVALID_OPERATION error is
610 check_tcs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
612 if (shProg
->data
->LinkStatus
&&
613 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
] != NULL
) {
617 _mesa_error(ctx
, GL_INVALID_OPERATION
,
618 "glGetProgramv(linked tessellation control shader required)");
624 * Check if a tessellation evaluation shader query is valid at this time.
625 * If not, report an error and return false.
627 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
629 * "If any of the pname values in this paragraph are queried for a program
630 * which has not been linked successfully, or which does not contain
631 * objects to form a tessellation evaluation shader, then an
632 * INVALID_OPERATION error is generated."
636 check_tes_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
638 if (shProg
->data
->LinkStatus
&&
639 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
] != NULL
) {
643 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramv(linked tessellation "
644 "evaluation shader required)");
650 * glGetProgramiv() - get shader program state.
651 * Note that this is for GLSL shader programs, not ARB vertex/fragment
652 * programs (see glGetProgramivARB).
655 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
,
658 struct gl_shader_program
*shProg
659 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramiv(program)");
661 /* Is transform feedback available in this context?
664 (ctx
->API
== API_OPENGL_COMPAT
&& ctx
->Extensions
.EXT_transform_feedback
)
665 || ctx
->API
== API_OPENGL_CORE
666 || _mesa_is_gles3(ctx
);
668 /* True if geometry shaders (of the form that was adopted into GLSL 1.50
669 * and GL 3.2) are available in this context
671 const bool has_gs
= _mesa_has_geometry_shaders(ctx
);
672 const bool has_tess
= _mesa_has_tessellation(ctx
);
674 /* Are uniform buffer objects available in this context?
677 (ctx
->API
== API_OPENGL_COMPAT
&&
678 ctx
->Extensions
.ARB_uniform_buffer_object
)
679 || ctx
->API
== API_OPENGL_CORE
680 || _mesa_is_gles3(ctx
);
687 case GL_DELETE_STATUS
:
688 *params
= shProg
->DeletePending
;
691 *params
= shProg
->data
->LinkStatus
? GL_TRUE
: GL_FALSE
;
693 case GL_VALIDATE_STATUS
:
694 *params
= shProg
->data
->Validated
;
696 case GL_INFO_LOG_LENGTH
:
697 *params
= (shProg
->data
->InfoLog
&& shProg
->data
->InfoLog
[0] != '\0') ?
698 strlen(shProg
->data
->InfoLog
) + 1 : 0;
700 case GL_ATTACHED_SHADERS
:
701 *params
= shProg
->NumShaders
;
703 case GL_ACTIVE_ATTRIBUTES
:
704 *params
= _mesa_count_active_attribs(shProg
);
706 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
707 *params
= _mesa_longest_attribute_name_length(shProg
);
709 case GL_ACTIVE_UNIFORMS
: {
711 const unsigned num_uniforms
=
712 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
713 for (*params
= 0, i
= 0; i
< num_uniforms
; i
++) {
714 if (!shProg
->data
->UniformStorage
[i
].is_shader_storage
)
719 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
722 const unsigned num_uniforms
=
723 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
725 for (i
= 0; i
< num_uniforms
; i
++) {
726 if (shProg
->data
->UniformStorage
[i
].is_shader_storage
)
729 /* Add one for the terminating NUL character for a non-array, and
730 * 4 for the "[0]" and the NUL for an array.
732 const GLint len
= strlen(shProg
->data
->UniformStorage
[i
].name
) + 1 +
733 ((shProg
->data
->UniformStorage
[i
].array_elements
!= 0) ? 3 : 0);
742 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
745 *params
= shProg
->TransformFeedback
.NumVarying
;
747 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
: {
753 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
754 /* Add one for the terminating NUL character.
757 strlen(shProg
->TransformFeedback
.VaryingNames
[i
]) + 1;
766 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
769 *params
= shProg
->TransformFeedback
.BufferMode
;
771 case GL_GEOMETRY_VERTICES_OUT
:
774 if (check_gs_query(ctx
, shProg
)) {
775 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
776 Program
->info
.gs
.vertices_out
;
779 case GL_GEOMETRY_SHADER_INVOCATIONS
:
780 if (!has_gs
|| !ctx
->Extensions
.ARB_gpu_shader5
)
782 if (check_gs_query(ctx
, shProg
)) {
783 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
784 Program
->info
.gs
.invocations
;
787 case GL_GEOMETRY_INPUT_TYPE
:
790 if (check_gs_query(ctx
, shProg
)) {
791 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
792 Program
->info
.gs
.input_primitive
;
795 case GL_GEOMETRY_OUTPUT_TYPE
:
798 if (check_gs_query(ctx
, shProg
)) {
799 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
800 Program
->info
.gs
.output_primitive
;
803 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
: {
810 for (i
= 0; i
< shProg
->data
->NumUniformBlocks
; i
++) {
811 /* Add one for the terminating NUL character.
813 const GLint len
= strlen(shProg
->data
->UniformBlocks
[i
].Name
) + 1;
822 case GL_ACTIVE_UNIFORM_BLOCKS
:
826 *params
= shProg
->data
->NumUniformBlocks
;
828 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
829 /* This enum isn't part of the OES extension for OpenGL ES 2.0. It is
830 * only available with desktop OpenGL 3.0+ with the
831 * GL_ARB_get_program_binary extension or OpenGL ES 3.0.
833 * On desktop, we ignore the 3.0+ requirement because it is silly.
835 if (!_mesa_is_desktop_gl(ctx
) && !_mesa_is_gles3(ctx
))
838 *params
= shProg
->BinaryRetreivableHint
;
840 case GL_PROGRAM_BINARY_LENGTH
:
841 if (ctx
->Const
.NumProgramBinaryFormats
== 0) {
844 _mesa_get_program_binary_length(ctx
, shProg
, params
);
847 case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS
:
848 if (!ctx
->Extensions
.ARB_shader_atomic_counters
)
851 *params
= shProg
->data
->NumAtomicBuffers
;
853 case GL_COMPUTE_WORK_GROUP_SIZE
: {
855 if (!_mesa_has_compute_shaders(ctx
))
857 if (!shProg
->data
->LinkStatus
) {
858 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(program not "
862 if (shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
] == NULL
) {
863 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(no compute "
867 for (i
= 0; i
< 3; i
++)
868 params
[i
] = shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
]->
869 Program
->info
.cs
.local_size
[i
];
872 case GL_PROGRAM_SEPARABLE
:
873 /* If the program has not been linked, return initial value 0. */
874 *params
= (shProg
->data
->LinkStatus
== LINKING_FAILURE
) ? 0 : shProg
->SeparateShader
;
877 /* ARB_tessellation_shader */
878 case GL_TESS_CONTROL_OUTPUT_VERTICES
:
881 if (check_tcs_query(ctx
, shProg
)) {
882 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->
883 Program
->info
.tess
.tcs_vertices_out
;
886 case GL_TESS_GEN_MODE
:
889 if (check_tes_query(ctx
, shProg
)) {
890 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
891 Program
->info
.tess
.primitive_mode
;
894 case GL_TESS_GEN_SPACING
:
897 if (check_tes_query(ctx
, shProg
)) {
898 const struct gl_linked_shader
*tes
=
899 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
];
900 switch (tes
->Program
->info
.tess
.spacing
) {
901 case TESS_SPACING_EQUAL
:
904 case TESS_SPACING_FRACTIONAL_ODD
:
905 *params
= GL_FRACTIONAL_ODD
;
907 case TESS_SPACING_FRACTIONAL_EVEN
:
908 *params
= GL_FRACTIONAL_EVEN
;
910 case TESS_SPACING_UNSPECIFIED
:
916 case GL_TESS_GEN_VERTEX_ORDER
:
919 if (check_tes_query(ctx
, shProg
)) {
920 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
921 Program
->info
.tess
.ccw
? GL_CCW
: GL_CW
;
924 case GL_TESS_GEN_POINT_MODE
:
927 if (check_tes_query(ctx
, shProg
)) {
928 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
929 Program
->info
.tess
.point_mode
? GL_TRUE
: GL_FALSE
;
936 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname=%s)",
937 _mesa_enum_to_string(pname
));
942 * glGetShaderiv() - get GLSL shader state
945 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
947 struct gl_shader
*shader
=
948 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
956 *params
= shader
->Type
;
958 case GL_DELETE_STATUS
:
959 *params
= shader
->DeletePending
;
961 case GL_COMPILE_STATUS
:
962 *params
= shader
->CompileStatus
? GL_TRUE
: GL_FALSE
;
964 case GL_INFO_LOG_LENGTH
:
965 *params
= (shader
->InfoLog
&& shader
->InfoLog
[0] != '\0') ?
966 strlen(shader
->InfoLog
) + 1 : 0;
968 case GL_SHADER_SOURCE_LENGTH
:
969 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
971 case GL_SPIR_V_BINARY_ARB
:
972 *params
= (shader
->spirv_data
!= NULL
);
975 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
982 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
983 GLsizei
*length
, GLchar
*infoLog
)
985 struct gl_shader_program
*shProg
;
987 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
988 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
990 * "If a negative number is provided where an argument of type sizei or
991 * sizeiptr is specified, an INVALID_VALUE error is generated."
994 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(bufSize < 0)");
998 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
999 "glGetProgramInfoLog(program)");
1004 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->data
->InfoLog
);
1009 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
1010 GLsizei
*length
, GLchar
*infoLog
)
1012 struct gl_shader
*sh
;
1014 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
1015 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
1017 * "If a negative number is provided where an argument of type sizei or
1018 * sizeiptr is specified, an INVALID_VALUE error is generated."
1021 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(bufSize < 0)");
1025 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderInfoLog(shader)");
1030 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
1035 * Return shader source code.
1038 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
1039 GLsizei
*length
, GLchar
*sourceOut
)
1041 struct gl_shader
*sh
;
1043 if (maxLength
< 0) {
1044 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderSource(bufSize < 0)");
1048 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
1052 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
1057 * Set/replace shader source code. A helper function used by
1058 * glShaderSource[ARB].
1061 set_shader_source(struct gl_shader
*sh
, const GLchar
*source
)
1065 /* The GL_ARB_gl_spirv spec adds the following to the end of the description
1068 * "If <shader> was previously associated with a SPIR-V module (via the
1069 * ShaderBinary command), that association is broken. Upon successful
1070 * completion of this command the SPIR_V_BINARY_ARB state of <shader>
1073 _mesa_shader_spirv_data_reference(&sh
->spirv_data
, NULL
);
1075 if (sh
->CompileStatus
== COMPILE_SKIPPED
&& !sh
->FallbackSource
) {
1076 /* If shader was previously compiled back-up the source in case of cache
1079 sh
->FallbackSource
= sh
->Source
;
1080 sh
->Source
= source
;
1082 /* free old shader source string and install new one */
1083 free((void *)sh
->Source
);
1084 sh
->Source
= source
;
1088 sh
->SourceChecksum
= util_hash_crc32(sh
->Source
, strlen(sh
->Source
));
1097 _mesa_compile_shader(struct gl_context
*ctx
, struct gl_shader
*sh
)
1102 /* The GL_ARB_gl_spirv spec says:
1104 * "Add a new error for the CompileShader command:
1106 * An INVALID_OPERATION error is generated if the SPIR_V_BINARY_ARB
1107 * state of <shader> is TRUE."
1109 if (sh
->spirv_data
) {
1110 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glCompileShader(SPIR-V)");
1115 /* If the user called glCompileShader without first calling
1116 * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
1118 sh
->CompileStatus
= COMPILE_FAILURE
;
1120 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1121 _mesa_log("GLSL source for %s shader %d:\n",
1122 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1123 _mesa_log("%s\n", sh
->Source
);
1126 /* this call will set the shader->CompileStatus field to indicate if
1127 * compilation was successful.
1129 _mesa_glsl_compile_shader(ctx
, sh
, false, false, false);
1131 if (ctx
->_Shader
->Flags
& GLSL_LOG
) {
1132 _mesa_write_shader_to_file(sh
);
1135 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1136 if (sh
->CompileStatus
) {
1138 _mesa_log("GLSL IR for shader %d:\n", sh
->Name
);
1139 _mesa_print_ir(_mesa_get_log_file(), sh
->ir
, NULL
);
1141 _mesa_log("No GLSL IR for shader %d (shader may be from "
1142 "cache)\n", sh
->Name
);
1146 _mesa_log("GLSL shader %d failed to compile.\n", sh
->Name
);
1148 if (sh
->InfoLog
&& sh
->InfoLog
[0] != 0) {
1149 _mesa_log("GLSL shader %d info log:\n", sh
->Name
);
1150 _mesa_log("%s\n", sh
->InfoLog
);
1155 if (!sh
->CompileStatus
) {
1156 if (ctx
->_Shader
->Flags
& GLSL_DUMP_ON_ERROR
) {
1157 _mesa_log("GLSL source for %s shader %d:\n",
1158 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1159 _mesa_log("%s\n", sh
->Source
);
1160 _mesa_log("Info Log:\n%s\n", sh
->InfoLog
);
1163 if (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
) {
1164 _mesa_debug(ctx
, "Error compiling shader %u:\n%s\n",
1165 sh
->Name
, sh
->InfoLog
);
1172 * Link a program's shaders.
1174 static ALWAYS_INLINE
void
1175 link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1182 /* From the ARB_transform_feedback2 specification:
1183 * "The error INVALID_OPERATION is generated by LinkProgram if <program>
1184 * is the name of a program being used by one or more transform feedback
1185 * objects, even if the objects are not currently bound or are paused."
1187 if (_mesa_transform_feedback_is_using_program(ctx
, shProg
)) {
1188 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1189 "glLinkProgram(transform feedback is using the program)");
1194 unsigned programs_in_use
= 0;
1196 for (unsigned stage
= 0; stage
< MESA_SHADER_STAGES
; stage
++) {
1197 if (ctx
->_Shader
->CurrentProgram
[stage
] &&
1198 ctx
->_Shader
->CurrentProgram
[stage
]->Id
== shProg
->Name
) {
1199 programs_in_use
|= 1 << stage
;
1203 FLUSH_VERTICES(ctx
, 0);
1204 _mesa_glsl_link_shader(ctx
, shProg
);
1206 /* From section 7.3 (Program Objects) of the OpenGL 4.5 spec:
1208 * "If LinkProgram or ProgramBinary successfully re-links a program
1209 * object that is active for any shader stage, then the newly generated
1210 * executable code will be installed as part of the current rendering
1211 * state for all shader stages where the program is active.
1212 * Additionally, the newly generated executable code is made part of
1213 * the state of any program pipeline for all stages where the program
1216 if (shProg
->data
->LinkStatus
&& programs_in_use
) {
1217 while (programs_in_use
) {
1218 const int stage
= u_bit_scan(&programs_in_use
);
1220 struct gl_program
*prog
= NULL
;
1221 if (shProg
->_LinkedShaders
[stage
])
1222 prog
= shProg
->_LinkedShaders
[stage
]->Program
;
1224 _mesa_use_program(ctx
, stage
, shProg
, prog
, ctx
->_Shader
);
1228 /* Capture .shader_test files. */
1229 const char *capture_path
= _mesa_get_shader_capture_path();
1230 if (shProg
->Name
!= 0 && shProg
->Name
!= ~0 && capture_path
!= NULL
) {
1232 char *filename
= ralloc_asprintf(NULL
, "%s/%u.shader_test",
1233 capture_path
, shProg
->Name
);
1234 file
= fopen(filename
, "w");
1236 fprintf(file
, "[require]\nGLSL%s >= %u.%02u\n",
1237 shProg
->IsES
? " ES" : "",
1238 shProg
->data
->Version
/ 100, shProg
->data
->Version
% 100);
1239 if (shProg
->SeparateShader
)
1240 fprintf(file
, "GL_ARB_separate_shader_objects\nSSO ENABLED\n");
1241 fprintf(file
, "\n");
1243 for (unsigned i
= 0; i
< shProg
->NumShaders
; i
++) {
1244 fprintf(file
, "[%s shader]\n%s\n",
1245 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1246 shProg
->Shaders
[i
]->Source
);
1250 _mesa_warning(ctx
, "Failed to open %s", filename
);
1253 ralloc_free(filename
);
1256 if (shProg
->data
->LinkStatus
== LINKING_FAILURE
&&
1257 (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
)) {
1258 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
1259 shProg
->Name
, shProg
->data
->InfoLog
);
1262 _mesa_update_vertex_processing_mode(ctx
);
1268 printf("Link %u shaders in program %u: %s\n",
1269 shProg
->NumShaders
, shProg
->Name
,
1270 shProg
->data
->LinkStatus
? "Success" : "Failed");
1272 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1273 printf(" shader %u, stage %u\n",
1274 shProg
->Shaders
[i
]->Name
,
1275 shProg
->Shaders
[i
]->Stage
);
1282 link_program_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1284 link_program(ctx
, shProg
, false);
1289 link_program_no_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1291 link_program(ctx
, shProg
, true);
1296 _mesa_link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1298 link_program_error(ctx
, shProg
);
1303 * Print basic shader info (for debug).
1306 print_shader_info(const struct gl_shader_program
*shProg
)
1310 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
1311 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1313 printf(" %s shader %u, checksum %u\n",
1314 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1315 shProg
->Shaders
[i
]->Name
,
1316 shProg
->Shaders
[i
]->SourceChecksum
);
1318 printf(" %s shader %u\n",
1319 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1320 shProg
->Shaders
[i
]->Name
);
1323 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
1324 printf(" vert prog %u\n",
1325 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
1326 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
1327 printf(" frag prog %u\n",
1328 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
1329 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
1330 printf(" geom prog %u\n",
1331 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
1332 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
])
1333 printf(" tesc prog %u\n",
1334 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->Program
->Id
);
1335 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
])
1336 printf(" tese prog %u\n",
1337 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->Program
->Id
);
1342 * Use the named shader program for subsequent glUniform calls
1345 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1348 if ((shProg
!= NULL
) && !shProg
->data
->LinkStatus
) {
1349 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1350 "%s(program %u not linked)", caller
, shProg
->Name
);
1354 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
1355 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
1361 * Use the named shader program for subsequent rendering.
1364 _mesa_use_shader_program(struct gl_context
*ctx
,
1365 struct gl_shader_program
*shProg
)
1367 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1368 struct gl_program
*new_prog
= NULL
;
1369 if (shProg
&& shProg
->_LinkedShaders
[i
])
1370 new_prog
= shProg
->_LinkedShaders
[i
]->Program
;
1371 _mesa_use_program(ctx
, i
, shProg
, new_prog
, &ctx
->Shader
);
1373 _mesa_active_program(ctx
, shProg
, "glUseProgram");
1378 * Do validation of the given shader program.
1379 * \param errMsg returns error message if validation fails.
1380 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1383 validate_shader_program(const struct gl_shader_program
*shProg
,
1386 if (!shProg
->data
->LinkStatus
) {
1390 /* From the GL spec, a program is invalid if any of these are true:
1392 any two active samplers in the current program object are of
1393 different types, but refer to the same texture image unit,
1395 any active sampler in the current program object refers to a texture
1396 image unit where fixed-function fragment processing accesses a
1397 texture target that does not match the sampler type, or
1399 the sum of the number of active samplers in the program and the
1400 number of texture image units enabled for fixed-function fragment
1401 processing exceeds the combined limit on the total number of texture
1402 image units allowed.
1406 * Check: any two active samplers in the current program object are of
1407 * different types, but refer to the same texture image unit,
1409 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
1417 * Called via glValidateProgram()
1420 validate_program(struct gl_context
*ctx
, GLuint program
)
1422 struct gl_shader_program
*shProg
;
1423 char errMsg
[100] = "";
1425 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1430 shProg
->data
->Validated
= validate_shader_program(shProg
, errMsg
);
1431 if (!shProg
->data
->Validated
) {
1432 /* update info log */
1433 if (shProg
->data
->InfoLog
) {
1434 ralloc_free(shProg
->data
->InfoLog
);
1436 shProg
->data
->InfoLog
= ralloc_strdup(shProg
->data
, errMsg
);
1442 _mesa_AttachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1444 GET_CURRENT_CONTEXT(ctx
);
1445 attach_shader_no_error(ctx
, program
, shader
);
1450 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1452 GET_CURRENT_CONTEXT(ctx
);
1453 attach_shader_err(ctx
, program
, shader
, "glAttachObjectARB");
1458 _mesa_AttachShader_no_error(GLuint program
, GLuint shader
)
1460 GET_CURRENT_CONTEXT(ctx
);
1461 attach_shader_no_error(ctx
, program
, shader
);
1466 _mesa_AttachShader(GLuint program
, GLuint shader
)
1468 GET_CURRENT_CONTEXT(ctx
);
1469 attach_shader_err(ctx
, program
, shader
, "glAttachShader");
1474 _mesa_CompileShader(GLuint shaderObj
)
1476 GET_CURRENT_CONTEXT(ctx
);
1477 if (MESA_VERBOSE
& VERBOSE_API
)
1478 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1479 _mesa_compile_shader(ctx
, _mesa_lookup_shader_err(ctx
, shaderObj
,
1480 "glCompileShader"));
1485 _mesa_CreateShader_no_error(GLenum type
)
1487 GET_CURRENT_CONTEXT(ctx
);
1488 return create_shader(ctx
, type
);
1493 _mesa_CreateShader(GLenum type
)
1495 GET_CURRENT_CONTEXT(ctx
);
1497 if (MESA_VERBOSE
& VERBOSE_API
)
1498 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_enum_to_string(type
));
1500 return create_shader_err(ctx
, type
, "glCreateShader");
1504 GLhandleARB GLAPIENTRY
1505 _mesa_CreateShaderObjectARB_no_error(GLenum type
)
1507 GET_CURRENT_CONTEXT(ctx
);
1508 return create_shader(ctx
, type
);
1512 GLhandleARB GLAPIENTRY
1513 _mesa_CreateShaderObjectARB(GLenum type
)
1515 GET_CURRENT_CONTEXT(ctx
);
1516 return create_shader_err(ctx
, type
, "glCreateShaderObjectARB");
1521 _mesa_CreateProgram(void)
1523 GET_CURRENT_CONTEXT(ctx
);
1524 if (MESA_VERBOSE
& VERBOSE_API
)
1525 _mesa_debug(ctx
, "glCreateProgram\n");
1526 return create_shader_program(ctx
);
1530 GLhandleARB GLAPIENTRY
1531 _mesa_CreateProgramObjectARB(void)
1533 GET_CURRENT_CONTEXT(ctx
);
1534 return create_shader_program(ctx
);
1539 _mesa_DeleteObjectARB(GLhandleARB obj
)
1541 if (MESA_VERBOSE
& VERBOSE_API
) {
1542 GET_CURRENT_CONTEXT(ctx
);
1543 _mesa_debug(ctx
, "glDeleteObjectARB(%lu)\n", (unsigned long)obj
);
1547 GET_CURRENT_CONTEXT(ctx
);
1548 FLUSH_VERTICES(ctx
, 0);
1549 if (is_program(ctx
, obj
)) {
1550 delete_shader_program(ctx
, obj
);
1552 else if (is_shader(ctx
, obj
)) {
1553 delete_shader(ctx
, obj
);
1563 _mesa_DeleteProgram(GLuint name
)
1566 GET_CURRENT_CONTEXT(ctx
);
1567 FLUSH_VERTICES(ctx
, 0);
1568 delete_shader_program(ctx
, name
);
1574 _mesa_DeleteShader(GLuint name
)
1577 GET_CURRENT_CONTEXT(ctx
);
1578 FLUSH_VERTICES(ctx
, 0);
1579 delete_shader(ctx
, name
);
1585 _mesa_DetachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1587 GET_CURRENT_CONTEXT(ctx
);
1588 detach_shader_no_error(ctx
, program
, shader
);
1593 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1595 GET_CURRENT_CONTEXT(ctx
);
1596 detach_shader_error(ctx
, program
, shader
);
1601 _mesa_DetachShader_no_error(GLuint program
, GLuint shader
)
1603 GET_CURRENT_CONTEXT(ctx
);
1604 detach_shader_no_error(ctx
, program
, shader
);
1609 _mesa_DetachShader(GLuint program
, GLuint shader
)
1611 GET_CURRENT_CONTEXT(ctx
);
1612 detach_shader_error(ctx
, program
, shader
);
1617 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1618 GLsizei
* count
, GLhandleARB
* obj
)
1620 GET_CURRENT_CONTEXT(ctx
);
1621 get_attached_shaders(ctx
, (GLuint
)container
, maxCount
, count
, NULL
, obj
);
1626 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1627 GLsizei
*count
, GLuint
*obj
)
1629 GET_CURRENT_CONTEXT(ctx
);
1630 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
, NULL
);
1635 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1636 GLcharARB
* infoLog
)
1638 GET_CURRENT_CONTEXT(ctx
);
1639 if (is_program(ctx
, object
)) {
1640 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1642 else if (is_shader(ctx
, object
)) {
1643 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1646 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1652 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1654 GET_CURRENT_CONTEXT(ctx
);
1655 /* Implement in terms of GetProgramiv, GetShaderiv */
1656 if (is_program(ctx
, object
)) {
1657 if (pname
== GL_OBJECT_TYPE_ARB
) {
1658 *params
= GL_PROGRAM_OBJECT_ARB
;
1661 get_programiv(ctx
, object
, pname
, params
);
1664 else if (is_shader(ctx
, object
)) {
1665 if (pname
== GL_OBJECT_TYPE_ARB
) {
1666 *params
= GL_SHADER_OBJECT_ARB
;
1669 get_shaderiv(ctx
, object
, pname
, params
);
1673 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1679 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1682 GLint iparams
[1] = {0}; /* XXX is one element enough? */
1683 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1684 params
[0] = (GLfloat
) iparams
[0];
1689 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1691 GET_CURRENT_CONTEXT(ctx
);
1692 get_programiv(ctx
, program
, pname
, params
);
1697 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1699 GET_CURRENT_CONTEXT(ctx
);
1700 get_shaderiv(ctx
, shader
, pname
, params
);
1705 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1706 GLsizei
*length
, GLchar
*infoLog
)
1708 GET_CURRENT_CONTEXT(ctx
);
1709 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1714 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1715 GLsizei
*length
, GLchar
*infoLog
)
1717 GET_CURRENT_CONTEXT(ctx
);
1718 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1723 _mesa_GetShaderSource(GLuint shader
, GLsizei maxLength
,
1724 GLsizei
*length
, GLchar
*sourceOut
)
1726 GET_CURRENT_CONTEXT(ctx
);
1727 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1731 GLhandleARB GLAPIENTRY
1732 _mesa_GetHandleARB(GLenum pname
)
1734 GET_CURRENT_CONTEXT(ctx
);
1735 return get_handle(ctx
, pname
);
1739 GLboolean GLAPIENTRY
1740 _mesa_IsProgram(GLuint name
)
1742 GET_CURRENT_CONTEXT(ctx
);
1743 return is_program(ctx
, name
);
1747 GLboolean GLAPIENTRY
1748 _mesa_IsShader(GLuint name
)
1750 GET_CURRENT_CONTEXT(ctx
);
1751 return is_shader(ctx
, name
);
1756 _mesa_LinkProgram_no_error(GLuint programObj
)
1758 GET_CURRENT_CONTEXT(ctx
);
1760 struct gl_shader_program
*shProg
=
1761 _mesa_lookup_shader_program(ctx
, programObj
);
1762 link_program_no_error(ctx
, shProg
);
1767 _mesa_LinkProgram(GLuint programObj
)
1769 GET_CURRENT_CONTEXT(ctx
);
1771 if (MESA_VERBOSE
& VERBOSE_API
)
1772 _mesa_debug(ctx
, "glLinkProgram %u\n", programObj
);
1774 struct gl_shader_program
*shProg
=
1775 _mesa_lookup_shader_program_err(ctx
, programObj
, "glLinkProgram");
1776 link_program_error(ctx
, shProg
);
1779 #ifdef ENABLE_SHADER_CACHE
1781 * Generate a SHA-1 hash value string for given source string.
1784 generate_sha1(const char *source
, char sha_str
[64])
1786 unsigned char sha
[20];
1787 _mesa_sha1_compute(source
, strlen(source
), sha
);
1788 _mesa_sha1_format(sha_str
, sha
);
1792 * Construct a full path for shader replacement functionality using
1795 * <path>/<stage prefix>_<CHECKSUM>.glsl
1798 construct_name(const gl_shader_stage stage
, const char *source
,
1802 static const char *types
[] = {
1803 "VS", "TC", "TE", "GS", "FS", "CS",
1806 generate_sha1(source
, sha
);
1807 return ralloc_asprintf(NULL
, "%s/%s_%s.glsl", path
, types
[stage
], sha
);
1811 * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1814 dump_shader(const gl_shader_stage stage
, const char *source
)
1816 static bool path_exists
= true;
1823 dump_path
= getenv("MESA_SHADER_DUMP_PATH");
1825 path_exists
= false;
1829 char *name
= construct_name(stage
, source
, dump_path
);
1831 f
= fopen(name
, "w");
1836 GET_CURRENT_CONTEXT(ctx
);
1837 _mesa_warning(ctx
, "could not open %s for dumping shader (%s)", name
,
1844 * Read shader source code from a file.
1845 * Useful for debugging to override an app's shader.
1848 read_shader(const gl_shader_stage stage
, const char *source
)
1851 static bool path_exists
= true;
1852 int len
, shader_size
= 0;
1859 read_path
= getenv("MESA_SHADER_READ_PATH");
1861 path_exists
= false;
1865 char *name
= construct_name(stage
, source
, read_path
);
1866 f
= fopen(name
, "r");
1871 /* allocate enough room for the entire shader */
1872 fseek(f
, 0, SEEK_END
);
1873 shader_size
= ftell(f
);
1875 assert(shader_size
);
1877 /* add one for terminating zero */
1880 buffer
= malloc(shader_size
);
1883 len
= fread(buffer
, 1, shader_size
, f
);
1891 #endif /* ENABLE_SHADER_CACHE */
1894 * Called via glShaderSource() and glShaderSourceARB() API functions.
1895 * Basically, concatenate the source code strings into one long string
1896 * and pass it to _mesa_shader_source().
1898 static ALWAYS_INLINE
void
1899 shader_source(struct gl_context
*ctx
, GLuint shaderObj
, GLsizei count
,
1900 const GLchar
*const *string
, const GLint
*length
, bool no_error
)
1903 GLsizei i
, totalLength
;
1905 struct gl_shader
*sh
;
1908 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glShaderSourceARB");
1912 if (string
== NULL
) {
1913 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1917 sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1921 * This array holds offsets of where the appropriate string ends, thus the
1922 * last element will be set to the total length of the source code.
1924 offsets
= malloc(count
* sizeof(GLint
));
1925 if (offsets
== NULL
) {
1926 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1930 for (i
= 0; i
< count
; i
++) {
1931 if (!no_error
&& string
[i
] == NULL
) {
1932 free((GLvoid
*) offsets
);
1933 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1934 "glShaderSourceARB(null string)");
1937 if (length
== NULL
|| length
[i
] < 0)
1938 offsets
[i
] = strlen(string
[i
]);
1940 offsets
[i
] = length
[i
];
1941 /* accumulate string lengths */
1943 offsets
[i
] += offsets
[i
- 1];
1946 /* Total length of source string is sum off all strings plus two.
1947 * One extra byte for terminating zero, another extra byte to silence
1948 * valgrind warnings in the parser/grammer code.
1950 totalLength
= offsets
[count
- 1] + 2;
1951 source
= malloc(totalLength
* sizeof(GLcharARB
));
1952 if (source
== NULL
) {
1953 free((GLvoid
*) offsets
);
1954 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1958 for (i
= 0; i
< count
; i
++) {
1959 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1960 memcpy(source
+ start
, string
[i
],
1961 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1963 source
[totalLength
- 1] = '\0';
1964 source
[totalLength
- 2] = '\0';
1966 #ifdef ENABLE_SHADER_CACHE
1967 GLcharARB
*replacement
;
1969 /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
1970 * if corresponding entry found from MESA_SHADER_READ_PATH.
1972 dump_shader(sh
->Stage
, source
);
1974 replacement
= read_shader(sh
->Stage
, source
);
1977 source
= replacement
;
1979 #endif /* ENABLE_SHADER_CACHE */
1981 set_shader_source(sh
, source
);
1988 _mesa_ShaderSource_no_error(GLuint shaderObj
, GLsizei count
,
1989 const GLchar
*const *string
, const GLint
*length
)
1991 GET_CURRENT_CONTEXT(ctx
);
1992 shader_source(ctx
, shaderObj
, count
, string
, length
, true);
1997 _mesa_ShaderSource(GLuint shaderObj
, GLsizei count
,
1998 const GLchar
*const *string
, const GLint
*length
)
2000 GET_CURRENT_CONTEXT(ctx
);
2001 shader_source(ctx
, shaderObj
, count
, string
, length
, false);
2005 static ALWAYS_INLINE
void
2006 use_program(GLuint program
, bool no_error
)
2008 GET_CURRENT_CONTEXT(ctx
);
2009 struct gl_shader_program
*shProg
= NULL
;
2011 if (MESA_VERBOSE
& VERBOSE_API
)
2012 _mesa_debug(ctx
, "glUseProgram %u\n", program
);
2016 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2019 if (_mesa_is_xfb_active_and_unpaused(ctx
)) {
2020 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2021 "glUseProgram(transform feedback active)");
2027 _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
2031 if (!shProg
->data
->LinkStatus
) {
2032 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2033 "glUseProgram(program %u not linked)", program
);
2038 if (ctx
->_Shader
->Flags
& GLSL_USE_PROG
) {
2039 print_shader_info(shProg
);
2044 /* The ARB_separate_shader_object spec says:
2046 * "The executable code for an individual shader stage is taken from
2047 * the current program for that stage. If there is a current program
2048 * object established by UseProgram, that program is considered current
2049 * for all stages. Otherwise, if there is a bound program pipeline
2050 * object (section 2.14.PPO), the program bound to the appropriate
2051 * stage of the pipeline object is considered current."
2054 /* Attach shader state to the binding point */
2055 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, &ctx
->Shader
);
2056 /* Update the program */
2057 _mesa_use_shader_program(ctx
, shProg
);
2059 /* Must be done first: detach the progam */
2060 _mesa_use_shader_program(ctx
, shProg
);
2061 /* Unattach shader_state binding point */
2062 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
,
2063 ctx
->Pipeline
.Default
);
2064 /* If a pipeline was bound, rebind it */
2065 if (ctx
->Pipeline
.Current
) {
2067 _mesa_BindProgramPipeline_no_error(ctx
->Pipeline
.Current
->Name
);
2069 _mesa_BindProgramPipeline(ctx
->Pipeline
.Current
->Name
);
2073 _mesa_update_vertex_processing_mode(ctx
);
2078 _mesa_UseProgram_no_error(GLuint program
)
2080 use_program(program
, true);
2085 _mesa_UseProgram(GLuint program
)
2087 use_program(program
, false);
2092 _mesa_ValidateProgram(GLuint program
)
2094 GET_CURRENT_CONTEXT(ctx
);
2095 validate_program(ctx
, program
);
2100 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2103 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
2104 GLint
* range
, GLint
* precision
)
2106 const struct gl_program_constants
*limits
;
2107 const struct gl_precision
*p
;
2108 GET_CURRENT_CONTEXT(ctx
);
2110 switch (shadertype
) {
2111 case GL_VERTEX_SHADER
:
2112 limits
= &ctx
->Const
.Program
[MESA_SHADER_VERTEX
];
2114 case GL_FRAGMENT_SHADER
:
2115 limits
= &ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
];
2118 _mesa_error(ctx
, GL_INVALID_ENUM
,
2119 "glGetShaderPrecisionFormat(shadertype)");
2123 switch (precisiontype
) {
2125 p
= &limits
->LowFloat
;
2127 case GL_MEDIUM_FLOAT
:
2128 p
= &limits
->MediumFloat
;
2131 p
= &limits
->HighFloat
;
2134 p
= &limits
->LowInt
;
2137 p
= &limits
->MediumInt
;
2140 p
= &limits
->HighInt
;
2143 _mesa_error(ctx
, GL_INVALID_ENUM
,
2144 "glGetShaderPrecisionFormat(precisiontype)");
2148 range
[0] = p
->RangeMin
;
2149 range
[1] = p
->RangeMax
;
2150 precision
[0] = p
->Precision
;
2155 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2158 _mesa_ReleaseShaderCompiler(void)
2160 _mesa_destroy_shader_compiler_caches();
2165 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2168 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
2169 const void* binary
, GLint length
)
2171 GET_CURRENT_CONTEXT(ctx
);
2172 struct gl_shader
**sh
;
2174 /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
2175 * page 88 of the OpenGL 4.5 specs state:
2177 * "An INVALID_VALUE error is generated if count or length is negative.
2178 * An INVALID_ENUM error is generated if binaryformat is not a supported
2179 * format returned in SHADER_BINARY_FORMATS."
2181 if (n
< 0 || length
< 0) {
2182 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderBinary(count or length < 0)");
2186 /* Get all shader objects at once so we can make the operation
2189 if (n
> SIZE_MAX
/ sizeof(*sh
)) {
2190 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderBinary(count)");
2194 sh
= alloca(sizeof(*sh
) * (size_t)n
);
2196 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderBinary");
2200 for (int i
= 0; i
< n
; ++i
) {
2201 sh
[i
] = _mesa_lookup_shader_err(ctx
, shaders
[i
], "glShaderBinary");
2206 if (binaryformat
== GL_SHADER_BINARY_FORMAT_SPIR_V_ARB
) {
2207 if (!ctx
->Extensions
.ARB_gl_spirv
) {
2208 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glShaderBinary(SPIR-V)");
2210 _mesa_spirv_shader_binary(ctx
, (unsigned) n
, sh
, binary
,
2217 _mesa_error(ctx
, GL_INVALID_ENUM
, "glShaderBinary(format)");
2222 _mesa_GetProgramBinary(GLuint program
, GLsizei bufSize
, GLsizei
*length
,
2223 GLenum
*binaryFormat
, GLvoid
*binary
)
2225 struct gl_shader_program
*shProg
;
2226 GLsizei length_dummy
;
2227 GET_CURRENT_CONTEXT(ctx
);
2230 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramBinary(bufSize < 0)");
2234 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramBinary");
2238 /* The ARB_get_program_binary spec says:
2240 * "If <length> is NULL, then no length is returned."
2242 * Ensure that length always points to valid storage to avoid multiple NULL
2243 * pointer checks below.
2246 length
= &length_dummy
;
2249 /* The ARB_get_program_binary spec says:
2251 * "When a program object's LINK_STATUS is FALSE, its program binary
2252 * length is zero, and a call to GetProgramBinary will generate an
2253 * INVALID_OPERATION error.
2255 if (!shProg
->data
->LinkStatus
) {
2256 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2257 "glGetProgramBinary(program %u not linked)",
2263 if (ctx
->Const
.NumProgramBinaryFormats
== 0) {
2265 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2266 "glGetProgramBinary(driver supports zero binary formats)");
2268 _mesa_get_program_binary(ctx
, shProg
, bufSize
, length
, binaryFormat
,
2270 assert(*length
== 0 || *binaryFormat
== GL_PROGRAM_BINARY_FORMAT_MESA
);
2275 _mesa_ProgramBinary(GLuint program
, GLenum binaryFormat
,
2276 const GLvoid
*binary
, GLsizei length
)
2278 struct gl_shader_program
*shProg
;
2279 GET_CURRENT_CONTEXT(ctx
);
2281 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glProgramBinary");
2285 _mesa_clear_shader_program_data(ctx
, shProg
);
2286 shProg
->data
= _mesa_create_shader_program_data();
2288 /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
2290 * "If a negative number is provided where an argument of type sizei or
2291 * sizeiptr is specified, an INVALID_VALUE error is generated."
2294 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramBinary(length < 0)");
2298 if (ctx
->Const
.NumProgramBinaryFormats
== 0 ||
2299 binaryFormat
!= GL_PROGRAM_BINARY_FORMAT_MESA
) {
2300 /* The ARB_get_program_binary spec says:
2302 * "<binaryFormat> and <binary> must be those returned by a previous
2303 * call to GetProgramBinary, and <length> must be the length of the
2304 * program binary as returned by GetProgramBinary or GetProgramiv with
2305 * <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
2306 * setting the LINK_STATUS of <program> to FALSE, if these conditions
2309 * Since any value of binaryFormat passed "is not one of those specified as
2310 * allowable for [this] command, an INVALID_ENUM error is generated."
2312 shProg
->data
->LinkStatus
= LINKING_FAILURE
;
2313 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramBinary");
2315 _mesa_program_binary(ctx
, shProg
, binaryFormat
, binary
, length
);
2320 static ALWAYS_INLINE
void
2321 program_parameteri(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
2322 GLuint pname
, GLint value
, bool no_error
)
2325 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
2326 /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
2327 * is part of OpenGL ES 3.0. For the ES2 case, this function shouldn't
2328 * even be in the dispatch table, so we shouldn't need to expclicitly
2331 * On desktop, we ignore the 3.0+ requirement because it is silly.
2334 /* The ARB_get_program_binary extension spec says:
2336 * "An INVALID_VALUE error is generated if the <value> argument to
2337 * ProgramParameteri is not TRUE or FALSE."
2339 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2343 /* No need to notify the driver. Any changes will actually take effect
2344 * the next time the shader is linked.
2346 * The ARB_get_program_binary extension spec says:
2348 * "To indicate that a program binary is likely to be retrieved,
2349 * ProgramParameteri should be called with <pname>
2350 * PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2351 * will not be in effect until the next time LinkProgram or
2352 * ProgramBinary has been called successfully."
2354 * The resloution of issue 9 in the extension spec also says:
2356 * "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2357 * to indicate to the GL implementation that this program will
2358 * likely be saved with GetProgramBinary at some point. This will
2359 * give the GL implementation the opportunity to track any state
2360 * changes made to the program before being saved such that when it
2361 * is loaded again a recompile can be avoided."
2363 shProg
->BinaryRetreivableHint
= value
;
2366 case GL_PROGRAM_SEPARABLE
:
2367 /* Spec imply that the behavior is the same as ARB_get_program_binary
2368 * Chapter 7.3 Program Objects
2370 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2373 shProg
->SeparateShader
= value
;
2378 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteri(pname=%s)",
2379 _mesa_enum_to_string(pname
));
2385 _mesa_error(ctx
, GL_INVALID_VALUE
,
2386 "glProgramParameteri(pname=%s, value=%d): "
2387 "value must be 0 or 1.",
2388 _mesa_enum_to_string(pname
),
2394 _mesa_ProgramParameteri_no_error(GLuint program
, GLenum pname
, GLint value
)
2396 GET_CURRENT_CONTEXT(ctx
);
2398 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, program
);
2399 program_parameteri(ctx
, shProg
, pname
, value
, true);
2404 _mesa_ProgramParameteri(GLuint program
, GLenum pname
, GLint value
)
2406 struct gl_shader_program
*shProg
;
2407 GET_CURRENT_CONTEXT(ctx
);
2409 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
2410 "glProgramParameteri");
2414 program_parameteri(ctx
, shProg
, pname
, value
, false);
2419 _mesa_use_program(struct gl_context
*ctx
, gl_shader_stage stage
,
2420 struct gl_shader_program
*shProg
, struct gl_program
*prog
,
2421 struct gl_pipeline_object
*shTarget
)
2423 struct gl_program
**target
;
2425 target
= &shTarget
->CurrentProgram
[stage
];
2427 _mesa_program_init_subroutine_defaults(ctx
, prog
);
2430 if (*target
!= prog
) {
2431 /* Program is current, flush it */
2432 if (shTarget
== ctx
->_Shader
) {
2433 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
2436 _mesa_reference_shader_program(ctx
,
2437 &shTarget
->ReferencedPrograms
[stage
],
2439 _mesa_reference_program(ctx
, target
, prog
);
2440 if (stage
== MESA_SHADER_VERTEX
)
2441 _mesa_update_vertex_processing_mode(ctx
);
2449 * Copy program-specific data generated by linking from the gl_shader_program
2450 * object to the gl_program object referred to by the gl_linked_shader.
2452 * This function expects _mesa_reference_program() to have been previously
2453 * called setting the gl_linked_shaders program reference.
2456 _mesa_copy_linked_program_data(const struct gl_shader_program
*src
,
2457 struct gl_linked_shader
*dst_sh
)
2459 assert(dst_sh
->Program
);
2461 struct gl_program
*dst
= dst_sh
->Program
;
2463 dst
->info
.separate_shader
= src
->SeparateShader
;
2465 switch (dst_sh
->Stage
) {
2466 case MESA_SHADER_GEOMETRY
: {
2467 dst
->info
.gs
.vertices_in
= src
->Geom
.VerticesIn
;
2468 dst
->info
.gs
.uses_end_primitive
= src
->Geom
.UsesEndPrimitive
;
2469 dst
->info
.gs
.uses_streams
= src
->Geom
.UsesStreams
;
2472 case MESA_SHADER_FRAGMENT
: {
2473 dst
->info
.fs
.depth_layout
= src
->FragDepthLayout
;
2476 case MESA_SHADER_COMPUTE
: {
2477 dst
->info
.cs
.shared_size
= src
->Comp
.SharedSize
;
2486 * ARB_separate_shader_objects: Compile & Link Program
2489 _mesa_CreateShaderProgramv(GLenum type
, GLsizei count
,
2490 const GLchar
* const *strings
)
2492 GET_CURRENT_CONTEXT(ctx
);
2494 const GLuint shader
= create_shader_err(ctx
, type
, "glCreateShaderProgramv");
2498 * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2499 * GL_INVALID_VALUE should be generated if count < 0
2502 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCreateShaderProgram (count < 0)");
2507 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
2509 _mesa_ShaderSource(shader
, count
, strings
, NULL
);
2510 _mesa_compile_shader(ctx
, sh
);
2512 program
= create_shader_program(ctx
);
2514 struct gl_shader_program
*shProg
;
2515 GLint compiled
= GL_FALSE
;
2517 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2519 shProg
->SeparateShader
= GL_TRUE
;
2521 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
2523 attach_shader_err(ctx
, program
, shader
, "glCreateShaderProgramv");
2524 _mesa_link_program(ctx
, shProg
);
2525 detach_shader_error(ctx
, program
, shader
);
2529 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
2530 append
-error
-to
-info
-log
;
2531 shProg
->data
->LinkStatus
= LINKING_FAILURE
;
2536 ralloc_strcat(&shProg
->data
->InfoLog
, sh
->InfoLog
);
2539 delete_shader(ctx
, shader
);
2547 * For GL_ARB_tessellation_shader
2550 _mesa_PatchParameteri_no_error(GLenum pname
, GLint value
)
2552 GET_CURRENT_CONTEXT(ctx
);
2553 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2557 extern void GLAPIENTRY
2558 _mesa_PatchParameteri(GLenum pname
, GLint value
)
2560 GET_CURRENT_CONTEXT(ctx
);
2562 if (!_mesa_has_tessellation(ctx
)) {
2563 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameteri");
2567 if (pname
!= GL_PATCH_VERTICES
) {
2568 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameteri");
2572 if (value
<= 0 || value
> ctx
->Const
.MaxPatchVertices
) {
2573 _mesa_error(ctx
, GL_INVALID_VALUE
, "glPatchParameteri");
2577 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2581 extern void GLAPIENTRY
2582 _mesa_PatchParameterfv(GLenum pname
, const GLfloat
*values
)
2584 GET_CURRENT_CONTEXT(ctx
);
2586 if (!_mesa_has_tessellation(ctx
)) {
2587 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameterfv");
2592 case GL_PATCH_DEFAULT_OUTER_LEVEL
:
2593 FLUSH_VERTICES(ctx
, 0);
2594 memcpy(ctx
->TessCtrlProgram
.patch_default_outer_level
, values
,
2595 4 * sizeof(GLfloat
));
2596 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2598 case GL_PATCH_DEFAULT_INNER_LEVEL
:
2599 FLUSH_VERTICES(ctx
, 0);
2600 memcpy(ctx
->TessCtrlProgram
.patch_default_inner_level
, values
,
2601 2 * sizeof(GLfloat
));
2602 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2605 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameterfv");
2611 * ARB_shader_subroutine
2614 _mesa_GetSubroutineUniformLocation(GLuint program
, GLenum shadertype
,
2617 GET_CURRENT_CONTEXT(ctx
);
2618 const char *api_name
= "glGetSubroutineUniformLocation";
2619 struct gl_shader_program
*shProg
;
2620 GLenum resource_type
;
2621 gl_shader_stage stage
;
2623 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2624 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2628 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2632 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2633 if (!shProg
->_LinkedShaders
[stage
]) {
2634 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2638 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2639 return _mesa_program_resource_location(shProg
, resource_type
, name
);
2643 _mesa_GetSubroutineIndex(GLuint program
, GLenum shadertype
,
2646 GET_CURRENT_CONTEXT(ctx
);
2647 const char *api_name
= "glGetSubroutineIndex";
2648 struct gl_shader_program
*shProg
;
2649 struct gl_program_resource
*res
;
2650 GLenum resource_type
;
2651 gl_shader_stage stage
;
2653 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2654 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2658 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2662 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2663 if (!shProg
->_LinkedShaders
[stage
]) {
2664 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2668 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2669 res
= _mesa_program_resource_find_name(shProg
, resource_type
, name
, NULL
);
2674 return _mesa_program_resource_index(shProg
, res
);
2679 _mesa_GetActiveSubroutineUniformiv(GLuint program
, GLenum shadertype
,
2680 GLuint index
, GLenum pname
, GLint
*values
)
2682 GET_CURRENT_CONTEXT(ctx
);
2683 const char *api_name
= "glGetActiveSubroutineUniformiv";
2684 struct gl_shader_program
*shProg
;
2685 struct gl_linked_shader
*sh
;
2686 gl_shader_stage stage
;
2687 struct gl_program_resource
*res
;
2688 const struct gl_uniform_storage
*uni
;
2689 GLenum resource_type
;
2692 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2693 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2697 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2701 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2702 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2704 sh
= shProg
->_LinkedShaders
[stage
];
2706 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2710 struct gl_program
*p
= shProg
->_LinkedShaders
[stage
]->Program
;
2711 if (index
>= p
->sh
.NumSubroutineUniforms
) {
2712 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name
);
2717 case GL_NUM_COMPATIBLE_SUBROUTINES
: {
2718 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2721 values
[0] = uni
->num_compatible_subroutines
;
2725 case GL_COMPATIBLE_SUBROUTINES
: {
2726 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2730 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2731 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2732 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2733 if (fn
->types
[j
] == uni
->type
) {
2734 values
[count
++] = i
;
2742 case GL_UNIFORM_SIZE
:
2743 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2746 values
[0] = uni
->array_elements
? uni
->array_elements
: 1;
2749 case GL_UNIFORM_NAME_LENGTH
:
2750 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2752 values
[0] = strlen(_mesa_program_resource_name(res
)) + 1
2753 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2757 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2764 _mesa_GetActiveSubroutineUniformName(GLuint program
, GLenum shadertype
,
2765 GLuint index
, GLsizei bufsize
,
2766 GLsizei
*length
, GLchar
*name
)
2768 GET_CURRENT_CONTEXT(ctx
);
2769 const char *api_name
= "glGetActiveSubroutineUniformName";
2770 struct gl_shader_program
*shProg
;
2771 GLenum resource_type
;
2772 gl_shader_stage stage
;
2774 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2775 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2779 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2783 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2784 if (!shProg
->_LinkedShaders
[stage
]) {
2785 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2789 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2790 /* get program resource name */
2791 _mesa_get_program_resource_name(shProg
, resource_type
,
2793 length
, name
, api_name
);
2798 _mesa_GetActiveSubroutineName(GLuint program
, GLenum shadertype
,
2799 GLuint index
, GLsizei bufsize
,
2800 GLsizei
*length
, GLchar
*name
)
2802 GET_CURRENT_CONTEXT(ctx
);
2803 const char *api_name
= "glGetActiveSubroutineName";
2804 struct gl_shader_program
*shProg
;
2805 GLenum resource_type
;
2806 gl_shader_stage stage
;
2808 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2809 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2813 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2817 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2818 if (!shProg
->_LinkedShaders
[stage
]) {
2819 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2822 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2823 _mesa_get_program_resource_name(shProg
, resource_type
,
2825 length
, name
, api_name
);
2829 _mesa_UniformSubroutinesuiv(GLenum shadertype
, GLsizei count
,
2830 const GLuint
*indices
)
2832 GET_CURRENT_CONTEXT(ctx
);
2833 const char *api_name
= "glUniformSubroutinesuiv";
2834 gl_shader_stage stage
;
2837 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2838 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2842 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2843 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2845 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2849 if (count
!= p
->sh
.NumSubroutineUniformRemapTable
) {
2850 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2855 bool flushed
= false;
2857 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2864 _mesa_flush_vertices_for_uniforms(ctx
, uni
);
2868 int uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2871 for (j
= i
; j
< i
+ uni_count
; j
++) {
2872 struct gl_subroutine_function
*subfn
= NULL
;
2873 if (indices
[j
] > p
->sh
.MaxSubroutineFunctionIndex
) {
2874 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2878 for (f
= 0; f
< p
->sh
.NumSubroutineFunctions
; f
++) {
2879 if (p
->sh
.SubroutineFunctions
[f
].index
== indices
[j
])
2880 subfn
= &p
->sh
.SubroutineFunctions
[f
];
2887 for (k
= 0; k
< subfn
->num_compat_types
; k
++) {
2888 if (subfn
->types
[k
] == uni
->type
)
2891 if (k
== subfn
->num_compat_types
) {
2892 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2896 ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[j
] = indices
[j
];
2904 _mesa_GetUniformSubroutineuiv(GLenum shadertype
, GLint location
,
2907 GET_CURRENT_CONTEXT(ctx
);
2908 const char *api_name
= "glGetUniformSubroutineuiv";
2909 gl_shader_stage stage
;
2911 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2912 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2916 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2917 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2919 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2923 if (location
>= p
->sh
.NumSubroutineUniformRemapTable
) {
2924 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2928 *params
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[location
];
2933 _mesa_GetProgramStageiv(GLuint program
, GLenum shadertype
,
2934 GLenum pname
, GLint
*values
)
2936 GET_CURRENT_CONTEXT(ctx
);
2937 const char *api_name
= "glGetProgramStageiv";
2938 struct gl_shader_program
*shProg
;
2939 struct gl_linked_shader
*sh
;
2940 gl_shader_stage stage
;
2942 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2943 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2947 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2951 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2952 sh
= shProg
->_LinkedShaders
[stage
];
2954 /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
2955 * INVALID_OPERATION in the case of not be linked.
2957 * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
2958 * same info using other specs (ARB_program_interface_query), without the
2959 * need of the program to be linked, being the value for that case 0.
2961 * But at the same time, some other methods require the program to be
2962 * linked for pname related to locations, so it would be inconsistent to
2963 * not do the same here. So we are:
2964 * * Return GL_INVALID_OPERATION if not linked only for locations.
2965 * * Setting a default value of 0, to be returned if not linked.
2969 if (pname
== GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
) {
2970 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2975 struct gl_program
*p
= sh
->Program
;
2977 case GL_ACTIVE_SUBROUTINES
:
2978 values
[0] = p
->sh
.NumSubroutineFunctions
;
2980 case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
:
2981 values
[0] = p
->sh
.NumSubroutineUniformRemapTable
;
2983 case GL_ACTIVE_SUBROUTINE_UNIFORMS
:
2984 values
[0] = p
->sh
.NumSubroutineUniforms
;
2986 case GL_ACTIVE_SUBROUTINE_MAX_LENGTH
:
2990 GLenum resource_type
;
2991 struct gl_program_resource
*res
;
2993 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2994 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2995 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2997 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1;
3002 values
[0] = max_len
;
3005 case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
:
3009 GLenum resource_type
;
3010 struct gl_program_resource
*res
;
3012 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
3013 for (i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3014 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
3016 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1
3017 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
3023 values
[0] = max_len
;
3027 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s", api_name
);
3034 find_compat_subroutine(struct gl_program
*p
, const struct glsl_type
*type
)
3038 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
3039 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
3040 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
3041 if (fn
->types
[j
] == type
)
3049 _mesa_shader_write_subroutine_index(struct gl_context
*ctx
,
3050 struct gl_program
*p
)
3054 if (p
->sh
.NumSubroutineUniformRemapTable
== 0)
3059 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3068 uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
3069 for (j
= 0; j
< uni_count
; j
++) {
3070 val
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[i
+ j
];
3071 memcpy(&uni
->storage
[j
], &val
, sizeof(int));
3074 _mesa_propagate_uniforms_to_driver_storage(uni
, 0, uni_count
);
3076 } while(i
< p
->sh
.NumSubroutineUniformRemapTable
);
3080 _mesa_shader_write_subroutine_indices(struct gl_context
*ctx
,
3081 gl_shader_stage stage
)
3083 if (ctx
->_Shader
->CurrentProgram
[stage
])
3084 _mesa_shader_write_subroutine_index(ctx
,
3085 ctx
->_Shader
->CurrentProgram
[stage
]);
3089 _mesa_program_init_subroutine_defaults(struct gl_context
*ctx
,
3090 struct gl_program
*p
)
3094 struct gl_subroutine_index_binding
*binding
= &ctx
->SubroutineIndex
[p
->info
.stage
];
3095 if (binding
->NumIndex
!= p
->sh
.NumSubroutineUniformRemapTable
) {
3096 binding
->IndexPtr
= realloc(binding
->IndexPtr
,
3097 p
->sh
.NumSubroutineUniformRemapTable
* (sizeof(GLuint
)));
3098 binding
->NumIndex
= p
->sh
.NumSubroutineUniformRemapTable
;
3101 for (int i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3102 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3107 binding
->IndexPtr
[i
] = find_compat_subroutine(p
, uni
->type
);