2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-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.
27 * Vertex/Fragment program optimizations and transformations for program
39 #include "programopt.h"
40 #include "program_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 GLint mvpState
[4][5] = {
61 { STATE_MATRIX
, STATE_MVP
, 0, 0, 0 }, /* state.matrix.mvp.row[0] */
62 { STATE_MATRIX
, STATE_MVP
, 0, 1, 1 }, /* state.matrix.mvp.row[1] */
63 { STATE_MATRIX
, STATE_MVP
, 0, 2, 2 }, /* state.matrix.mvp.row[2] */
64 { STATE_MATRIX
, STATE_MVP
, 0, 3, 3 }, /* 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_memcpy(newInst
+ 4, vprog
->Base
.Instructions
,
104 origLen
* sizeof(struct prog_instruction
));
106 /* free old instructions */
107 _mesa_free(vprog
->Base
.Instructions
);
109 /* install new instructions */
110 vprog
->Base
.Instructions
= newInst
;
111 vprog
->Base
.NumInstructions
= newLen
;
112 vprog
->Base
.InputsRead
|= VERT_BIT_POS
;
113 vprog
->Base
.OutputsWritten
|= (1 << VERT_RESULT_HPOS
);
119 * Append extra instructions onto the given fragment program to implement
120 * the fog mode specified by fprog->FogOption.
121 * The fragment.fogcoord input is used to compute the fog blend factor.
123 * XXX with a little work, this function could be adapted to add fog code
124 * to vertex programs too.
127 _mesa_append_fog_code(GLcontext
*ctx
, struct gl_fragment_program
*fprog
)
129 static const GLint fogParamsState
[] = { STATE_FOG_PARAMS
, 0, 0, 0, 0 };
130 static const GLint fogColorState
[] = { STATE_FOG_COLOR
, 0, 0, 0, 0 };
131 struct prog_instruction
*newInst
, *inst
;
132 const GLuint origLen
= fprog
->Base
.NumInstructions
;
133 const GLuint newLen
= origLen
+ 6;
135 GLint fogParamsRef
, fogColorRef
; /* state references */
136 GLuint colorTemp
, fogFactorTemp
; /* temporary registerss */
138 GLuint fogConsts
; /* constant values for EXP, EXP2 mode */
140 if (fprog
->FogOption
== GL_NONE
) {
141 _mesa_problem(ctx
, "_mesa_append_fog_code() called for fragment program"
142 " with FogOption == GL_NONE");
146 /* Alloc storage for new instructions */
147 newInst
= _mesa_alloc_instructions(newLen
);
149 _mesa_error(ctx
, GL_OUT_OF_MEMORY
,
150 "glProgramString(inserting fog_option code)");
154 /* Copy orig instructions into new instruction buffer */
155 _mesa_memcpy(newInst
, fprog
->Base
.Instructions
,
156 origLen
* sizeof(struct prog_instruction
));
158 /* PARAM fogParamsRef = state.fog.params; */
160 = _mesa_add_state_reference(fprog
->Base
.Parameters
, fogParamsState
);
161 /* PARAM fogColorRef = state.fog.color; */
163 = _mesa_add_state_reference(fprog
->Base
.Parameters
, fogColorState
);
165 /* TEMP colorTemp; */
166 colorTemp
= fprog
->Base
.NumTemporaries
++;
167 /* TEMP fogFactorTemp; */
168 fogFactorTemp
= fprog
->Base
.NumTemporaries
++;
170 /* PARAM fogVals = { 1/ln(2), 1/sqrt(ln(2), 0, 0 }; */
171 fogVals
[0] = 1.0 / log(2.0);
172 fogVals
[1] = 1.0 / SQRTF(log(2.0));
175 fogConsts
= _mesa_add_unnamed_constant(fprog
->Base
.Parameters
, fogVals
);
177 /* Scan program to find where result.color is written */
179 for (i
= 0; i
< fprog
->Base
.NumInstructions
; i
++) {
180 if (inst
->Opcode
== OPCODE_END
)
182 if (inst
->DstReg
.File
== PROGRAM_OUTPUT
&&
183 inst
->DstReg
.Index
== FRAG_RESULT_COLR
) {
184 /* change the instruction to write to colorTemp w/ clamping */
185 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
186 inst
->DstReg
.Index
= colorTemp
;
187 inst
->SaturateMode
= SATURATE_ZERO_ONE
;
188 /* don't break (may be several writes to result.color) */
192 assert(inst
->Opcode
== OPCODE_END
); /* we'll overwrite this inst */
194 _mesa_init_instructions(inst
, 6);
196 /* emit instructions to compute fog blending factor */
197 if (fprog
->FogOption
== GL_LINEAR
) {
198 /* SUB fogFactorTemp.x, fogParamsRef.z, fragment.fogcoord.x; */
199 inst
->Opcode
= OPCODE_SUB
;
200 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
201 inst
->DstReg
.Index
= fogFactorTemp
;
202 inst
->DstReg
.WriteMask
= WRITEMASK_X
;
203 inst
->SrcReg
[0].File
= PROGRAM_STATE_VAR
;
204 inst
->SrcReg
[0].Index
= fogParamsRef
;
205 inst
->SrcReg
[0].Swizzle
= SWIZZLE_Z
;
206 inst
->SrcReg
[1].File
= PROGRAM_INPUT
;
207 inst
->SrcReg
[1].Index
= FRAG_ATTRIB_FOGC
;
209 /* MUL fogFactorTemp.x, fogFactorTemp, fogParamsRef.w; */
210 inst
->Opcode
= OPCODE_MUL
;
211 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
212 inst
->DstReg
.Index
= fogFactorTemp
;
213 inst
->DstReg
.WriteMask
= WRITEMASK_X
;
214 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
215 inst
->SrcReg
[0].Index
= fogFactorTemp
;
216 inst
->SrcReg
[1].File
= PROGRAM_STATE_VAR
;
217 inst
->SrcReg
[1].Index
= fogParamsRef
;
218 inst
->SrcReg
[1].Swizzle
= SWIZZLE_W
;
222 ASSERT(fprog
->FogOption
== GL_EXP
|| fprog
->FogOption
== GL_EXP2
);
223 /* MUL fogFactorTemp.x, fogParamsRef.x, fragment.fogcoord; */
224 inst
->Opcode
= OPCODE_MUL
;
225 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
226 inst
->DstReg
.Index
= fogFactorTemp
;
227 inst
->DstReg
.WriteMask
= WRITEMASK_X
;
228 inst
->SrcReg
[0].File
= PROGRAM_STATE_VAR
;
229 inst
->SrcReg
[0].Index
= fogParamsRef
;
230 inst
->SrcReg
[0].Swizzle
= SWIZZLE_X
; /* X=density */
231 inst
->SrcReg
[1].File
= PROGRAM_INPUT
;
232 inst
->SrcReg
[1].Index
= FRAG_ATTRIB_FOGC
;
233 inst
->SrcReg
[1].Swizzle
= SWIZZLE_X
;
235 if (fprog
->FogOption
== GL_EXP2
) {
236 /* MUL fogFactorTemp.x, fogFactorTemp.x, fogFactorTemp.x; */
237 inst
->Opcode
= OPCODE_MUL
;
238 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
239 inst
->DstReg
.Index
= fogFactorTemp
;
240 inst
->DstReg
.WriteMask
= WRITEMASK_X
;
241 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
242 inst
->SrcReg
[0].Index
= fogFactorTemp
;
243 inst
->SrcReg
[1].File
= PROGRAM_TEMPORARY
;
244 inst
->SrcReg
[1].Index
= fogFactorTemp
;
247 /* EXP: MUL fogFactorTemp.x, fogFactorTemp.x, {1/ln(2)}; */
248 /* EXP2: MUL fogFactorTemp.x, fogFactorTemp.x, {1/sqrt(ln(2))}; */
249 inst
->Opcode
= OPCODE_MUL
;
250 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
251 inst
->DstReg
.Index
= fogFactorTemp
;
252 inst
->DstReg
.WriteMask
= WRITEMASK_X
;
253 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
254 inst
->SrcReg
[0].Index
= fogFactorTemp
;
255 inst
->SrcReg
[1].File
= PROGRAM_CONSTANT
;
256 inst
->SrcReg
[1].Index
= fogConsts
;
257 inst
->SrcReg
[1].Swizzle
258 = (fprog
->FogOption
== GL_EXP
) ? SWIZZLE_X
: SWIZZLE_Y
;
260 /* EX2_SAT fogFactorTemp.x, -fogFactorTemp.x; */
261 inst
->Opcode
= OPCODE_EX2
;
262 inst
->DstReg
.File
= PROGRAM_TEMPORARY
;
263 inst
->DstReg
.Index
= fogFactorTemp
;
264 inst
->DstReg
.WriteMask
= WRITEMASK_X
;
265 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
266 inst
->SrcReg
[0].Index
= fogFactorTemp
;
267 inst
->SrcReg
[0].NegateBase
= GL_TRUE
;
268 inst
->SaturateMode
= SATURATE_ZERO_ONE
;
271 /* LRP result.color.xyz, fogFactorTemp.xxxx, colorTemp, fogColorRef; */
272 inst
->Opcode
= OPCODE_LRP
;
273 inst
->DstReg
.File
= PROGRAM_OUTPUT
;
274 inst
->DstReg
.Index
= FRAG_RESULT_COLR
;
275 inst
->DstReg
.WriteMask
= WRITEMASK_XYZ
;
276 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
277 inst
->SrcReg
[0].Index
= fogFactorTemp
;
278 inst
->SrcReg
[0].Swizzle
279 = MAKE_SWIZZLE4(SWIZZLE_X
, SWIZZLE_X
, SWIZZLE_X
, SWIZZLE_X
);
280 inst
->SrcReg
[1].File
= PROGRAM_TEMPORARY
;
281 inst
->SrcReg
[1].Index
= colorTemp
;
282 inst
->SrcReg
[2].File
= PROGRAM_STATE_VAR
;
283 inst
->SrcReg
[2].Index
= fogColorRef
;
285 /* MOV result.color.w, colorTemp.x; # copy alpha */
286 inst
->Opcode
= OPCODE_MOV
;
287 inst
->DstReg
.File
= PROGRAM_OUTPUT
;
288 inst
->DstReg
.Index
= FRAG_RESULT_COLR
;
289 inst
->DstReg
.WriteMask
= WRITEMASK_W
;
290 inst
->SrcReg
[0].File
= PROGRAM_TEMPORARY
;
291 inst
->SrcReg
[0].Index
= colorTemp
;
294 inst
->Opcode
= OPCODE_END
;
297 /* free old instructions */
298 _mesa_free(fprog
->Base
.Instructions
);
300 /* install new instructions */
301 fprog
->Base
.Instructions
= newInst
;
302 fprog
->Base
.NumInstructions
= inst
- newInst
;
303 fprog
->Base
.InputsRead
|= FRAG_BIT_FOGC
;
304 /* XXX do this? fprog->FogOption = GL_NONE; */