2 * Mesa 3-D graphics library
5 * Copyright (C) 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.
36 #include "prog_instruction.h"
37 #include "prog_parameter.h"
38 #include "prog_print.h"
39 #include "prog_statevars.h"
40 #include "shader_api.h"
41 #include "slang_link.h"
47 link_varying_vars(struct gl_shader_program
*shProg
, struct gl_program
*prog
)
49 GLuint
*map
, i
, firstVarying
, newFile
;
50 GLbitfield varsWritten
, varsRead
;
52 map
= (GLuint
*) malloc(prog
->Varying
->NumParameters
* sizeof(GLuint
));
56 for (i
= 0; i
< prog
->Varying
->NumParameters
; i
++) {
57 /* see if this varying is in the linked varying list */
58 const struct gl_program_parameter
*var
59 = prog
->Varying
->Parameters
+ i
;
61 GLint j
= _mesa_lookup_parameter_index(shProg
->Varying
, -1, var
->Name
);
63 /* already in list, check size */
64 if (var
->Size
!= shProg
->Varying
->Parameters
[j
].Size
) {
70 /* not already in linked list */
71 j
= _mesa_add_varying(shProg
->Varying
, var
->Name
, var
->Size
);
79 /* Varying variables are treated like other vertex program outputs
80 * (and like other fragment program inputs). The position of the
81 * first varying differs for vertex/fragment programs...
82 * Also, replace File=PROGRAM_VARYING with File=PROGRAM_INPUT/OUTPUT.
84 if (prog
->Target
== GL_VERTEX_PROGRAM_ARB
) {
85 firstVarying
= VERT_RESULT_VAR0
;
86 newFile
= PROGRAM_OUTPUT
;
89 assert(prog
->Target
== GL_FRAGMENT_PROGRAM_ARB
);
90 firstVarying
= FRAG_ATTRIB_VAR0
;
91 newFile
= PROGRAM_INPUT
;
94 /* keep track of which varying vars we read and write */
95 varsWritten
= varsRead
= 0x0;
97 /* OK, now scan the program/shader instructions looking for varying vars,
98 * replacing the old index with the new index.
100 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
101 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
104 if (inst
->DstReg
.File
== PROGRAM_VARYING
) {
105 inst
->DstReg
.File
= newFile
;
106 inst
->DstReg
.Index
= map
[ inst
->DstReg
.Index
] + firstVarying
;
107 varsWritten
|= (1 << inst
->DstReg
.Index
);
110 for (j
= 0; j
< 3; j
++) {
111 if (inst
->SrcReg
[j
].File
== PROGRAM_VARYING
) {
112 inst
->SrcReg
[j
].File
= newFile
;
113 inst
->SrcReg
[j
].Index
= map
[ inst
->SrcReg
[j
].Index
] + firstVarying
;
114 varsRead
|= (1 << inst
->SrcReg
[j
].Index
);
117 /* XXX update program OutputsWritten, InputsRead */
120 if (prog
->Target
== GL_VERTEX_PROGRAM_ARB
) {
121 prog
->OutputsWritten
|= varsWritten
;
124 assert(prog
->Target
== GL_FRAGMENT_PROGRAM_ARB
);
125 prog
->InputsRead
|= varsRead
;
136 is_uniform(GLuint file
)
138 return (file
== PROGRAM_ENV_PARAM
||
139 file
== PROGRAM_STATE_VAR
||
140 file
== PROGRAM_NAMED_PARAM
||
141 file
== PROGRAM_CONSTANT
||
142 file
== PROGRAM_SAMPLER
||
143 file
== PROGRAM_UNIFORM
);
148 link_uniform_vars(struct gl_shader_program
*shProg
, struct gl_program
*prog
)
153 printf("================ pre link uniforms ===============\n");
154 _mesa_print_parameter_list(shProg
->Uniforms
);
157 map
= (GLuint
*) malloc(prog
->Parameters
->NumParameters
* sizeof(GLuint
));
161 for (i
= 0; i
< prog
->Parameters
->NumParameters
; /* incr below*/) {
162 /* see if this uniform is in the linked uniform list */
163 const struct gl_program_parameter
*p
= prog
->Parameters
->Parameters
+ i
;
164 const GLfloat
*pVals
= prog
->Parameters
->ParameterValues
[i
];
169 assert(is_uniform(p
->Type
));
172 j
= _mesa_lookup_parameter_index(shProg
->Uniforms
, -1, p
->Name
);
176 ASSERT(p
->Type
== PROGRAM_CONSTANT
);
177 if (_mesa_lookup_parameter_constant(shProg
->Uniforms
, pVals
,
178 p
->Size
, &j
, NULL
)) {
187 /* already in list, check size XXX check this */
189 assert(p
->Size
== shProg
->Uniforms
->Parameters
[j
].Size
);
193 /* not already in linked list */
195 case PROGRAM_ENV_PARAM
:
196 j
= _mesa_add_named_parameter(shProg
->Uniforms
, p
->Name
, pVals
);
198 case PROGRAM_CONSTANT
:
199 j
= _mesa_add_named_constant(shProg
->Uniforms
, p
->Name
, pVals
, p
->Size
);
201 case PROGRAM_STATE_VAR
:
202 j
= _mesa_add_state_reference(shProg
->Uniforms
, p
->StateIndexes
);
204 case PROGRAM_UNIFORM
:
205 j
= _mesa_add_uniform(shProg
->Uniforms
, p
->Name
, p
->Size
);
207 case PROGRAM_SAMPLER
:
208 j
= _mesa_add_sampler(shProg
->Uniforms
, p
->Name
);
211 _mesa_problem(NULL
, "bad parameter type in link_uniform_vars()");
229 printf("================ post link uniforms ===============\n");
230 _mesa_print_parameter_list(shProg
->Uniforms
);
236 for (i
= 0; i
< prog
->Parameters
->NumParameters
; i
++) {
237 printf("map[%d] = %d\n", i
, map
[i
]);
239 _mesa_print_parameter_list(shProg
->Uniforms
);
243 /* OK, now scan the program/shader instructions looking for uniform vars,
244 * replacing the old index with the new index.
246 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
247 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
250 if (is_uniform(inst
->DstReg
.File
)) {
251 inst
->DstReg
.Index
= map
[ inst
->DstReg
.Index
];
254 for (j
= 0; j
< 3; j
++) {
255 if (is_uniform(inst
->SrcReg
[j
].File
)) {
256 inst
->SrcReg
[j
].Index
= map
[ inst
->SrcReg
[j
].Index
];
260 if (inst
->Opcode
== OPCODE_TEX
||
261 inst
->Opcode
== OPCODE_TXB
||
262 inst
->Opcode
== OPCODE_TXP
) {
264 printf("====== remap sampler from %d to %d\n",
265 inst->Sampler, map[ inst->Sampler ]);
267 inst
->Sampler
= map
[ inst
->Sampler
];
278 * Resolve binding of generic vertex attributes.
279 * For example, if the vertex shader declared "attribute vec4 foobar" we'll
280 * allocate a generic vertex attribute for "foobar" and plug that value into
281 * the vertex program instructions.
284 _slang_resolve_attributes(struct gl_shader_program
*shProg
,
285 struct gl_program
*prog
)
288 GLbitfield usedAttributes
;
289 GLint size
= 4; /* XXX fix */
291 assert(prog
->Target
== GL_VERTEX_PROGRAM_ARB
);
293 /* Build a bitmask indicating which attribute indexes have been
294 * explicitly bound by the user with glBindAttributeLocation().
296 usedAttributes
= 0x0;
297 for (i
= 0; i
< shProg
->Attributes
->NumParameters
; i
++) {
298 GLint attr
= shProg
->Attributes
->Parameters
[i
].StateIndexes
[0];
299 usedAttributes
|= attr
;
302 if (!shProg
->Attributes
)
303 shProg
->Attributes
= _mesa_new_parameter_list();
306 * Scan program for generic attribute references
308 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
309 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
310 for (j
= 0; j
< 3; j
++) {
311 if (inst
->SrcReg
[j
].File
== PROGRAM_INPUT
&&
312 inst
->SrcReg
[j
].Index
>= VERT_ATTRIB_GENERIC0
) {
313 /* this is a generic attrib */
314 const GLint k
= inst
->SrcReg
[j
].Index
- VERT_ATTRIB_GENERIC0
;
315 const char *name
= prog
->Attributes
->Parameters
[k
].Name
;
316 /* See if this attrib name is in the program's attribute list
317 * (i.e. was bound by the user).
319 GLint index
= _mesa_lookup_parameter_index(shProg
->Attributes
,
323 /* found, user must have specified a binding */
324 attr
= shProg
->Attributes
->Parameters
[index
].StateIndexes
[0];
327 /* Not found, choose our own attribute number.
328 * Start at 1 since generic attribute 0 always aliases
331 for (attr
= 1; attr
< MAX_VERTEX_ATTRIBS
; attr
++) {
332 if (((1 << attr
) & usedAttributes
) == 0)
335 if (attr
== MAX_VERTEX_ATTRIBS
) {
336 /* too many! XXX record error log */
339 _mesa_add_attribute(shProg
->Attributes
, name
, size
, attr
);
342 inst
->SrcReg
[j
].Index
= VERT_ATTRIB_GENERIC0
+ attr
;
351 * Scan program instructions to update the program's InputsRead and
352 * OutputsWritten fields.
355 _slang_update_inputs_outputs(struct gl_program
*prog
)
359 prog
->InputsRead
= 0x0;
360 prog
->OutputsWritten
= 0x0;
362 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
363 const struct prog_instruction
*inst
= prog
->Instructions
+ i
;
364 const GLuint numSrc
= _mesa_num_inst_src_regs(inst
->Opcode
);
365 for (j
= 0; j
< numSrc
; j
++) {
366 if (inst
->SrcReg
[j
].File
== PROGRAM_INPUT
) {
367 prog
->InputsRead
|= 1 << inst
->SrcReg
[j
].Index
;
370 if (inst
->DstReg
.File
== PROGRAM_OUTPUT
) {
371 prog
->OutputsWritten
|= 1 << inst
->DstReg
.Index
;
378 * Scan a vertex program looking for instances of
379 * (PROGRAM_INPUT, VERT_ATTRIB_GENERIC0 + oldAttrib) and replace with
380 * (PROGRAM_INPUT, VERT_ATTRIB_GENERIC0 + newAttrib).
381 * This is used when the user calls glBindAttribLocation on an already linked
385 _slang_remap_attribute(struct gl_program
*prog
, GLuint oldAttrib
, GLuint newAttrib
)
389 assert(prog
->Target
== GL_VERTEX_PROGRAM_ARB
);
391 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
392 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
393 for (j
= 0; j
< 3; j
++) {
394 if (inst
->SrcReg
[j
].File
== PROGRAM_INPUT
) {
395 if (inst
->SrcReg
[j
].Index
== VERT_ATTRIB_GENERIC0
+ oldAttrib
) {
396 inst
->SrcReg
[j
].Index
= VERT_ATTRIB_GENERIC0
+ newAttrib
;
402 _slang_update_inputs_outputs(prog
);
408 * Scan program for texture instructions, lookup sampler/uniform's value
409 * to determine which texture unit to use.
410 * Also, update the program's TexturesUsed[] array.
413 _slang_resolve_samplers(struct gl_shader_program
*shProg
,
414 struct gl_program
*prog
)
418 for (i
= 0; i
< MAX_TEXTURE_IMAGE_UNITS
; i
++)
419 prog
->TexturesUsed
[i
] = 0;
421 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
422 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
423 if (inst
->Opcode
== OPCODE_TEX
||
424 inst
->Opcode
== OPCODE_TXB
||
425 inst
->Opcode
== OPCODE_TXP
) {
426 GLint sampleUnit
= (GLint
) shProg
->Uniforms
->ParameterValues
[inst
->Sampler
][0];
427 assert(sampleUnit
< MAX_TEXTURE_IMAGE_UNITS
);
428 inst
->TexSrcUnit
= sampleUnit
;
430 prog
->TexturesUsed
[inst
->TexSrcUnit
] |= (1 << inst
->TexSrcTarget
);
438 static struct gl_vertex_program
*
439 vertex_program(struct gl_program
*prog
)
441 assert(prog
->Target
== GL_VERTEX_PROGRAM_ARB
);
442 return (struct gl_vertex_program
*) prog
;
447 static struct gl_fragment_program
*
448 fragment_program(struct gl_program
*prog
)
450 assert(prog
->Target
== GL_FRAGMENT_PROGRAM_ARB
);
451 return (struct gl_fragment_program
*) prog
;
456 * Shader linker. Currently:
458 * 1. The last attached vertex shader and fragment shader are linked.
459 * 2. Varying vars in the two shaders are combined so their locations
460 * agree between the vertex and fragment stages. They're treated as
461 * vertex program output attribs and as fragment program input attribs.
462 * 3. Uniform vars (including state references, constants, etc) from the
463 * vertex and fragment shaders are merged into one group. Recall that
464 * GLSL uniforms are shared by all linked shaders.
465 * 4. The vertex and fragment programs are cloned and modified to update
466 * src/dst register references so they use the new, linked uniform/
467 * varying storage locations.
470 _slang_link(GLcontext
*ctx
,
471 GLhandleARB programObj
,
472 struct gl_shader_program
*shProg
)
474 const struct gl_vertex_program
*vertProg
;
475 const struct gl_fragment_program
*fragProg
;
478 _mesa_free_shader_program_data(ctx
, shProg
);
480 shProg
->Uniforms
= _mesa_new_parameter_list();
481 shProg
->Varying
= _mesa_new_parameter_list();
484 * Find attached vertex shader, fragment shader
488 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
489 if (shProg
->Shaders
[i
]->Type
== GL_VERTEX_SHADER
)
490 vertProg
= vertex_program(shProg
->Shaders
[i
]->Programs
[0]);
491 else if (shProg
->Shaders
[i
]->Type
== GL_FRAGMENT_SHADER
)
492 fragProg
= fragment_program(shProg
->Shaders
[i
]->Programs
[0]);
494 _mesa_problem(ctx
, "unexpected shader target in slang_link()");
498 * Make copies of the vertex/fragment programs now since we'll be
499 * changing src/dst registers after merging the uniforms and varying vars.
502 shProg
->VertexProgram
503 = vertex_program(_mesa_clone_program(ctx
, &vertProg
->Base
));
506 shProg
->VertexProgram
= NULL
;
510 shProg
->FragmentProgram
511 = fragment_program(_mesa_clone_program(ctx
, &fragProg
->Base
));
514 shProg
->FragmentProgram
= NULL
;
517 if (shProg
->VertexProgram
)
518 link_varying_vars(shProg
, &shProg
->VertexProgram
->Base
);
519 if (shProg
->FragmentProgram
)
520 link_varying_vars(shProg
, &shProg
->FragmentProgram
->Base
);
522 if (shProg
->VertexProgram
)
523 link_uniform_vars(shProg
, &shProg
->VertexProgram
->Base
);
524 if (shProg
->FragmentProgram
)
525 link_uniform_vars(shProg
, &shProg
->FragmentProgram
->Base
);
527 /* The vertex and fragment programs share a common set of uniforms now */
528 if (shProg
->VertexProgram
) {
529 _mesa_free_parameter_list(shProg
->VertexProgram
->Base
.Parameters
);
530 shProg
->VertexProgram
->Base
.Parameters
= shProg
->Uniforms
;
532 if (shProg
->FragmentProgram
) {
533 _mesa_free_parameter_list(shProg
->FragmentProgram
->Base
.Parameters
);
534 shProg
->FragmentProgram
->Base
.Parameters
= shProg
->Uniforms
;
537 if (shProg
->VertexProgram
) {
538 _slang_resolve_samplers(shProg
, &shProg
->VertexProgram
->Base
);
540 if (shProg
->FragmentProgram
) {
541 _slang_resolve_samplers(shProg
, &shProg
->FragmentProgram
->Base
);
544 if (shProg
->VertexProgram
) {
545 if (!_slang_resolve_attributes(shProg
, &shProg
->VertexProgram
->Base
)) {
547 _mesa_problem(ctx
, "_slang_resolve_attributes() failed");
552 if (shProg
->VertexProgram
) {
553 _slang_update_inputs_outputs(&shProg
->VertexProgram
->Base
);
554 if (!(shProg
->VertexProgram
->Base
.OutputsWritten
& (1 << VERT_RESULT_HPOS
))) {
555 /* the vertex program did not compute a vertex position */
556 if (shProg
->InfoLog
) {
557 _mesa_free(shProg
->InfoLog
);
560 = _mesa_strdup("gl_Position was not written by vertex shader\n");
561 shProg
->LinkStatus
= GL_FALSE
;
565 if (shProg
->FragmentProgram
)
566 _slang_update_inputs_outputs(&shProg
->FragmentProgram
->Base
);
568 if (fragProg
&& shProg
->FragmentProgram
) {
570 printf("************** original fragment program\n");
571 _mesa_print_program(&fragProg
->Base
);
572 _mesa_print_program_parameters(ctx
, &fragProg
->Base
);
575 printf("************** linked fragment prog\n");
576 _mesa_print_program(&shProg
->FragmentProgram
->Base
);
577 _mesa_print_program_parameters(ctx
, &shProg
->FragmentProgram
->Base
);
581 if (vertProg
&& shProg
->VertexProgram
) {
583 printf("************** original vertex program\n");
584 _mesa_print_program(&vertProg
->Base
);
585 _mesa_print_program_parameters(ctx
, &vertProg
->Base
);
588 printf("************** linked vertex prog\n");
589 _mesa_print_program(&shProg
->VertexProgram
->Base
);
590 _mesa_print_program_parameters(ctx
, &shProg
->VertexProgram
->Base
);
594 shProg
->LinkStatus
= (shProg
->VertexProgram
|| shProg
->FragmentProgram
);