2 * Mesa 3-D graphics library
5 * Copyright (C) 2004-2007 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * Implementation of GLSL-related API functions
33 * 1. Check that the right error code is generated for all _mesa_error() calls.
34 * 2. Insert FLUSH_VERTICES calls in various places
43 #include "prog_parameter.h"
44 #include "prog_print.h"
45 #include "prog_statevars.h"
46 #include "prog_uniform.h"
47 #include "shader/shader_api.h"
48 #include "shader/slang/slang_compile.h"
49 #include "shader/slang/slang_link.h"
54 * Allocate a new gl_shader_program object, initialize it.
56 static struct gl_shader_program
*
57 _mesa_new_shader_program(GLcontext
*ctx
, GLuint name
)
59 struct gl_shader_program
*shProg
;
60 shProg
= CALLOC_STRUCT(gl_shader_program
);
62 shProg
->Type
= GL_SHADER_PROGRAM_MESA
;
65 shProg
->Attributes
= _mesa_new_parameter_list();
72 * Clear (free) the shader program state that gets produced by linking.
75 _mesa_clear_shader_program_data(GLcontext
*ctx
,
76 struct gl_shader_program
*shProg
)
78 _mesa_reference_vertprog(ctx
, &shProg
->VertexProgram
, NULL
);
79 _mesa_reference_fragprog(ctx
, &shProg
->FragmentProgram
, NULL
);
81 if (shProg
->Uniforms
) {
82 _mesa_free_uniform_list(shProg
->Uniforms
);
83 shProg
->Uniforms
= NULL
;
86 if (shProg
->Varying
) {
87 _mesa_free_parameter_list(shProg
->Varying
);
88 shProg
->Varying
= NULL
;
94 * Free all the data that hangs off a shader program object, but not the
98 _mesa_free_shader_program_data(GLcontext
*ctx
,
99 struct gl_shader_program
*shProg
)
103 assert(shProg
->Type
== GL_SHADER_PROGRAM_MESA
);
105 _mesa_clear_shader_program_data(ctx
, shProg
);
107 if (shProg
->Attributes
) {
108 _mesa_free_parameter_list(shProg
->Attributes
);
109 shProg
->Attributes
= NULL
;
113 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
114 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
116 shProg
->NumShaders
= 0;
118 if (shProg
->Shaders
) {
119 _mesa_free(shProg
->Shaders
);
120 shProg
->Shaders
= NULL
;
123 if (shProg
->InfoLog
) {
124 _mesa_free(shProg
->InfoLog
);
125 shProg
->InfoLog
= NULL
;
131 * Free/delete a shader program object.
134 _mesa_free_shader_program(GLcontext
*ctx
, struct gl_shader_program
*shProg
)
136 _mesa_free_shader_program_data(ctx
, shProg
);
143 * Set ptr to point to shProg.
144 * If ptr is pointing to another object, decrement its refcount (and delete
145 * if refcount hits zero).
146 * Then set ptr to point to shProg, incrementing its refcount.
148 /* XXX this could be static */
150 _mesa_reference_shader_program(GLcontext
*ctx
,
151 struct gl_shader_program
**ptr
,
152 struct gl_shader_program
*shProg
)
155 if (*ptr
== shProg
) {
160 /* Unreference the old shader program */
161 GLboolean deleteFlag
= GL_FALSE
;
162 struct gl_shader_program
*old
= *ptr
;
164 ASSERT(old
->RefCount
> 0);
167 printf("ShaderProgram %p ID=%u RefCount-- to %d\n",
168 (void *) old
, old
->Name
, old
->RefCount
);
170 deleteFlag
= (old
->RefCount
== 0);
173 _mesa_HashRemove(ctx
->Shared
->ShaderObjects
, old
->Name
);
174 _mesa_free_shader_program(ctx
, old
);
184 printf("ShaderProgram %p ID=%u RefCount++ to %d\n",
185 (void *) shProg
, shProg
->Name
, shProg
->RefCount
);
193 * Lookup a GLSL program object.
195 struct gl_shader_program
*
196 _mesa_lookup_shader_program(GLcontext
*ctx
, GLuint name
)
198 struct gl_shader_program
*shProg
;
200 shProg
= (struct gl_shader_program
*)
201 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
202 /* Note that both gl_shader and gl_shader_program objects are kept
203 * in the same hash table. Check the object's type to be sure it's
204 * what we're expecting.
206 if (shProg
&& shProg
->Type
!= GL_SHADER_PROGRAM_MESA
) {
216 * Allocate a new gl_shader object, initialize it.
219 _mesa_new_shader(GLcontext
*ctx
, GLuint name
, GLenum type
)
221 struct gl_shader
*shader
;
222 assert(type
== GL_FRAGMENT_SHADER
|| type
== GL_VERTEX_SHADER
);
223 shader
= CALLOC_STRUCT(gl_shader
);
227 shader
->RefCount
= 1;
234 _mesa_free_shader(GLcontext
*ctx
, struct gl_shader
*sh
)
238 _mesa_free((void *) sh
->Source
);
240 _mesa_free(sh
->InfoLog
);
241 for (i
= 0; i
< sh
->NumPrograms
; i
++)
242 _mesa_reference_program(ctx
, &sh
->Programs
[i
], NULL
);
244 _mesa_free(sh
->Programs
);
250 * Set ptr to point to sh.
251 * If ptr is pointing to another shader, decrement its refcount (and delete
252 * if refcount hits zero).
253 * Then set ptr to point to sh, incrementing its refcount.
255 /* XXX this could be static */
257 _mesa_reference_shader(GLcontext
*ctx
, struct gl_shader
**ptr
,
258 struct gl_shader
*sh
)
266 /* Unreference the old shader */
267 GLboolean deleteFlag
= GL_FALSE
;
268 struct gl_shader
*old
= *ptr
;
270 ASSERT(old
->RefCount
> 0);
272 /*printf("SHADER DECR %p (%d) to %d\n",
273 (void*) old, old->Name, old->RefCount);*/
274 deleteFlag
= (old
->RefCount
== 0);
277 _mesa_HashRemove(ctx
->Shared
->ShaderObjects
, old
->Name
);
278 _mesa_free_shader(ctx
, old
);
288 /*printf("SHADER INCR %p (%d) to %d\n",
289 (void*) sh, sh->Name, sh->RefCount);*/
296 * Lookup a GLSL shader object.
299 _mesa_lookup_shader(GLcontext
*ctx
, GLuint name
)
302 struct gl_shader
*sh
= (struct gl_shader
*)
303 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
304 /* Note that both gl_shader and gl_shader_program objects are kept
305 * in the same hash table. Check the object's type to be sure it's
306 * what we're expecting.
308 if (sh
&& sh
->Type
== GL_SHADER_PROGRAM_MESA
) {
318 * Initialize context's shader state.
321 _mesa_init_shader_state(GLcontext
* ctx
)
323 /* Device drivers may override these to control what kind of instructions
324 * are generated by the GLSL compiler.
326 ctx
->Shader
.EmitHighLevelInstructions
= GL_TRUE
;
327 ctx
->Shader
.EmitCondCodes
= GL_FALSE
;/*GL_TRUE;*/ /* XXX probably want GL_FALSE... */
328 ctx
->Shader
.EmitComments
= GL_FALSE
;
333 * Free the per-context shader-related state.
336 _mesa_free_shader_state(GLcontext
*ctx
)
338 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, NULL
);
343 * Copy string from <src> to <dst>, up to maxLength characters, returning
344 * length of <dst> in <length>.
345 * \param src the strings source
346 * \param maxLength max chars to copy
347 * \param length returns number of chars copied
348 * \param dst the string destination
351 copy_string(GLchar
*dst
, GLsizei maxLength
, GLsizei
*length
, const GLchar
*src
)
354 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
364 * Called via ctx->Driver.AttachShader()
367 _mesa_attach_shader(GLcontext
*ctx
, GLuint program
, GLuint shader
)
369 struct gl_shader_program
*shProg
370 = _mesa_lookup_shader_program(ctx
, program
);
371 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
375 if (!shProg
|| !sh
) {
376 _mesa_error(ctx
, GL_INVALID_VALUE
,
377 "glAttachShader(bad program or shader name)");
381 n
= shProg
->NumShaders
;
383 for (i
= 0; i
< n
; i
++) {
384 if (shProg
->Shaders
[i
] == sh
) {
385 /* already attached */
391 shProg
->Shaders
= (struct gl_shader
**)
392 _mesa_realloc(shProg
->Shaders
,
393 n
* sizeof(struct gl_shader
*),
394 (n
+ 1) * sizeof(struct gl_shader
*));
395 if (!shProg
->Shaders
) {
396 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
401 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
402 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
403 shProg
->NumShaders
++;
408 _mesa_get_attrib_location(GLcontext
*ctx
, GLuint program
,
411 struct gl_shader_program
*shProg
412 = _mesa_lookup_shader_program(ctx
, program
);
415 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetAttribLocation");
419 if (!shProg
->LinkStatus
) {
420 _mesa_error(ctx
, GL_INVALID_OPERATION
,
421 "glGetAttribLocation(program not linked)");
428 if (shProg
->Attributes
) {
429 GLint i
= _mesa_lookup_parameter_index(shProg
->Attributes
, -1, name
);
431 return shProg
->Attributes
->Parameters
[i
].StateIndexes
[0];
439 _mesa_bind_attrib_location(GLcontext
*ctx
, GLuint program
, GLuint index
,
442 struct gl_shader_program
*shProg
443 = _mesa_lookup_shader_program(ctx
, program
);
444 const GLint size
= -1; /* unknown size */
448 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBindAttribLocation(program)");
455 if (strncmp(name
, "gl_", 3) == 0) {
456 _mesa_error(ctx
, GL_INVALID_OPERATION
,
457 "glBindAttribLocation(illegal name)");
461 if (shProg
->LinkStatus
) {
462 /* get current index/location for the attribute */
463 oldIndex
= _mesa_get_attrib_location(ctx
, program
, name
);
469 /* this will replace the current value if it's already in the list */
470 i
= _mesa_add_attribute(shProg
->Attributes
, name
, size
, index
);
472 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glBindAttribLocation");
475 if (shProg
->VertexProgram
&& oldIndex
>= 0 && oldIndex
!= index
) {
476 /* If the index changed, need to search/replace references to that attribute
477 * in the vertex program.
479 _slang_remap_attribute(&shProg
->VertexProgram
->Base
, oldIndex
, index
);
485 _mesa_create_shader(GLcontext
*ctx
, GLenum type
)
487 struct gl_shader
*sh
;
490 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
493 case GL_FRAGMENT_SHADER
:
494 case GL_VERTEX_SHADER
:
495 sh
= _mesa_new_shader(ctx
, name
, type
);
498 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(type)");
502 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, sh
);
509 _mesa_create_program(GLcontext
*ctx
)
512 struct gl_shader_program
*shProg
;
514 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
515 shProg
= _mesa_new_shader_program(ctx
, name
);
517 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, shProg
);
519 assert(shProg
->RefCount
== 1);
526 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
530 _mesa_delete_program2(GLcontext
*ctx
, GLuint name
)
533 * NOTE: deleting shaders/programs works a bit differently than
534 * texture objects (and buffer objects, etc). Shader/program
535 * handles/IDs exist in the hash table until the object is really
536 * deleted (refcount==0). With texture objects, the handle/ID is
537 * removed from the hash table in glDeleteTextures() while the tex
538 * object itself might linger until its refcount goes to zero.
540 struct gl_shader_program
*shProg
;
542 shProg
= _mesa_lookup_shader_program(ctx
, name
);
544 _mesa_error(ctx
, GL_INVALID_VALUE
, "glDeleteProgram(name)");
548 shProg
->DeletePending
= GL_TRUE
;
550 /* effectively, decr shProg's refcount */
551 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
556 _mesa_delete_shader(GLcontext
*ctx
, GLuint shader
)
558 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
563 sh
->DeletePending
= GL_TRUE
;
565 /* effectively, decr sh's refcount */
566 _mesa_reference_shader(ctx
, &sh
, NULL
);
571 _mesa_detach_shader(GLcontext
*ctx
, GLuint program
, GLuint shader
)
573 struct gl_shader_program
*shProg
574 = _mesa_lookup_shader_program(ctx
, program
);
579 _mesa_error(ctx
, GL_INVALID_VALUE
,
580 "glDetachShader(bad program or shader name)");
584 n
= shProg
->NumShaders
;
586 for (i
= 0; i
< n
; i
++) {
587 if (shProg
->Shaders
[i
]->Name
== shader
) {
589 struct gl_shader
**newList
;
592 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
594 /* alloc new, smaller array */
595 newList
= (struct gl_shader
**)
596 _mesa_malloc((n
- 1) * sizeof(struct gl_shader
*));
598 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
601 for (j
= 0; j
< i
; j
++) {
602 newList
[j
] = shProg
->Shaders
[j
];
605 newList
[j
++] = shProg
->Shaders
[i
];
606 _mesa_free(shProg
->Shaders
);
608 shProg
->Shaders
= newList
;
609 shProg
->NumShaders
= n
- 1;
614 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
615 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
616 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
617 assert(shProg
->Shaders
[j
]->RefCount
> 0);
627 _mesa_error(ctx
, GL_INVALID_VALUE
,
628 "glDetachShader(shader not found)");
633 _mesa_get_active_attrib(GLcontext
*ctx
, GLuint program
, GLuint index
,
634 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
635 GLenum
*type
, GLchar
*nameOut
)
637 static const GLenum vec_types
[] = {
638 GL_FLOAT
, GL_FLOAT_VEC2
, GL_FLOAT_VEC3
, GL_FLOAT_VEC4
640 struct gl_shader_program
*shProg
641 = _mesa_lookup_shader_program(ctx
, program
);
645 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveAttrib");
649 if (!shProg
->Attributes
|| index
>= shProg
->Attributes
->NumParameters
) {
650 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveAttrib(index)");
654 copy_string(nameOut
, maxLength
, length
,
655 shProg
->Attributes
->Parameters
[index
].Name
);
656 sz
= shProg
->Attributes
->Parameters
[index
].Size
;
660 *type
= vec_types
[sz
]; /* XXX this is a temporary hack */
665 * Called via ctx->Driver.GetActiveUniform().
668 _mesa_get_active_uniform(GLcontext
*ctx
, GLuint program
, GLuint index
,
669 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
670 GLenum
*type
, GLchar
*nameOut
)
672 const struct gl_shader_program
*shProg
673 = _mesa_lookup_shader_program(ctx
, program
);
674 const struct gl_program
*prog
;
678 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveUniform");
682 if (!shProg
->Uniforms
|| index
>= shProg
->Uniforms
->NumUniforms
) {
683 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveUniform(index)");
687 progPos
= shProg
->Uniforms
->Uniforms
[index
].VertPos
;
689 prog
= &shProg
->VertexProgram
->Base
;
692 progPos
= shProg
->Uniforms
->Uniforms
[index
].FragPos
;
694 prog
= &shProg
->FragmentProgram
->Base
;
698 if (!prog
|| progPos
< 0)
699 return; /* should never happen */
702 copy_string(nameOut
, maxLength
, length
,
703 prog
->Parameters
->Parameters
[progPos
].Name
);
705 *size
= prog
->Parameters
->Parameters
[progPos
].Size
;
708 *type
= prog
->Parameters
->Parameters
[progPos
].DataType
;
713 * Called via ctx->Driver.GetAttachedShaders().
716 _mesa_get_attached_shaders(GLcontext
*ctx
, GLuint program
, GLsizei maxCount
,
717 GLsizei
*count
, GLuint
*obj
)
719 struct gl_shader_program
*shProg
720 = _mesa_lookup_shader_program(ctx
, program
);
723 for (i
= 0; i
< maxCount
&& i
< shProg
->NumShaders
; i
++) {
724 obj
[i
] = shProg
->Shaders
[i
]->Name
;
730 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetAttachedShaders");
736 _mesa_get_handle(GLcontext
*ctx
, GLenum pname
)
739 GET_CURRENT_CONTEXT(ctx
);
742 case GL_PROGRAM_OBJECT_ARB
:
744 struct gl2_program_intf
**pro
= ctx
->Shader
.CurrentProgram
;
747 return (**pro
)._container
._generic
.
748 GetName((struct gl2_generic_intf
**) (pro
));
752 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
760 _mesa_get_programiv(GLcontext
*ctx
, GLuint program
,
761 GLenum pname
, GLint
*params
)
763 struct gl_shader_program
*shProg
764 = _mesa_lookup_shader_program(ctx
, program
);
767 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
772 case GL_DELETE_STATUS
:
773 *params
= shProg
->DeletePending
;
776 *params
= shProg
->LinkStatus
;
778 case GL_VALIDATE_STATUS
:
779 *params
= shProg
->Validated
;
781 case GL_INFO_LOG_LENGTH
:
782 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
784 case GL_ATTACHED_SHADERS
:
785 *params
= shProg
->NumShaders
;
787 case GL_ACTIVE_ATTRIBUTES
:
788 *params
= shProg
->Attributes
? shProg
->Attributes
->NumParameters
: 0;
790 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
791 *params
= _mesa_longest_parameter_name(shProg
->Attributes
,
794 case GL_ACTIVE_UNIFORMS
:
795 *params
= shProg
->Uniforms
? shProg
->Uniforms
->NumUniforms
: 0;
797 case GL_ACTIVE_UNIFORM_MAX_LENGTH
:
798 *params
= _mesa_longest_uniform_name(shProg
->Uniforms
);
800 (*params
)++; /* add one for terminating zero */
803 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname)");
810 _mesa_get_shaderiv(GLcontext
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
812 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
815 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderiv(shader)");
821 *params
= shader
->Type
;
823 case GL_DELETE_STATUS
:
824 *params
= shader
->DeletePending
;
826 case GL_COMPILE_STATUS
:
827 *params
= shader
->CompileStatus
;
829 case GL_INFO_LOG_LENGTH
:
830 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
832 case GL_SHADER_SOURCE_LENGTH
:
833 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
836 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
843 _mesa_get_program_info_log(GLcontext
*ctx
, GLuint program
, GLsizei bufSize
,
844 GLsizei
*length
, GLchar
*infoLog
)
846 struct gl_shader_program
*shProg
847 = _mesa_lookup_shader_program(ctx
, program
);
849 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
852 copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
857 _mesa_get_shader_info_log(GLcontext
*ctx
, GLuint shader
, GLsizei bufSize
,
858 GLsizei
*length
, GLchar
*infoLog
)
860 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
862 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
865 copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
870 * Called via ctx->Driver.GetShaderSource().
873 _mesa_get_shader_source(GLcontext
*ctx
, GLuint shader
, GLsizei maxLength
,
874 GLsizei
*length
, GLchar
*sourceOut
)
876 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
878 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderSource(shader)");
881 copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
886 * Called via ctx->Driver.GetUniformfv().
889 _mesa_get_uniformfv(GLcontext
*ctx
, GLuint program
, GLint location
,
892 struct gl_shader_program
*shProg
893 = _mesa_lookup_shader_program(ctx
, program
);
895 if (location
< shProg
->Uniforms
->NumUniforms
) {
897 const struct gl_program
*prog
= NULL
;
899 progPos
= shProg
->Uniforms
->Uniforms
[location
].VertPos
;
901 prog
= &shProg
->VertexProgram
->Base
;
904 progPos
= shProg
->Uniforms
->Uniforms
[location
].FragPos
;
906 prog
= &shProg
->FragmentProgram
->Base
;
912 for (i
= 0; i
< prog
->Parameters
->Parameters
[progPos
].Size
; i
++) {
913 params
[i
] = prog
->Parameters
->ParameterValues
[progPos
][i
];
918 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetUniformfv(location)");
922 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetUniformfv(program)");
928 * Called via ctx->Driver.GetUniformLocation().
931 _mesa_get_uniform_location(GLcontext
*ctx
, GLuint program
, const GLchar
*name
)
933 struct gl_shader_program
*shProg
934 = _mesa_lookup_shader_program(ctx
, program
);
938 return _mesa_lookup_uniform(shProg
->Uniforms
, name
);
943 _mesa_is_program(GLcontext
*ctx
, GLuint name
)
945 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
946 return shProg
? GL_TRUE
: GL_FALSE
;
951 _mesa_is_shader(GLcontext
*ctx
, GLuint name
)
953 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
954 return shader
? GL_TRUE
: GL_FALSE
;
960 * Called via ctx->Driver.ShaderSource()
963 _mesa_shader_source(GLcontext
*ctx
, GLuint shader
, const GLchar
*source
)
965 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
967 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSource(shaderObj)");
971 /* free old shader source string and install new one */
973 _mesa_free((void *) sh
->Source
);
976 sh
->CompileStatus
= GL_FALSE
;
981 * Called via ctx->Driver.CompileShader()
984 _mesa_compile_shader(GLcontext
*ctx
, GLuint shaderObj
)
986 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shaderObj
);
989 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCompileShader(shaderObj)");
993 sh
->CompileStatus
= _slang_compile(ctx
, sh
);
998 * Called via ctx->Driver.LinkProgram()
1001 _mesa_link_program(GLcontext
*ctx
, GLuint program
)
1003 struct gl_shader_program
*shProg
;
1005 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1007 _mesa_error(ctx
, GL_INVALID_VALUE
, "glLinkProgram(program)");
1011 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1013 _slang_link(ctx
, program
, shProg
);
1018 * Called via ctx->Driver.UseProgram()
1021 _mesa_use_program(GLcontext
*ctx
, GLuint program
)
1023 struct gl_shader_program
*shProg
;
1025 if (ctx
->Shader
.CurrentProgram
&&
1026 ctx
->Shader
.CurrentProgram
->Name
== program
) {
1031 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1034 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1036 _mesa_error(ctx
, GL_INVALID_VALUE
,
1037 "glUseProgramObjectARB(programObj)");
1045 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, shProg
);
1051 * Update the vertex and fragment program's TexturesUsed arrays.
1054 update_textures_used(struct gl_program
*prog
)
1058 memset(prog
->TexturesUsed
, 0, sizeof(prog
->TexturesUsed
));
1060 for (s
= 0; s
< MAX_SAMPLERS
; s
++) {
1061 if (prog
->SamplersUsed
& (1 << s
)) {
1062 GLuint u
= prog
->SamplerUnits
[s
];
1063 GLuint t
= prog
->SamplerTargets
[s
];
1064 assert(u
< MAX_TEXTURE_IMAGE_UNITS
);
1065 prog
->TexturesUsed
[u
] |= (1 << t
);
1072 * Set the value of a program's uniform variable.
1073 * \param program the program whose uniform to update
1074 * \param location the location/index of the uniform
1075 * \param type the datatype of the uniform
1076 * \param count the number of uniforms to set
1077 * \param elems number of elements per uniform
1078 * \param values the new values
1081 set_program_uniform(GLcontext
*ctx
, struct gl_program
*program
, GLint location
,
1082 GLenum type
, GLint count
, GLint elems
, const void *values
)
1084 if (program
->Parameters
->Parameters
[location
].Type
== PROGRAM_SAMPLER
) {
1085 /* This controls which texture unit which is used by a sampler */
1086 GLuint texUnit
, sampler
;
1088 /* data type for setting samplers must be int */
1089 if (type
!= GL_INT
|| count
!= 1) {
1090 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1091 "glUniform(only glUniform1i can be used "
1092 "to set sampler uniforms)");
1096 sampler
= (GLuint
) program
->Parameters
->ParameterValues
[location
][0];
1097 texUnit
= ((GLuint
*) values
)[0];
1099 /* check that the sampler (tex unit index) is legal */
1100 if (texUnit
>= ctx
->Const
.MaxTextureImageUnits
) {
1101 _mesa_error(ctx
, GL_INVALID_VALUE
,
1102 "glUniform1(invalid sampler/tex unit index)");
1106 /* This maps a sampler to a texture unit: */
1107 program
->SamplerUnits
[sampler
] = texUnit
;
1108 update_textures_used(program
);
1110 FLUSH_VERTICES(ctx
, _NEW_TEXTURE
);
1113 /* ordinary uniform variable */
1116 if (count
* elems
> program
->Parameters
->Parameters
[location
].Size
) {
1117 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(count too large)");
1121 for (k
= 0; k
< count
; k
++) {
1122 GLfloat
*uniformVal
= program
->Parameters
->ParameterValues
[location
+ k
];
1123 if (type
== GL_INT
||
1124 type
== GL_INT_VEC2
||
1125 type
== GL_INT_VEC3
||
1126 type
== GL_INT_VEC4
) {
1127 const GLint
*iValues
= ((const GLint
*) values
) + k
* elems
;
1128 for (i
= 0; i
< elems
; i
++) {
1129 uniformVal
[i
] = (GLfloat
) iValues
[i
];
1133 const GLfloat
*fValues
= ((const GLfloat
*) values
) + k
* elems
;
1134 for (i
= 0; i
< elems
; i
++) {
1135 uniformVal
[i
] = fValues
[i
];
1144 * Called via ctx->Driver.Uniform().
1147 _mesa_uniform(GLcontext
*ctx
, GLint location
, GLsizei count
,
1148 const GLvoid
*values
, GLenum type
)
1150 struct gl_shader_program
*shProg
= ctx
->Shader
.CurrentProgram
;
1153 if (!shProg
|| !shProg
->LinkStatus
) {
1154 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(program not linked)");
1159 return; /* The standard specifies this as a no-op */
1162 if (location
< 0 || location
>= (GLint
) shProg
->Uniforms
->NumUniforms
) {
1163 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniform(location)");
1168 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniform(count < 0)");
1190 _mesa_problem(ctx
, "Invalid type in _mesa_uniform");
1194 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1196 /* A uniform var may be used by both a vertex shader and a fragment
1197 * shader. We may need to update one or both shader's uniform here:
1199 if (shProg
->VertexProgram
) {
1200 GLint loc
= shProg
->Uniforms
->Uniforms
[location
].VertPos
;
1202 set_program_uniform(ctx
, &shProg
->VertexProgram
->Base
,
1203 loc
, type
, count
, elems
, values
);
1207 if (shProg
->FragmentProgram
) {
1208 GLint loc
= shProg
->Uniforms
->Uniforms
[location
].FragPos
;
1210 set_program_uniform(ctx
, &shProg
->FragmentProgram
->Base
,
1211 loc
, type
, count
, elems
, values
);
1218 set_program_uniform_matrix(GLcontext
*ctx
, struct gl_program
*program
,
1219 GLuint location
, GLuint rows
, GLuint cols
,
1220 GLboolean transpose
, const GLfloat
*values
)
1223 * Note: the _columns_ of a matrix are stored in program registers, not
1226 /* XXXX need to test 3x3 and 2x2 matrices... */
1229 for (col
= 0; col
< cols
; col
++) {
1230 GLfloat
*v
= program
->Parameters
->ParameterValues
[location
+ col
];
1231 for (row
= 0; row
< rows
; row
++) {
1232 v
[row
] = values
[row
* cols
+ col
];
1238 for (col
= 0; col
< cols
; col
++) {
1239 GLfloat
*v
= program
->Parameters
->ParameterValues
[location
+ col
];
1240 for (row
= 0; row
< rows
; row
++) {
1241 v
[row
] = values
[col
* rows
+ row
];
1249 * Called by ctx->Driver.UniformMatrix().
1252 _mesa_uniform_matrix(GLcontext
*ctx
, GLint cols
, GLint rows
,
1253 GLenum matrixType
, GLint location
, GLsizei count
,
1254 GLboolean transpose
, const GLfloat
*values
)
1256 struct gl_shader_program
*shProg
= ctx
->Shader
.CurrentProgram
;
1258 if (!shProg
|| !shProg
->LinkStatus
) {
1259 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1260 "glUniformMatrix(program not linked)");
1265 return; /* The standard specifies this as a no-op */
1267 if (location
< 0 || location
>= shProg
->Uniforms
->NumUniforms
) {
1268 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniformMatrix(location)");
1271 if (values
== NULL
) {
1272 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniformMatrix");
1276 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1278 if (shProg
->VertexProgram
) {
1279 GLint loc
= shProg
->Uniforms
->Uniforms
[location
].VertPos
;
1281 set_program_uniform_matrix(ctx
, &shProg
->VertexProgram
->Base
,
1282 loc
, rows
, cols
, transpose
, values
);
1286 if (shProg
->FragmentProgram
) {
1287 GLint loc
= shProg
->Uniforms
->Uniforms
[location
].FragPos
;
1289 set_program_uniform_matrix(ctx
, &shProg
->FragmentProgram
->Base
,
1290 loc
, rows
, cols
, transpose
, values
);
1297 _mesa_validate_program(GLcontext
*ctx
, GLuint program
)
1299 struct gl_shader_program
*shProg
;
1300 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1302 _mesa_error(ctx
, GL_INVALID_VALUE
, "glValidateProgram(program)");
1306 shProg
->Validated
= GL_TRUE
;
1308 /* From the GL spec:
1309 any two active samplers in the current program object are of
1310 different types, but refer to the same texture image unit,
1312 any active sampler in the current program object refers to a texture
1313 image unit where fixed-function fragment processing accesses a
1314 texture target that does not match the sampler type, or
1316 the sum of the number of active samplers in the program and the
1317 number of texture image units enabled for fixed-function fragment
1318 processing exceeds the combined limit on the total number of texture
1319 image units allowed.
1325 * Plug in Mesa's GLSL functions into the device driver function table.
1328 _mesa_init_glsl_driver_functions(struct dd_function_table
*driver
)
1330 driver
->AttachShader
= _mesa_attach_shader
;
1331 driver
->BindAttribLocation
= _mesa_bind_attrib_location
;
1332 driver
->CompileShader
= _mesa_compile_shader
;
1333 driver
->CreateProgram
= _mesa_create_program
;
1334 driver
->CreateShader
= _mesa_create_shader
;
1335 driver
->DeleteProgram2
= _mesa_delete_program2
;
1336 driver
->DeleteShader
= _mesa_delete_shader
;
1337 driver
->DetachShader
= _mesa_detach_shader
;
1338 driver
->GetActiveAttrib
= _mesa_get_active_attrib
;
1339 driver
->GetActiveUniform
= _mesa_get_active_uniform
;
1340 driver
->GetAttachedShaders
= _mesa_get_attached_shaders
;
1341 driver
->GetAttribLocation
= _mesa_get_attrib_location
;
1342 driver
->GetHandle
= _mesa_get_handle
;
1343 driver
->GetProgramiv
= _mesa_get_programiv
;
1344 driver
->GetProgramInfoLog
= _mesa_get_program_info_log
;
1345 driver
->GetShaderiv
= _mesa_get_shaderiv
;
1346 driver
->GetShaderInfoLog
= _mesa_get_shader_info_log
;
1347 driver
->GetShaderSource
= _mesa_get_shader_source
;
1348 driver
->GetUniformfv
= _mesa_get_uniformfv
;
1349 driver
->GetUniformLocation
= _mesa_get_uniform_location
;
1350 driver
->IsProgram
= _mesa_is_program
;
1351 driver
->IsShader
= _mesa_is_shader
;
1352 driver
->LinkProgram
= _mesa_link_program
;
1353 driver
->ShaderSource
= _mesa_shader_source
;
1354 driver
->Uniform
= _mesa_uniform
;
1355 driver
->UniformMatrix
= _mesa_uniform_matrix
;
1356 driver
->UseProgram
= _mesa_use_program
;
1357 driver
->ValidateProgram
= _mesa_validate_program
;