2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-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 * Vertex/Fragment program optimizations and transformations for program
36 #include "prog_parameter.h"
37 #include "prog_statevars.h"
39 #include "programopt.h"
40 #include "prog_instruction.h"
44 * This function inserts instructions for coordinate modelview * projection
45 * into a vertex program.
46 * May be used to implement the position_invariant option.
49 _mesa_insert_mvp_code(GLcontext
*ctx
, struct gl_vertex_program
*vprog
)
51 struct prog_instruction
*newInst
;
52 const GLuint origLen
= vprog
->Base
.NumInstructions
;
53 const GLuint newLen
= origLen
+ 4;
57 * Setup state references for the modelview/projection matrix.
58 * XXX we should check if these state vars are already declared.
60 static const gl_state_index mvpState
[4][STATE_LENGTH
] = {
61 { STATE_MVP_MATRIX
, 0, 0, 0, 0 }, /* state.matrix.mvp.row[0] */
62 { STATE_MVP_MATRIX
, 0, 1, 1, 0 }, /* state.matrix.mvp.row[1] */
63 { STATE_MVP_MATRIX
, 0, 2, 2, 0 }, /* state.matrix.mvp.row[2] */
64 { STATE_MVP_MATRIX
, 0, 3, 3, 0 }, /* state.matrix.mvp.row[3] */
68 for (i
= 0; i
< 4; i
++) {
69 mvpRef
[i
] = _mesa_add_state_reference(vprog
->Base
.Parameters
,
73 /* Alloc storage for new instructions */
74 newInst
= _mesa_alloc_instructions(newLen
);
76 _mesa_error(ctx
, GL_OUT_OF_MEMORY
,
77 "glProgramString(inserting position_invariant code)");
82 * Generated instructions:
83 * newInst[0] = DP4 result.position.x, mvp.row[0], vertex.position;
84 * newInst[1] = DP4 result.position.y, mvp.row[1], vertex.position;
85 * newInst[2] = DP4 result.position.z, mvp.row[2], vertex.position;
86 * newInst[3] = DP4 result.position.w, mvp.row[3], vertex.position;
88 _mesa_init_instructions(newInst
, 4);
89 for (i
= 0; i
< 4; i
++) {
90 newInst
[i
].Opcode
= OPCODE_DP4
;
91 newInst
[i
].DstReg
.File
= PROGRAM_OUTPUT
;
92 newInst
[i
].DstReg
.Index
= VERT_RESULT_HPOS
;
93 newInst
[i
].DstReg
.WriteMask
= (WRITEMASK_X
<< i
);
94 newInst
[i
].SrcReg
[0].File
= PROGRAM_STATE_VAR
;
95 newInst
[i
].SrcReg
[0].Index
= mvpRef
[i
];
96 newInst
[i
].SrcReg
[0].Swizzle
= SWIZZLE_NOOP
;
97 newInst
[i
].SrcReg
[1].File
= PROGRAM_INPUT
;
98 newInst
[i
].SrcReg
[1].Index
= VERT_ATTRIB_POS
;
99 newInst
[i
].SrcReg
[1].Swizzle
= SWIZZLE_NOOP
;
102 /* Append original instructions after new instructions */
103 _mesa_copy_instructions (newInst
+ 4, vprog
->Base
.Instructions
, origLen
);
105 /* free old instructions */
106 _mesa_free_instructions(vprog
->Base
.Instructions
, origLen
);
108 /* install new instructions */
109 vprog
->Base
.Instructions
= newInst
;
110 vprog
->Base
.NumInstructions
= newLen
;
111 vprog
->Base
.InputsRead
|= VERT_BIT_POS
;
112 vprog
->Base
.OutputsWritten
|= (1 << VERT_RESULT_HPOS
);
118 * Append extra instructions onto the given fragment program to implement
119 * the fog mode specified by fprog->FogOption.
120 * The fragment.fogcoord input is used to compute the fog blend factor.
122 * XXX with a little work, this function could be adapted to add fog code
123 * to vertex programs too.
126 _mesa_append_fog_code(GLcontext
*ctx
, struct gl_fragment_program
*fprog
)
128 static const gl_state_index fogPStateOpt
[STATE_LENGTH
]
129 = { STATE_INTERNAL
, STATE_FOG_PARAMS_OPTIMIZED
, 0, 0, 0 };
130 static const gl_state_index fogColorState
[STATE_LENGTH
]
131 = { STATE_FOG_COLOR
, 0, 0, 0, 0};
132 struct prog_instruction
*newInst
, *inst
;
133 const GLuint origLen
= fprog
->Base
.NumInstructions
;
134 const GLuint newLen
= origLen
+ 5;
136 GLint fogPRefOpt
, fogColorRef
; /* state references */
137 GLuint colorTemp
, fogFactorTemp
; /* temporary registerss */
139 if (fprog
->FogOption
== GL_NONE
) {
140 _mesa_problem(ctx
, "_mesa_append_fog_code() called for fragment program"
141 " with FogOption == GL_NONE");
145 /* Alloc storage for new instructions */
146 newInst
= _mesa_alloc_instructions(newLen
);
148 _mesa_error(ctx
, GL_OUT_OF_MEMORY
,
149 "glProgramString(inserting fog_option code)");
153 /* Copy orig instructions into new instruction buffer */
154 _mesa_copy_instructions(newInst
, fprog
->Base
.Instructions
, origLen
);
156 /* PARAM fogParamsRefOpt = internal optimized fog params; */
158 = _mesa_add_state_reference(fprog
->Base
.Parameters
, fogPStateOpt
);
159 /* PARAM fogColorRef = state.fog.color; */
161 = _mesa_add_state_reference(fprog
->Base
.Parameters
, fogColorState
);
163 /* TEMP colorTemp; */
164 colorTemp
= fprog
->Base
.NumTemporaries
++;
165 /* TEMP fogFactorTemp; */
166 fogFactorTemp
= fprog
->Base
.NumTemporaries
++;
168 /* Scan program to find where result.color is written */
170 for (i
= 0; i
< fprog
->Base
.NumInstructions
; i
++) {
171 if (inst
->Opcode
== OPCODE_END
)
173 if (inst
->DstReg
.File
== PROGRAM_OUTPUT
&&
174 inst
->DstReg
.Index
== FRAG_RESULT_COLR
) {
175 /* change the instruction to write to colorTemp w/ clamping */
176 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
177 inst
->DstReg
.Index
= colorTemp
;
178 inst
->SaturateMode
= SATURATE_ZERO_ONE
;
179 /* don't break (may be several writes to result.color) */
183 assert(inst
->Opcode
== OPCODE_END
); /* we'll overwrite this inst */
185 _mesa_init_instructions(inst
, 5);
187 /* emit instructions to compute fog blending factor */
188 if (fprog
->FogOption
== GL_LINEAR
) {
189 /* MAD fogFactorTemp.x, fragment.fogcoord.x, fogPRefOpt.x, fogPRefOpt.y; */
190 inst
->Opcode
= OPCODE_MAD
;
191 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
192 inst
->DstReg
.Index
= fogFactorTemp
;
193 inst
->DstReg
.WriteMask
= WRITEMASK_X
;
194 inst
->SrcReg
[0].File
= PROGRAM_INPUT
;
195 inst
->SrcReg
[0].Index
= FRAG_ATTRIB_FOGC
;
196 inst
->SrcReg
[0].Swizzle
= SWIZZLE_XXXX
;
197 inst
->SrcReg
[1].File
= PROGRAM_STATE_VAR
;
198 inst
->SrcReg
[1].Index
= fogPRefOpt
;
199 inst
->SrcReg
[1].Swizzle
= SWIZZLE_XXXX
;
200 inst
->SrcReg
[2].File
= PROGRAM_STATE_VAR
;
201 inst
->SrcReg
[2].Index
= fogPRefOpt
;
202 inst
->SrcReg
[2].Swizzle
= SWIZZLE_YYYY
;
203 inst
->SaturateMode
= SATURATE_ZERO_ONE
;
207 ASSERT(fprog
->FogOption
== GL_EXP
|| fprog
->FogOption
== GL_EXP2
);
208 /* fogPRefOpt.z = d/ln(2), fogPRefOpt.w = d/sqrt(ln(2) */
209 /* EXP: MUL fogFactorTemp.x, fogPRefOpt.z, fragment.fogcoord.x; */
210 /* EXP2: MUL fogFactorTemp.x, fogPRefOpt.w, fragment.fogcoord.x; */
211 inst
->Opcode
= OPCODE_MUL
;
212 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
213 inst
->DstReg
.Index
= fogFactorTemp
;
214 inst
->DstReg
.WriteMask
= WRITEMASK_X
;
215 inst
->SrcReg
[0].File
= PROGRAM_STATE_VAR
;
216 inst
->SrcReg
[0].Index
= fogPRefOpt
;
217 inst
->SrcReg
[0].Swizzle
218 = (fprog
->FogOption
== GL_EXP
) ? SWIZZLE_ZZZZ
: SWIZZLE_WWWW
;
219 inst
->SrcReg
[1].File
= PROGRAM_INPUT
;
220 inst
->SrcReg
[1].Index
= FRAG_ATTRIB_FOGC
;
221 inst
->SrcReg
[1].Swizzle
= SWIZZLE_XXXX
;
223 if (fprog
->FogOption
== GL_EXP2
) {
224 /* MUL fogFactorTemp.x, fogFactorTemp.x, fogFactorTemp.x; */
225 inst
->Opcode
= OPCODE_MUL
;
226 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
227 inst
->DstReg
.Index
= fogFactorTemp
;
228 inst
->DstReg
.WriteMask
= WRITEMASK_X
;
229 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
230 inst
->SrcReg
[0].Index
= fogFactorTemp
;
231 inst
->SrcReg
[0].Swizzle
= SWIZZLE_XXXX
;
232 inst
->SrcReg
[1].File
= PROGRAM_TEMPORARY
;
233 inst
->SrcReg
[1].Index
= fogFactorTemp
;
234 inst
->SrcReg
[1].Swizzle
= SWIZZLE_XXXX
;
237 /* EX2_SAT fogFactorTemp.x, -fogFactorTemp.x; */
238 inst
->Opcode
= OPCODE_EX2
;
239 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
240 inst
->DstReg
.Index
= fogFactorTemp
;
241 inst
->DstReg
.WriteMask
= WRITEMASK_X
;
242 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
243 inst
->SrcReg
[0].Index
= fogFactorTemp
;
244 inst
->SrcReg
[0].NegateBase
= NEGATE_XYZW
;
245 inst
->SrcReg
[0].Swizzle
= SWIZZLE_XXXX
;
246 inst
->SaturateMode
= SATURATE_ZERO_ONE
;
249 /* LRP result.color.xyz, fogFactorTemp.xxxx, colorTemp, fogColorRef; */
250 inst
->Opcode
= OPCODE_LRP
;
251 inst
->DstReg
.File
= PROGRAM_OUTPUT
;
252 inst
->DstReg
.Index
= FRAG_RESULT_COLR
;
253 inst
->DstReg
.WriteMask
= WRITEMASK_XYZ
;
254 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
255 inst
->SrcReg
[0].Index
= fogFactorTemp
;
256 inst
->SrcReg
[0].Swizzle
= SWIZZLE_XXXX
;
257 inst
->SrcReg
[1].File
= PROGRAM_TEMPORARY
;
258 inst
->SrcReg
[1].Index
= colorTemp
;
259 inst
->SrcReg
[1].Swizzle
= SWIZZLE_NOOP
;
260 inst
->SrcReg
[2].File
= PROGRAM_STATE_VAR
;
261 inst
->SrcReg
[2].Index
= fogColorRef
;
262 inst
->SrcReg
[2].Swizzle
= SWIZZLE_NOOP
;
264 /* MOV result.color.w, colorTemp.x; # copy alpha */
265 inst
->Opcode
= OPCODE_MOV
;
266 inst
->DstReg
.File
= PROGRAM_OUTPUT
;
267 inst
->DstReg
.Index
= FRAG_RESULT_COLR
;
268 inst
->DstReg
.WriteMask
= WRITEMASK_W
;
269 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
270 inst
->SrcReg
[0].Index
= colorTemp
;
271 inst
->SrcReg
[0].Swizzle
= SWIZZLE_NOOP
;
274 inst
->Opcode
= OPCODE_END
;
277 /* free old instructions */
278 _mesa_free_instructions(fprog
->Base
.Instructions
, origLen
);
280 /* install new instructions */
281 fprog
->Base
.Instructions
= newInst
;
282 fprog
->Base
.NumInstructions
= inst
- newInst
;
283 fprog
->Base
.InputsRead
|= FRAG_BIT_FOGC
;
284 /* XXX do this? fprog->FogOption = GL_NONE; */
290 is_texture_instruction(const struct prog_instruction
*inst
)
292 switch (inst
->Opcode
) {
307 * Count the number of texure indirections in the given program.
308 * The program's NumTexIndirections field will be updated.
309 * See the GL_ARB_fragment_program spec (issue 24) for details.
310 * XXX we count texture indirections in texenvprogram.c (maybe use this code
311 * instead and elsewhere).
314 _mesa_count_texture_indirections(struct gl_program
*prog
)
316 GLuint indirections
= 1;
317 GLbitfield tempsOutput
= 0x0;
318 GLbitfield aluTemps
= 0x0;
321 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
322 const struct prog_instruction
*inst
= prog
->Instructions
+ i
;
324 if (is_texture_instruction(inst
)) {
325 if (((inst
->SrcReg
[0].File
== PROGRAM_TEMPORARY
) &&
326 (tempsOutput
& (1 << inst
->SrcReg
[0].Index
))) ||
327 ((inst
->Opcode
!= OPCODE_KIL
) &&
328 (inst
->DstReg
.File
== PROGRAM_TEMPORARY
) &&
329 (aluTemps
& (1 << inst
->DstReg
.Index
))))
338 for (j
= 0; j
< 3; j
++) {
339 if (inst
->SrcReg
[j
].File
== PROGRAM_TEMPORARY
)
340 aluTemps
|= (1 << inst
->SrcReg
[j
].Index
);
342 if (inst
->DstReg
.File
== PROGRAM_TEMPORARY
)
343 aluTemps
|= (1 << inst
->DstReg
.Index
);
346 if ((inst
->Opcode
!= OPCODE_KIL
) && (inst
->DstReg
.File
== PROGRAM_TEMPORARY
))
347 tempsOutput
|= (1 << inst
->DstReg
.Index
);
350 prog
->NumTexIndirections
= indirections
;
355 * Count number of texture instructions in given program and update the
356 * program's NumTexInstructions field.
359 _mesa_count_texture_instructions(struct gl_program
*prog
)
362 prog
->NumTexInstructions
= 0;
363 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
364 prog
->NumTexInstructions
+= is_texture_instruction(prog
->Instructions
+ i
);
370 * Scan/rewrite program to remove reads of varying (output) registers.
371 * In GLSL vertex shaders, varying vars can be read and written.
372 * Normally, vertex varying vars are implemented as output registers.
373 * On some hardware, trying to read an output register causes trouble.
374 * So, rewrite the program to use a temporary register in this case.
377 _mesa_remove_varying_reads(struct gl_program
*prog
)
380 GLint outputMap
[VERT_RESULT_MAX
];
381 GLuint numVaryingReads
= 0;
383 assert(prog
->Target
== GL_VERTEX_PROGRAM_ARB
);
385 for (i
= 0; i
< VERT_RESULT_MAX
; i
++)
388 /* look for instructions which read from varying vars */
389 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
390 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
391 const GLuint numSrc
= _mesa_num_inst_src_regs(inst
->Opcode
);
393 for (j
= 0; j
< numSrc
; j
++) {
394 if (inst
->SrcReg
[j
].File
== PROGRAM_VARYING
) {
395 /* replace the read with a temp reg */
396 const GLuint var
= inst
->SrcReg
[j
].Index
;
397 if (outputMap
[var
] == -1) {
399 outputMap
[var
] = _mesa_find_free_register(prog
,
402 inst
->SrcReg
[j
].File
= PROGRAM_TEMPORARY
;
403 inst
->SrcReg
[j
].Index
= outputMap
[var
];
408 if (numVaryingReads
== 0)
409 return; /* nothing to be done */
411 /* look for instructions which write to the varying vars identified above */
412 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
413 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
414 const GLuint numSrc
= _mesa_num_inst_src_regs(inst
->Opcode
);
416 for (j
= 0; j
< numSrc
; j
++) {
417 if (inst
->DstReg
.File
== PROGRAM_VARYING
&&
418 outputMap
[inst
->DstReg
.Index
] >= 0) {
419 /* change inst to write to the temp reg, instead of the varying */
420 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
421 inst
->DstReg
.Index
= outputMap
[inst
->DstReg
.Index
];
426 /* insert new instructions to copy the temp vars to the varying vars */
428 struct prog_instruction
*inst
;
431 /* Look for END instruction and insert the new varying writes */
433 for (i
= 0; i
< prog
->NumInstructions
; i
++) {
434 struct prog_instruction
*inst
= prog
->Instructions
+ i
;
435 if (inst
->Opcode
== OPCODE_END
) {
437 _mesa_insert_instructions(prog
, i
, numVaryingReads
);
444 /* insert new MOV instructions here */
445 inst
= prog
->Instructions
+ endPos
;
446 for (var
= 0; var
< VERT_RESULT_MAX
; var
++) {
447 if (outputMap
[var
] >= 0) {
448 /* MOV VAR[var], TEMP[tmp]; */
449 inst
->Opcode
= OPCODE_MOV
;
450 inst
->DstReg
.File
= PROGRAM_VARYING
;
451 inst
->DstReg
.Index
= var
;
452 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
453 inst
->SrcReg
[0].Index
= outputMap
[var
];