/* * Mesa 3-D graphics library * * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /** * \file programopt.c * Vertex/Fragment program optimizations and transformations for program * options, etc. * * \author Brian Paul */ #include "main/glheader.h" #include "main/context.h" #include "prog_parameter.h" #include "prog_statevars.h" #include "program.h" #include "programopt.h" #include "prog_instruction.h" /** * This function inserts instructions for coordinate modelview * projection * into a vertex program. * May be used to implement the position_invariant option. */ static void _mesa_insert_mvp_dp4_code(struct gl_context *ctx, struct gl_program *vprog) { struct prog_instruction *newInst; const GLuint origLen = vprog->NumInstructions; const GLuint newLen = origLen + 4; GLuint i; /* * Setup state references for the modelview/projection matrix. * XXX we should check if these state vars are already declared. */ static const gl_state_index mvpState[4][STATE_LENGTH] = { { STATE_MVP_MATRIX, 0, 0, 0, 0 }, /* state.matrix.mvp.row[0] */ { STATE_MVP_MATRIX, 0, 1, 1, 0 }, /* state.matrix.mvp.row[1] */ { STATE_MVP_MATRIX, 0, 2, 2, 0 }, /* state.matrix.mvp.row[2] */ { STATE_MVP_MATRIX, 0, 3, 3, 0 }, /* state.matrix.mvp.row[3] */ }; GLint mvpRef[4]; for (i = 0; i < 4; i++) { mvpRef[i] = _mesa_add_state_reference(vprog->Parameters, mvpState[i]); } /* Alloc storage for new instructions */ newInst = _mesa_alloc_instructions(newLen); if (!newInst) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramString(inserting position_invariant code)"); return; } /* * Generated instructions: * newInst[0] = DP4 result.position.x, mvp.row[0], vertex.position; * newInst[1] = DP4 result.position.y, mvp.row[1], vertex.position; * newInst[2] = DP4 result.position.z, mvp.row[2], vertex.position; * newInst[3] = DP4 result.position.w, mvp.row[3], vertex.position; */ _mesa_init_instructions(newInst, 4); for (i = 0; i < 4; i++) { newInst[i].Opcode = OPCODE_DP4; newInst[i].DstReg.File = PROGRAM_OUTPUT; newInst[i].DstReg.Index = VARYING_SLOT_POS; newInst[i].DstReg.WriteMask = (WRITEMASK_X << i); newInst[i].SrcReg[0].File = PROGRAM_STATE_VAR; newInst[i].SrcReg[0].Index = mvpRef[i]; newInst[i].SrcReg[0].Swizzle = SWIZZLE_NOOP; newInst[i].SrcReg[1].File = PROGRAM_INPUT; newInst[i].SrcReg[1].Index = VERT_ATTRIB_POS; newInst[i].SrcReg[1].Swizzle = SWIZZLE_NOOP; } /* Append original instructions after new instructions */ _mesa_copy_instructions (newInst + 4, vprog->Instructions, origLen); /* free old instructions */ _mesa_free_instructions(vprog->Instructions, origLen); /* install new instructions */ vprog->Instructions = newInst; vprog->NumInstructions = newLen; vprog->info.inputs_read |= VERT_BIT_POS; vprog->info.outputs_written |= BITFIELD64_BIT(VARYING_SLOT_POS); } static void _mesa_insert_mvp_mad_code(struct gl_context *ctx, struct gl_program *vprog) { struct prog_instruction *newInst; const GLuint origLen = vprog->NumInstructions; const GLuint newLen = origLen + 4; GLuint hposTemp; GLuint i; /* * Setup state references for the modelview/projection matrix. * XXX we should check if these state vars are already declared. */ static const gl_state_index mvpState[4][STATE_LENGTH] = { { STATE_MVP_MATRIX, 0, 0, 0, STATE_MATRIX_TRANSPOSE }, { STATE_MVP_MATRIX, 0, 1, 1, STATE_MATRIX_TRANSPOSE }, { STATE_MVP_MATRIX, 0, 2, 2, STATE_MATRIX_TRANSPOSE }, { STATE_MVP_MATRIX, 0, 3, 3, STATE_MATRIX_TRANSPOSE }, }; GLint mvpRef[4]; for (i = 0; i < 4; i++) { mvpRef[i] = _mesa_add_state_reference(vprog->Parameters, mvpState[i]); } /* Alloc storage for new instructions */ newInst = _mesa_alloc_instructions(newLen); if (!newInst) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramString(inserting position_invariant code)"); return; } /* TEMP hposTemp; */ hposTemp = vprog->NumTemporaries++; /* * Generated instructions: * emit_op2(p, OPCODE_MUL, tmp, 0, swizzle1(src,X), mat[0]); * emit_op3(p, OPCODE_MAD, tmp, 0, swizzle1(src,Y), mat[1], tmp); * emit_op3(p, OPCODE_MAD, tmp, 0, swizzle1(src,Z), mat[2], tmp); * emit_op3(p, OPCODE_MAD, dest, 0, swizzle1(src,W), mat[3], tmp); */ _mesa_init_instructions(newInst, 4); newInst[0].Opcode = OPCODE_MUL; newInst[0].DstReg.File = PROGRAM_TEMPORARY; newInst[0].DstReg.Index = hposTemp; newInst[0].DstReg.WriteMask = WRITEMASK_XYZW; newInst[0].SrcReg[0].File = PROGRAM_INPUT; newInst[0].SrcReg[0].Index = VERT_ATTRIB_POS; newInst[0].SrcReg[0].Swizzle = SWIZZLE_XXXX; newInst[0].SrcReg[1].File = PROGRAM_STATE_VAR; newInst[0].SrcReg[1].Index = mvpRef[0]; newInst[0].SrcReg[1].Swizzle = SWIZZLE_NOOP; for (i = 1; i <= 2; i++) { newInst[i].Opcode = OPCODE_MAD; newInst[i].DstReg.File = PROGRAM_TEMPORARY; newInst[i].DstReg.Index = hposTemp; newInst[i].DstReg.WriteMask = WRITEMASK_XYZW; newInst[i].SrcReg[0].File = PROGRAM_INPUT; newInst[i].SrcReg[0].Index = VERT_ATTRIB_POS; newInst[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(i,i,i,i); newInst[i].SrcReg[1].File = PROGRAM_STATE_VAR; newInst[i].SrcReg[1].Index = mvpRef[i]; newInst[i].SrcReg[1].Swizzle = SWIZZLE_NOOP; newInst[i].SrcReg[2].File = PROGRAM_TEMPORARY; newInst[i].SrcReg[2].Index = hposTemp; newInst[1].SrcReg[2].Swizzle = SWIZZLE_NOOP; } newInst[3].Opcode = OPCODE_MAD; newInst[3].DstReg.File = PROGRAM_OUTPUT; newInst[3].DstReg.Index = VARYING_SLOT_POS; newInst[3].DstReg.WriteMask = WRITEMASK_XYZW; newInst[3].SrcReg[0].File = PROGRAM_INPUT; newInst[3].SrcReg[0].Index = VERT_ATTRIB_POS; newInst[3].SrcReg[0].Swizzle = SWIZZLE_WWWW; newInst[3].SrcReg[1].File = PROGRAM_STATE_VAR; newInst[3].SrcReg[1].Index = mvpRef[3]; newInst[3].SrcReg[1].Swizzle = SWIZZLE_NOOP; newInst[3].SrcReg[2].File = PROGRAM_TEMPORARY; newInst[3].SrcReg[2].Index = hposTemp; newInst[3].SrcReg[2].Swizzle = SWIZZLE_NOOP; /* Append original instructions after new instructions */ _mesa_copy_instructions (newInst + 4, vprog->Instructions, origLen); /* free old instructions */ _mesa_free_instructions(vprog->Instructions, origLen); /* install new instructions */ vprog->Instructions = newInst; vprog->NumInstructions = newLen; vprog->info.inputs_read |= VERT_BIT_POS; vprog->info.outputs_written |= BITFIELD64_BIT(VARYING_SLOT_POS); } void _mesa_insert_mvp_code(struct gl_context *ctx, struct gl_program *vprog) { if (ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].OptimizeForAOS) _mesa_insert_mvp_dp4_code( ctx, vprog ); else _mesa_insert_mvp_mad_code( ctx, vprog ); } /** * Append instructions to implement fog * * The \c fragment.fogcoord input is used to compute the fog blend factor. * * \param ctx The GL context * \param fprog Fragment program that fog instructions will be appended to. * \param fog_mode Fog mode. One of \c GL_EXP, \c GL_EXP2, or \c GL_LINEAR. * \param saturate True if writes to color outputs should be clamped to [0, 1] * * \note * This function sets \c VARYING_BIT_FOGC in \c fprog->info.inputs_read. * * \todo With a little work, this function could be adapted to add fog code * to vertex programs too. */ void _mesa_append_fog_code(struct gl_context *ctx, struct gl_program *fprog, GLenum fog_mode, GLboolean saturate) { static const gl_state_index fogPStateOpt[STATE_LENGTH] = { STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED, 0, 0, 0 }; static const gl_state_index fogColorState[STATE_LENGTH] = { STATE_FOG_COLOR, 0, 0, 0, 0}; struct prog_instruction *newInst, *inst; const GLuint origLen = fprog->NumInstructions; const GLuint newLen = origLen + 5; GLuint i; GLint fogPRefOpt, fogColorRef; /* state references */ GLuint colorTemp, fogFactorTemp; /* temporary registerss */ if (fog_mode == GL_NONE) { _mesa_problem(ctx, "_mesa_append_fog_code() called for fragment program" " with fog_mode == GL_NONE"); return; } if (!(fprog->info.outputs_written & (1 << FRAG_RESULT_COLOR))) { /* program doesn't output color, so nothing to do */ return; } /* Alloc storage for new instructions */ newInst = _mesa_alloc_instructions(newLen); if (!newInst) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramString(inserting fog_option code)"); return; } /* Copy orig instructions into new instruction buffer */ _mesa_copy_instructions(newInst, fprog->Instructions, origLen); /* PARAM fogParamsRefOpt = internal optimized fog params; */ fogPRefOpt = _mesa_add_state_reference(fprog->Parameters, fogPStateOpt); /* PARAM fogColorRef = state.fog.color; */ fogColorRef = _mesa_add_state_reference(fprog->Parameters, fogColorState); /* TEMP colorTemp; */ colorTemp = fprog->NumTemporaries++; /* TEMP fogFactorTemp; */ fogFactorTemp = fprog->NumTemporaries++; /* Scan program to find where result.color is written */ inst = newInst; for (i = 0; i < fprog->NumInstructions; i++) { if (inst->Opcode == OPCODE_END) break; if (inst->DstReg.File == PROGRAM_OUTPUT && inst->DstReg.Index == FRAG_RESULT_COLOR) { /* change the instruction to write to colorTemp w/ clamping */ inst->DstReg.File = PROGRAM_TEMPORARY; inst->DstReg.Index = colorTemp; inst->Saturate = saturate; /* don't break (may be several writes to result.color) */ } inst++; } assert(inst->Opcode == OPCODE_END); /* we'll overwrite this inst */ _mesa_init_instructions(inst, 5); /* emit instructions to compute fog blending factor */ /* this is always clamped to [0, 1] regardless of fragment clamping */ if (fog_mode == GL_LINEAR) { /* MAD fogFactorTemp.x, fragment.fogcoord.x, fogPRefOpt.x, fogPRefOpt.y; */ inst->Opcode = OPCODE_MAD; inst->DstReg.File = PROGRAM_TEMPORARY; inst->DstReg.Index = fogFactorTemp; inst->DstReg.WriteMask = WRITEMASK_X; inst->SrcReg[0].File = PROGRAM_INPUT; inst->SrcReg[0].Index = VARYING_SLOT_FOGC; inst->SrcReg[0].Swizzle = SWIZZLE_XXXX; inst->SrcReg[1].File = PROGRAM_STATE_VAR; inst->SrcReg[1].Index = fogPRefOpt; inst->SrcReg[1].Swizzle = SWIZZLE_XXXX; inst->SrcReg[2].File = PROGRAM_STATE_VAR; inst->SrcReg[2].Index = fogPRefOpt; inst->SrcReg[2].Swizzle = SWIZZLE_YYYY; inst->Saturate = GL_TRUE; inst++; } else { assert(fog_mode == GL_EXP || fog_mode == GL_EXP2); /* fogPRefOpt.z = d/ln(2), fogPRefOpt.w = d/sqrt(ln(2) */ /* EXP: MUL fogFactorTemp.x, fogPRefOpt.z, fragment.fogcoord.x; */ /* EXP2: MUL fogFactorTemp.x, fogPRefOpt.w, fragment.fogcoord.x; */ inst->Opcode = OPCODE_MUL; inst->DstReg.File = PROGRAM_TEMPORARY; inst->DstReg.Index = fogFactorTemp; inst->DstReg.WriteMask = WRITEMASK_X; inst->SrcReg[0].File = PROGRAM_STATE_VAR; inst->SrcReg[0].Index = fogPRefOpt; inst->SrcReg[0].Swizzle = (fog_mode == GL_EXP) ? SWIZZLE_ZZZZ : SWIZZLE_WWWW; inst->SrcReg[1].File = PROGRAM_INPUT; inst->SrcReg[1].Index = VARYING_SLOT_FOGC; inst->SrcReg[1].Swizzle = SWIZZLE_XXXX; inst++; if (fog_mode == GL_EXP2) { /* MUL fogFactorTemp.x, fogFactorTemp.x, fogFactorTemp.x; */ inst->Opcode = OPCODE_MUL; inst->DstReg.File = PROGRAM_TEMPORARY; inst->DstReg.Index = fogFactorTemp; inst->DstReg.WriteMask = WRITEMASK_X; inst->SrcReg[0].File = PROGRAM_TEMPORARY; inst->SrcReg[0].Index = fogFactorTemp; inst->SrcReg[0].Swizzle = SWIZZLE_XXXX; inst->SrcReg[1].File = PROGRAM_TEMPORARY; inst->SrcReg[1].Index = fogFactorTemp; inst->SrcReg[1].Swizzle = SWIZZLE_XXXX; inst++; } /* EX2_SAT fogFactorTemp.x, -fogFactorTemp.x; */ inst->Opcode = OPCODE_EX2; inst->DstReg.File = PROGRAM_TEMPORARY; inst->DstReg.Index = fogFactorTemp; inst->DstReg.WriteMask = WRITEMASK_X; inst->SrcReg[0].File = PROGRAM_TEMPORARY; inst->SrcReg[0].Index = fogFactorTemp; inst->SrcReg[0].Negate = NEGATE_XYZW; inst->SrcReg[0].Swizzle = SWIZZLE_XXXX; inst->Saturate = GL_TRUE; inst++; } /* LRP result.color.xyz, fogFactorTemp.xxxx, colorTemp, fogColorRef; */ inst->Opcode = OPCODE_LRP; inst->DstReg.File = PROGRAM_OUTPUT; inst->DstReg.Index = FRAG_RESULT_COLOR; inst->DstReg.WriteMask = WRITEMASK_XYZ; inst->SrcReg[0].File = PROGRAM_TEMPORARY; inst->SrcReg[0].Index = fogFactorTemp; inst->SrcReg[0].Swizzle = SWIZZLE_XXXX; inst->SrcReg[1].File = PROGRAM_TEMPORARY; inst->SrcReg[1].Index = colorTemp; inst->SrcReg[1].Swizzle = SWIZZLE_NOOP; inst->SrcReg[2].File = PROGRAM_STATE_VAR; inst->SrcReg[2].Index = fogColorRef; inst->SrcReg[2].Swizzle = SWIZZLE_NOOP; inst++; /* MOV result.color.w, colorTemp.x; # copy alpha */ inst->Opcode = OPCODE_MOV; inst->DstReg.File = PROGRAM_OUTPUT; inst->DstReg.Index = FRAG_RESULT_COLOR; inst->DstReg.WriteMask = WRITEMASK_W; inst->SrcReg[0].File = PROGRAM_TEMPORARY; inst->SrcReg[0].Index = colorTemp; inst->SrcReg[0].Swizzle = SWIZZLE_NOOP; inst++; /* END; */ inst->Opcode = OPCODE_END; inst++; /* free old instructions */ _mesa_free_instructions(fprog->Instructions, origLen); /* install new instructions */ fprog->Instructions = newInst; fprog->NumInstructions = inst - newInst; fprog->info.inputs_read |= VARYING_BIT_FOGC; assert(fprog->info.outputs_written & (1 << FRAG_RESULT_COLOR)); } static GLboolean is_texture_instruction(const struct prog_instruction *inst) { switch (inst->Opcode) { case OPCODE_TEX: case OPCODE_TXB: case OPCODE_TXD: case OPCODE_TXL: case OPCODE_TXP: return GL_TRUE; default: return GL_FALSE; } } /** * Count the number of texure indirections in the given program. * The program's NumTexIndirections field will be updated. * See the GL_ARB_fragment_program spec (issue 24) for details. * XXX we count texture indirections in texenvprogram.c (maybe use this code * instead and elsewhere). */ void _mesa_count_texture_indirections(struct gl_program *prog) { GLuint indirections = 1; GLbitfield tempsOutput = 0x0; GLbitfield aluTemps = 0x0; GLuint i; for (i = 0; i < prog->NumInstructions; i++) { const struct prog_instruction *inst = prog->Instructions + i; if (is_texture_instruction(inst)) { if (((inst->SrcReg[0].File == PROGRAM_TEMPORARY) && (tempsOutput & (1 << inst->SrcReg[0].Index))) || ((inst->Opcode != OPCODE_KIL) && (inst->DstReg.File == PROGRAM_TEMPORARY) && (aluTemps & (1 << inst->DstReg.Index)))) { indirections++; tempsOutput = 0x0; aluTemps = 0x0; } } else { GLuint j; for (j = 0; j < 3; j++) { if (inst->SrcReg[j].File == PROGRAM_TEMPORARY) aluTemps |= (1 << inst->SrcReg[j].Index); } if (inst->DstReg.File == PROGRAM_TEMPORARY) aluTemps |= (1 << inst->DstReg.Index); } if ((inst->Opcode != OPCODE_KIL) && (inst->DstReg.File == PROGRAM_TEMPORARY)) tempsOutput |= (1 << inst->DstReg.Index); } prog->NumTexIndirections = indirections; } /** * Count number of texture instructions in given program and update the * program's NumTexInstructions field. */ void _mesa_count_texture_instructions(struct gl_program *prog) { GLuint i; prog->NumTexInstructions = 0; for (i = 0; i < prog->NumInstructions; i++) { prog->NumTexInstructions += is_texture_instruction(prog->Instructions + i); } } /** * Scan/rewrite program to remove reads of custom (output) registers. * The passed type has to be PROGRAM_OUTPUT. * On some hardware, trying to read an output register causes trouble. * So, rewrite the program to use a temporary register in this case. */ void _mesa_remove_output_reads(struct gl_program *prog, gl_register_file type) { GLuint i; GLint outputMap[VARYING_SLOT_MAX]; GLuint numVaryingReads = 0; GLboolean usedTemps[MAX_PROGRAM_TEMPS]; GLuint firstTemp = 0; _mesa_find_used_registers(prog, PROGRAM_TEMPORARY, usedTemps, MAX_PROGRAM_TEMPS); assert(type == PROGRAM_OUTPUT); for (i = 0; i < VARYING_SLOT_MAX; i++) outputMap[i] = -1; /* look for instructions which read from varying vars */ for (i = 0; i < prog->NumInstructions; i++) { struct prog_instruction *inst = prog->Instructions + i; const GLuint numSrc = _mesa_num_inst_src_regs(inst->Opcode); GLuint j; for (j = 0; j < numSrc; j++) { if (inst->SrcReg[j].File == type) { /* replace the read with a temp reg */ const GLuint var = inst->SrcReg[j].Index; if (outputMap[var] == -1) { numVaryingReads++; outputMap[var] = _mesa_find_free_register(usedTemps, MAX_PROGRAM_TEMPS, firstTemp); firstTemp = outputMap[var] + 1; } inst->SrcReg[j].File = PROGRAM_TEMPORARY; inst->SrcReg[j].Index = outputMap[var]; } } } if (numVaryingReads == 0) return; /* nothing to be done */ /* look for instructions which write to the varying vars identified above */ for (i = 0; i < prog->NumInstructions; i++) { struct prog_instruction *inst = prog->Instructions + i; if (inst->DstReg.File == type && outputMap[inst->DstReg.Index] >= 0) { /* change inst to write to the temp reg, instead of the varying */ inst->DstReg.File = PROGRAM_TEMPORARY; inst->DstReg.Index = outputMap[inst->DstReg.Index]; } } /* insert new instructions to copy the temp vars to the varying vars */ { struct prog_instruction *inst; GLint endPos, var; /* Look for END instruction and insert the new varying writes */ endPos = -1; for (i = 0; i < prog->NumInstructions; i++) { struct prog_instruction *inst = prog->Instructions + i; if (inst->Opcode == OPCODE_END) { endPos = i; _mesa_insert_instructions(prog, i, numVaryingReads); break; } } assert(endPos >= 0); /* insert new MOV instructions here */ inst = prog->Instructions + endPos; for (var = 0; var < VARYING_SLOT_MAX; var++) { if (outputMap[var] >= 0) { /* MOV VAR[var], TEMP[tmp]; */ inst->Opcode = OPCODE_MOV; inst->DstReg.File = type; inst->DstReg.Index = var; inst->SrcReg[0].File = PROGRAM_TEMPORARY; inst->SrcReg[0].Index = outputMap[var]; inst++; } } } } void _mesa_program_fragment_position_to_sysval(struct gl_program *prog) { GLuint i; if (prog->Target != GL_FRAGMENT_PROGRAM_ARB || !(prog->info.inputs_read & BITFIELD64_BIT(VARYING_SLOT_POS))) return; prog->info.inputs_read &= ~BITFIELD64_BIT(VARYING_SLOT_POS); prog->SystemValuesRead |= 1 << SYSTEM_VALUE_FRAG_COORD; for (i = 0; i < prog->NumInstructions; i++) { struct prog_instruction *inst = prog->Instructions + i; const GLuint numSrc = _mesa_num_inst_src_regs(inst->Opcode); GLuint j; for (j = 0; j < numSrc; j++) { if (inst->SrcReg[j].File == PROGRAM_INPUT && inst->SrcReg[j].Index == VARYING_SLOT_POS) { inst->SrcReg[j].File = PROGRAM_SYSTEM_VALUE; inst->SrcReg[j].Index = SYSTEM_VALUE_FRAG_COORD; } } } }