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
;
326 GLint size
= 4; /* XXX fix */
328 assert(prog
->Target
== GL_VERTEX_PROGRAM_ARB
);
330 /* Build a bitmask indicating which attribute indexes have been
331 * explicitly bound by the user with glBindAttributeLocation().
333 usedAttributes
= 0x0;
334 for (i
= 0; i
< shProg
->Attributes
->NumParameters
; i
++) {
335 GLint attr
= shProg
->Attributes
->Parameters
[i
].StateIndexes
[1];
336 usedAttributes
|= attr
;
339 if (!shProg
->Attributes
)
340 shProg
->Attributes
= _mesa_new_parameter_list();
343 * Scan program for generic attribute references
345 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
346 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
347 for (j
= 0; j
< 3; j
++) {
348 if (inst
->SrcReg
[j
].File
== PROGRAM_INPUT
&&
349 inst
->SrcReg
[j
].Index
>= VERT_ATTRIB_GENERIC0
) {
350 /* this is a generic attrib */
351 const GLint k
= inst
->SrcReg
[j
].Index
- VERT_ATTRIB_GENERIC0
;
352 const char *name
= prog
->Attributes
->Parameters
[k
].Name
;
353 /* See if this attrib name is in the program's attribute list
354 * (i.e. was bound by the user).
356 GLint index
= _mesa_lookup_parameter_index(shProg
->Attributes
,
360 /* found, user must have specified a binding */
361 attr
= shProg
->Attributes
->Parameters
[index
].StateIndexes
[1];
364 /* not found, choose our own attribute number */
365 for (attr
= 0; attr
< MAX_VERTEX_ATTRIBS
; attr
++) {
366 if (((1 << attr
) & usedAttributes
) == 0)
369 if (attr
== MAX_VERTEX_ATTRIBS
) {
370 /* too many! XXX record error log */
373 _mesa_add_attribute(shProg
->Attributes
, name
, size
, attr
);
376 inst
->SrcReg
[j
].Index
= VERT_ATTRIB_GENERIC0
+ attr
;
385 * Scan program instructions to update the program's InputsRead and
386 * OutputsWritten fields.
389 _slang_update_inputs_outputs(struct gl_program
*prog
)
393 prog
->InputsRead
= 0x0;
394 prog
->OutputsWritten
= 0x0;
396 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
397 const struct prog_instruction
*inst
= prog
->Instructions
+ i
;
398 const GLuint numSrc
= _mesa_num_inst_src_regs(inst
->Opcode
);
399 for (j
= 0; j
< numSrc
; j
++) {
400 if (inst
->SrcReg
[j
].File
== PROGRAM_INPUT
) {
401 prog
->InputsRead
|= 1 << inst
->SrcReg
[j
].Index
;
404 if (inst
->DstReg
.File
== PROGRAM_OUTPUT
) {
405 prog
->OutputsWritten
|= 1 << inst
->DstReg
.Index
;
412 * Scan a vertex program looking for instances of
413 * (PROGRAM_INPUT, VERT_ATTRIB_GENERIC0 + oldAttrib) and replace with
414 * (PROGRAM_INPUT, VERT_ATTRIB_GENERIC0 + newAttrib).
415 * This is used when the user calls glBindAttribLocation on an already linked
419 _slang_remap_attribute(struct gl_program
*prog
, GLuint oldAttrib
, GLuint newAttrib
)
423 assert(prog
->Target
== GL_VERTEX_PROGRAM_ARB
);
425 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
426 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
427 for (j
= 0; j
< 3; j
++) {
428 if (inst
->SrcReg
[j
].File
== PROGRAM_INPUT
) {
429 if (inst
->SrcReg
[j
].Index
== VERT_ATTRIB_GENERIC0
+ oldAttrib
) {
430 inst
->SrcReg
[j
].Index
= VERT_ATTRIB_GENERIC0
+ newAttrib
;
436 _slang_update_inputs_outputs(prog
);
442 * Scan program for texture instructions, lookup sampler/uniform's value
443 * to determine which texture unit to use.
444 * Also, update the program's TexturesUsed[] array.
447 _slang_resolve_samplers(struct gl_shader_program
*shProg
,
448 struct gl_program
*prog
)
452 for (i
= 0; i
< MAX_TEXTURE_IMAGE_UNITS
; i
++)
453 prog
->TexturesUsed
[i
] = 0;
455 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
456 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
457 if (inst
->Opcode
== OPCODE_TEX
||
458 inst
->Opcode
== OPCODE_TXB
||
459 inst
->Opcode
== OPCODE_TXP
) {
460 GLint sampleUnit
= (GLint
) shProg
->Uniforms
->ParameterValues
[inst
->Sampler
][0];
461 assert(sampleUnit
< MAX_TEXTURE_IMAGE_UNITS
);
462 inst
->TexSrcUnit
= sampleUnit
;
464 prog
->TexturesUsed
[inst
->TexSrcUnit
] |= (1 << inst
->TexSrcTarget
);
472 static struct gl_vertex_program
*
473 vertex_program(struct gl_program
*prog
)
475 assert(prog
->Target
== GL_VERTEX_PROGRAM_ARB
);
476 return (struct gl_vertex_program
*) prog
;
481 static struct gl_fragment_program
*
482 fragment_program(struct gl_program
*prog
)
484 assert(prog
->Target
== GL_FRAGMENT_PROGRAM_ARB
);
485 return (struct gl_fragment_program
*) prog
;
490 * Shader linker. Currently:
492 * 1. The last attached vertex shader and fragment shader are linked.
493 * 2. Varying vars in the two shaders are combined so their locations
494 * agree between the vertex and fragment stages. They're treated as
495 * vertex program output attribs and as fragment program input attribs.
496 * 3. Uniform vars (including state references, constants, etc) from the
497 * vertex and fragment shaders are merged into one group. Recall that
498 * GLSL uniforms are shared by all linked shaders.
499 * 4. The vertex and fragment programs are cloned and modified to update
500 * src/dst register references so they use the new, linked uniform/
501 * varying storage locations.
504 _slang_link2(GLcontext
*ctx
,
505 GLhandleARB programObj
,
506 struct gl_shader_program
*shProg
)
508 struct gl_vertex_program
*vertProg
;
509 struct gl_fragment_program
*fragProg
;
512 _mesa_free_shader_program_data(ctx
, shProg
);
514 shProg
->Uniforms
= _mesa_new_parameter_list();
515 shProg
->Varying
= _mesa_new_parameter_list();
518 * Find attached vertex shader, fragment shader
522 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
523 if (shProg
->Shaders
[i
]->Type
== GL_VERTEX_SHADER
)
524 vertProg
= vertex_program(shProg
->Shaders
[i
]->Programs
[0]);
525 else if (shProg
->Shaders
[i
]->Type
== GL_FRAGMENT_SHADER
)
526 fragProg
= fragment_program(shProg
->Shaders
[i
]->Programs
[0]);
528 _mesa_problem(ctx
, "unexpected shader target in slang_link2()");
530 if (!vertProg
|| !fragProg
) {
531 /* XXX is it legal to have one but not the other?? */
532 /* XXX record error */
533 shProg
->LinkStatus
= GL_FALSE
;
537 if (!vertProg
->Base
.Varying
|| !fragProg
->Base
.Varying
) {
539 _mesa_problem(ctx
, "vertex/fragment program lacks varying list!");
540 shProg
->LinkStatus
= GL_FALSE
;
545 * Make copies of the vertex/fragment programs now since we'll be
546 * changing src/dst registers after merging the uniforms and varying vars.
548 shProg
->VertexProgram
549 = vertex_program(_mesa_clone_program(ctx
, &vertProg
->Base
));
550 shProg
->FragmentProgram
551 = fragment_program(_mesa_clone_program(ctx
, &fragProg
->Base
));
553 link_varying_vars(shProg
, &shProg
->VertexProgram
->Base
);
554 link_varying_vars(shProg
, &shProg
->FragmentProgram
->Base
);
556 link_uniform_vars(shProg
, &shProg
->VertexProgram
->Base
);
557 link_uniform_vars(shProg
, &shProg
->FragmentProgram
->Base
);
559 /* The vertex and fragment programs share a common set of uniforms now */
560 _mesa_free_parameter_list(shProg
->VertexProgram
->Base
.Parameters
);
561 _mesa_free_parameter_list(shProg
->FragmentProgram
->Base
.Parameters
);
562 shProg
->VertexProgram
->Base
.Parameters
= shProg
->Uniforms
;
563 shProg
->FragmentProgram
->Base
.Parameters
= shProg
->Uniforms
;
565 _slang_resolve_branches(&shProg
->VertexProgram
->Base
);
566 _slang_resolve_branches(&shProg
->FragmentProgram
->Base
);
568 _slang_resolve_samplers(shProg
, &shProg
->VertexProgram
->Base
);
569 _slang_resolve_samplers(shProg
, &shProg
->FragmentProgram
->Base
);
571 _slang_resolve_attributes(shProg
, &shProg
->VertexProgram
->Base
);
573 _slang_update_inputs_outputs(&shProg
->VertexProgram
->Base
);
574 _slang_update_inputs_outputs(&shProg
->FragmentProgram
->Base
);
577 printf("************** original fragment program\n");
578 _mesa_print_program(&fragProg
->Base
);
579 _mesa_print_program_parameters(ctx
, &fragProg
->Base
);
582 printf("************** linked fragment prog\n");
583 _mesa_print_program(&shProg
->FragmentProgram
->Base
);
584 _mesa_print_program_parameters(ctx
, &shProg
->FragmentProgram
->Base
);
587 printf("************** original vertex program\n");
588 _mesa_print_program(&vertProg
->Base
);
589 _mesa_print_program_parameters(ctx
, &fragProg
->Base
);
592 printf("************** linked vertex prog\n");
593 _mesa_print_program(&shProg
->VertexProgram
->Base
);
594 _mesa_print_program_parameters(ctx
, &shProg
->VertexProgram
->Base
);
597 shProg
->LinkStatus
= (shProg
->VertexProgram
&& shProg
->FragmentProgram
);