projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[OPENGL]
[reactos.git] / reactos / dll / opengl / mesa / src / mesa / program / programopt.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.5.3
4 *
5 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
6 *
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:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
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.
23 */
24
25 /**
26 * \file programopt.c
27 * Vertex/Fragment program optimizations and transformations for program
28 * options, etc.
29 *
30 * \author Brian Paul
31 */
32
33
34 #include "main/glheader.h"
35 #include "main/context.h"
36 #include "prog_parameter.h"
37 #include "prog_statevars.h"
38 #include "program.h"
39 #include "programopt.h"
40 #include "prog_instruction.h"
41
42
43 /**
44 * This function inserts instructions for coordinate modelview * projection
45 * into a vertex program.
46 * May be used to implement the position_invariant option.
47 */
48 static void
49 _mesa_insert_mvp_dp4_code(struct gl_context *ctx, struct gl_vertex_program *vprog)
50 {
51 struct prog_instruction *newInst;
52 const GLuint origLen = vprog->Base.NumInstructions;
53 const GLuint newLen = origLen + 4;
54 GLuint i;
55
56 /*
57 * Setup state references for the modelview/projection matrix.
58 * XXX we should check if these state vars are already declared.
59 */
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] */
65 };
66 GLint mvpRef[4];
67
68 for (i = 0; i < 4; i++) {
69 mvpRef[i] = _mesa_add_state_reference(vprog->Base.Parameters,
70 mvpState[i]);
71 }
72
73 /* Alloc storage for new instructions */
74 newInst = _mesa_alloc_instructions(newLen);
75 if (!newInst) {
76 _mesa_error(ctx, GL_OUT_OF_MEMORY,
77 "glProgramString(inserting position_invariant code)");
78 return;
79 }
80
81 /*
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;
87 */
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;
100 }
101
102 /* Append original instructions after new instructions */
103 _mesa_copy_instructions (newInst + 4, vprog->Base.Instructions, origLen);
104
105 /* free old instructions */
106 _mesa_free_instructions(vprog->Base.Instructions, origLen);
107
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 |= BITFIELD64_BIT(VERT_RESULT_HPOS);
113 }
114
115
116 static void
117 _mesa_insert_mvp_mad_code(struct gl_context *ctx, struct gl_vertex_program *vprog)
118 {
119 struct prog_instruction *newInst;
120 const GLuint origLen = vprog->Base.NumInstructions;
121 const GLuint newLen = origLen + 4;
122 GLuint hposTemp;
123 GLuint i;
124
125 /*
126 * Setup state references for the modelview/projection matrix.
127 * XXX we should check if these state vars are already declared.
128 */
129 static const gl_state_index mvpState[4][STATE_LENGTH] = {
130 { STATE_MVP_MATRIX, 0, 0, 0, STATE_MATRIX_TRANSPOSE },
131 { STATE_MVP_MATRIX, 0, 1, 1, STATE_MATRIX_TRANSPOSE },
132 { STATE_MVP_MATRIX, 0, 2, 2, STATE_MATRIX_TRANSPOSE },
133 { STATE_MVP_MATRIX, 0, 3, 3, STATE_MATRIX_TRANSPOSE },
134 };
135 GLint mvpRef[4];
136
137 for (i = 0; i < 4; i++) {
138 mvpRef[i] = _mesa_add_state_reference(vprog->Base.Parameters,
139 mvpState[i]);
140 }
141
142 /* Alloc storage for new instructions */
143 newInst = _mesa_alloc_instructions(newLen);
144 if (!newInst) {
145 _mesa_error(ctx, GL_OUT_OF_MEMORY,
146 "glProgramString(inserting position_invariant code)");
147 return;
148 }
149
150 /* TEMP hposTemp; */
151 hposTemp = vprog->Base.NumTemporaries++;
152
153 /*
154 * Generated instructions:
155 * emit_op2(p, OPCODE_MUL, tmp, 0, swizzle1(src,X), mat[0]);
156 * emit_op3(p, OPCODE_MAD, tmp, 0, swizzle1(src,Y), mat[1], tmp);
157 * emit_op3(p, OPCODE_MAD, tmp, 0, swizzle1(src,Z), mat[2], tmp);
158 * emit_op3(p, OPCODE_MAD, dest, 0, swizzle1(src,W), mat[3], tmp);
159 */
160 _mesa_init_instructions(newInst, 4);
161
162 newInst[0].Opcode = OPCODE_MUL;
163 newInst[0].DstReg.File = PROGRAM_TEMPORARY;
164 newInst[0].DstReg.Index = hposTemp;
165 newInst[0].DstReg.WriteMask = WRITEMASK_XYZW;
166 newInst[0].SrcReg[0].File = PROGRAM_INPUT;
167 newInst[0].SrcReg[0].Index = VERT_ATTRIB_POS;
168 newInst[0].SrcReg[0].Swizzle = SWIZZLE_XXXX;
169 newInst[0].SrcReg[1].File = PROGRAM_STATE_VAR;
170 newInst[0].SrcReg[1].Index = mvpRef[0];
171 newInst[0].SrcReg[1].Swizzle = SWIZZLE_NOOP;
172
173 for (i = 1; i <= 2; i++) {
174 newInst[i].Opcode = OPCODE_MAD;
175 newInst[i].DstReg.File = PROGRAM_TEMPORARY;
176 newInst[i].DstReg.Index = hposTemp;
177 newInst[i].DstReg.WriteMask = WRITEMASK_XYZW;
178 newInst[i].SrcReg[0].File = PROGRAM_INPUT;
179 newInst[i].SrcReg[0].Index = VERT_ATTRIB_POS;
180 newInst[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(i,i,i,i);
181 newInst[i].SrcReg[1].File = PROGRAM_STATE_VAR;
182 newInst[i].SrcReg[1].Index = mvpRef[i];
183 newInst[i].SrcReg[1].Swizzle = SWIZZLE_NOOP;
184 newInst[i].SrcReg[2].File = PROGRAM_TEMPORARY;
185 newInst[i].SrcReg[2].Index = hposTemp;
186 newInst[1].SrcReg[2].Swizzle = SWIZZLE_NOOP;
187 }
188
189 newInst[3].Opcode = OPCODE_MAD;
190 newInst[3].DstReg.File = PROGRAM_OUTPUT;
191 newInst[3].DstReg.Index = VERT_RESULT_HPOS;
192 newInst[3].DstReg.WriteMask = WRITEMASK_XYZW;
193 newInst[3].SrcReg[0].File = PROGRAM_INPUT;
194 newInst[3].SrcReg[0].Index = VERT_ATTRIB_POS;
195 newInst[3].SrcReg[0].Swizzle = SWIZZLE_WWWW;
196 newInst[3].SrcReg[1].File = PROGRAM_STATE_VAR;
197 newInst[3].SrcReg[1].Index = mvpRef[3];
198 newInst[3].SrcReg[1].Swizzle = SWIZZLE_NOOP;
199 newInst[3].SrcReg[2].File = PROGRAM_TEMPORARY;
200 newInst[3].SrcReg[2].Index = hposTemp;
201 newInst[3].SrcReg[2].Swizzle = SWIZZLE_NOOP;
202
203
204 /* Append original instructions after new instructions */
205 _mesa_copy_instructions (newInst + 4, vprog->Base.Instructions, origLen);
206
207 /* free old instructions */
208 _mesa_free_instructions(vprog->Base.Instructions, origLen);
209
210 /* install new instructions */
211 vprog->Base.Instructions = newInst;
212 vprog->Base.NumInstructions = newLen;
213 vprog->Base.InputsRead |= VERT_BIT_POS;
214 vprog->Base.OutputsWritten |= BITFIELD64_BIT(VERT_RESULT_HPOS);
215 }
216
217
218 void
219 _mesa_insert_mvp_code(struct gl_context *ctx, struct gl_vertex_program *vprog)
220 {
221 if (ctx->mvp_with_dp4)
222 _mesa_insert_mvp_dp4_code( ctx, vprog );
223 else
224 _mesa_insert_mvp_mad_code( ctx, vprog );
225 }
226
227
228
229
230
231
232 /**
233 * Append instructions to implement fog
234 *
235 * The \c fragment.fogcoord input is used to compute the fog blend factor.
236 *
237 * \param ctx The GL context
238 * \param fprog Fragment program that fog instructions will be appended to.
239 * \param fog_mode Fog mode. One of \c GL_EXP, \c GL_EXP2, or \c GL_LINEAR.
240 * \param saturate True if writes to color outputs should be clamped to [0, 1]
241 *
242 * \note
243 * This function sets \c FRAG_BIT_FOGC in \c fprog->Base.InputsRead.
244 *
245 * \todo With a little work, this function could be adapted to add fog code
246 * to vertex programs too.
247 */
248 void
249 _mesa_append_fog_code(struct gl_context *ctx,
250 struct gl_fragment_program *fprog, GLenum fog_mode,
251 GLboolean saturate)
252 {
253 static const gl_state_index fogPStateOpt[STATE_LENGTH]
254 = { STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED, 0, 0, 0 };
255 static const gl_state_index fogColorState[STATE_LENGTH]
256 = { STATE_FOG_COLOR, 0, 0, 0, 0};
257 struct prog_instruction *newInst, *inst;
258 const GLuint origLen = fprog->Base.NumInstructions;
259 const GLuint newLen = origLen + 5;
260 GLuint i;
261 GLint fogPRefOpt, fogColorRef; /* state references */
262 GLuint colorTemp, fogFactorTemp; /* temporary registerss */
263
264 if (fog_mode == GL_NONE) {
265 _mesa_problem(ctx, "_mesa_append_fog_code() called for fragment program"
266 " with fog_mode == GL_NONE");
267 return;
268 }
269
270 if (!(fprog->Base.OutputsWritten & (1 << FRAG_RESULT_COLOR))) {
271 /* program doesn't output color, so nothing to do */
272 return;
273 }
274
275 /* Alloc storage for new instructions */
276 newInst = _mesa_alloc_instructions(newLen);
277 if (!newInst) {
278 _mesa_error(ctx, GL_OUT_OF_MEMORY,
279 "glProgramString(inserting fog_option code)");
280 return;
281 }
282
283 /* Copy orig instructions into new instruction buffer */
284 _mesa_copy_instructions(newInst, fprog->Base.Instructions, origLen);
285
286 /* PARAM fogParamsRefOpt = internal optimized fog params; */
287 fogPRefOpt
288 = _mesa_add_state_reference(fprog->Base.Parameters, fogPStateOpt);
289 /* PARAM fogColorRef = state.fog.color; */
290 fogColorRef
291 = _mesa_add_state_reference(fprog->Base.Parameters, fogColorState);
292
293 /* TEMP colorTemp; */
294 colorTemp = fprog->Base.NumTemporaries++;
295 /* TEMP fogFactorTemp; */
296 fogFactorTemp = fprog->Base.NumTemporaries++;
297
298 /* Scan program to find where result.color is written */
299 inst = newInst;
300 for (i = 0; i < fprog->Base.NumInstructions; i++) {
301 if (inst->Opcode == OPCODE_END)
302 break;
303 if (inst->DstReg.File == PROGRAM_OUTPUT &&
304 inst->DstReg.Index == FRAG_RESULT_COLOR) {
305 /* change the instruction to write to colorTemp w/ clamping */
306 inst->DstReg.File = PROGRAM_TEMPORARY;
307 inst->DstReg.Index = colorTemp;
308 inst->SaturateMode = saturate;
309 /* don't break (may be several writes to result.color) */
310 }
311 inst++;
312 }
313 assert(inst->Opcode == OPCODE_END); /* we'll overwrite this inst */
314
315 _mesa_init_instructions(inst, 5);
316
317 /* emit instructions to compute fog blending factor */
318 /* this is always clamped to [0, 1] regardless of fragment clamping */
319 if (fog_mode == GL_LINEAR) {
320 /* MAD fogFactorTemp.x, fragment.fogcoord.x, fogPRefOpt.x, fogPRefOpt.y; */
321 inst->Opcode = OPCODE_MAD;
322 inst->DstReg.File = PROGRAM_TEMPORARY;
323 inst->DstReg.Index = fogFactorTemp;
324 inst->DstReg.WriteMask = WRITEMASK_X;
325 inst->SrcReg[0].File = PROGRAM_INPUT;
326 inst->SrcReg[0].Index = FRAG_ATTRIB_FOGC;
327 inst->SrcReg[0].Swizzle = SWIZZLE_XXXX;
328 inst->SrcReg[1].File = PROGRAM_STATE_VAR;
329 inst->SrcReg[1].Index = fogPRefOpt;
330 inst->SrcReg[1].Swizzle = SWIZZLE_XXXX;
331 inst->SrcReg[2].File = PROGRAM_STATE_VAR;
332 inst->SrcReg[2].Index = fogPRefOpt;
333 inst->SrcReg[2].Swizzle = SWIZZLE_YYYY;
334 inst->SaturateMode = SATURATE_ZERO_ONE;
335 inst++;
336 }
337 else {
338 ASSERT(fog_mode == GL_EXP || fog_mode == GL_EXP2);
339 /* fogPRefOpt.z = d/ln(2), fogPRefOpt.w = d/sqrt(ln(2) */
340 /* EXP: MUL fogFactorTemp.x, fogPRefOpt.z, fragment.fogcoord.x; */
341 /* EXP2: MUL fogFactorTemp.x, fogPRefOpt.w, fragment.fogcoord.x; */
342 inst->Opcode = OPCODE_MUL;
343 inst->DstReg.File = PROGRAM_TEMPORARY;
344 inst->DstReg.Index = fogFactorTemp;
345 inst->DstReg.WriteMask = WRITEMASK_X;
346 inst->SrcReg[0].File = PROGRAM_STATE_VAR;
347 inst->SrcReg[0].Index = fogPRefOpt;
348 inst->SrcReg[0].Swizzle
349 = (fog_mode == GL_EXP) ? SWIZZLE_ZZZZ : SWIZZLE_WWWW;
350 inst->SrcReg[1].File = PROGRAM_INPUT;
351 inst->SrcReg[1].Index = FRAG_ATTRIB_FOGC;
352 inst->SrcReg[1].Swizzle = SWIZZLE_XXXX;
353 inst++;
354 if (fog_mode == GL_EXP2) {
355 /* MUL fogFactorTemp.x, fogFactorTemp.x, fogFactorTemp.x; */
356 inst->Opcode = OPCODE_MUL;
357 inst->DstReg.File = PROGRAM_TEMPORARY;
358 inst->DstReg.Index = fogFactorTemp;
359 inst->DstReg.WriteMask = WRITEMASK_X;
360 inst->SrcReg[0].File = PROGRAM_TEMPORARY;
361 inst->SrcReg[0].Index = fogFactorTemp;
362 inst->SrcReg[0].Swizzle = SWIZZLE_XXXX;
363 inst->SrcReg[1].File = PROGRAM_TEMPORARY;
364 inst->SrcReg[1].Index = fogFactorTemp;
365 inst->SrcReg[1].Swizzle = SWIZZLE_XXXX;
366 inst++;
367 }
368 /* EX2_SAT fogFactorTemp.x, -fogFactorTemp.x; */
369 inst->Opcode = OPCODE_EX2;
370 inst->DstReg.File = PROGRAM_TEMPORARY;
371 inst->DstReg.Index = fogFactorTemp;
372 inst->DstReg.WriteMask = WRITEMASK_X;
373 inst->SrcReg[0].File = PROGRAM_TEMPORARY;
374 inst->SrcReg[0].Index = fogFactorTemp;
375 inst->SrcReg[0].Negate = NEGATE_XYZW;
376 inst->SrcReg[0].Swizzle = SWIZZLE_XXXX;
377 inst->SaturateMode = SATURATE_ZERO_ONE;
378 inst++;
379 }
380 /* LRP result.color.xyz, fogFactorTemp.xxxx, colorTemp, fogColorRef; */
381 inst->Opcode = OPCODE_LRP;
382 inst->DstReg.File = PROGRAM_OUTPUT;
383 inst->DstReg.Index = FRAG_RESULT_COLOR;
384 inst->DstReg.WriteMask = WRITEMASK_XYZ;
385 inst->SrcReg[0].File = PROGRAM_TEMPORARY;
386 inst->SrcReg[0].Index = fogFactorTemp;
387 inst->SrcReg[0].Swizzle = SWIZZLE_XXXX;
388 inst->SrcReg[1].File = PROGRAM_TEMPORARY;
389 inst->SrcReg[1].Index = colorTemp;
390 inst->SrcReg[1].Swizzle = SWIZZLE_NOOP;
391 inst->SrcReg[2].File = PROGRAM_STATE_VAR;
392 inst->SrcReg[2].Index = fogColorRef;
393 inst->SrcReg[2].Swizzle = SWIZZLE_NOOP;
394 inst++;
395 /* MOV result.color.w, colorTemp.x; # copy alpha */
396 inst->Opcode = OPCODE_MOV;
397 inst->DstReg.File = PROGRAM_OUTPUT;
398 inst->DstReg.Index = FRAG_RESULT_COLOR;
399 inst->DstReg.WriteMask = WRITEMASK_W;
400 inst->SrcReg[0].File = PROGRAM_TEMPORARY;
401 inst->SrcReg[0].Index = colorTemp;
402 inst->SrcReg[0].Swizzle = SWIZZLE_NOOP;
403 inst++;
404 /* END; */
405 inst->Opcode = OPCODE_END;
406 inst++;
407
408 /* free old instructions */
409 _mesa_free_instructions(fprog->Base.Instructions, origLen);
410
411 /* install new instructions */
412 fprog->Base.Instructions = newInst;
413 fprog->Base.NumInstructions = inst - newInst;
414 fprog->Base.InputsRead |= FRAG_BIT_FOGC;
415 assert(fprog->Base.OutputsWritten & (1 << FRAG_RESULT_COLOR));
416 }
417
418
419
420 static GLboolean
421 is_texture_instruction(const struct prog_instruction *inst)
422 {
423 switch (inst->Opcode) {
424 case OPCODE_TEX:
425 case OPCODE_TXB:
426 case OPCODE_TXD:
427 case OPCODE_TXL:
428 case OPCODE_TXP:
429 case OPCODE_TXP_NV:
430 return GL_TRUE;
431 default:
432 return GL_FALSE;
433 }
434 }
435
436
437 /**
438 * Count the number of texure indirections in the given program.
439 * The program's NumTexIndirections field will be updated.
440 * See the GL_ARB_fragment_program spec (issue 24) for details.
441 * XXX we count texture indirections in texenvprogram.c (maybe use this code
442 * instead and elsewhere).
443 */
444 void
445 _mesa_count_texture_indirections(struct gl_program *prog)
446 {
447 GLuint indirections = 1;
448 GLbitfield tempsOutput = 0x0;
449 GLbitfield aluTemps = 0x0;
450 GLuint i;
451
452 for (i = 0; i < prog->NumInstructions; i++) {
453 const struct prog_instruction *inst = prog->Instructions + i;
454
455 if (is_texture_instruction(inst)) {
456 if (((inst->SrcReg[0].File == PROGRAM_TEMPORARY) &&
457 (tempsOutput & (1 << inst->SrcReg[0].Index))) ||
458 ((inst->Opcode != OPCODE_KIL) &&
459 (inst->DstReg.File == PROGRAM_TEMPORARY) &&
460 (aluTemps & (1 << inst->DstReg.Index))))
461 {
462 indirections++;
463 tempsOutput = 0x0;
464 aluTemps = 0x0;
465 }
466 }
467 else {
468 GLuint j;
469 for (j = 0; j < 3; j++) {
470 if (inst->SrcReg[j].File == PROGRAM_TEMPORARY)
471 aluTemps |= (1 << inst->SrcReg[j].Index);
472 }
473 if (inst->DstReg.File == PROGRAM_TEMPORARY)
474 aluTemps |= (1 << inst->DstReg.Index);
475 }
476
477 if ((inst->Opcode != OPCODE_KIL) && (inst->DstReg.File == PROGRAM_TEMPORARY))
478 tempsOutput |= (1 << inst->DstReg.Index);
479 }
480
481 prog->NumTexIndirections = indirections;
482 }
483
484
485 /**
486 * Count number of texture instructions in given program and update the
487 * program's NumTexInstructions field.
488 */
489 void
490 _mesa_count_texture_instructions(struct gl_program *prog)
491 {
492 GLuint i;
493 prog->NumTexInstructions = 0;
494 for (i = 0; i < prog->NumInstructions; i++) {
495 prog->NumTexInstructions += is_texture_instruction(prog->Instructions + i);
496 }
497 }
498
499
500 /**
501 * Scan/rewrite program to remove reads of custom (output) registers.
502 * The passed type has to be either PROGRAM_OUTPUT or PROGRAM_VARYING
503 * (for vertex shaders).
504 * In GLSL shaders, varying vars can be read and written.
505 * On some hardware, trying to read an output register causes trouble.
506 * So, rewrite the program to use a temporary register in this case.
507 */
508 void
509 _mesa_remove_output_reads(struct gl_program *prog, gl_register_file type)
510 {
511 GLuint i;
512 GLint outputMap[VERT_RESULT_MAX];
513 GLuint numVaryingReads = 0;
514 GLboolean usedTemps[MAX_PROGRAM_TEMPS];
515 GLuint firstTemp = 0;
516
517 _mesa_find_used_registers(prog, PROGRAM_TEMPORARY,
518 usedTemps, MAX_PROGRAM_TEMPS);
519
520 assert(type == PROGRAM_VARYING || type == PROGRAM_OUTPUT);
521 assert(prog->Target == GL_VERTEX_PROGRAM_ARB || type != PROGRAM_VARYING);
522
523 for (i = 0; i < VERT_RESULT_MAX; i++)
524 outputMap[i] = -1;
525
526 /* look for instructions which read from varying vars */
527 for (i = 0; i < prog->NumInstructions; i++) {
528 struct prog_instruction *inst = prog->Instructions + i;
529 const GLuint numSrc = _mesa_num_inst_src_regs(inst->Opcode);
530 GLuint j;
531 for (j = 0; j < numSrc; j++) {
532 if (inst->SrcReg[j].File == type) {
533 /* replace the read with a temp reg */
534 const GLuint var = inst->SrcReg[j].Index;
535 if (outputMap[var] == -1) {
536 numVaryingReads++;
537 outputMap[var] = _mesa_find_free_register(usedTemps,
538 MAX_PROGRAM_TEMPS,
539 firstTemp);
540 firstTemp = outputMap[var] + 1;
541 }
542 inst->SrcReg[j].File = PROGRAM_TEMPORARY;
543 inst->SrcReg[j].Index = outputMap[var];
544 }
545 }
546 }
547
548 if (numVaryingReads == 0)
549 return; /* nothing to be done */
550
551 /* look for instructions which write to the varying vars identified above */
552 for (i = 0; i < prog->NumInstructions; i++) {
553 struct prog_instruction *inst = prog->Instructions + i;
554 if (inst->DstReg.File == type &&
555 outputMap[inst->DstReg.Index] >= 0) {
556 /* change inst to write to the temp reg, instead of the varying */
557 inst->DstReg.File = PROGRAM_TEMPORARY;
558 inst->DstReg.Index = outputMap[inst->DstReg.Index];
559 }
560 }
561
562 /* insert new instructions to copy the temp vars to the varying vars */
563 {
564 struct prog_instruction *inst;
565 GLint endPos, var;
566
567 /* Look for END instruction and insert the new varying writes */
568 endPos = -1;
569 for (i = 0; i < prog->NumInstructions; i++) {
570 struct prog_instruction *inst = prog->Instructions + i;
571 if (inst->Opcode == OPCODE_END) {
572 endPos = i;
573 _mesa_insert_instructions(prog, i, numVaryingReads);
574 break;
575 }
576 }
577
578 assert(endPos >= 0);
579
580 /* insert new MOV instructions here */
581 inst = prog->Instructions + endPos;
582 for (var = 0; var < VERT_RESULT_MAX; var++) {
583 if (outputMap[var] >= 0) {
584 /* MOV VAR[var], TEMP[tmp]; */
585 inst->Opcode = OPCODE_MOV;
586 inst->DstReg.File = type;
587 inst->DstReg.Index = var;
588 inst->SrcReg[0].File = PROGRAM_TEMPORARY;
589 inst->SrcReg[0].Index = outputMap[var];
590 inst++;
591 }
592 }
593 }
594 }
595
596
597 /**
598 * Make the given fragment program into a "no-op" shader.
599 * Actually, just copy the incoming fragment color (or texcoord)
600 * to the output color.
601 * This is for debug/test purposes.
602 */
603 void
604 _mesa_nop_fragment_program(struct gl_context *ctx, struct gl_fragment_program *prog)
605 {
606 struct prog_instruction *inst;
607 GLuint inputAttr;
608
609 inst = _mesa_alloc_instructions(2);
610 if (!inst) {
611 _mesa_error(ctx, GL_OUT_OF_MEMORY, "_mesa_nop_fragment_program");
612 return;
613 }
614
615 _mesa_init_instructions(inst, 2);
616
617 inst[0].Opcode = OPCODE_MOV;
618 inst[0].DstReg.File = PROGRAM_OUTPUT;
619 inst[0].DstReg.Index = FRAG_RESULT_COLOR;
620 inst[0].SrcReg[0].File = PROGRAM_INPUT;
621 if (prog->Base.InputsRead & FRAG_BIT_COL0)
622 inputAttr = FRAG_ATTRIB_COL0;
623 else
624 inputAttr = FRAG_ATTRIB_TEX0;
625 inst[0].SrcReg[0].Index = inputAttr;
626
627 inst[1].Opcode = OPCODE_END;
628
629 _mesa_free_instructions(prog->Base.Instructions,
630 prog->Base.NumInstructions);
631
632 prog->Base.Instructions = inst;
633 prog->Base.NumInstructions = 2;
634 prog->Base.InputsRead = BITFIELD64_BIT(inputAttr);
635 prog->Base.OutputsWritten = BITFIELD64_BIT(FRAG_RESULT_COLOR);
636 }
637
638
639 /**
640 * \sa _mesa_nop_fragment_program
641 * Replace the given vertex program with a "no-op" program that just
642 * transforms vertex position and emits color.
643 */
644 void
645 _mesa_nop_vertex_program(struct gl_context *ctx, struct gl_vertex_program *prog)
646 {
647 struct prog_instruction *inst;
648 GLuint inputAttr;
649
650 /*
651 * Start with a simple vertex program that emits color.
652 */
653 inst = _mesa_alloc_instructions(2);
654 if (!inst) {
655 _mesa_error(ctx, GL_OUT_OF_MEMORY, "_mesa_nop_vertex_program");
656 return;
657 }
658
659 _mesa_init_instructions(inst, 2);
660
661 inst[0].Opcode = OPCODE_MOV;
662 inst[0].DstReg.File = PROGRAM_OUTPUT;
663 inst[0].DstReg.Index = VERT_RESULT_COL0;
664 inst[0].SrcReg[0].File = PROGRAM_INPUT;
665 if (prog->Base.InputsRead & VERT_BIT_COLOR0)
666 inputAttr = VERT_ATTRIB_COLOR0;
667 else
668 inputAttr = VERT_ATTRIB_TEX0;
669 inst[0].SrcReg[0].Index = inputAttr;
670
671 inst[1].Opcode = OPCODE_END;
672
673 _mesa_free_instructions(prog->Base.Instructions,
674 prog->Base.NumInstructions);
675
676 prog->Base.Instructions = inst;
677 prog->Base.NumInstructions = 2;
678 prog->Base.InputsRead = BITFIELD64_BIT(inputAttr);
679 prog->Base.OutputsWritten = BITFIELD64_BIT(VERT_RESULT_COL0);
680
681 /*
682 * Now insert code to do standard modelview/projection transformation.
683 */
684 _mesa_insert_mvp_code(ctx, prog);
685 }
A free Windows-compatible Operating System