2 * Mesa 3-D graphics library
5 * Copyright (C) 2006 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(enum register_file 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
, &swizzle
)) {
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
, (const GLint
*) 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
);
228 printf("================ post link uniforms ===============\n");
229 _mesa_print_parameter_list(shProg
->Uniforms
);
235 for (i
= 0; i
< prog
->Parameters
->NumParameters
; i
++) {
236 printf("map[%d] = %d\n", i
, map
[i
]);
238 _mesa_print_parameter_list(shProg
->Uniforms
);
242 /* OK, now scan the program/shader instructions looking for uniform vars,
243 * replacing the old index with the new index.
245 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
246 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
249 if (is_uniform(inst
->DstReg
.File
)) {
250 inst
->DstReg
.Index
= map
[ inst
->DstReg
.Index
];
253 for (j
= 0; j
< 3; j
++) {
254 if (is_uniform(inst
->SrcReg
[j
].File
)) {
255 inst
->SrcReg
[j
].Index
= map
[ inst
->SrcReg
[j
].Index
];
259 if (inst
->Opcode
== OPCODE_TEX
||
260 inst
->Opcode
== OPCODE_TXB
||
261 inst
->Opcode
== OPCODE_TXP
) {
262 printf("====== remap sampler from %d to %d\n",
263 inst
->Sampler
, map
[ inst
->Sampler
]);
264 inst
->Sampler
= map
[ inst
->Sampler
];
278 _slang_resolve_branches(struct gl_program
*prog
)
284 struct target targets
[500];
285 GLuint numTargets
= 0;
288 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
289 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
290 if (inst
->Opcode
== OPCODE_NOP
&& inst
->Comment
) {
291 targets
[numTargets
].Name
= inst
->Comment
;
292 targets
[numTargets
].Pos
= i
;
297 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
298 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
299 if (inst
->Opcode
== OPCODE_BRA
) {
300 for (j
= 0; j
< numTargets
; j
++) {
301 if (!strcmp(inst
->Comment
, targets
[j
].Name
)) {
302 inst
->BranchTarget
= targets
[j
].Pos
;
306 if (j
== numTargets
) {
315 * Resolve binding of generic vertex attributes.
316 * For example, if the vertex shader declared "attribute vec4 foobar" we'll
317 * allocate a generic vertex attribute for "foobar" and plug that value into
318 * the vertex program instructions.
321 _slang_resolve_attributes(struct gl_shader_program
*shProg
,
322 struct gl_program
*prog
)
325 GLbitfield usedAttributes
;
327 assert(prog
->Target
== GL_VERTEX_PROGRAM_ARB
);
329 /* Build a bitmask indicating which attribute indexes have been
330 * explicitly bound by the user with glBindAttributeLocation().
332 usedAttributes
= 0x0;
333 for (i
= 0; i
< shProg
->Attributes
->NumParameters
; i
++) {
334 GLint attr
= shProg
->Attributes
->Parameters
[i
].StateIndexes
[1];
335 usedAttributes
|= attr
;
338 if (!shProg
->Attributes
)
339 shProg
->Attributes
= _mesa_new_parameter_list();
342 * Scan program for generic attribute references
344 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
345 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
346 for (j
= 0; j
< 3; j
++) {
347 if (inst
->SrcReg
[j
].File
== PROGRAM_INPUT
&&
348 inst
->SrcReg
[j
].Index
>= VERT_ATTRIB_GENERIC0
) {
349 /* this is a generic attrib */
350 const GLint k
= inst
->SrcReg
[j
].Index
- VERT_ATTRIB_GENERIC0
;
351 const char *name
= prog
->Attributes
->Parameters
[k
].Name
;
352 /* See if this attrib name is in the program's attribute list
353 * (i.e. was bound by the user).
355 GLint index
= _mesa_lookup_parameter_index(shProg
->Attributes
,
359 /* found, user must have specified a binding */
360 attr
= shProg
->Attributes
->Parameters
[index
].StateIndexes
[1];
363 /* not found, choose our own attribute number */
364 for (attr
= 0; attr
< MAX_VERTEX_ATTRIBS
; attr
++) {
365 if (((1 << attr
) & usedAttributes
) == 0)
368 if (attr
== MAX_VERTEX_ATTRIBS
) {
369 /* too many! XXX record error log */
372 _mesa_add_attribute(shProg
->Attributes
, name
, attr
);
375 inst
->SrcReg
[j
].Index
= VERT_ATTRIB_GENERIC0
+ attr
;
384 * Scan program instructions to update the program's InputsRead and
385 * OutputsWritten fields.
388 _slang_update_inputs_outputs(struct gl_program
*prog
)
392 prog
->InputsRead
= 0x0;
393 prog
->OutputsWritten
= 0x0;
395 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
396 const struct prog_instruction
*inst
= prog
->Instructions
+ i
;
397 const GLuint numSrc
= _mesa_num_inst_src_regs(inst
->Opcode
);
398 for (j
= 0; j
< numSrc
; j
++) {
399 if (inst
->SrcReg
[j
].File
== PROGRAM_INPUT
) {
400 prog
->InputsRead
|= 1 << inst
->SrcReg
[j
].Index
;
403 if (inst
->DstReg
.File
== PROGRAM_OUTPUT
) {
404 prog
->OutputsWritten
|= 1 << inst
->DstReg
.Index
;
411 * Scan a vertex program looking for instances of
412 * (PROGRAM_INPUT, VERT_ATTRIB_GENERIC0 + oldAttrib) and replace with
413 * (PROGRAM_INPUT, VERT_ATTRIB_GENERIC0 + newAttrib).
414 * This is used when the user calls glBindAttribLocation on an already linked
418 _slang_remap_attribute(struct gl_program
*prog
, GLuint oldAttrib
, GLuint newAttrib
)
422 assert(prog
->Target
== GL_VERTEX_PROGRAM_ARB
);
424 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
425 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
426 for (j
= 0; j
< 3; j
++) {
427 if (inst
->SrcReg
[j
].File
== PROGRAM_INPUT
) {
428 if (inst
->SrcReg
[j
].Index
== VERT_ATTRIB_GENERIC0
+ oldAttrib
) {
429 inst
->SrcReg
[j
].Index
= VERT_ATTRIB_GENERIC0
+ newAttrib
;
435 _slang_update_inputs_outputs(prog
);
441 * Scan program for texture instructions, lookup sampler/uniform's value
442 * to determine which texture unit to use.
443 * Also, update the program's TexturesUsed[] array.
446 _slang_resolve_samplers(struct gl_shader_program
*shProg
,
447 struct gl_program
*prog
)
451 for (i
= 0; i
< MAX_TEXTURE_IMAGE_UNITS
; i
++)
452 prog
->TexturesUsed
[i
] = 0;
454 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
455 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
456 if (inst
->Opcode
== OPCODE_TEX
||
457 inst
->Opcode
== OPCODE_TXB
||
458 inst
->Opcode
== OPCODE_TXP
) {
459 GLint sampleUnit
= (GLint
) shProg
->Uniforms
->ParameterValues
[inst
->Sampler
][0];
460 assert(sampleUnit
< MAX_TEXTURE_IMAGE_UNITS
);
461 inst
->TexSrcUnit
= sampleUnit
;
463 prog
->TexturesUsed
[inst
->TexSrcUnit
] |= (1 << inst
->TexSrcTarget
);
471 static struct gl_vertex_program
*
472 vertex_program(struct gl_program
*prog
)
474 assert(prog
->Target
== GL_VERTEX_PROGRAM_ARB
);
475 return (struct gl_vertex_program
*) prog
;
480 static struct gl_fragment_program
*
481 fragment_program(struct gl_program
*prog
)
483 assert(prog
->Target
== GL_FRAGMENT_PROGRAM_ARB
);
484 return (struct gl_fragment_program
*) prog
;
489 * Shader linker. Currently:
491 * 1. The last attached vertex shader and fragment shader are linked.
492 * 2. Varying vars in the two shaders are combined so their locations
493 * agree between the vertex and fragment stages. They're treated as
494 * vertex program output attribs and as fragment program input attribs.
495 * 3. Uniform vars (including state references, constants, etc) from the
496 * vertex and fragment shaders are merged into one group. Recall that
497 * GLSL uniforms are shared by all linked shaders.
498 * 4. The vertex and fragment programs are cloned and modified to update
499 * src/dst register references so they use the new, linked uniform/
500 * varying storage locations.
503 _slang_link2(GLcontext
*ctx
,
504 GLhandleARB programObj
,
505 struct gl_shader_program
*shProg
)
507 struct gl_vertex_program
*vertProg
;
508 struct gl_fragment_program
*fragProg
;
511 _mesa_free_shader_program_data(ctx
, shProg
);
513 shProg
->Uniforms
= _mesa_new_parameter_list();
514 shProg
->Varying
= _mesa_new_parameter_list();
517 * Find attached vertex shader, fragment shader
521 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
522 if (shProg
->Shaders
[i
]->Type
== GL_VERTEX_SHADER
)
523 vertProg
= vertex_program(shProg
->Shaders
[i
]->Programs
[0]);
524 else if (shProg
->Shaders
[i
]->Type
== GL_FRAGMENT_SHADER
)
525 fragProg
= fragment_program(shProg
->Shaders
[i
]->Programs
[0]);
527 _mesa_problem(ctx
, "unexpected shader target in slang_link2()");
529 if (!vertProg
|| !fragProg
) {
530 /* XXX is it legal to have one but not the other?? */
531 /* XXX record error */
532 shProg
->LinkStatus
= GL_FALSE
;
536 if (!vertProg
->Base
.Varying
|| !fragProg
->Base
.Varying
) {
538 _mesa_problem(ctx
, "vertex/fragment program lacks varying list!");
539 shProg
->LinkStatus
= GL_FALSE
;
544 * Make copies of the vertex/fragment programs now since we'll be
545 * changing src/dst registers after merging the uniforms and varying vars.
547 shProg
->VertexProgram
548 = vertex_program(_mesa_clone_program(ctx
, &vertProg
->Base
));
549 shProg
->FragmentProgram
550 = fragment_program(_mesa_clone_program(ctx
, &fragProg
->Base
));
552 link_varying_vars(shProg
, &shProg
->VertexProgram
->Base
);
553 link_varying_vars(shProg
, &shProg
->FragmentProgram
->Base
);
555 link_uniform_vars(shProg
, &shProg
->VertexProgram
->Base
);
556 link_uniform_vars(shProg
, &shProg
->FragmentProgram
->Base
);
558 /* The vertex and fragment programs share a common set of uniforms now */
559 _mesa_free_parameter_list(shProg
->VertexProgram
->Base
.Parameters
);
560 _mesa_free_parameter_list(shProg
->FragmentProgram
->Base
.Parameters
);
561 shProg
->VertexProgram
->Base
.Parameters
= shProg
->Uniforms
;
562 shProg
->FragmentProgram
->Base
.Parameters
= shProg
->Uniforms
;
564 _slang_resolve_branches(&shProg
->VertexProgram
->Base
);
565 _slang_resolve_branches(&shProg
->FragmentProgram
->Base
);
567 _slang_resolve_samplers(shProg
, &shProg
->VertexProgram
->Base
);
568 _slang_resolve_samplers(shProg
, &shProg
->FragmentProgram
->Base
);
570 _slang_resolve_attributes(shProg
, &shProg
->VertexProgram
->Base
);
572 _slang_update_inputs_outputs(&shProg
->VertexProgram
->Base
);
573 _slang_update_inputs_outputs(&shProg
->FragmentProgram
->Base
);
576 printf("************** original fragment program\n");
577 _mesa_print_program(&fragProg
->Base
);
578 _mesa_print_program_parameters(ctx
, &fragProg
->Base
);
581 printf("************** linked fragment prog\n");
582 _mesa_print_program(&shProg
->FragmentProgram
->Base
);
583 _mesa_print_program_parameters(ctx
, &shProg
->FragmentProgram
->Base
);
586 printf("************** original vertex program\n");
587 _mesa_print_program(&vertProg
->Base
);
588 _mesa_print_program_parameters(ctx
, &fragProg
->Base
);
591 printf("************** linked vertex prog\n");
592 _mesa_print_program(&shProg
->VertexProgram
->Base
);
593 _mesa_print_program_parameters(ctx
, &shProg
->VertexProgram
->Base
);
596 shProg
->LinkStatus
= (shProg
->VertexProgram
&& shProg
->FragmentProgram
);