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
);
2076 _mesa_UseProgram_no_error(GLuint program
)
2078 use_program(program
, true);
2083 _mesa_UseProgram(GLuint program
)
2085 use_program(program
, false);
2090 _mesa_ValidateProgram(GLuint program
)
2092 GET_CURRENT_CONTEXT(ctx
);
2093 validate_program(ctx
, program
);
2098 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2101 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
2102 GLint
* range
, GLint
* precision
)
2104 const struct gl_program_constants
*limits
;
2105 const struct gl_precision
*p
;
2106 GET_CURRENT_CONTEXT(ctx
);
2108 switch (shadertype
) {
2109 case GL_VERTEX_SHADER
:
2110 limits
= &ctx
->Const
.Program
[MESA_SHADER_VERTEX
];
2112 case GL_FRAGMENT_SHADER
:
2113 limits
= &ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
];
2116 _mesa_error(ctx
, GL_INVALID_ENUM
,
2117 "glGetShaderPrecisionFormat(shadertype)");
2121 switch (precisiontype
) {
2123 p
= &limits
->LowFloat
;
2125 case GL_MEDIUM_FLOAT
:
2126 p
= &limits
->MediumFloat
;
2129 p
= &limits
->HighFloat
;
2132 p
= &limits
->LowInt
;
2135 p
= &limits
->MediumInt
;
2138 p
= &limits
->HighInt
;
2141 _mesa_error(ctx
, GL_INVALID_ENUM
,
2142 "glGetShaderPrecisionFormat(precisiontype)");
2146 range
[0] = p
->RangeMin
;
2147 range
[1] = p
->RangeMax
;
2148 precision
[0] = p
->Precision
;
2153 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2156 _mesa_ReleaseShaderCompiler(void)
2158 _mesa_destroy_shader_compiler_caches();
2163 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2166 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
2167 const void* binary
, GLint length
)
2169 GET_CURRENT_CONTEXT(ctx
);
2170 struct gl_shader
**sh
;
2172 /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
2173 * page 88 of the OpenGL 4.5 specs state:
2175 * "An INVALID_VALUE error is generated if count or length is negative.
2176 * An INVALID_ENUM error is generated if binaryformat is not a supported
2177 * format returned in SHADER_BINARY_FORMATS."
2179 if (n
< 0 || length
< 0) {
2180 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderBinary(count or length < 0)");
2184 /* Get all shader objects at once so we can make the operation
2187 if (n
> SIZE_MAX
/ sizeof(*sh
)) {
2188 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderBinary(count)");
2192 sh
= alloca(sizeof(*sh
) * (size_t)n
);
2194 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderBinary");
2198 for (int i
= 0; i
< n
; ++i
) {
2199 sh
[i
] = _mesa_lookup_shader_err(ctx
, shaders
[i
], "glShaderBinary");
2204 if (binaryformat
== GL_SHADER_BINARY_FORMAT_SPIR_V_ARB
) {
2205 if (!ctx
->Extensions
.ARB_gl_spirv
) {
2206 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glShaderBinary(SPIR-V)");
2208 _mesa_spirv_shader_binary(ctx
, (unsigned) n
, sh
, binary
,
2215 _mesa_error(ctx
, GL_INVALID_ENUM
, "glShaderBinary(format)");
2220 _mesa_GetProgramBinary(GLuint program
, GLsizei bufSize
, GLsizei
*length
,
2221 GLenum
*binaryFormat
, GLvoid
*binary
)
2223 struct gl_shader_program
*shProg
;
2224 GLsizei length_dummy
;
2225 GET_CURRENT_CONTEXT(ctx
);
2228 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramBinary(bufSize < 0)");
2232 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramBinary");
2236 /* The ARB_get_program_binary spec says:
2238 * "If <length> is NULL, then no length is returned."
2240 * Ensure that length always points to valid storage to avoid multiple NULL
2241 * pointer checks below.
2244 length
= &length_dummy
;
2247 /* The ARB_get_program_binary spec says:
2249 * "When a program object's LINK_STATUS is FALSE, its program binary
2250 * length is zero, and a call to GetProgramBinary will generate an
2251 * INVALID_OPERATION error.
2253 if (!shProg
->data
->LinkStatus
) {
2254 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2255 "glGetProgramBinary(program %u not linked)",
2261 if (ctx
->Const
.NumProgramBinaryFormats
== 0) {
2263 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2264 "glGetProgramBinary(driver supports zero binary formats)");
2266 _mesa_get_program_binary(ctx
, shProg
, bufSize
, length
, binaryFormat
,
2268 assert(*length
== 0 || *binaryFormat
== GL_PROGRAM_BINARY_FORMAT_MESA
);
2273 _mesa_ProgramBinary(GLuint program
, GLenum binaryFormat
,
2274 const GLvoid
*binary
, GLsizei length
)
2276 struct gl_shader_program
*shProg
;
2277 GET_CURRENT_CONTEXT(ctx
);
2279 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glProgramBinary");
2283 _mesa_clear_shader_program_data(ctx
, shProg
);
2284 shProg
->data
= _mesa_create_shader_program_data();
2286 /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
2288 * "If a negative number is provided where an argument of type sizei or
2289 * sizeiptr is specified, an INVALID_VALUE error is generated."
2292 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramBinary(length < 0)");
2296 if (ctx
->Const
.NumProgramBinaryFormats
== 0 ||
2297 binaryFormat
!= GL_PROGRAM_BINARY_FORMAT_MESA
) {
2298 /* The ARB_get_program_binary spec says:
2300 * "<binaryFormat> and <binary> must be those returned by a previous
2301 * call to GetProgramBinary, and <length> must be the length of the
2302 * program binary as returned by GetProgramBinary or GetProgramiv with
2303 * <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
2304 * setting the LINK_STATUS of <program> to FALSE, if these conditions
2307 * Since any value of binaryFormat passed "is not one of those specified as
2308 * allowable for [this] command, an INVALID_ENUM error is generated."
2310 shProg
->data
->LinkStatus
= LINKING_FAILURE
;
2311 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramBinary");
2313 _mesa_program_binary(ctx
, shProg
, binaryFormat
, binary
, length
);
2318 static ALWAYS_INLINE
void
2319 program_parameteri(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
2320 GLuint pname
, GLint value
, bool no_error
)
2323 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
2324 /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
2325 * is part of OpenGL ES 3.0. For the ES2 case, this function shouldn't
2326 * even be in the dispatch table, so we shouldn't need to expclicitly
2329 * On desktop, we ignore the 3.0+ requirement because it is silly.
2332 /* The ARB_get_program_binary extension spec says:
2334 * "An INVALID_VALUE error is generated if the <value> argument to
2335 * ProgramParameteri is not TRUE or FALSE."
2337 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2341 /* No need to notify the driver. Any changes will actually take effect
2342 * the next time the shader is linked.
2344 * The ARB_get_program_binary extension spec says:
2346 * "To indicate that a program binary is likely to be retrieved,
2347 * ProgramParameteri should be called with <pname>
2348 * PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2349 * will not be in effect until the next time LinkProgram or
2350 * ProgramBinary has been called successfully."
2352 * The resloution of issue 9 in the extension spec also says:
2354 * "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2355 * to indicate to the GL implementation that this program will
2356 * likely be saved with GetProgramBinary at some point. This will
2357 * give the GL implementation the opportunity to track any state
2358 * changes made to the program before being saved such that when it
2359 * is loaded again a recompile can be avoided."
2361 shProg
->BinaryRetreivableHint
= value
;
2364 case GL_PROGRAM_SEPARABLE
:
2365 /* Spec imply that the behavior is the same as ARB_get_program_binary
2366 * Chapter 7.3 Program Objects
2368 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2371 shProg
->SeparateShader
= value
;
2376 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteri(pname=%s)",
2377 _mesa_enum_to_string(pname
));
2383 _mesa_error(ctx
, GL_INVALID_VALUE
,
2384 "glProgramParameteri(pname=%s, value=%d): "
2385 "value must be 0 or 1.",
2386 _mesa_enum_to_string(pname
),
2392 _mesa_ProgramParameteri_no_error(GLuint program
, GLenum pname
, GLint value
)
2394 GET_CURRENT_CONTEXT(ctx
);
2396 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, program
);
2397 program_parameteri(ctx
, shProg
, pname
, value
, true);
2402 _mesa_ProgramParameteri(GLuint program
, GLenum pname
, GLint value
)
2404 struct gl_shader_program
*shProg
;
2405 GET_CURRENT_CONTEXT(ctx
);
2407 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
2408 "glProgramParameteri");
2412 program_parameteri(ctx
, shProg
, pname
, value
, false);
2417 _mesa_use_program(struct gl_context
*ctx
, gl_shader_stage stage
,
2418 struct gl_shader_program
*shProg
, struct gl_program
*prog
,
2419 struct gl_pipeline_object
*shTarget
)
2421 struct gl_program
**target
;
2423 target
= &shTarget
->CurrentProgram
[stage
];
2425 _mesa_program_init_subroutine_defaults(ctx
, prog
);
2428 if (*target
!= prog
) {
2429 /* Program is current, flush it */
2430 if (shTarget
== ctx
->_Shader
) {
2431 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
2434 _mesa_reference_shader_program(ctx
,
2435 &shTarget
->ReferencedPrograms
[stage
],
2437 _mesa_reference_program(ctx
, target
, prog
);
2438 if (stage
== MESA_SHADER_VERTEX
)
2439 _mesa_update_vertex_processing_mode(ctx
);
2447 * Copy program-specific data generated by linking from the gl_shader_program
2448 * object to the gl_program object referred to by the gl_linked_shader.
2450 * This function expects _mesa_reference_program() to have been previously
2451 * called setting the gl_linked_shaders program reference.
2454 _mesa_copy_linked_program_data(const struct gl_shader_program
*src
,
2455 struct gl_linked_shader
*dst_sh
)
2457 assert(dst_sh
->Program
);
2459 struct gl_program
*dst
= dst_sh
->Program
;
2461 dst
->info
.separate_shader
= src
->SeparateShader
;
2463 switch (dst_sh
->Stage
) {
2464 case MESA_SHADER_GEOMETRY
: {
2465 dst
->info
.gs
.vertices_in
= src
->Geom
.VerticesIn
;
2466 dst
->info
.gs
.uses_end_primitive
= src
->Geom
.UsesEndPrimitive
;
2467 dst
->info
.gs
.uses_streams
= src
->Geom
.UsesStreams
;
2470 case MESA_SHADER_FRAGMENT
: {
2471 dst
->info
.fs
.depth_layout
= src
->FragDepthLayout
;
2474 case MESA_SHADER_COMPUTE
: {
2475 dst
->info
.cs
.shared_size
= src
->Comp
.SharedSize
;
2484 * ARB_separate_shader_objects: Compile & Link Program
2487 _mesa_CreateShaderProgramv(GLenum type
, GLsizei count
,
2488 const GLchar
* const *strings
)
2490 GET_CURRENT_CONTEXT(ctx
);
2492 const GLuint shader
= create_shader_err(ctx
, type
, "glCreateShaderProgramv");
2496 * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2497 * GL_INVALID_VALUE should be generated if count < 0
2500 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCreateShaderProgram (count < 0)");
2505 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
2507 _mesa_ShaderSource(shader
, count
, strings
, NULL
);
2508 _mesa_compile_shader(ctx
, sh
);
2510 program
= create_shader_program(ctx
);
2512 struct gl_shader_program
*shProg
;
2513 GLint compiled
= GL_FALSE
;
2515 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2517 shProg
->SeparateShader
= GL_TRUE
;
2519 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
2521 attach_shader_err(ctx
, program
, shader
, "glCreateShaderProgramv");
2522 _mesa_link_program(ctx
, shProg
);
2523 detach_shader_error(ctx
, program
, shader
);
2527 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
2528 append
-error
-to
-info
-log
;
2529 shProg
->data
->LinkStatus
= LINKING_FAILURE
;
2534 ralloc_strcat(&shProg
->data
->InfoLog
, sh
->InfoLog
);
2537 delete_shader(ctx
, shader
);
2545 * For GL_ARB_tessellation_shader
2548 _mesa_PatchParameteri_no_error(GLenum pname
, GLint value
)
2550 GET_CURRENT_CONTEXT(ctx
);
2551 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2555 extern void GLAPIENTRY
2556 _mesa_PatchParameteri(GLenum pname
, GLint value
)
2558 GET_CURRENT_CONTEXT(ctx
);
2560 if (!_mesa_has_tessellation(ctx
)) {
2561 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameteri");
2565 if (pname
!= GL_PATCH_VERTICES
) {
2566 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameteri");
2570 if (value
<= 0 || value
> ctx
->Const
.MaxPatchVertices
) {
2571 _mesa_error(ctx
, GL_INVALID_VALUE
, "glPatchParameteri");
2575 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2579 extern void GLAPIENTRY
2580 _mesa_PatchParameterfv(GLenum pname
, const GLfloat
*values
)
2582 GET_CURRENT_CONTEXT(ctx
);
2584 if (!_mesa_has_tessellation(ctx
)) {
2585 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameterfv");
2590 case GL_PATCH_DEFAULT_OUTER_LEVEL
:
2591 FLUSH_VERTICES(ctx
, 0);
2592 memcpy(ctx
->TessCtrlProgram
.patch_default_outer_level
, values
,
2593 4 * sizeof(GLfloat
));
2594 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2596 case GL_PATCH_DEFAULT_INNER_LEVEL
:
2597 FLUSH_VERTICES(ctx
, 0);
2598 memcpy(ctx
->TessCtrlProgram
.patch_default_inner_level
, values
,
2599 2 * sizeof(GLfloat
));
2600 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2603 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameterfv");
2609 * ARB_shader_subroutine
2612 _mesa_GetSubroutineUniformLocation(GLuint program
, GLenum shadertype
,
2615 GET_CURRENT_CONTEXT(ctx
);
2616 const char *api_name
= "glGetSubroutineUniformLocation";
2617 struct gl_shader_program
*shProg
;
2618 GLenum resource_type
;
2619 gl_shader_stage stage
;
2621 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2622 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2626 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2630 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2631 if (!shProg
->_LinkedShaders
[stage
]) {
2632 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2636 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2637 return _mesa_program_resource_location(shProg
, resource_type
, name
);
2641 _mesa_GetSubroutineIndex(GLuint program
, GLenum shadertype
,
2644 GET_CURRENT_CONTEXT(ctx
);
2645 const char *api_name
= "glGetSubroutineIndex";
2646 struct gl_shader_program
*shProg
;
2647 struct gl_program_resource
*res
;
2648 GLenum resource_type
;
2649 gl_shader_stage stage
;
2651 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2652 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2656 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2660 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2661 if (!shProg
->_LinkedShaders
[stage
]) {
2662 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2666 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2667 res
= _mesa_program_resource_find_name(shProg
, resource_type
, name
, NULL
);
2672 return _mesa_program_resource_index(shProg
, res
);
2677 _mesa_GetActiveSubroutineUniformiv(GLuint program
, GLenum shadertype
,
2678 GLuint index
, GLenum pname
, GLint
*values
)
2680 GET_CURRENT_CONTEXT(ctx
);
2681 const char *api_name
= "glGetActiveSubroutineUniformiv";
2682 struct gl_shader_program
*shProg
;
2683 struct gl_linked_shader
*sh
;
2684 gl_shader_stage stage
;
2685 struct gl_program_resource
*res
;
2686 const struct gl_uniform_storage
*uni
;
2687 GLenum resource_type
;
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 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2702 sh
= shProg
->_LinkedShaders
[stage
];
2704 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2708 struct gl_program
*p
= shProg
->_LinkedShaders
[stage
]->Program
;
2709 if (index
>= p
->sh
.NumSubroutineUniforms
) {
2710 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name
);
2715 case GL_NUM_COMPATIBLE_SUBROUTINES
: {
2716 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2719 values
[0] = uni
->num_compatible_subroutines
;
2723 case GL_COMPATIBLE_SUBROUTINES
: {
2724 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2728 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2729 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2730 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2731 if (fn
->types
[j
] == uni
->type
) {
2732 values
[count
++] = i
;
2740 case GL_UNIFORM_SIZE
:
2741 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2744 values
[0] = uni
->array_elements
? uni
->array_elements
: 1;
2747 case GL_UNIFORM_NAME_LENGTH
:
2748 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2750 values
[0] = strlen(_mesa_program_resource_name(res
)) + 1
2751 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2755 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2762 _mesa_GetActiveSubroutineUniformName(GLuint program
, GLenum shadertype
,
2763 GLuint index
, GLsizei bufsize
,
2764 GLsizei
*length
, GLchar
*name
)
2766 GET_CURRENT_CONTEXT(ctx
);
2767 const char *api_name
= "glGetActiveSubroutineUniformName";
2768 struct gl_shader_program
*shProg
;
2769 GLenum resource_type
;
2770 gl_shader_stage stage
;
2772 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2773 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2777 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2781 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2782 if (!shProg
->_LinkedShaders
[stage
]) {
2783 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2787 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2788 /* get program resource name */
2789 _mesa_get_program_resource_name(shProg
, resource_type
,
2791 length
, name
, api_name
);
2796 _mesa_GetActiveSubroutineName(GLuint program
, GLenum shadertype
,
2797 GLuint index
, GLsizei bufsize
,
2798 GLsizei
*length
, GLchar
*name
)
2800 GET_CURRENT_CONTEXT(ctx
);
2801 const char *api_name
= "glGetActiveSubroutineName";
2802 struct gl_shader_program
*shProg
;
2803 GLenum resource_type
;
2804 gl_shader_stage stage
;
2806 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2807 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2811 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2815 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2816 if (!shProg
->_LinkedShaders
[stage
]) {
2817 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2820 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2821 _mesa_get_program_resource_name(shProg
, resource_type
,
2823 length
, name
, api_name
);
2827 _mesa_UniformSubroutinesuiv(GLenum shadertype
, GLsizei count
,
2828 const GLuint
*indices
)
2830 GET_CURRENT_CONTEXT(ctx
);
2831 const char *api_name
= "glUniformSubroutinesuiv";
2832 gl_shader_stage stage
;
2835 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2836 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2840 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2841 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2843 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2847 if (count
!= p
->sh
.NumSubroutineUniformRemapTable
) {
2848 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2853 bool flushed
= false;
2855 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2862 _mesa_flush_vertices_for_uniforms(ctx
, uni
);
2866 int uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2869 for (j
= i
; j
< i
+ uni_count
; j
++) {
2870 struct gl_subroutine_function
*subfn
= NULL
;
2871 if (indices
[j
] > p
->sh
.MaxSubroutineFunctionIndex
) {
2872 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2876 for (f
= 0; f
< p
->sh
.NumSubroutineFunctions
; f
++) {
2877 if (p
->sh
.SubroutineFunctions
[f
].index
== indices
[j
])
2878 subfn
= &p
->sh
.SubroutineFunctions
[f
];
2885 for (k
= 0; k
< subfn
->num_compat_types
; k
++) {
2886 if (subfn
->types
[k
] == uni
->type
)
2889 if (k
== subfn
->num_compat_types
) {
2890 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2894 ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[j
] = indices
[j
];
2902 _mesa_GetUniformSubroutineuiv(GLenum shadertype
, GLint location
,
2905 GET_CURRENT_CONTEXT(ctx
);
2906 const char *api_name
= "glGetUniformSubroutineuiv";
2907 gl_shader_stage stage
;
2909 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2910 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2914 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2915 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2917 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2921 if (location
>= p
->sh
.NumSubroutineUniformRemapTable
) {
2922 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2926 *params
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[location
];
2931 _mesa_GetProgramStageiv(GLuint program
, GLenum shadertype
,
2932 GLenum pname
, GLint
*values
)
2934 GET_CURRENT_CONTEXT(ctx
);
2935 const char *api_name
= "glGetProgramStageiv";
2936 struct gl_shader_program
*shProg
;
2937 struct gl_linked_shader
*sh
;
2938 gl_shader_stage stage
;
2940 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2941 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2945 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2949 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2950 sh
= shProg
->_LinkedShaders
[stage
];
2952 /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
2953 * INVALID_OPERATION in the case of not be linked.
2955 * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
2956 * same info using other specs (ARB_program_interface_query), without the
2957 * need of the program to be linked, being the value for that case 0.
2959 * But at the same time, some other methods require the program to be
2960 * linked for pname related to locations, so it would be inconsistent to
2961 * not do the same here. So we are:
2962 * * Return GL_INVALID_OPERATION if not linked only for locations.
2963 * * Setting a default value of 0, to be returned if not linked.
2967 if (pname
== GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
) {
2968 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2973 struct gl_program
*p
= sh
->Program
;
2975 case GL_ACTIVE_SUBROUTINES
:
2976 values
[0] = p
->sh
.NumSubroutineFunctions
;
2978 case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
:
2979 values
[0] = p
->sh
.NumSubroutineUniformRemapTable
;
2981 case GL_ACTIVE_SUBROUTINE_UNIFORMS
:
2982 values
[0] = p
->sh
.NumSubroutineUniforms
;
2984 case GL_ACTIVE_SUBROUTINE_MAX_LENGTH
:
2988 GLenum resource_type
;
2989 struct gl_program_resource
*res
;
2991 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2992 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2993 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2995 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1;
3000 values
[0] = max_len
;
3003 case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
:
3007 GLenum resource_type
;
3008 struct gl_program_resource
*res
;
3010 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
3011 for (i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3012 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
3014 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1
3015 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
3021 values
[0] = max_len
;
3025 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s", api_name
);
3032 find_compat_subroutine(struct gl_program
*p
, const struct glsl_type
*type
)
3036 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
3037 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
3038 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
3039 if (fn
->types
[j
] == type
)
3047 _mesa_shader_write_subroutine_index(struct gl_context
*ctx
,
3048 struct gl_program
*p
)
3052 if (p
->sh
.NumSubroutineUniformRemapTable
== 0)
3057 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3066 uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
3067 for (j
= 0; j
< uni_count
; j
++) {
3068 val
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[i
+ j
];
3069 memcpy(&uni
->storage
[j
], &val
, sizeof(int));
3072 _mesa_propagate_uniforms_to_driver_storage(uni
, 0, uni_count
);
3074 } while(i
< p
->sh
.NumSubroutineUniformRemapTable
);
3078 _mesa_shader_write_subroutine_indices(struct gl_context
*ctx
,
3079 gl_shader_stage stage
)
3081 if (ctx
->_Shader
->CurrentProgram
[stage
])
3082 _mesa_shader_write_subroutine_index(ctx
,
3083 ctx
->_Shader
->CurrentProgram
[stage
]);
3087 _mesa_program_init_subroutine_defaults(struct gl_context
*ctx
,
3088 struct gl_program
*p
)
3092 struct gl_subroutine_index_binding
*binding
= &ctx
->SubroutineIndex
[p
->info
.stage
];
3093 if (binding
->NumIndex
!= p
->sh
.NumSubroutineUniformRemapTable
) {
3094 binding
->IndexPtr
= realloc(binding
->IndexPtr
,
3095 p
->sh
.NumSubroutineUniformRemapTable
* (sizeof(GLuint
)));
3096 binding
->NumIndex
= p
->sh
.NumSubroutineUniformRemapTable
;
3099 for (int i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3100 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3105 binding
->IndexPtr
[i
] = find_compat_subroutine(p
, uni
->type
);