1 // Copyright 2016 The SwiftShader Authors. All Rights Reserved. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #include "VertexProgram.hpp" 16 17 #include "VertexShader.hpp" 18 #include "SamplerCore.hpp" 19 #include "Renderer/Renderer.hpp" 20 #include "Renderer/Vertex.hpp" 21 #include "Common/Half.hpp" 22 #include "Common/Debug.hpp" 23 24 namespace sw 25 { VertexProgram(const VertexProcessor::State & state,const VertexShader * shader)26 VertexProgram::VertexProgram(const VertexProcessor::State &state, const VertexShader *shader) 27 : VertexRoutine(state, shader), 28 shader(shader), 29 r(shader->indirectAddressableTemporaries), 30 aL(shader->getLimits().loops), 31 increment(shader->getLimits().loops), 32 iteration(shader->getLimits().loops), 33 callStack(shader->getLimits().stack) 34 { 35 auto limits = shader->getLimits(); 36 ifFalseBlock.resize(limits.ifs); 37 loopRepTestBlock.resize(limits.loops); 38 loopRepEndBlock.resize(limits.loops); 39 labelBlock.resize(limits.maxLabel + 1); 40 isConditionalIf.resize(limits.ifs); 41 42 loopDepth = -1; 43 enableStack[0] = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF); 44 45 if(shader->containsBreakInstruction()) 46 { 47 enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF); 48 } 49 50 if(shader->containsContinueInstruction()) 51 { 52 enableContinue = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF); 53 } 54 55 if(shader->isInstanceIdDeclared()) 56 { 57 instanceID = *Pointer<Int>(data + OFFSET(DrawData,instanceID)); 58 } 59 } 60 ~VertexProgram()61 VertexProgram::~VertexProgram() 62 { 63 } 64 pipeline(UInt & index)65 void VertexProgram::pipeline(UInt &index) 66 { 67 if(!state.preTransformed) 68 { 69 program(index); 70 } 71 else 72 { 73 passThrough(); 74 } 75 } 76 program(UInt & index)77 void VertexProgram::program(UInt &index) 78 { 79 // shader->print("VertexShader-%0.8X.txt", state.shaderID); 80 81 unsigned short shaderModel = shader->getShaderModel(); 82 83 enableIndex = 0; 84 stackIndex = 0; 85 86 if(shader->containsLeaveInstruction()) 87 { 88 enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF); 89 } 90 91 if(shader->isVertexIdDeclared()) 92 { 93 if(state.textureSampling) 94 { 95 vertexID = Int4(Int(index)); 96 } 97 else 98 { 99 vertexID = Insert(vertexID, As<Int>(index), 0); 100 vertexID = Insert(vertexID, As<Int>(index + 1), 1); 101 vertexID = Insert(vertexID, As<Int>(index + 2), 2); 102 vertexID = Insert(vertexID, As<Int>(index + 3), 3); 103 } 104 } 105 106 // Create all call site return blocks up front 107 for(size_t i = 0; i < shader->getLength(); i++) 108 { 109 const Shader::Instruction *instruction = shader->getInstruction(i); 110 Shader::Opcode opcode = instruction->opcode; 111 112 if(opcode == Shader::OPCODE_CALL || opcode == Shader::OPCODE_CALLNZ) 113 { 114 const Dst &dst = instruction->dst; 115 116 ASSERT(callRetBlock[dst.label].size() == dst.callSite); 117 callRetBlock[dst.label].push_back(Nucleus::createBasicBlock()); 118 } 119 } 120 121 for(size_t i = 0; i < shader->getLength(); i++) 122 { 123 const Shader::Instruction *instruction = shader->getInstruction(i); 124 Shader::Opcode opcode = instruction->opcode; 125 126 if(opcode == Shader::OPCODE_DCL || opcode == Shader::OPCODE_DEF || opcode == Shader::OPCODE_DEFI || opcode == Shader::OPCODE_DEFB) 127 { 128 continue; 129 } 130 131 Dst dst = instruction->dst; 132 Src src0 = instruction->src[0]; 133 Src src1 = instruction->src[1]; 134 Src src2 = instruction->src[2]; 135 Src src3 = instruction->src[3]; 136 Src src4 = instruction->src[4]; 137 138 bool predicate = instruction->predicate; 139 Control control = instruction->control; 140 bool integer = dst.type == Shader::PARAMETER_ADDR; 141 bool pp = dst.partialPrecision; 142 143 Vector4f d; 144 Vector4f s0; 145 Vector4f s1; 146 Vector4f s2; 147 Vector4f s3; 148 Vector4f s4; 149 150 if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegister(src0); 151 if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegister(src1); 152 if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegister(src2); 153 if(src3.type != Shader::PARAMETER_VOID) s3 = fetchRegister(src3); 154 if(src4.type != Shader::PARAMETER_VOID) s4 = fetchRegister(src4); 155 156 switch(opcode) 157 { 158 case Shader::OPCODE_VS_1_0: break; 159 case Shader::OPCODE_VS_1_1: break; 160 case Shader::OPCODE_VS_2_0: break; 161 case Shader::OPCODE_VS_2_x: break; 162 case Shader::OPCODE_VS_2_sw: break; 163 case Shader::OPCODE_VS_3_0: break; 164 case Shader::OPCODE_VS_3_sw: break; 165 case Shader::OPCODE_DCL: break; 166 case Shader::OPCODE_DEF: break; 167 case Shader::OPCODE_DEFI: break; 168 case Shader::OPCODE_DEFB: break; 169 case Shader::OPCODE_NOP: break; 170 case Shader::OPCODE_ABS: abs(d, s0); break; 171 case Shader::OPCODE_IABS: iabs(d, s0); break; 172 case Shader::OPCODE_ADD: add(d, s0, s1); break; 173 case Shader::OPCODE_IADD: iadd(d, s0, s1); break; 174 case Shader::OPCODE_CRS: crs(d, s0, s1); break; 175 case Shader::OPCODE_FORWARD1: forward1(d, s0, s1, s2); break; 176 case Shader::OPCODE_FORWARD2: forward2(d, s0, s1, s2); break; 177 case Shader::OPCODE_FORWARD3: forward3(d, s0, s1, s2); break; 178 case Shader::OPCODE_FORWARD4: forward4(d, s0, s1, s2); break; 179 case Shader::OPCODE_REFLECT1: reflect1(d, s0, s1); break; 180 case Shader::OPCODE_REFLECT2: reflect2(d, s0, s1); break; 181 case Shader::OPCODE_REFLECT3: reflect3(d, s0, s1); break; 182 case Shader::OPCODE_REFLECT4: reflect4(d, s0, s1); break; 183 case Shader::OPCODE_REFRACT1: refract1(d, s0, s1, s2.x); break; 184 case Shader::OPCODE_REFRACT2: refract2(d, s0, s1, s2.x); break; 185 case Shader::OPCODE_REFRACT3: refract3(d, s0, s1, s2.x); break; 186 case Shader::OPCODE_REFRACT4: refract4(d, s0, s1, s2.x); break; 187 case Shader::OPCODE_DP1: dp1(d, s0, s1); break; 188 case Shader::OPCODE_DP2: dp2(d, s0, s1); break; 189 case Shader::OPCODE_DP3: dp3(d, s0, s1); break; 190 case Shader::OPCODE_DP4: dp4(d, s0, s1); break; 191 case Shader::OPCODE_DET2: det2(d, s0, s1); break; 192 case Shader::OPCODE_DET3: det3(d, s0, s1, s2); break; 193 case Shader::OPCODE_DET4: det4(d, s0, s1, s2, s3); break; 194 case Shader::OPCODE_ATT: att(d, s0, s1); break; 195 case Shader::OPCODE_EXP2X: exp2x(d, s0, pp); break; 196 case Shader::OPCODE_EXP2: exp2(d, s0, pp); break; 197 case Shader::OPCODE_EXPP: expp(d, s0, shaderModel); break; 198 case Shader::OPCODE_EXP: exp(d, s0, pp); break; 199 case Shader::OPCODE_FRC: frc(d, s0); break; 200 case Shader::OPCODE_TRUNC: trunc(d, s0); break; 201 case Shader::OPCODE_FLOOR: floor(d, s0); break; 202 case Shader::OPCODE_ROUND: round(d, s0); break; 203 case Shader::OPCODE_ROUNDEVEN: roundEven(d, s0); break; 204 case Shader::OPCODE_CEIL: ceil(d, s0); break; 205 case Shader::OPCODE_LIT: lit(d, s0); break; 206 case Shader::OPCODE_LOG2X: log2x(d, s0, pp); break; 207 case Shader::OPCODE_LOG2: log2(d, s0, pp); break; 208 case Shader::OPCODE_LOGP: logp(d, s0, shaderModel); break; 209 case Shader::OPCODE_LOG: log(d, s0, pp); break; 210 case Shader::OPCODE_LRP: lrp(d, s0, s1, s2); break; 211 case Shader::OPCODE_STEP: step(d, s0, s1); break; 212 case Shader::OPCODE_SMOOTH: smooth(d, s0, s1, s2); break; 213 case Shader::OPCODE_ISINF: isinf(d, s0); break; 214 case Shader::OPCODE_ISNAN: isnan(d, s0); break; 215 case Shader::OPCODE_FLOATBITSTOINT: 216 case Shader::OPCODE_FLOATBITSTOUINT: 217 case Shader::OPCODE_INTBITSTOFLOAT: 218 case Shader::OPCODE_UINTBITSTOFLOAT: d = s0; break; 219 case Shader::OPCODE_PACKSNORM2x16: packSnorm2x16(d, s0); break; 220 case Shader::OPCODE_PACKUNORM2x16: packUnorm2x16(d, s0); break; 221 case Shader::OPCODE_PACKHALF2x16: packHalf2x16(d, s0); break; 222 case Shader::OPCODE_UNPACKSNORM2x16: unpackSnorm2x16(d, s0); break; 223 case Shader::OPCODE_UNPACKUNORM2x16: unpackUnorm2x16(d, s0); break; 224 case Shader::OPCODE_UNPACKHALF2x16: unpackHalf2x16(d, s0); break; 225 case Shader::OPCODE_M3X2: M3X2(d, s0, src1); break; 226 case Shader::OPCODE_M3X3: M3X3(d, s0, src1); break; 227 case Shader::OPCODE_M3X4: M3X4(d, s0, src1); break; 228 case Shader::OPCODE_M4X3: M4X3(d, s0, src1); break; 229 case Shader::OPCODE_M4X4: M4X4(d, s0, src1); break; 230 case Shader::OPCODE_MAD: mad(d, s0, s1, s2); break; 231 case Shader::OPCODE_IMAD: imad(d, s0, s1, s2); break; 232 case Shader::OPCODE_MAX: max(d, s0, s1); break; 233 case Shader::OPCODE_IMAX: imax(d, s0, s1); break; 234 case Shader::OPCODE_UMAX: umax(d, s0, s1); break; 235 case Shader::OPCODE_MIN: min(d, s0, s1); break; 236 case Shader::OPCODE_IMIN: imin(d, s0, s1); break; 237 case Shader::OPCODE_UMIN: umin(d, s0, s1); break; 238 case Shader::OPCODE_MOV: mov(d, s0, integer); break; 239 case Shader::OPCODE_MOVA: mov(d, s0, true); break; 240 case Shader::OPCODE_NEG: neg(d, s0); break; 241 case Shader::OPCODE_INEG: ineg(d, s0); break; 242 case Shader::OPCODE_F2B: f2b(d, s0); break; 243 case Shader::OPCODE_B2F: b2f(d, s0); break; 244 case Shader::OPCODE_F2I: f2i(d, s0); break; 245 case Shader::OPCODE_I2F: i2f(d, s0); break; 246 case Shader::OPCODE_F2U: f2u(d, s0); break; 247 case Shader::OPCODE_U2F: u2f(d, s0); break; 248 case Shader::OPCODE_I2B: i2b(d, s0); break; 249 case Shader::OPCODE_B2I: b2i(d, s0); break; 250 case Shader::OPCODE_MUL: mul(d, s0, s1); break; 251 case Shader::OPCODE_IMUL: imul(d, s0, s1); break; 252 case Shader::OPCODE_NRM2: nrm2(d, s0, pp); break; 253 case Shader::OPCODE_NRM3: nrm3(d, s0, pp); break; 254 case Shader::OPCODE_NRM4: nrm4(d, s0, pp); break; 255 case Shader::OPCODE_POWX: powx(d, s0, s1, pp); break; 256 case Shader::OPCODE_POW: pow(d, s0, s1, pp); break; 257 case Shader::OPCODE_RCPX: rcpx(d, s0, pp); break; 258 case Shader::OPCODE_DIV: div(d, s0, s1); break; 259 case Shader::OPCODE_IDIV: idiv(d, s0, s1); break; 260 case Shader::OPCODE_UDIV: udiv(d, s0, s1); break; 261 case Shader::OPCODE_MOD: mod(d, s0, s1); break; 262 case Shader::OPCODE_IMOD: imod(d, s0, s1); break; 263 case Shader::OPCODE_UMOD: umod(d, s0, s1); break; 264 case Shader::OPCODE_SHL: shl(d, s0, s1); break; 265 case Shader::OPCODE_ISHR: ishr(d, s0, s1); break; 266 case Shader::OPCODE_USHR: ushr(d, s0, s1); break; 267 case Shader::OPCODE_RSQX: rsqx(d, s0, pp); break; 268 case Shader::OPCODE_SQRT: sqrt(d, s0, pp); break; 269 case Shader::OPCODE_RSQ: rsq(d, s0, pp); break; 270 case Shader::OPCODE_LEN2: len2(d.x, s0, pp); break; 271 case Shader::OPCODE_LEN3: len3(d.x, s0, pp); break; 272 case Shader::OPCODE_LEN4: len4(d.x, s0, pp); break; 273 case Shader::OPCODE_DIST1: dist1(d.x, s0, s1, pp); break; 274 case Shader::OPCODE_DIST2: dist2(d.x, s0, s1, pp); break; 275 case Shader::OPCODE_DIST3: dist3(d.x, s0, s1, pp); break; 276 case Shader::OPCODE_DIST4: dist4(d.x, s0, s1, pp); break; 277 case Shader::OPCODE_SGE: step(d, s1, s0); break; 278 case Shader::OPCODE_SGN: sgn(d, s0); break; 279 case Shader::OPCODE_ISGN: isgn(d, s0); break; 280 case Shader::OPCODE_SINCOS: sincos(d, s0, pp); break; 281 case Shader::OPCODE_COS: cos(d, s0, pp); break; 282 case Shader::OPCODE_SIN: sin(d, s0, pp); break; 283 case Shader::OPCODE_TAN: tan(d, s0); break; 284 case Shader::OPCODE_ACOS: acos(d, s0); break; 285 case Shader::OPCODE_ASIN: asin(d, s0); break; 286 case Shader::OPCODE_ATAN: atan(d, s0); break; 287 case Shader::OPCODE_ATAN2: atan2(d, s0, s1); break; 288 case Shader::OPCODE_COSH: cosh(d, s0, pp); break; 289 case Shader::OPCODE_SINH: sinh(d, s0, pp); break; 290 case Shader::OPCODE_TANH: tanh(d, s0, pp); break; 291 case Shader::OPCODE_ACOSH: acosh(d, s0, pp); break; 292 case Shader::OPCODE_ASINH: asinh(d, s0, pp); break; 293 case Shader::OPCODE_ATANH: atanh(d, s0, pp); break; 294 case Shader::OPCODE_SLT: slt(d, s0, s1); break; 295 case Shader::OPCODE_SUB: sub(d, s0, s1); break; 296 case Shader::OPCODE_ISUB: isub(d, s0, s1); break; 297 case Shader::OPCODE_BREAK: BREAK(); break; 298 case Shader::OPCODE_BREAKC: BREAKC(s0, s1, control); break; 299 case Shader::OPCODE_BREAKP: BREAKP(src0); break; 300 case Shader::OPCODE_CONTINUE: CONTINUE(); break; 301 case Shader::OPCODE_TEST: TEST(); break; 302 case Shader::OPCODE_SCALAR: SCALAR(); break; 303 case Shader::OPCODE_CALL: CALL(dst.label, dst.callSite); break; 304 case Shader::OPCODE_CALLNZ: CALLNZ(dst.label, dst.callSite, src0); break; 305 case Shader::OPCODE_ELSE: ELSE(); break; 306 case Shader::OPCODE_ENDIF: ENDIF(); break; 307 case Shader::OPCODE_ENDLOOP: ENDLOOP(); break; 308 case Shader::OPCODE_ENDREP: ENDREP(); break; 309 case Shader::OPCODE_ENDWHILE: ENDWHILE(); break; 310 case Shader::OPCODE_ENDSWITCH: ENDSWITCH(); break; 311 case Shader::OPCODE_IF: IF(src0); break; 312 case Shader::OPCODE_IFC: IFC(s0, s1, control); break; 313 case Shader::OPCODE_LABEL: LABEL(dst.index); break; 314 case Shader::OPCODE_LOOP: LOOP(src1); break; 315 case Shader::OPCODE_REP: REP(src0); break; 316 case Shader::OPCODE_WHILE: WHILE(src0); break; 317 case Shader::OPCODE_SWITCH: SWITCH(); break; 318 case Shader::OPCODE_RET: RET(); break; 319 case Shader::OPCODE_LEAVE: LEAVE(); break; 320 case Shader::OPCODE_CMP: cmp(d, s0, s1, control); break; 321 case Shader::OPCODE_ICMP: icmp(d, s0, s1, control); break; 322 case Shader::OPCODE_UCMP: ucmp(d, s0, s1, control); break; 323 case Shader::OPCODE_SELECT: select(d, s0, s1, s2); break; 324 case Shader::OPCODE_EXTRACT: extract(d.x, s0, s1.x); break; 325 case Shader::OPCODE_INSERT: insert(d, s0, s1.x, s2.x); break; 326 case Shader::OPCODE_ALL: all(d.x, s0); break; 327 case Shader::OPCODE_ANY: any(d.x, s0); break; 328 case Shader::OPCODE_NOT: bitwise_not(d, s0); break; 329 case Shader::OPCODE_OR: bitwise_or(d, s0, s1); break; 330 case Shader::OPCODE_XOR: bitwise_xor(d, s0, s1); break; 331 case Shader::OPCODE_AND: bitwise_and(d, s0, s1); break; 332 case Shader::OPCODE_EQ: equal(d, s0, s1); break; 333 case Shader::OPCODE_NE: notEqual(d, s0, s1); break; 334 case Shader::OPCODE_TEXLDL: TEXLOD(d, s0, src1, s0.w); break; 335 case Shader::OPCODE_TEXLOD: TEXLOD(d, s0, src1, s2.x); break; 336 case Shader::OPCODE_TEX: TEX(d, s0, src1); break; 337 case Shader::OPCODE_TEXOFFSET: TEXOFFSET(d, s0, src1, s2); break; 338 case Shader::OPCODE_TEXLODOFFSET: TEXLODOFFSET(d, s0, src1, s2, s3.x); break; 339 case Shader::OPCODE_TEXELFETCH: TEXELFETCH(d, s0, src1, s2.x); break; 340 case Shader::OPCODE_TEXELFETCHOFFSET: TEXELFETCHOFFSET(d, s0, src1, s2, s3.x); break; 341 case Shader::OPCODE_TEXGRAD: TEXGRAD(d, s0, src1, s2, s3); break; 342 case Shader::OPCODE_TEXGRADOFFSET: TEXGRADOFFSET(d, s0, src1, s2, s3, s4); break; 343 case Shader::OPCODE_TEXSIZE: TEXSIZE(d, s0.x, src1); break; 344 case Shader::OPCODE_END: break; 345 default: 346 ASSERT(false); 347 } 348 349 if(dst.type != Shader::PARAMETER_VOID && dst.type != Shader::PARAMETER_LABEL && opcode != Shader::OPCODE_NOP) 350 { 351 if(dst.saturate) 352 { 353 if(dst.x) d.x = Max(d.x, Float4(0.0f)); 354 if(dst.y) d.y = Max(d.y, Float4(0.0f)); 355 if(dst.z) d.z = Max(d.z, Float4(0.0f)); 356 if(dst.w) d.w = Max(d.w, Float4(0.0f)); 357 358 if(dst.x) d.x = Min(d.x, Float4(1.0f)); 359 if(dst.y) d.y = Min(d.y, Float4(1.0f)); 360 if(dst.z) d.z = Min(d.z, Float4(1.0f)); 361 if(dst.w) d.w = Min(d.w, Float4(1.0f)); 362 } 363 364 if(instruction->isPredicated()) 365 { 366 Vector4f pDst; // FIXME: Rename 367 368 switch(dst.type) 369 { 370 case Shader::PARAMETER_VOID: break; 371 case Shader::PARAMETER_TEMP: 372 if(dst.rel.type == Shader::PARAMETER_VOID) 373 { 374 if(dst.x) pDst.x = r[dst.index].x; 375 if(dst.y) pDst.y = r[dst.index].y; 376 if(dst.z) pDst.z = r[dst.index].z; 377 if(dst.w) pDst.w = r[dst.index].w; 378 } 379 else if(!dst.rel.dynamic) 380 { 381 Int a = dst.index + relativeAddress(dst.rel); 382 383 if(dst.x) pDst.x = r[a].x; 384 if(dst.y) pDst.y = r[a].y; 385 if(dst.z) pDst.z = r[a].z; 386 if(dst.w) pDst.w = r[a].w; 387 } 388 else 389 { 390 Int4 a = dst.index + dynamicAddress(dst.rel); 391 392 if(dst.x) pDst.x = r[a].x; 393 if(dst.y) pDst.y = r[a].y; 394 if(dst.z) pDst.z = r[a].z; 395 if(dst.w) pDst.w = r[a].w; 396 } 397 break; 398 case Shader::PARAMETER_ADDR: pDst = a0; break; 399 case Shader::PARAMETER_RASTOUT: 400 switch(dst.index) 401 { 402 case 0: 403 if(dst.x) pDst.x = o[Pos].x; 404 if(dst.y) pDst.y = o[Pos].y; 405 if(dst.z) pDst.z = o[Pos].z; 406 if(dst.w) pDst.w = o[Pos].w; 407 break; 408 case 1: 409 pDst.x = o[Fog].x; 410 break; 411 case 2: 412 pDst.x = o[Pts].y; 413 break; 414 default: 415 ASSERT(false); 416 } 417 break; 418 case Shader::PARAMETER_ATTROUT: 419 if(dst.x) pDst.x = o[C0 + dst.index].x; 420 if(dst.y) pDst.y = o[C0 + dst.index].y; 421 if(dst.z) pDst.z = o[C0 + dst.index].z; 422 if(dst.w) pDst.w = o[C0 + dst.index].w; 423 break; 424 case Shader::PARAMETER_TEXCRDOUT: 425 // case Shader::PARAMETER_OUTPUT: 426 if(shaderModel < 0x0300) 427 { 428 if(dst.x) pDst.x = o[T0 + dst.index].x; 429 if(dst.y) pDst.y = o[T0 + dst.index].y; 430 if(dst.z) pDst.z = o[T0 + dst.index].z; 431 if(dst.w) pDst.w = o[T0 + dst.index].w; 432 } 433 else if(dst.rel.type == Shader::PARAMETER_VOID) // Not relative 434 { 435 if(dst.x) pDst.x = o[dst.index].x; 436 if(dst.y) pDst.y = o[dst.index].y; 437 if(dst.z) pDst.z = o[dst.index].z; 438 if(dst.w) pDst.w = o[dst.index].w; 439 } 440 else if(!dst.rel.dynamic) 441 { 442 Int a = dst.index + relativeAddress(dst.rel); 443 444 if(dst.x) pDst.x = o[a].x; 445 if(dst.y) pDst.y = o[a].y; 446 if(dst.z) pDst.z = o[a].z; 447 if(dst.w) pDst.w = o[a].w; 448 } 449 else 450 { 451 Int4 a = dst.index + dynamicAddress(dst.rel); 452 453 if(dst.x) pDst.x = o[a].x; 454 if(dst.y) pDst.y = o[a].y; 455 if(dst.z) pDst.z = o[a].z; 456 if(dst.w) pDst.w = o[a].w; 457 } 458 break; 459 case Shader::PARAMETER_LABEL: break; 460 case Shader::PARAMETER_PREDICATE: pDst = p0; break; 461 case Shader::PARAMETER_INPUT: break; 462 default: 463 ASSERT(false); 464 } 465 466 Int4 enable = enableMask(instruction); 467 468 Int4 xEnable = enable; 469 Int4 yEnable = enable; 470 Int4 zEnable = enable; 471 Int4 wEnable = enable; 472 473 if(predicate) 474 { 475 unsigned char pSwizzle = instruction->predicateSwizzle; 476 477 Float4 xPredicate = p0[(pSwizzle >> 0) & 0x03]; 478 Float4 yPredicate = p0[(pSwizzle >> 2) & 0x03]; 479 Float4 zPredicate = p0[(pSwizzle >> 4) & 0x03]; 480 Float4 wPredicate = p0[(pSwizzle >> 6) & 0x03]; 481 482 if(!instruction->predicateNot) 483 { 484 if(dst.x) xEnable = xEnable & As<Int4>(xPredicate); 485 if(dst.y) yEnable = yEnable & As<Int4>(yPredicate); 486 if(dst.z) zEnable = zEnable & As<Int4>(zPredicate); 487 if(dst.w) wEnable = wEnable & As<Int4>(wPredicate); 488 } 489 else 490 { 491 if(dst.x) xEnable = xEnable & ~As<Int4>(xPredicate); 492 if(dst.y) yEnable = yEnable & ~As<Int4>(yPredicate); 493 if(dst.z) zEnable = zEnable & ~As<Int4>(zPredicate); 494 if(dst.w) wEnable = wEnable & ~As<Int4>(wPredicate); 495 } 496 } 497 498 if(dst.x) d.x = As<Float4>(As<Int4>(d.x) & xEnable); 499 if(dst.y) d.y = As<Float4>(As<Int4>(d.y) & yEnable); 500 if(dst.z) d.z = As<Float4>(As<Int4>(d.z) & zEnable); 501 if(dst.w) d.w = As<Float4>(As<Int4>(d.w) & wEnable); 502 503 if(dst.x) d.x = As<Float4>(As<Int4>(d.x) | (As<Int4>(pDst.x) & ~xEnable)); 504 if(dst.y) d.y = As<Float4>(As<Int4>(d.y) | (As<Int4>(pDst.y) & ~yEnable)); 505 if(dst.z) d.z = As<Float4>(As<Int4>(d.z) | (As<Int4>(pDst.z) & ~zEnable)); 506 if(dst.w) d.w = As<Float4>(As<Int4>(d.w) | (As<Int4>(pDst.w) & ~wEnable)); 507 } 508 509 switch(dst.type) 510 { 511 case Shader::PARAMETER_VOID: 512 break; 513 case Shader::PARAMETER_TEMP: 514 if(dst.rel.type == Shader::PARAMETER_VOID) 515 { 516 if(dst.x) r[dst.index].x = d.x; 517 if(dst.y) r[dst.index].y = d.y; 518 if(dst.z) r[dst.index].z = d.z; 519 if(dst.w) r[dst.index].w = d.w; 520 } 521 else if(!dst.rel.dynamic) 522 { 523 Int a = dst.index + relativeAddress(dst.rel); 524 525 if(dst.x) r[a].x = d.x; 526 if(dst.y) r[a].y = d.y; 527 if(dst.z) r[a].z = d.z; 528 if(dst.w) r[a].w = d.w; 529 } 530 else 531 { 532 Int4 a = dst.index + dynamicAddress(dst.rel); 533 534 if(dst.x) r.scatter_x(a, d.x); 535 if(dst.y) r.scatter_y(a, d.y); 536 if(dst.z) r.scatter_z(a, d.z); 537 if(dst.w) r.scatter_w(a, d.w); 538 } 539 break; 540 case Shader::PARAMETER_ADDR: 541 if(dst.x) a0.x = d.x; 542 if(dst.y) a0.y = d.y; 543 if(dst.z) a0.z = d.z; 544 if(dst.w) a0.w = d.w; 545 break; 546 case Shader::PARAMETER_RASTOUT: 547 switch(dst.index) 548 { 549 case 0: 550 if(dst.x) o[Pos].x = d.x; 551 if(dst.y) o[Pos].y = d.y; 552 if(dst.z) o[Pos].z = d.z; 553 if(dst.w) o[Pos].w = d.w; 554 break; 555 case 1: 556 o[Fog].x = d.x; 557 break; 558 case 2: 559 o[Pts].y = d.x; 560 break; 561 default: ASSERT(false); 562 } 563 break; 564 case Shader::PARAMETER_ATTROUT: 565 if(dst.x) o[C0 + dst.index].x = d.x; 566 if(dst.y) o[C0 + dst.index].y = d.y; 567 if(dst.z) o[C0 + dst.index].z = d.z; 568 if(dst.w) o[C0 + dst.index].w = d.w; 569 break; 570 case Shader::PARAMETER_TEXCRDOUT: 571 // case Shader::PARAMETER_OUTPUT: 572 if(shaderModel < 0x0300) 573 { 574 if(dst.x) o[T0 + dst.index].x = d.x; 575 if(dst.y) o[T0 + dst.index].y = d.y; 576 if(dst.z) o[T0 + dst.index].z = d.z; 577 if(dst.w) o[T0 + dst.index].w = d.w; 578 } 579 else if(dst.rel.type == Shader::PARAMETER_VOID) // Not relative 580 { 581 if(dst.x) o[dst.index].x = d.x; 582 if(dst.y) o[dst.index].y = d.y; 583 if(dst.z) o[dst.index].z = d.z; 584 if(dst.w) o[dst.index].w = d.w; 585 } 586 else if(!dst.rel.dynamic) 587 { 588 Int a = dst.index + relativeAddress(dst.rel); 589 590 if(dst.x) o[a].x = d.x; 591 if(dst.y) o[a].y = d.y; 592 if(dst.z) o[a].z = d.z; 593 if(dst.w) o[a].w = d.w; 594 } 595 else 596 { 597 Int4 a = dst.index + dynamicAddress(dst.rel); 598 599 if(dst.x) o.scatter_x(a, d.x); 600 if(dst.y) o.scatter_y(a, d.y); 601 if(dst.z) o.scatter_z(a, d.z); 602 if(dst.w) o.scatter_w(a, d.w); 603 } 604 break; 605 case Shader::PARAMETER_LABEL: break; 606 case Shader::PARAMETER_PREDICATE: p0 = d; break; 607 case Shader::PARAMETER_INPUT: break; 608 default: 609 ASSERT(false); 610 } 611 } 612 } 613 614 if(currentLabel != -1) 615 { 616 Nucleus::setInsertBlock(returnBlock); 617 } 618 } 619 passThrough()620 void VertexProgram::passThrough() 621 { 622 if(shader) 623 { 624 for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++) 625 { 626 unsigned char usage = shader->getOutput(i, 0).usage; 627 628 switch(usage) 629 { 630 case 0xFF: 631 continue; 632 case Shader::USAGE_PSIZE: 633 o[i].y = v[i].x; 634 break; 635 case Shader::USAGE_TEXCOORD: 636 o[i].x = v[i].x; 637 o[i].y = v[i].y; 638 o[i].z = v[i].z; 639 o[i].w = v[i].w; 640 break; 641 case Shader::USAGE_POSITION: 642 o[i].x = v[i].x; 643 o[i].y = v[i].y; 644 o[i].z = v[i].z; 645 o[i].w = v[i].w; 646 break; 647 case Shader::USAGE_COLOR: 648 o[i].x = v[i].x; 649 o[i].y = v[i].y; 650 o[i].z = v[i].z; 651 o[i].w = v[i].w; 652 break; 653 case Shader::USAGE_FOG: 654 o[i].x = v[i].x; 655 break; 656 default: 657 ASSERT(false); 658 } 659 } 660 } 661 else 662 { 663 o[Pos].x = v[PositionT].x; 664 o[Pos].y = v[PositionT].y; 665 o[Pos].z = v[PositionT].z; 666 o[Pos].w = v[PositionT].w; 667 668 for(int i = 0; i < 2; i++) 669 { 670 o[C0 + i].x = v[Color0 + i].x; 671 o[C0 + i].y = v[Color0 + i].y; 672 o[C0 + i].z = v[Color0 + i].z; 673 o[C0 + i].w = v[Color0 + i].w; 674 } 675 676 for(int i = 0; i < 8; i++) 677 { 678 o[T0 + i].x = v[TexCoord0 + i].x; 679 o[T0 + i].y = v[TexCoord0 + i].y; 680 o[T0 + i].z = v[TexCoord0 + i].z; 681 o[T0 + i].w = v[TexCoord0 + i].w; 682 } 683 684 o[Pts].y = v[PointSize].x; 685 } 686 } 687 fetchRegister(const Src & src,unsigned int offset)688 Vector4f VertexProgram::fetchRegister(const Src &src, unsigned int offset) 689 { 690 Vector4f reg; 691 unsigned int i = src.index + offset; 692 693 switch(src.type) 694 { 695 case Shader::PARAMETER_TEMP: 696 if(src.rel.type == Shader::PARAMETER_VOID) 697 { 698 reg = r[i]; 699 } 700 else if(!src.rel.dynamic) 701 { 702 reg = r[i + relativeAddress(src.rel, src.bufferIndex)]; 703 } 704 else 705 { 706 reg = r[i + dynamicAddress(src.rel)]; 707 } 708 break; 709 case Shader::PARAMETER_CONST: 710 reg = readConstant(src, offset); 711 break; 712 case Shader::PARAMETER_INPUT: 713 if(src.rel.type == Shader::PARAMETER_VOID) 714 { 715 reg = v[i]; 716 } 717 else if(!src.rel.dynamic) 718 { 719 reg = v[i + relativeAddress(src.rel, src.bufferIndex)]; 720 } 721 else 722 { 723 reg = v[i + dynamicAddress(src.rel)]; 724 } 725 break; 726 case Shader::PARAMETER_VOID: return r[0]; // Dummy 727 case Shader::PARAMETER_FLOAT4LITERAL: 728 // This is used for all literal types, and since Reactor doesn't guarantee 729 // preserving the bit pattern of float constants, we must construct them 730 // as integer constants and bitcast. 731 reg.x = As<Float4>(Int4(src.integer[0])); 732 reg.y = As<Float4>(Int4(src.integer[1])); 733 reg.z = As<Float4>(Int4(src.integer[2])); 734 reg.w = As<Float4>(Int4(src.integer[3])); 735 break; 736 case Shader::PARAMETER_ADDR: reg = a0; break; 737 case Shader::PARAMETER_CONSTBOOL: return r[0]; // Dummy 738 case Shader::PARAMETER_CONSTINT: return r[0]; // Dummy 739 case Shader::PARAMETER_LOOP: return r[0]; // Dummy 740 case Shader::PARAMETER_PREDICATE: return r[0]; // Dummy 741 case Shader::PARAMETER_SAMPLER: 742 if(src.rel.type == Shader::PARAMETER_VOID) 743 { 744 reg.x = As<Float4>(Int4(i)); 745 } 746 else if(src.rel.type == Shader::PARAMETER_TEMP) 747 { 748 reg.x = As<Float4>(Int4(i) + As<Int4>(r[src.rel.index].x)); 749 } 750 return reg; 751 case Shader::PARAMETER_OUTPUT: 752 if(src.rel.type == Shader::PARAMETER_VOID) 753 { 754 reg = o[i]; 755 } 756 else if(!src.rel.dynamic) 757 { 758 reg = o[i + relativeAddress(src.rel, src.bufferIndex)]; 759 } 760 else 761 { 762 reg = o[i + dynamicAddress(src.rel)]; 763 } 764 break; 765 case Shader::PARAMETER_MISCTYPE: 766 if(src.index == Shader::InstanceIDIndex) 767 { 768 reg.x = As<Float>(instanceID); 769 } 770 else if(src.index == Shader::VertexIDIndex) 771 { 772 reg.x = As<Float4>(vertexID); 773 } 774 else ASSERT(false); 775 return reg; 776 default: 777 ASSERT(false); 778 } 779 780 const Float4 &x = reg[(src.swizzle >> 0) & 0x3]; 781 const Float4 &y = reg[(src.swizzle >> 2) & 0x3]; 782 const Float4 &z = reg[(src.swizzle >> 4) & 0x3]; 783 const Float4 &w = reg[(src.swizzle >> 6) & 0x3]; 784 785 Vector4f mod; 786 787 switch(src.modifier) 788 { 789 case Shader::MODIFIER_NONE: 790 mod.x = x; 791 mod.y = y; 792 mod.z = z; 793 mod.w = w; 794 break; 795 case Shader::MODIFIER_NEGATE: 796 mod.x = -x; 797 mod.y = -y; 798 mod.z = -z; 799 mod.w = -w; 800 break; 801 case Shader::MODIFIER_ABS: 802 mod.x = Abs(x); 803 mod.y = Abs(y); 804 mod.z = Abs(z); 805 mod.w = Abs(w); 806 break; 807 case Shader::MODIFIER_ABS_NEGATE: 808 mod.x = -Abs(x); 809 mod.y = -Abs(y); 810 mod.z = -Abs(z); 811 mod.w = -Abs(w); 812 break; 813 case Shader::MODIFIER_NOT: 814 mod.x = As<Float4>(As<Int4>(x) ^ Int4(0xFFFFFFFF)); 815 mod.y = As<Float4>(As<Int4>(y) ^ Int4(0xFFFFFFFF)); 816 mod.z = As<Float4>(As<Int4>(z) ^ Int4(0xFFFFFFFF)); 817 mod.w = As<Float4>(As<Int4>(w) ^ Int4(0xFFFFFFFF)); 818 break; 819 default: 820 ASSERT(false); 821 } 822 823 return mod; 824 } 825 uniformAddress(int bufferIndex,unsigned int index)826 RValue<Pointer<Byte>> VertexProgram::uniformAddress(int bufferIndex, unsigned int index) 827 { 828 if(bufferIndex == -1) 829 { 830 return data + OFFSET(DrawData, vs.c[index]); 831 } 832 else 833 { 834 return *Pointer<Pointer<Byte>>(data + OFFSET(DrawData, vs.u[bufferIndex])) + index; 835 } 836 } 837 uniformAddress(int bufferIndex,unsigned int index,Int & offset)838 RValue<Pointer<Byte>> VertexProgram::uniformAddress(int bufferIndex, unsigned int index, Int &offset) 839 { 840 return uniformAddress(bufferIndex, index) + offset * sizeof(float4); 841 } 842 readConstant(const Src & src,unsigned int offset)843 Vector4f VertexProgram::readConstant(const Src &src, unsigned int offset) 844 { 845 Vector4f c; 846 unsigned int i = src.index + offset; 847 848 if(src.rel.type == Shader::PARAMETER_VOID) // Not relative 849 { 850 c.x = c.y = c.z = c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, i)); 851 852 c.x = c.x.xxxx; 853 c.y = c.y.yyyy; 854 c.z = c.z.zzzz; 855 c.w = c.w.wwww; 856 857 if(shader->containsDefineInstruction()) // Constant may be known at compile time 858 { 859 for(size_t j = 0; j < shader->getLength(); j++) 860 { 861 const Shader::Instruction &instruction = *shader->getInstruction(j); 862 863 if(instruction.opcode == Shader::OPCODE_DEF) 864 { 865 if(instruction.dst.index == i) 866 { 867 c.x = Float4(instruction.src[0].value[0]); 868 c.y = Float4(instruction.src[0].value[1]); 869 c.z = Float4(instruction.src[0].value[2]); 870 c.w = Float4(instruction.src[0].value[3]); 871 872 break; 873 } 874 } 875 } 876 } 877 } 878 else if(!src.rel.dynamic || src.rel.type == Shader::PARAMETER_LOOP) 879 { 880 Int a = relativeAddress(src.rel, src.bufferIndex); 881 882 c.x = c.y = c.z = c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, i, a)); 883 884 c.x = c.x.xxxx; 885 c.y = c.y.yyyy; 886 c.z = c.z.zzzz; 887 c.w = c.w.wwww; 888 } 889 else 890 { 891 int component = src.rel.swizzle & 0x03; 892 Float4 a; 893 894 switch(src.rel.type) 895 { 896 case Shader::PARAMETER_ADDR: a = a0[component]; break; 897 case Shader::PARAMETER_TEMP: a = r[src.rel.index][component]; break; 898 case Shader::PARAMETER_INPUT: a = v[src.rel.index][component]; break; 899 case Shader::PARAMETER_OUTPUT: a = o[src.rel.index][component]; break; 900 case Shader::PARAMETER_CONST: a = *Pointer<Float>(uniformAddress(src.bufferIndex, src.rel.index) + component * sizeof(float)); break; 901 case Shader::PARAMETER_MISCTYPE: 902 switch(src.rel.index) 903 { 904 case Shader::InstanceIDIndex: a = As<Float4>(Int4(instanceID)); break; 905 case Shader::VertexIDIndex: a = As<Float4>(vertexID); break; 906 default: ASSERT(false); 907 } 908 break; 909 default: ASSERT(false); 910 } 911 912 Int4 index = Int4(i) + As<Int4>(a) * Int4(src.rel.scale); 913 914 if (src.bufferIndex == -1) 915 { 916 index = Min(As<UInt4>(index), UInt4(VERTEX_UNIFORM_VECTORS)); // Clamp to constant register range, c[VERTEX_UNIFORM_VECTORS] = {0, 0, 0, 0} 917 } 918 919 Int index0 = Extract(index, 0); 920 Int index1 = Extract(index, 1); 921 Int index2 = Extract(index, 2); 922 Int index3 = Extract(index, 3); 923 924 c.x = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index0), 16); 925 c.y = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index1), 16); 926 c.z = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index2), 16); 927 c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index3), 16); 928 929 transpose4x4(c.x, c.y, c.z, c.w); 930 } 931 932 return c; 933 } 934 relativeAddress(const Shader::Relative & rel,int bufferIndex)935 Int VertexProgram::relativeAddress(const Shader::Relative &rel, int bufferIndex) 936 { 937 ASSERT(!rel.dynamic); 938 939 if(rel.type == Shader::PARAMETER_TEMP) 940 { 941 return As<Int>(Extract(r[rel.index].x, 0)) * rel.scale; 942 } 943 else if(rel.type == Shader::PARAMETER_INPUT) 944 { 945 return As<Int>(Extract(v[rel.index].x, 0)) * rel.scale; 946 } 947 else if(rel.type == Shader::PARAMETER_OUTPUT) 948 { 949 return As<Int>(Extract(o[rel.index].x, 0)) * rel.scale; 950 } 951 else if(rel.type == Shader::PARAMETER_CONST) 952 { 953 return *Pointer<Int>(uniformAddress(bufferIndex, rel.index)) * rel.scale; 954 } 955 else if(rel.type == Shader::PARAMETER_LOOP) 956 { 957 return aL[loopDepth]; 958 } 959 else ASSERT(false); 960 961 return 0; 962 } 963 dynamicAddress(const Shader::Relative & rel)964 Int4 VertexProgram::dynamicAddress(const Shader::Relative &rel) 965 { 966 int component = rel.swizzle & 0x03; 967 Float4 a; 968 969 switch(rel.type) 970 { 971 case Shader::PARAMETER_ADDR: a = a0[component]; break; 972 case Shader::PARAMETER_TEMP: a = r[rel.index][component]; break; 973 case Shader::PARAMETER_INPUT: a = v[rel.index][component]; break; 974 case Shader::PARAMETER_OUTPUT: a = o[rel.index][component]; break; 975 case Shader::PARAMETER_MISCTYPE: 976 switch(rel.index) 977 { 978 case Shader::InstanceIDIndex: a = As<Float>(instanceID); break; 979 case Shader::VertexIDIndex: a = As<Float4>(vertexID); break; 980 default: ASSERT(false); 981 } 982 break; 983 default: ASSERT(false); 984 } 985 986 return As<Int4>(a) * Int4(rel.scale); 987 } 988 enableMask(const Shader::Instruction * instruction)989 Int4 VertexProgram::enableMask(const Shader::Instruction *instruction) 990 { 991 if(scalar) 992 { 993 return Int4(0xFFFFFFFF); 994 } 995 996 Int4 enable = instruction->analysisBranch ? Int4(enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))]) : Int4(0xFFFFFFFF); 997 998 if(shader->containsBreakInstruction() && instruction->analysisBreak) 999 { 1000 enable &= enableBreak; 1001 } 1002 1003 if(shader->containsContinueInstruction() && instruction->analysisContinue) 1004 { 1005 enable &= enableContinue; 1006 } 1007 1008 if(shader->containsLeaveInstruction() && instruction->analysisLeave) 1009 { 1010 enable &= enableLeave; 1011 } 1012 1013 return enable; 1014 } 1015 M3X2(Vector4f & dst,Vector4f & src0,Src & src1)1016 void VertexProgram::M3X2(Vector4f &dst, Vector4f &src0, Src &src1) 1017 { 1018 Vector4f row0 = fetchRegister(src1, 0); 1019 Vector4f row1 = fetchRegister(src1, 1); 1020 1021 dst.x = dot3(src0, row0); 1022 dst.y = dot3(src0, row1); 1023 } 1024 M3X3(Vector4f & dst,Vector4f & src0,Src & src1)1025 void VertexProgram::M3X3(Vector4f &dst, Vector4f &src0, Src &src1) 1026 { 1027 Vector4f row0 = fetchRegister(src1, 0); 1028 Vector4f row1 = fetchRegister(src1, 1); 1029 Vector4f row2 = fetchRegister(src1, 2); 1030 1031 dst.x = dot3(src0, row0); 1032 dst.y = dot3(src0, row1); 1033 dst.z = dot3(src0, row2); 1034 } 1035 M3X4(Vector4f & dst,Vector4f & src0,Src & src1)1036 void VertexProgram::M3X4(Vector4f &dst, Vector4f &src0, Src &src1) 1037 { 1038 Vector4f row0 = fetchRegister(src1, 0); 1039 Vector4f row1 = fetchRegister(src1, 1); 1040 Vector4f row2 = fetchRegister(src1, 2); 1041 Vector4f row3 = fetchRegister(src1, 3); 1042 1043 dst.x = dot3(src0, row0); 1044 dst.y = dot3(src0, row1); 1045 dst.z = dot3(src0, row2); 1046 dst.w = dot3(src0, row3); 1047 } 1048 M4X3(Vector4f & dst,Vector4f & src0,Src & src1)1049 void VertexProgram::M4X3(Vector4f &dst, Vector4f &src0, Src &src1) 1050 { 1051 Vector4f row0 = fetchRegister(src1, 0); 1052 Vector4f row1 = fetchRegister(src1, 1); 1053 Vector4f row2 = fetchRegister(src1, 2); 1054 1055 dst.x = dot4(src0, row0); 1056 dst.y = dot4(src0, row1); 1057 dst.z = dot4(src0, row2); 1058 } 1059 M4X4(Vector4f & dst,Vector4f & src0,Src & src1)1060 void VertexProgram::M4X4(Vector4f &dst, Vector4f &src0, Src &src1) 1061 { 1062 Vector4f row0 = fetchRegister(src1, 0); 1063 Vector4f row1 = fetchRegister(src1, 1); 1064 Vector4f row2 = fetchRegister(src1, 2); 1065 Vector4f row3 = fetchRegister(src1, 3); 1066 1067 dst.x = dot4(src0, row0); 1068 dst.y = dot4(src0, row1); 1069 dst.z = dot4(src0, row2); 1070 dst.w = dot4(src0, row3); 1071 } 1072 BREAK()1073 void VertexProgram::BREAK() 1074 { 1075 enableBreak = enableBreak & ~enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))]; 1076 } 1077 BREAKC(Vector4f & src0,Vector4f & src1,Control control)1078 void VertexProgram::BREAKC(Vector4f &src0, Vector4f &src1, Control control) 1079 { 1080 Int4 condition; 1081 1082 switch(control) 1083 { 1084 case Shader::CONTROL_GT: condition = CmpNLE(src0.x, src1.x); break; 1085 case Shader::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x); break; 1086 case Shader::CONTROL_GE: condition = CmpNLT(src0.x, src1.x); break; 1087 case Shader::CONTROL_LT: condition = CmpLT(src0.x, src1.x); break; 1088 case Shader::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x); break; 1089 case Shader::CONTROL_LE: condition = CmpLE(src0.x, src1.x); break; 1090 default: 1091 ASSERT(false); 1092 } 1093 1094 BREAK(condition); 1095 } 1096 BREAKP(const Src & predicateRegister)1097 void VertexProgram::BREAKP(const Src &predicateRegister) // FIXME: Factor out parts common with BREAKC 1098 { 1099 Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]); 1100 1101 if(predicateRegister.modifier == Shader::MODIFIER_NOT) 1102 { 1103 condition = ~condition; 1104 } 1105 1106 BREAK(condition); 1107 } 1108 BREAK(Int4 & condition)1109 void VertexProgram::BREAK(Int4 &condition) 1110 { 1111 condition &= enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))]; 1112 1113 enableBreak = enableBreak & ~condition; 1114 } 1115 CONTINUE()1116 void VertexProgram::CONTINUE() 1117 { 1118 enableContinue = enableContinue & ~enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))]; 1119 } 1120 TEST()1121 void VertexProgram::TEST() 1122 { 1123 enableContinue = restoreContinue.back(); 1124 restoreContinue.pop_back(); 1125 } 1126 SCALAR()1127 void VertexProgram::SCALAR() 1128 { 1129 scalar = true; 1130 } 1131 CALL(int labelIndex,int callSiteIndex)1132 void VertexProgram::CALL(int labelIndex, int callSiteIndex) 1133 { 1134 if(!labelBlock[labelIndex]) 1135 { 1136 labelBlock[labelIndex] = Nucleus::createBasicBlock(); 1137 } 1138 1139 if(callRetBlock[labelIndex].size() > 1) 1140 { 1141 callStack[stackIndex++] = UInt(callSiteIndex); 1142 } 1143 1144 Int4 restoreLeave = enableLeave; 1145 1146 Nucleus::createBr(labelBlock[labelIndex]); 1147 Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]); 1148 1149 enableLeave = restoreLeave; 1150 } 1151 CALLNZ(int labelIndex,int callSiteIndex,const Src & src)1152 void VertexProgram::CALLNZ(int labelIndex, int callSiteIndex, const Src &src) 1153 { 1154 if(src.type == Shader::PARAMETER_CONSTBOOL) 1155 { 1156 CALLNZb(labelIndex, callSiteIndex, src); 1157 } 1158 else if(src.type == Shader::PARAMETER_PREDICATE) 1159 { 1160 CALLNZp(labelIndex, callSiteIndex, src); 1161 } 1162 else ASSERT(false); 1163 } 1164 CALLNZb(int labelIndex,int callSiteIndex,const Src & boolRegister)1165 void VertexProgram::CALLNZb(int labelIndex, int callSiteIndex, const Src &boolRegister) 1166 { 1167 Bool condition = (*Pointer<Byte>(data + OFFSET(DrawData,vs.b[boolRegister.index])) != Byte(0)); // FIXME 1168 1169 if(boolRegister.modifier == Shader::MODIFIER_NOT) 1170 { 1171 condition = !condition; 1172 } 1173 1174 if(!labelBlock[labelIndex]) 1175 { 1176 labelBlock[labelIndex] = Nucleus::createBasicBlock(); 1177 } 1178 1179 if(callRetBlock[labelIndex].size() > 1) 1180 { 1181 callStack[stackIndex++] = UInt(callSiteIndex); 1182 } 1183 1184 Int4 restoreLeave = enableLeave; 1185 1186 branch(condition, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]); 1187 Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]); 1188 1189 enableLeave = restoreLeave; 1190 } 1191 CALLNZp(int labelIndex,int callSiteIndex,const Src & predicateRegister)1192 void VertexProgram::CALLNZp(int labelIndex, int callSiteIndex, const Src &predicateRegister) 1193 { 1194 Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]); 1195 1196 if(predicateRegister.modifier == Shader::MODIFIER_NOT) 1197 { 1198 condition = ~condition; 1199 } 1200 1201 condition &= enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))]; 1202 1203 if(!labelBlock[labelIndex]) 1204 { 1205 labelBlock[labelIndex] = Nucleus::createBasicBlock(); 1206 } 1207 1208 if(callRetBlock[labelIndex].size() > 1) 1209 { 1210 callStack[stackIndex++] = UInt(callSiteIndex); 1211 } 1212 1213 enableIndex++; 1214 enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))] = condition; 1215 Int4 restoreLeave = enableLeave; 1216 1217 Bool notAllFalse = SignMask(condition) != 0; 1218 branch(notAllFalse, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]); 1219 Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]); 1220 1221 enableIndex--; 1222 enableLeave = restoreLeave; 1223 } 1224 ELSE()1225 void VertexProgram::ELSE() 1226 { 1227 ifDepth--; 1228 1229 BasicBlock *falseBlock = ifFalseBlock[ifDepth]; 1230 BasicBlock *endBlock = Nucleus::createBasicBlock(); 1231 1232 if(isConditionalIf[ifDepth]) 1233 { 1234 Int4 condition = ~enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))] & enableStack[Min(enableIndex - 1, Int(MAX_SHADER_ENABLE_STACK_SIZE))]; 1235 Bool notAllFalse = SignMask(condition) != 0; 1236 1237 branch(notAllFalse, falseBlock, endBlock); 1238 1239 enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))] = ~enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))] & enableStack[Min(enableIndex - 1, Int(MAX_SHADER_ENABLE_STACK_SIZE))]; 1240 } 1241 else 1242 { 1243 Nucleus::createBr(endBlock); 1244 Nucleus::setInsertBlock(falseBlock); 1245 } 1246 1247 ifFalseBlock[ifDepth] = endBlock; 1248 1249 ifDepth++; 1250 } 1251 ENDIF()1252 void VertexProgram::ENDIF() 1253 { 1254 ifDepth--; 1255 1256 BasicBlock *endBlock = ifFalseBlock[ifDepth]; 1257 1258 Nucleus::createBr(endBlock); 1259 Nucleus::setInsertBlock(endBlock); 1260 1261 if(isConditionalIf[ifDepth]) 1262 { 1263 enableIndex--; 1264 } 1265 } 1266 ENDLOOP()1267 void VertexProgram::ENDLOOP() 1268 { 1269 loopRepDepth--; 1270 1271 aL[loopDepth] = aL[loopDepth] + increment[loopDepth]; // FIXME: += 1272 1273 BasicBlock *testBlock = loopRepTestBlock[loopRepDepth]; 1274 BasicBlock *endBlock = loopRepEndBlock[loopRepDepth]; 1275 1276 Nucleus::createBr(testBlock); 1277 Nucleus::setInsertBlock(endBlock); 1278 1279 loopDepth--; 1280 enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF); 1281 } 1282 ENDREP()1283 void VertexProgram::ENDREP() 1284 { 1285 loopRepDepth--; 1286 1287 BasicBlock *testBlock = loopRepTestBlock[loopRepDepth]; 1288 BasicBlock *endBlock = loopRepEndBlock[loopRepDepth]; 1289 1290 Nucleus::createBr(testBlock); 1291 Nucleus::setInsertBlock(endBlock); 1292 1293 loopDepth--; 1294 enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF); 1295 } 1296 ENDWHILE()1297 void VertexProgram::ENDWHILE() 1298 { 1299 loopRepDepth--; 1300 1301 BasicBlock *testBlock = loopRepTestBlock[loopRepDepth]; 1302 BasicBlock *endBlock = loopRepEndBlock[loopRepDepth]; 1303 1304 Nucleus::createBr(testBlock); 1305 Nucleus::setInsertBlock(endBlock); 1306 1307 enableIndex--; 1308 scalar = false; 1309 } 1310 ENDSWITCH()1311 void VertexProgram::ENDSWITCH() 1312 { 1313 loopRepDepth--; 1314 1315 BasicBlock *endBlock = loopRepEndBlock[loopRepDepth]; 1316 1317 Nucleus::createBr(endBlock); 1318 Nucleus::setInsertBlock(endBlock); 1319 } 1320 IF(const Src & src)1321 void VertexProgram::IF(const Src &src) 1322 { 1323 if(src.type == Shader::PARAMETER_CONSTBOOL) 1324 { 1325 IFb(src); 1326 } 1327 else if(src.type == Shader::PARAMETER_PREDICATE) 1328 { 1329 IFp(src); 1330 } 1331 else 1332 { 1333 Int4 condition = As<Int4>(fetchRegister(src).x); 1334 IF(condition); 1335 } 1336 } 1337 IFb(const Src & boolRegister)1338 void VertexProgram::IFb(const Src &boolRegister) 1339 { 1340 ASSERT(ifDepth < 24 + 4); 1341 1342 Bool condition = (*Pointer<Byte>(data + OFFSET(DrawData,vs.b[boolRegister.index])) != Byte(0)); // FIXME 1343 1344 if(boolRegister.modifier == Shader::MODIFIER_NOT) 1345 { 1346 condition = !condition; 1347 } 1348 1349 BasicBlock *trueBlock = Nucleus::createBasicBlock(); 1350 BasicBlock *falseBlock = Nucleus::createBasicBlock(); 1351 1352 branch(condition, trueBlock, falseBlock); 1353 1354 isConditionalIf[ifDepth] = false; 1355 ifFalseBlock[ifDepth] = falseBlock; 1356 1357 ifDepth++; 1358 } 1359 IFp(const Src & predicateRegister)1360 void VertexProgram::IFp(const Src &predicateRegister) 1361 { 1362 Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]); 1363 1364 if(predicateRegister.modifier == Shader::MODIFIER_NOT) 1365 { 1366 condition = ~condition; 1367 } 1368 1369 IF(condition); 1370 } 1371 IFC(Vector4f & src0,Vector4f & src1,Control control)1372 void VertexProgram::IFC(Vector4f &src0, Vector4f &src1, Control control) 1373 { 1374 Int4 condition; 1375 1376 switch(control) 1377 { 1378 case Shader::CONTROL_GT: condition = CmpNLE(src0.x, src1.x); break; 1379 case Shader::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x); break; 1380 case Shader::CONTROL_GE: condition = CmpNLT(src0.x, src1.x); break; 1381 case Shader::CONTROL_LT: condition = CmpLT(src0.x, src1.x); break; 1382 case Shader::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x); break; 1383 case Shader::CONTROL_LE: condition = CmpLE(src0.x, src1.x); break; 1384 default: 1385 ASSERT(false); 1386 } 1387 1388 IF(condition); 1389 } 1390 IF(Int4 & condition)1391 void VertexProgram::IF(Int4 &condition) 1392 { 1393 condition &= enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))]; 1394 1395 enableIndex++; 1396 enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))] = condition; 1397 1398 BasicBlock *trueBlock = Nucleus::createBasicBlock(); 1399 BasicBlock *falseBlock = Nucleus::createBasicBlock(); 1400 1401 Bool notAllFalse = SignMask(condition) != 0; 1402 1403 branch(notAllFalse, trueBlock, falseBlock); 1404 1405 isConditionalIf[ifDepth] = true; 1406 ifFalseBlock[ifDepth] = falseBlock; 1407 1408 ifDepth++; 1409 } 1410 LABEL(int labelIndex)1411 void VertexProgram::LABEL(int labelIndex) 1412 { 1413 if(!labelBlock[labelIndex]) 1414 { 1415 labelBlock[labelIndex] = Nucleus::createBasicBlock(); 1416 } 1417 1418 Nucleus::setInsertBlock(labelBlock[labelIndex]); 1419 currentLabel = labelIndex; 1420 } 1421 LOOP(const Src & integerRegister)1422 void VertexProgram::LOOP(const Src &integerRegister) 1423 { 1424 loopDepth++; 1425 1426 iteration[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][0])); 1427 aL[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][1])); 1428 increment[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][2])); 1429 1430 // FIXME: Compiles to two instructions? 1431 If(increment[loopDepth] == 0) 1432 { 1433 increment[loopDepth] = 1; 1434 } 1435 1436 BasicBlock *loopBlock = Nucleus::createBasicBlock(); 1437 BasicBlock *testBlock = Nucleus::createBasicBlock(); 1438 BasicBlock *endBlock = Nucleus::createBasicBlock(); 1439 1440 loopRepTestBlock[loopRepDepth] = testBlock; 1441 loopRepEndBlock[loopRepDepth] = endBlock; 1442 1443 // FIXME: jump(testBlock) 1444 Nucleus::createBr(testBlock); 1445 Nucleus::setInsertBlock(testBlock); 1446 1447 branch(iteration[loopDepth] > 0, loopBlock, endBlock); 1448 Nucleus::setInsertBlock(loopBlock); 1449 1450 iteration[loopDepth] = iteration[loopDepth] - 1; // FIXME: -- 1451 1452 loopRepDepth++; 1453 } 1454 REP(const Src & integerRegister)1455 void VertexProgram::REP(const Src &integerRegister) 1456 { 1457 loopDepth++; 1458 1459 iteration[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][0])); 1460 aL[loopDepth] = aL[loopDepth - 1]; 1461 1462 BasicBlock *loopBlock = Nucleus::createBasicBlock(); 1463 BasicBlock *testBlock = Nucleus::createBasicBlock(); 1464 BasicBlock *endBlock = Nucleus::createBasicBlock(); 1465 1466 loopRepTestBlock[loopRepDepth] = testBlock; 1467 loopRepEndBlock[loopRepDepth] = endBlock; 1468 1469 // FIXME: jump(testBlock) 1470 Nucleus::createBr(testBlock); 1471 Nucleus::setInsertBlock(testBlock); 1472 1473 branch(iteration[loopDepth] > 0, loopBlock, endBlock); 1474 Nucleus::setInsertBlock(loopBlock); 1475 1476 iteration[loopDepth] = iteration[loopDepth] - 1; // FIXME: -- 1477 1478 loopRepDepth++; 1479 } 1480 WHILE(const Src & temporaryRegister)1481 void VertexProgram::WHILE(const Src &temporaryRegister) 1482 { 1483 enableIndex++; 1484 1485 BasicBlock *loopBlock = Nucleus::createBasicBlock(); 1486 BasicBlock *testBlock = Nucleus::createBasicBlock(); 1487 BasicBlock *endBlock = Nucleus::createBasicBlock(); 1488 1489 loopRepTestBlock[loopRepDepth] = testBlock; 1490 loopRepEndBlock[loopRepDepth] = endBlock; 1491 1492 Int4 restoreBreak = enableBreak; 1493 restoreContinue.push_back(enableContinue); 1494 1495 // TODO: jump(testBlock) 1496 Nucleus::createBr(testBlock); 1497 Nucleus::setInsertBlock(testBlock); 1498 1499 const Vector4f &src = fetchRegister(temporaryRegister); 1500 Int4 condition = As<Int4>(src.x); 1501 condition &= enableStack[Min(enableIndex - 1, Int(MAX_SHADER_ENABLE_STACK_SIZE))]; 1502 if(shader->containsLeaveInstruction()) condition &= enableLeave; 1503 if(shader->containsBreakInstruction()) condition &= enableBreak; 1504 enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))] = condition; 1505 1506 Bool notAllFalse = SignMask(condition) != 0; 1507 branch(notAllFalse, loopBlock, endBlock); 1508 1509 Nucleus::setInsertBlock(endBlock); 1510 enableBreak = restoreBreak; 1511 1512 Nucleus::setInsertBlock(loopBlock); 1513 1514 loopRepDepth++; 1515 scalar = false; 1516 } 1517 SWITCH()1518 void VertexProgram::SWITCH() 1519 { 1520 BasicBlock *endBlock = Nucleus::createBasicBlock(); 1521 1522 loopRepTestBlock[loopRepDepth] = nullptr; 1523 loopRepEndBlock[loopRepDepth] = endBlock; 1524 1525 Int4 restoreBreak = enableBreak; 1526 1527 BasicBlock *currentBlock = Nucleus::getInsertBlock(); 1528 1529 Nucleus::setInsertBlock(endBlock); 1530 enableBreak = restoreBreak; 1531 1532 Nucleus::setInsertBlock(currentBlock); 1533 1534 loopRepDepth++; 1535 } 1536 RET()1537 void VertexProgram::RET() 1538 { 1539 if(currentLabel == -1) 1540 { 1541 returnBlock = Nucleus::createBasicBlock(); 1542 Nucleus::createBr(returnBlock); 1543 } 1544 else 1545 { 1546 BasicBlock *unreachableBlock = Nucleus::createBasicBlock(); 1547 1548 if(callRetBlock[currentLabel].size() > 1) // Pop the return destination from the call stack 1549 { 1550 // FIXME: Encapsulate 1551 UInt index = callStack[--stackIndex]; 1552 1553 Value *value = index.loadValue(); 1554 SwitchCases *switchCases = Nucleus::createSwitch(value, unreachableBlock, (int)callRetBlock[currentLabel].size()); 1555 1556 for(unsigned int i = 0; i < callRetBlock[currentLabel].size(); i++) 1557 { 1558 Nucleus::addSwitchCase(switchCases, i, callRetBlock[currentLabel][i]); 1559 } 1560 } 1561 else if(callRetBlock[currentLabel].size() == 1) // Jump directly to the unique return destination 1562 { 1563 Nucleus::createBr(callRetBlock[currentLabel][0]); 1564 } 1565 else // Function isn't called 1566 { 1567 Nucleus::createBr(unreachableBlock); 1568 } 1569 1570 Nucleus::setInsertBlock(unreachableBlock); 1571 Nucleus::createUnreachable(); 1572 } 1573 } 1574 LEAVE()1575 void VertexProgram::LEAVE() 1576 { 1577 enableLeave = enableLeave & ~enableStack[Min(enableIndex, Int(MAX_SHADER_ENABLE_STACK_SIZE))]; 1578 1579 // FIXME: Return from function if all instances left 1580 // FIXME: Use enableLeave in other control-flow constructs 1581 } 1582 TEX(Vector4f & dst,Vector4f & src0,const Src & src1)1583 void VertexProgram::TEX(Vector4f &dst, Vector4f &src0, const Src &src1) 1584 { 1585 dst = sampleTexture(src1, src0, (src0.x), (src0), (src0), (src0), Base); 1586 } 1587 TEXOFFSET(Vector4f & dst,Vector4f & src0,const Src & src1,Vector4f & offset)1588 void VertexProgram::TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset) 1589 { 1590 dst = sampleTexture(src1, src0, (src0.x), (src0), (src0), offset, {Base, Offset}); 1591 } 1592 TEXLOD(Vector4f & dst,Vector4f & src0,const Src & src1,Float4 & lod)1593 void VertexProgram::TEXLOD(Vector4f &dst, Vector4f &src0, const Src& src1, Float4 &lod) 1594 { 1595 dst = sampleTexture(src1, src0, lod, (src0), (src0), (src0), Lod); 1596 } 1597 TEXLODOFFSET(Vector4f & dst,Vector4f & src0,const Src & src1,Vector4f & offset,Float4 & lod)1598 void VertexProgram::TEXLODOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset, Float4 &lod) 1599 { 1600 dst = sampleTexture(src1, src0, lod, (src0), (src0), offset, {Lod, Offset}); 1601 } 1602 TEXELFETCH(Vector4f & dst,Vector4f & src0,const Src & src1,Float4 & lod)1603 void VertexProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1, Float4 &lod) 1604 { 1605 dst = sampleTexture(src1, src0, lod, (src0), (src0), (src0), Fetch); 1606 } 1607 TEXELFETCHOFFSET(Vector4f & dst,Vector4f & src0,const Src & src1,Vector4f & offset,Float4 & lod)1608 void VertexProgram::TEXELFETCHOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset, Float4 &lod) 1609 { 1610 dst = sampleTexture(src1, src0, lod, (src0), (src0), offset, {Fetch, Offset}); 1611 } 1612 TEXGRAD(Vector4f & dst,Vector4f & src0,const Src & src1,Vector4f & dsx,Vector4f & dsy)1613 void VertexProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &dsx, Vector4f &dsy) 1614 { 1615 dst = sampleTexture(src1, src0, (src0.x), dsx, dsy, src0, Grad); 1616 } 1617 TEXGRADOFFSET(Vector4f & dst,Vector4f & src0,const Src & src1,Vector4f & dsx,Vector4f & dsy,Vector4f & offset)1618 void VertexProgram::TEXGRADOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &dsx, Vector4f &dsy, Vector4f &offset) 1619 { 1620 dst = sampleTexture(src1, src0, (src0.x), dsx, dsy, offset, {Grad, Offset}); 1621 } 1622 TEXSIZE(Vector4f & dst,Float4 & lod,const Src & src1)1623 void VertexProgram::TEXSIZE(Vector4f &dst, Float4 &lod, const Src &src1) 1624 { 1625 bool uniformSampler = (src1.type == Shader::PARAMETER_SAMPLER && src1.rel.type == Shader::PARAMETER_VOID); 1626 Int offset = uniformSampler ? src1.index * sizeof(Texture) : As<Int>(Float(fetchRegister(src1).x.x)) * sizeof(Texture); 1627 Pointer<Byte> texture = data + OFFSET(DrawData, mipmap[TEXTURE_IMAGE_UNITS]) + offset; 1628 1629 dst = SamplerCore::textureSize(texture, lod); 1630 } 1631 sampleTexture(const Src & s,Vector4f & uvwq,Float4 & lod,Vector4f & dsx,Vector4f & dsy,Vector4f & offset,SamplerFunction function)1632 Vector4f VertexProgram::sampleTexture(const Src &s, Vector4f &uvwq, Float4 &lod, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function) 1633 { 1634 Vector4f tmp; 1635 1636 if(s.type == Shader::PARAMETER_SAMPLER && s.rel.type == Shader::PARAMETER_VOID) 1637 { 1638 tmp = sampleTexture(s.index, uvwq, lod, dsx, dsy, offset, function); 1639 } 1640 else 1641 { 1642 Int index = As<Int>(Float(fetchRegister(s).x.x)); 1643 1644 for(int i = 0; i < VERTEX_TEXTURE_IMAGE_UNITS; i++) 1645 { 1646 if(shader->usesSampler(i)) 1647 { 1648 If(index == i) 1649 { 1650 tmp = sampleTexture(i, uvwq, lod, dsx, dsy, offset, function); 1651 // FIXME: When the sampler states are the same, we could use one sampler and just index the texture 1652 } 1653 } 1654 } 1655 } 1656 1657 Vector4f c; 1658 c.x = tmp[(s.swizzle >> 0) & 0x3]; 1659 c.y = tmp[(s.swizzle >> 2) & 0x3]; 1660 c.z = tmp[(s.swizzle >> 4) & 0x3]; 1661 c.w = tmp[(s.swizzle >> 6) & 0x3]; 1662 1663 return c; 1664 } 1665 sampleTexture(int sampler,Vector4f & uvwq,Float4 & lod,Vector4f & dsx,Vector4f & dsy,Vector4f & offset,SamplerFunction function)1666 Vector4f VertexProgram::sampleTexture(int sampler, Vector4f &uvwq, Float4 &lod, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function) 1667 { 1668 Pointer<Byte> texture = data + OFFSET(DrawData, mipmap[TEXTURE_IMAGE_UNITS]) + sampler * sizeof(Texture); 1669 return SamplerCore(constants, state.sampler[sampler]).sampleTexture(texture, uvwq.x, uvwq.y, uvwq.z, uvwq.w, lod, dsx, dsy, offset, function); 1670 } 1671 } 1672