-// SwiftShader Software Renderer\r
-//\r
-// Copyright(c) 2015 Google Inc.\r
-//\r
-// All rights reserved. No part of this software may be copied, distributed, transmitted,\r
-// transcribed, stored in a retrieval system, translated into any human or computer\r
-// language by any means, or disclosed to third parties without the explicit written\r
-// agreement of Google Inc. Without such an agreement, no rights or licenses, express\r
-// or implied, including but not limited to any patent rights, are granted to you.\r
-//\r
-\r
-#include "PixelProgram.hpp"\r
-#include "Primitive.hpp"\r
-#include "Renderer.hpp"\r
-#include "SamplerCore.hpp"\r
-\r
-namespace sw\r
-{\r
- extern bool postBlendSRGB;\r
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "PixelProgram.hpp"
+#include "Primitive.hpp"
+#include "Renderer.hpp"
+#include "SamplerCore.hpp"
+
+namespace sw
+{
+ extern bool postBlendSRGB;
extern bool booleanFaceRegister;
extern bool halfIntegerCoordinates; // Pixel centers are not at integer coordinates
- extern bool fullPixelPositionRegister;\r
-\r
- void PixelProgram::setBuiltins(PixelRoutine::Registers &rBase, Int &x, Int &y, Float4(&z)[4], Float4 &w)\r
- {\r
- Registers& r = *static_cast<Registers*>(&rBase);\r
-\r
+ extern bool fullPixelPositionRegister;
+
+ void PixelProgram::setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w)
+ {
if(shader->getVersion() >= 0x0300)
{
- if(shader->vPosDeclared)
+ if(shader->isVPosDeclared())
{
if(!halfIntegerCoordinates)
{
- r.vPos.x = Float4(Float(x)) + Float4(0, 1, 0, 1);
- r.vPos.y = Float4(Float(y)) + Float4(0, 0, 1, 1);
+ vPos.x = Float4(Float(x)) + Float4(0, 1, 0, 1);
+ vPos.y = Float4(Float(y)) + Float4(0, 0, 1, 1);
}
else
{
- r.vPos.x = Float4(Float(x)) + Float4(0.5f, 1.5f, 0.5f, 1.5f);
- r.vPos.y = Float4(Float(y)) + Float4(0.5f, 0.5f, 1.5f, 1.5f);
+ vPos.x = Float4(Float(x)) + Float4(0.5f, 1.5f, 0.5f, 1.5f);
+ vPos.y = Float4(Float(y)) + Float4(0.5f, 0.5f, 1.5f, 1.5f);
}
if(fullPixelPositionRegister)
{
- r.vPos.z = z[0]; // FIXME: Centroid?
- r.vPos.w = w; // FIXME: Centroid?
+ vPos.z = z[0]; // FIXME: Centroid?
+ vPos.w = w; // FIXME: Centroid?
}
}
- if(shader->vFaceDeclared)
+ if(shader->isVFaceDeclared())
{
- Float4 area = *Pointer<Float>(r.primitive + OFFSET(Primitive, area));
+ Float4 area = *Pointer<Float>(primitive + OFFSET(Primitive, area));
Float4 face = booleanFaceRegister ? Float4(As<Float4>(CmpNLT(area, Float4(0.0f)))) : area;
- r.vFace.x = face;
- r.vFace.y = face;
- r.vFace.z = face;
- r.vFace.w = face;
+ vFace.x = face;
+ vFace.y = face;
+ vFace.z = face;
+ vFace.w = face;
}
- }\r
- }\r
-\r
- void PixelProgram::applyShader(PixelRoutine::Registers &rBase, Int cMask[4])
- {\r
- Registers& r = *static_cast<Registers*>(&rBase);
+ }
+ }
- r.enableIndex = 0;
- r.stackIndex = 0;
+ void PixelProgram::applyShader(Int cMask[4])
+ {
+ enableIndex = 0;
+ stackIndex = 0;
if(shader->containsLeaveInstruction())
{
- r.enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
}
for(int i = 0; i < RENDERTARGETS; i++)
{
if(state.targetFormat[i] != FORMAT_NULL)
{
- r.oC[i] = Vector4f(0.0f, 0.0f, 0.0f, 0.0f);
+ oC[i] = Vector4f(0.0f, 0.0f, 0.0f, 0.0f);
}
}
}
}
+ bool broadcastColor0 = true;
+
for(size_t i = 0; i < shader->getLength(); i++)
{
const Shader::Instruction *instruction = shader->getInstruction(i);
{
if(dst.type == Shader::PARAMETER_TEXTURE)
{
- d.x = r.v[2 + dst.index].x;
- d.y = r.v[2 + dst.index].y;
- d.z = r.v[2 + dst.index].z;
- d.w = r.v[2 + dst.index].w;
+ d.x = v[2 + dst.index].x;
+ d.y = v[2 + dst.index].y;
+ d.z = v[2 + dst.index].z;
+ d.w = v[2 + dst.index].w;
}
else
{
- d = r.r[dst.index];
+ d = r[dst.index];
}
}
- if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegisterF(r, src0);
- if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegisterF(r, src1);
- if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegisterF(r, src2);
- if(src3.type != Shader::PARAMETER_VOID) s3 = fetchRegisterF(r, src3);
- if(src4.type != Shader::PARAMETER_VOID) s4 = fetchRegisterF(r, src4);
+ if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegister(src0);
+ if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegister(src1);
+ if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegister(src2);
+ if(src3.type != Shader::PARAMETER_VOID) s3 = fetchRegister(src3);
+ if(src4.type != Shader::PARAMETER_VOID) s4 = fetchRegister(src4);
switch(opcode)
{
case Shader::OPCODE_U2F: u2f(d, s0); break;
case Shader::OPCODE_I2B: i2b(d, s0); break;
case Shader::OPCODE_B2I: b2i(d, s0); break;
- case Shader::OPCODE_U2B: u2b(d, s0); break;
- case Shader::OPCODE_B2U: b2u(d, s0); break;
case Shader::OPCODE_ADD: add(d, s0, s1); break;
case Shader::OPCODE_IADD: iadd(d, s0, s1); break;
case Shader::OPCODE_SUB: sub(d, s0, s1); break;
case Shader::OPCODE_FLOATBITSTOUINT:
case Shader::OPCODE_INTBITSTOFLOAT:
case Shader::OPCODE_UINTBITSTOFLOAT: d = s0; break;
+ case Shader::OPCODE_PACKSNORM2x16: packSnorm2x16(d, s0); break;
+ case Shader::OPCODE_PACKUNORM2x16: packUnorm2x16(d, s0); break;
+ case Shader::OPCODE_PACKHALF2x16: packHalf2x16(d, s0); break;
+ case Shader::OPCODE_UNPACKSNORM2x16: unpackSnorm2x16(d, s0); break;
+ case Shader::OPCODE_UNPACKUNORM2x16: unpackUnorm2x16(d, s0); break;
+ case Shader::OPCODE_UNPACKHALF2x16: unpackHalf2x16(d, s0); break;
case Shader::OPCODE_POWX: powx(d, s0, s1, pp); break;
case Shader::OPCODE_POW: pow(d, s0, s1, pp); break;
case Shader::OPCODE_SGN: sgn(d, s0); break;
+ case Shader::OPCODE_ISGN: isgn(d, s0); break;
case Shader::OPCODE_CRS: crs(d, s0, s1); break;
case Shader::OPCODE_FORWARD1: forward1(d, s0, s1, s2); break;
case Shader::OPCODE_FORWARD2: forward2(d, s0, s1, s2); break;
case Shader::OPCODE_NRM3: nrm3(d, s0, pp); break;
case Shader::OPCODE_NRM4: nrm4(d, s0, pp); break;
case Shader::OPCODE_ABS: abs(d, s0); break;
+ case Shader::OPCODE_IABS: iabs(d, s0); break;
case Shader::OPCODE_SINCOS: sincos(d, s0, pp); break;
case Shader::OPCODE_COS: cos(d, s0, pp); break;
case Shader::OPCODE_SIN: sin(d, s0, pp); break;
case Shader::OPCODE_ACOSH: acosh(d, s0, pp); break;
case Shader::OPCODE_ASINH: asinh(d, s0, pp); break;
case Shader::OPCODE_ATANH: atanh(d, s0, pp); break;
- case Shader::OPCODE_M4X4: M4X4(r, d, s0, src1); break;
- case Shader::OPCODE_M4X3: M4X3(r, d, s0, src1); break;
- case Shader::OPCODE_M3X4: M3X4(r, d, s0, src1); break;
- case Shader::OPCODE_M3X3: M3X3(r, d, s0, src1); break;
- case Shader::OPCODE_M3X2: M3X2(r, d, s0, src1); break;
- case Shader::OPCODE_TEX: TEXLD(r, d, s0, src1, project, bias); break;
- case Shader::OPCODE_TEXLDD: TEXLDD(r, d, s0, src1, s2, s3, project, bias); break;
- case Shader::OPCODE_TEXLDL: TEXLDL(r, d, s0, src1, project, bias); break;
- case Shader::OPCODE_TEXSIZE: TEXSIZE(r, d, s0.x, src1); break;
+ case Shader::OPCODE_M4X4: M4X4(d, s0, src1); break;
+ case Shader::OPCODE_M4X3: M4X3(d, s0, src1); break;
+ case Shader::OPCODE_M3X4: M3X4(d, s0, src1); break;
+ case Shader::OPCODE_M3X3: M3X3(d, s0, src1); break;
+ case Shader::OPCODE_M3X2: M3X2(d, s0, src1); break;
+ case Shader::OPCODE_TEX: TEXLD(d, s0, src1, project, bias); break;
+ case Shader::OPCODE_TEXLDD: TEXLDD(d, s0, src1, s2, s3); break;
+ case Shader::OPCODE_TEXLDL: TEXLDL(d, s0, src1); break;
+ case Shader::OPCODE_TEXSIZE: TEXSIZE(d, s0.x, src1); break;
case Shader::OPCODE_TEXKILL: TEXKILL(cMask, d, dst.mask); break;
- case Shader::OPCODE_TEXOFFSET: TEXOFFSET(r, d, s0, src1, s2, s3, project, bias); break;
- case Shader::OPCODE_TEXLDLOFFSET: TEXLDL(r, d, s0, src1, s2, project, bias); break;
- case Shader::OPCODE_TEXELFETCH: TEXELFETCH(r, d, s0, src1, s2); break;
- case Shader::OPCODE_TEXELFETCHOFFSET: TEXELFETCH(r, d, s0, src1, s2, s3); break;
- case Shader::OPCODE_TEXGRAD: TEXGRAD(r, d, s0, src1, s2, s3); break;
- case Shader::OPCODE_TEXGRADOFFSET: TEXGRAD(r, d, s0, src1, s2, s3, s4); break;
- case Shader::OPCODE_DISCARD: DISCARD(r, cMask, instruction); break;
+ case Shader::OPCODE_TEXOFFSET: TEXOFFSET(d, s0, src1, s2, bias); break;
+ case Shader::OPCODE_TEXLDLOFFSET: TEXLDL(d, s0, src1, s2, bias); break;
+ case Shader::OPCODE_TEXELFETCH: TEXELFETCH(d, s0, src1); break;
+ case Shader::OPCODE_TEXELFETCHOFFSET: TEXELFETCH(d, s0, src1, s2); break;
+ case Shader::OPCODE_TEXGRAD: TEXGRAD(d, s0, src1, s2, s3); break;
+ case Shader::OPCODE_TEXGRADOFFSET: TEXGRAD(d, s0, src1, s2, s3, s4); break;
+ case Shader::OPCODE_DISCARD: DISCARD(cMask, instruction); break;
case Shader::OPCODE_DFDX: DFDX(d, s0); break;
case Shader::OPCODE_DFDY: DFDY(d, s0); break;
case Shader::OPCODE_FWIDTH: FWIDTH(d, s0); break;
- case Shader::OPCODE_BREAK: BREAK(r); break;
- case Shader::OPCODE_BREAKC: BREAKC(r, s0, s1, control); break;
- case Shader::OPCODE_BREAKP: BREAKP(r, src0); break;
- case Shader::OPCODE_CONTINUE: CONTINUE(r); break;
+ case Shader::OPCODE_BREAK: BREAK(); break;
+ case Shader::OPCODE_BREAKC: BREAKC(s0, s1, control); break;
+ case Shader::OPCODE_BREAKP: BREAKP(src0); break;
+ case Shader::OPCODE_CONTINUE: CONTINUE(); break;
case Shader::OPCODE_TEST: TEST(); break;
- case Shader::OPCODE_CALL: CALL(r, dst.label, dst.callSite); break;
- case Shader::OPCODE_CALLNZ: CALLNZ(r, dst.label, dst.callSite, src0); break;
- case Shader::OPCODE_ELSE: ELSE(r); break;
- case Shader::OPCODE_ENDIF: ENDIF(r); break;
- case Shader::OPCODE_ENDLOOP: ENDLOOP(r); break;
- case Shader::OPCODE_ENDREP: ENDREP(r); break;
- case Shader::OPCODE_ENDWHILE: ENDWHILE(r); break;
- case Shader::OPCODE_IF: IF(r, src0); break;
- case Shader::OPCODE_IFC: IFC(r, s0, s1, control); break;
+ case Shader::OPCODE_CALL: CALL(dst.label, dst.callSite); break;
+ case Shader::OPCODE_CALLNZ: CALLNZ(dst.label, dst.callSite, src0); break;
+ case Shader::OPCODE_ELSE: ELSE(); break;
+ case Shader::OPCODE_ENDIF: ENDIF(); break;
+ case Shader::OPCODE_ENDLOOP: ENDLOOP(); break;
+ case Shader::OPCODE_ENDREP: ENDREP(); break;
+ case Shader::OPCODE_ENDWHILE: ENDWHILE(); break;
+ case Shader::OPCODE_ENDSWITCH: ENDSWITCH(); break;
+ case Shader::OPCODE_IF: IF(src0); break;
+ case Shader::OPCODE_IFC: IFC(s0, s1, control); break;
case Shader::OPCODE_LABEL: LABEL(dst.index); break;
- case Shader::OPCODE_LOOP: LOOP(r, src1); break;
- case Shader::OPCODE_REP: REP(r, src0); break;
- case Shader::OPCODE_WHILE: WHILE(r, src0); break;
- case Shader::OPCODE_RET: RET(r); break;
- case Shader::OPCODE_LEAVE: LEAVE(r); break;
+ case Shader::OPCODE_LOOP: LOOP(src1); break;
+ case Shader::OPCODE_REP: REP(src0); break;
+ case Shader::OPCODE_WHILE: WHILE(src0); break;
+ case Shader::OPCODE_SWITCH: SWITCH(); break;
+ case Shader::OPCODE_RET: RET(); break;
+ case Shader::OPCODE_LEAVE: LEAVE(); break;
case Shader::OPCODE_CMP: cmp(d, s0, s1, control); break;
case Shader::OPCODE_ALL: all(d.x, s0); break;
case Shader::OPCODE_ANY: any(d.x, s0); break;
- case Shader::OPCODE_NOT: not(d, s0); break;
- case Shader::OPCODE_OR: or(d, s0, s1); break;
- case Shader::OPCODE_XOR: xor(d, s0, s1); break;
- case Shader::OPCODE_AND: and(d, s0, s1); break;
+ case Shader::OPCODE_NOT: bitwise_not(d, s0); break;
+ case Shader::OPCODE_OR: bitwise_or(d, s0, s1); break;
+ case Shader::OPCODE_XOR: bitwise_xor(d, s0, s1); break;
+ case Shader::OPCODE_AND: bitwise_and(d, s0, s1); break;
case Shader::OPCODE_EQ: equal(d, s0, s1); break;
case Shader::OPCODE_NE: notEqual(d, s0, s1); break;
case Shader::OPCODE_END: break;
case Shader::PARAMETER_TEMP:
if(dst.rel.type == Shader::PARAMETER_VOID)
{
- if(dst.x) pDst.x = r.r[dst.index].x;
- if(dst.y) pDst.y = r.r[dst.index].y;
- if(dst.z) pDst.z = r.r[dst.index].z;
- if(dst.w) pDst.w = r.r[dst.index].w;
+ if(dst.x) pDst.x = r[dst.index].x;
+ if(dst.y) pDst.y = r[dst.index].y;
+ if(dst.z) pDst.z = r[dst.index].z;
+ if(dst.w) pDst.w = r[dst.index].w;
}
else
{
- Int a = relativeAddress(r, dst);
+ Int a = relativeAddress(dst);
- if(dst.x) pDst.x = r.r[dst.index + a].x;
- if(dst.y) pDst.y = r.r[dst.index + a].y;
- if(dst.z) pDst.z = r.r[dst.index + a].z;
- if(dst.w) pDst.w = r.r[dst.index + a].w;
+ if(dst.x) pDst.x = r[dst.index + a].x;
+ if(dst.y) pDst.y = r[dst.index + a].y;
+ if(dst.z) pDst.z = r[dst.index + a].z;
+ if(dst.w) pDst.w = r[dst.index + a].w;
}
break;
case Shader::PARAMETER_COLOROUT:
if(dst.rel.type == Shader::PARAMETER_VOID)
{
- if(dst.x) pDst.x = r.oC[dst.index].x;
- if(dst.y) pDst.y = r.oC[dst.index].y;
- if(dst.z) pDst.z = r.oC[dst.index].z;
- if(dst.w) pDst.w = r.oC[dst.index].w;
+ if(dst.x) pDst.x = oC[dst.index].x;
+ if(dst.y) pDst.y = oC[dst.index].y;
+ if(dst.z) pDst.z = oC[dst.index].z;
+ if(dst.w) pDst.w = oC[dst.index].w;
}
else
{
- Int a = relativeAddress(r, dst) + dst.index;
+ Int a = relativeAddress(dst) + dst.index;
- if(dst.x) pDst.x = r.oC[a].x;
- if(dst.y) pDst.y = r.oC[a].y;
- if(dst.z) pDst.z = r.oC[a].z;
- if(dst.w) pDst.w = r.oC[a].w;
+ if(dst.x) pDst.x = oC[a].x;
+ if(dst.y) pDst.y = oC[a].y;
+ if(dst.z) pDst.z = oC[a].z;
+ if(dst.w) pDst.w = oC[a].w;
}
break;
case Shader::PARAMETER_PREDICATE:
- if(dst.x) pDst.x = r.p0.x;
- if(dst.y) pDst.y = r.p0.y;
- if(dst.z) pDst.z = r.p0.z;
- if(dst.w) pDst.w = r.p0.w;
+ if(dst.x) pDst.x = p0.x;
+ if(dst.y) pDst.y = p0.y;
+ if(dst.z) pDst.z = p0.z;
+ if(dst.w) pDst.w = p0.w;
break;
case Shader::PARAMETER_DEPTHOUT:
- pDst.x = r.oDepth;
+ pDst.x = oDepth;
break;
default:
ASSERT(false);
}
- Int4 enable = enableMask(r, instruction);
+ Int4 enable = enableMask(instruction);
Int4 xEnable = enable;
Int4 yEnable = enable;
{
unsigned char pSwizzle = instruction->predicateSwizzle;
- Float4 xPredicate = r.p0[(pSwizzle >> 0) & 0x03];
- Float4 yPredicate = r.p0[(pSwizzle >> 2) & 0x03];
- Float4 zPredicate = r.p0[(pSwizzle >> 4) & 0x03];
- Float4 wPredicate = r.p0[(pSwizzle >> 6) & 0x03];
+ Float4 xPredicate = p0[(pSwizzle >> 0) & 0x03];
+ Float4 yPredicate = p0[(pSwizzle >> 2) & 0x03];
+ Float4 zPredicate = p0[(pSwizzle >> 4) & 0x03];
+ Float4 wPredicate = p0[(pSwizzle >> 6) & 0x03];
if(!instruction->predicateNot)
{
case Shader::PARAMETER_TEMP:
if(dst.rel.type == Shader::PARAMETER_VOID)
{
- if(dst.x) r.r[dst.index].x = d.x;
- if(dst.y) r.r[dst.index].y = d.y;
- if(dst.z) r.r[dst.index].z = d.z;
- if(dst.w) r.r[dst.index].w = d.w;
+ if(dst.x) r[dst.index].x = d.x;
+ if(dst.y) r[dst.index].y = d.y;
+ if(dst.z) r[dst.index].z = d.z;
+ if(dst.w) r[dst.index].w = d.w;
}
else
{
- Int a = relativeAddress(r, dst);
+ Int a = relativeAddress(dst);
- if(dst.x) r.r[dst.index + a].x = d.x;
- if(dst.y) r.r[dst.index + a].y = d.y;
- if(dst.z) r.r[dst.index + a].z = d.z;
- if(dst.w) r.r[dst.index + a].w = d.w;
+ if(dst.x) r[dst.index + a].x = d.x;
+ if(dst.y) r[dst.index + a].y = d.y;
+ if(dst.z) r[dst.index + a].z = d.z;
+ if(dst.w) r[dst.index + a].w = d.w;
}
break;
case Shader::PARAMETER_COLOROUT:
if(dst.rel.type == Shader::PARAMETER_VOID)
{
- if(dst.x) { r.oC[dst.index].x = d.x; }
- if(dst.y) { r.oC[dst.index].y = d.y; }
- if(dst.z) { r.oC[dst.index].z = d.z; }
- if(dst.w) { r.oC[dst.index].w = d.w; }
+ broadcastColor0 = (dst.index == 0) && broadcastColor0;
+
+ if(dst.x) { oC[dst.index].x = d.x; }
+ if(dst.y) { oC[dst.index].y = d.y; }
+ if(dst.z) { oC[dst.index].z = d.z; }
+ if(dst.w) { oC[dst.index].w = d.w; }
}
else
{
- Int a = relativeAddress(r, dst) + dst.index;
+ broadcastColor0 = false;
+ Int a = relativeAddress(dst) + dst.index;
- if(dst.x) { r.oC[a].x = d.x; }
- if(dst.y) { r.oC[a].y = d.y; }
- if(dst.z) { r.oC[a].z = d.z; }
- if(dst.w) { r.oC[a].w = d.w; }
+ if(dst.x) { oC[a].x = d.x; }
+ if(dst.y) { oC[a].y = d.y; }
+ if(dst.z) { oC[a].z = d.z; }
+ if(dst.w) { oC[a].w = d.w; }
}
break;
case Shader::PARAMETER_PREDICATE:
- if(dst.x) r.p0.x = d.x;
- if(dst.y) r.p0.y = d.y;
- if(dst.z) r.p0.z = d.z;
- if(dst.w) r.p0.w = d.w;
+ if(dst.x) p0.x = d.x;
+ if(dst.y) p0.y = d.y;
+ if(dst.z) p0.z = d.z;
+ if(dst.w) p0.w = d.w;
break;
case Shader::PARAMETER_DEPTHOUT:
- r.oDepth = d.x;
+ oDepth = d.x;
break;
default:
ASSERT(false);
Nucleus::setInsertBlock(returnBlock);
}
- for(int i = 0; i < RENDERTARGETS; i++)
+ if(broadcastColor0)
+ {
+ for(int i = 0; i < RENDERTARGETS; i++)
+ {
+ c[i] = oC[0];
+ }
+ }
+ else
{
- r.c[i] = r.oC[i];
+ for(int i = 0; i < RENDERTARGETS; i++)
+ {
+ c[i] = oC[i];
+ }
}
}
-\r
- Bool PixelProgram::alphaTest(PixelRoutine::Registers &rBase, Int cMask[4])\r
- {\r
- Registers& r = *static_cast<Registers*>(&rBase);\r
-\r
- clampColor(r.c);
-\r
+
+ Bool PixelProgram::alphaTest(Int cMask[4])
+ {
+ clampColor(c);
+
if(!state.alphaTestActive())
{
return true;
if(state.transparencyAntialiasing == TRANSPARENCY_NONE)
{
- Short4 alpha = RoundShort4(r.c[0].w * Float4(0x1000));
+ Short4 alpha = RoundShort4(c[0].w * Float4(0x1000));
- PixelRoutine::alphaTest(r, aMask, alpha);
+ PixelRoutine::alphaTest(aMask, alpha);
for(unsigned int q = 0; q < state.multiSample; q++)
{
}
else if(state.transparencyAntialiasing == TRANSPARENCY_ALPHA_TO_COVERAGE)
{
- alphaToCoverage(r, cMask, r.c[0].w);
+ alphaToCoverage(cMask, c[0].w);
}
else ASSERT(false);
pass = pass | cMask[q];
}
- return pass != 0x0;\r
- }\r
-\r
- void PixelProgram::rasterOperation(PixelRoutine::Registers &rBase, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4])\r
- {\r
- Registers& r = *static_cast<Registers*>(&rBase);\r
-\r
+ return pass != 0x0;
+ }
+
+ void PixelProgram::rasterOperation(Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4])
+ {
for(int index = 0; index < RENDERTARGETS; index++)
{
if(!state.colorWriteActive(index))
{
continue;
- }\r
+ }
- if(!postBlendSRGB && state.writeSRGB)
+ if(!postBlendSRGB && state.writeSRGB && !isSRGB(index))
{
- r.c[index].x = linearToSRGB(r.c[index].x);
- r.c[index].y = linearToSRGB(r.c[index].y);
- r.c[index].z = linearToSRGB(r.c[index].z);
+ c[index].x = linearToSRGB(c[index].x);
+ c[index].y = linearToSRGB(c[index].y);
+ c[index].z = linearToSRGB(c[index].z);
}
if(index == 0)
{
- fogBlend(r, r.c[index], fog);
+ fogBlend(c[index], fog);
}
switch(state.targetFormat[index])
case FORMAT_X8B8G8R8:
case FORMAT_A8R8G8B8:
case FORMAT_A8B8G8R8:
+ case FORMAT_SRGB8_X8:
+ case FORMAT_SRGB8_A8:
+ case FORMAT_G8R8:
+ case FORMAT_R8:
case FORMAT_A8:
case FORMAT_G16R16:
case FORMAT_A16B16G16R16:
for(unsigned int q = 0; q < state.multiSample; q++)
{
- Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(r.data + OFFSET(DrawData, colorSliceB[index]));
+ Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(data + OFFSET(DrawData, colorSliceB[index]));
Vector4s color;
- color.x = convertFixed16(r.c[index].x, false);
- color.y = convertFixed16(r.c[index].y, false);
- color.z = convertFixed16(r.c[index].z, false);
- color.w = convertFixed16(r.c[index].w, false);
+ if(state.targetFormat[index] == FORMAT_R5G6B5)
+ {
+ color.x = UShort4(c[index].x * Float4(0xFBFF), false);
+ color.y = UShort4(c[index].y * Float4(0xFDFF), false);
+ color.z = UShort4(c[index].z * Float4(0xFBFF), false);
+ color.w = UShort4(c[index].w * Float4(0xFFFF), false);
+ }
+ else
+ {
+ color.x = convertFixed16(c[index].x, false);
+ color.y = convertFixed16(c[index].y, false);
+ color.z = convertFixed16(c[index].z, false);
+ color.w = convertFixed16(c[index].w, false);
+ }
if(state.multiSampleMask & (1 << q))
{
- alphaBlend(r, index, buffer, color, x);
- logicOperation(r, index, buffer, color, x);
- writeColor(r, index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+ alphaBlend(index, buffer, color, x);
+ logicOperation(index, buffer, color, x);
+ writeColor(index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
}
}
break;
case FORMAT_R32F:
case FORMAT_G32R32F:
+ case FORMAT_X32B32G32R32F:
case FORMAT_A32B32G32R32F:
+ case FORMAT_R32I:
+ case FORMAT_G32R32I:
+ case FORMAT_A32B32G32R32I:
+ case FORMAT_R32UI:
+ case FORMAT_G32R32UI:
+ case FORMAT_A32B32G32R32UI:
+ case FORMAT_R16I:
+ case FORMAT_G16R16I:
+ case FORMAT_A16B16G16R16I:
+ case FORMAT_R16UI:
+ case FORMAT_G16R16UI:
+ case FORMAT_A16B16G16R16UI:
+ case FORMAT_R8I:
+ case FORMAT_G8R8I:
+ case FORMAT_A8B8G8R8I:
+ case FORMAT_R8UI:
+ case FORMAT_G8R8UI:
+ case FORMAT_A8B8G8R8UI:
for(unsigned int q = 0; q < state.multiSample; q++)
{
- Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(r.data + OFFSET(DrawData, colorSliceB[index]));
- Vector4f color = r.c[index];
+ Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(data + OFFSET(DrawData, colorSliceB[index]));
+ Vector4f color = c[index];
if(state.multiSampleMask & (1 << q))
{
- alphaBlend(r, index, buffer, color, x);
- writeColor(r, index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+ alphaBlend(index, buffer, color, x);
+ writeColor(index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
}
}
break;
}
}
- void PixelProgram::sampleTexture(Registers &r, Vector4f &c, const Src &sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
+ void PixelProgram::sampleTexture(Vector4f &c, const Src &sampler, Vector4f &uvwq, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
{
+ Vector4f tmp;
+
if(sampler.type == Shader::PARAMETER_SAMPLER && sampler.rel.type == Shader::PARAMETER_VOID)
{
- sampleTexture(r, c, sampler.index, u, v, w, q, dsx, dsy, project, bias, gradients, lodProvided);
+ sampleTexture(tmp, sampler.index, uvwq, dsx, dsy, offset, function);
}
else
{
- Int index = As<Int>(Float(fetchRegisterF(r, sampler).x.x));
+ Int index = As<Int>(Float(fetchRegister(sampler).x.x));
for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++)
{
{
If(index == i)
{
- sampleTexture(r, c, i, u, v, w, q, dsx, dsy, project, bias, gradients, lodProvided);
+ sampleTexture(tmp, i, uvwq, dsx, dsy, offset, function);
// FIXME: When the sampler states are the same, we could use one sampler and just index the texture
}
}
}
}
+
+ c.x = tmp[(sampler.swizzle >> 0) & 0x3];
+ c.y = tmp[(sampler.swizzle >> 2) & 0x3];
+ c.z = tmp[(sampler.swizzle >> 4) & 0x3];
+ c.w = tmp[(sampler.swizzle >> 6) & 0x3];
}
- void PixelProgram::sampleTexture(Registers &r, Vector4f &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
+ void PixelProgram::sampleTexture(Vector4f &c, int samplerIndex, Vector4f &uvwq, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
{
-#if PERF_PROFILE
- Long texTime = Ticks();
-#endif
+ #if PERF_PROFILE
+ Long texTime = Ticks();
+ #endif
- Pointer<Byte> texture = r.data + OFFSET(DrawData, mipmap) + stage * sizeof(Texture);
+ Pointer<Byte> texture = data + OFFSET(DrawData, mipmap) + samplerIndex * sizeof(Texture);
+ sampler[samplerIndex]->sampleTexture(texture, c, uvwq.x, uvwq.y, uvwq.z, uvwq.w, dsx, dsy, offset, function);
- if(!project)
- {
- sampler[stage]->sampleTexture(texture, c, u, v, w, q, dsx, dsy, bias, gradients, lodProvided);
- }
- else
- {
- Float4 rq = reciprocal(q);
-
- Float4 u_q = u * rq;
- Float4 v_q = v * rq;
- Float4 w_q = w * rq;
-
- sampler[stage]->sampleTexture(texture, c, u_q, v_q, w_q, q, dsx, dsy, bias, gradients, lodProvided);
- }
-
-#if PERF_PROFILE
- r.cycles[PERF_TEX] += Ticks() - texTime;
-#endif
+ #if PERF_PROFILE
+ cycles[PERF_TEX] += Ticks() - texTime;
+ #endif
}
void PixelProgram::clampColor(Vector4f oC[RENDERTARGETS])
case FORMAT_A8B8G8R8:
case FORMAT_X8R8G8B8:
case FORMAT_X8B8G8R8:
+ case FORMAT_SRGB8_X8:
+ case FORMAT_SRGB8_A8:
+ case FORMAT_G8R8:
+ case FORMAT_R8:
case FORMAT_A8:
case FORMAT_G16R16:
case FORMAT_A16B16G16R16:
break;
case FORMAT_R32F:
case FORMAT_G32R32F:
+ case FORMAT_X32B32G32R32F:
case FORMAT_A32B32G32R32F:
+ case FORMAT_R32I:
+ case FORMAT_G32R32I:
+ case FORMAT_A32B32G32R32I:
+ case FORMAT_R32UI:
+ case FORMAT_G32R32UI:
+ case FORMAT_A32B32G32R32UI:
+ case FORMAT_R16I:
+ case FORMAT_G16R16I:
+ case FORMAT_A16B16G16R16I:
+ case FORMAT_R16UI:
+ case FORMAT_G16R16UI:
+ case FORMAT_A16B16G16R16UI:
+ case FORMAT_R8I:
+ case FORMAT_G8R8I:
+ case FORMAT_A8B8G8R8I:
+ case FORMAT_R8UI:
+ case FORMAT_G8R8UI:
+ case FORMAT_A8B8G8R8UI:
break;
default:
ASSERT(false);
}
}
- Int4 PixelProgram::enableMask(Registers &r, const Shader::Instruction *instruction)
+ Int4 PixelProgram::enableMask(const Shader::Instruction *instruction)
{
- Int4 enable = instruction->analysisBranch ? Int4(r.enableStack[r.enableIndex]) : Int4(0xFFFFFFFF);
+ Int4 enable = instruction->analysisBranch ? Int4(enableStack[enableIndex]) : Int4(0xFFFFFFFF);
if(!whileTest)
{
if(shader->containsBreakInstruction() && instruction->analysisBreak)
{
- enable &= r.enableBreak;
+ enable &= enableBreak;
}
if(shader->containsContinueInstruction() && instruction->analysisContinue)
{
- enable &= r.enableContinue;
+ enable &= enableContinue;
}
if(shader->containsLeaveInstruction() && instruction->analysisLeave)
{
- enable &= r.enableLeave;
+ enable &= enableLeave;
}
}
return enable;
}
- Vector4f PixelProgram::fetchRegisterF(Registers &r, const Src &src, int offset)
+ Vector4f PixelProgram::fetchRegister(const Src &src, unsigned int offset)
{
Vector4f reg;
- int i = src.index + offset;
+ unsigned int i = src.index + offset;
switch(src.type)
{
case Shader::PARAMETER_TEMP:
if(src.rel.type == Shader::PARAMETER_VOID)
{
- reg = r.r[i];
+ reg = r[i];
}
else
{
- Int a = relativeAddress(r, src);
+ Int a = relativeAddress(src, src.bufferIndex);
- reg = r.r[i + a];
+ reg = r[i + a];
}
break;
case Shader::PARAMETER_INPUT:
{
if(src.rel.type == Shader::PARAMETER_VOID) // Not relative
{
- reg = r.v[i];
- }
- else if(src.rel.type == Shader::PARAMETER_LOOP)
- {
- Int aL = r.aL[r.loopDepth];
-
- reg = r.v[i + aL];
+ reg = v[i];
}
else
{
- Int a = relativeAddress(r, src);
+ Int a = relativeAddress(src, src.bufferIndex);
- reg = r.v[i + a];
+ reg = v[i + a];
}
}
break;
case Shader::PARAMETER_CONST:
- reg = readConstant(r, src, offset);
+ reg = readConstant(src, offset);
break;
case Shader::PARAMETER_TEXTURE:
- reg = r.v[2 + i];
+ reg = v[2 + i];
break;
case Shader::PARAMETER_MISCTYPE:
- if(src.index == 0) reg = r.vPos;
- if(src.index == 1) reg = r.vFace;
+ if(src.index == Shader::VPosIndex) reg = vPos;
+ if(src.index == Shader::VFaceIndex) reg = vFace;
break;
case Shader::PARAMETER_SAMPLER:
if(src.rel.type == Shader::PARAMETER_VOID)
}
else if(src.rel.type == Shader::PARAMETER_TEMP)
{
- reg.x = As<Float4>(Int4(i) + As<Int4>(r.r[src.rel.index].x));
+ reg.x = As<Float4>(Int4(i) + As<Int4>(r[src.rel.index].x));
}
return reg;
case Shader::PARAMETER_PREDICATE: return reg; // Dummy
case Shader::PARAMETER_COLOROUT:
if(src.rel.type == Shader::PARAMETER_VOID) // Not relative
{
- reg = r.oC[i];
+ reg = oC[i];
}
else
{
- Int a = relativeAddress(r, src);
+ Int a = relativeAddress(src, src.bufferIndex);
- reg = r.oC[i + a];
+ reg = oC[i + a];
}
break;
case Shader::PARAMETER_DEPTHOUT:
- reg.x = r.oDepth;
+ reg.x = oDepth;
break;
default:
ASSERT(false);
return mod;
}
- Vector4f PixelProgram::readConstant(Registers &r, const Src &src, int offset)
+ RValue<Pointer<Byte>> PixelProgram::uniformAddress(int bufferIndex, unsigned int index)
{
- Vector4f c;
+ if(bufferIndex == -1)
+ {
+ return data + OFFSET(DrawData, ps.c[index]);
+ }
+ else
+ {
+ return *Pointer<Pointer<Byte>>(data + OFFSET(DrawData, ps.u[bufferIndex])) + index;
+ }
+ }
- int i = src.index + offset;
+ RValue<Pointer<Byte>> PixelProgram::uniformAddress(int bufferIndex, unsigned int index, Int& offset)
+ {
+ return uniformAddress(bufferIndex, index) + offset * sizeof(float4);
+ }
+
+ Vector4f PixelProgram::readConstant(const Src &src, unsigned int offset)
+ {
+ Vector4f c;
+ unsigned int i = src.index + offset;
if(src.rel.type == Shader::PARAMETER_VOID) // Not relative
{
- c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData, ps.c[i]));
+ c.x = c.y = c.z = c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, i));
c.x = c.x.xxxx;
c.y = c.y.yyyy;
}
else if(src.rel.type == Shader::PARAMETER_LOOP)
{
- Int loopCounter = r.aL[r.loopDepth];
+ Int loopCounter = aL[loopDepth];
- c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData, ps.c[i]) + loopCounter * 16);
+ c.x = c.y = c.z = c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, i, loopCounter));
c.x = c.x.xxxx;
c.y = c.y.yyyy;
}
else
{
- Int a = relativeAddress(r, src);
+ Int a = relativeAddress(src, src.bufferIndex);
- c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData, ps.c[i]) + a * 16);
+ c.x = c.y = c.z = c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, i, a));
c.x = c.x.xxxx;
c.y = c.y.yyyy;
return c;
}
- Int PixelProgram::relativeAddress(Registers &r, const Shader::Parameter &var)
+ Int PixelProgram::relativeAddress(const Shader::Parameter &var, int bufferIndex)
{
ASSERT(var.rel.deterministic);
if(var.rel.type == Shader::PARAMETER_TEMP)
{
- return As<Int>(Extract(r.r[var.rel.index].x, 0)) * var.rel.scale;
+ return As<Int>(Extract(r[var.rel.index].x, 0)) * var.rel.scale;
}
else if(var.rel.type == Shader::PARAMETER_INPUT)
{
- return As<Int>(Extract(r.v[var.rel.index].x, 0)) * var.rel.scale;
+ return As<Int>(Extract(v[var.rel.index].x, 0)) * var.rel.scale;
}
else if(var.rel.type == Shader::PARAMETER_OUTPUT)
{
- return As<Int>(Extract(r.oC[var.rel.index].x, 0)) * var.rel.scale;
+ return As<Int>(Extract(oC[var.rel.index].x, 0)) * var.rel.scale;
}
else if(var.rel.type == Shader::PARAMETER_CONST)
{
- RValue<Int4> c = *Pointer<Int4>(r.data + OFFSET(DrawData, ps.c[var.rel.index]));
-
- return Extract(c, 0) * var.rel.scale;
+ return *Pointer<Int>(uniformAddress(bufferIndex, var.rel.index)) * var.rel.scale;
+ }
+ else if(var.rel.type == Shader::PARAMETER_LOOP)
+ {
+ return aL[loopDepth];
}
else ASSERT(false);
return Min(Max(sRGB, Float4(0.0f)), Float4(1.0f));
}
- void PixelProgram::M3X2(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
+ void PixelProgram::M3X2(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f row0 = fetchRegisterF(r, src1, 0);
- Vector4f row1 = fetchRegisterF(r, src1, 1);
+ Vector4f row0 = fetchRegister(src1, 0);
+ Vector4f row1 = fetchRegister(src1, 1);
dst.x = dot3(src0, row0);
dst.y = dot3(src0, row1);
}
- void PixelProgram::M3X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
+ void PixelProgram::M3X3(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f row0 = fetchRegisterF(r, src1, 0);
- Vector4f row1 = fetchRegisterF(r, src1, 1);
- Vector4f row2 = fetchRegisterF(r, src1, 2);
+ Vector4f row0 = fetchRegister(src1, 0);
+ Vector4f row1 = fetchRegister(src1, 1);
+ Vector4f row2 = fetchRegister(src1, 2);
dst.x = dot3(src0, row0);
dst.y = dot3(src0, row1);
dst.z = dot3(src0, row2);
}
- void PixelProgram::M3X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
+ void PixelProgram::M3X4(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f row0 = fetchRegisterF(r, src1, 0);
- Vector4f row1 = fetchRegisterF(r, src1, 1);
- Vector4f row2 = fetchRegisterF(r, src1, 2);
- Vector4f row3 = fetchRegisterF(r, src1, 3);
+ Vector4f row0 = fetchRegister(src1, 0);
+ Vector4f row1 = fetchRegister(src1, 1);
+ Vector4f row2 = fetchRegister(src1, 2);
+ Vector4f row3 = fetchRegister(src1, 3);
dst.x = dot3(src0, row0);
dst.y = dot3(src0, row1);
dst.w = dot3(src0, row3);
}
- void PixelProgram::M4X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
+ void PixelProgram::M4X3(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f row0 = fetchRegisterF(r, src1, 0);
- Vector4f row1 = fetchRegisterF(r, src1, 1);
- Vector4f row2 = fetchRegisterF(r, src1, 2);
+ Vector4f row0 = fetchRegister(src1, 0);
+ Vector4f row1 = fetchRegister(src1, 1);
+ Vector4f row2 = fetchRegister(src1, 2);
dst.x = dot4(src0, row0);
dst.y = dot4(src0, row1);
dst.z = dot4(src0, row2);
}
- void PixelProgram::M4X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
+ void PixelProgram::M4X4(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f row0 = fetchRegisterF(r, src1, 0);
- Vector4f row1 = fetchRegisterF(r, src1, 1);
- Vector4f row2 = fetchRegisterF(r, src1, 2);
- Vector4f row3 = fetchRegisterF(r, src1, 3);
+ Vector4f row0 = fetchRegister(src1, 0);
+ Vector4f row1 = fetchRegister(src1, 1);
+ Vector4f row2 = fetchRegister(src1, 2);
+ Vector4f row3 = fetchRegister(src1, 3);
dst.x = dot4(src0, row0);
dst.y = dot4(src0, row1);
dst.w = dot4(src0, row3);
}
- void PixelProgram::TEXLD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
+ void PixelProgram::TEXLD(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
{
- Vector4f tmp;
- sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src0, src0, project, bias);
+ if(project)
+ {
+ Vector4f proj;
+ Float4 rw = reciprocal(src0.w);
+ proj.x = src0.x * rw;
+ proj.y = src0.y * rw;
+ proj.z = src0.z * rw;
- dst.x = tmp[(src1.swizzle >> 0) & 0x3];
- dst.y = tmp[(src1.swizzle >> 2) & 0x3];
- dst.z = tmp[(src1.swizzle >> 4) & 0x3];
- dst.w = tmp[(src1.swizzle >> 6) & 0x3];
+ sampleTexture(dst, src1, proj, src0, src0, src0, Implicit);
+ }
+ else
+ {
+ sampleTexture(dst, src1, src0, src0, src0, src0, bias ? Bias : Implicit);
+ }
}
- void PixelProgram::TEXOFFSET(Registers &r, Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &src3, bool project, bool bias)
+ void PixelProgram::TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, bool bias)
{
- UNIMPLEMENTED();
+ sampleTexture(dst, src1, src0, src0, src0, src2, {bias ? Bias : Implicit, Offset});
}
- void PixelProgram::TEXLDL(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, bool project, bool bias)
+ void PixelProgram::TEXLDL(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, bool bias)
{
- UNIMPLEMENTED();
+ sampleTexture(dst, src1, src0, src0, src0, offset, {Lod, Offset});
}
- void PixelProgram::TEXELFETCH(Registers &r, Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2)
+ void PixelProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1)
{
- UNIMPLEMENTED();
+ sampleTexture(dst, src1, src0, src0, src0, src0, Fetch);
}
- void PixelProgram::TEXELFETCH(Registers &r, Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &offset)
+ void PixelProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset)
{
- UNIMPLEMENTED();
+ sampleTexture(dst, src1, src0, src0, src0, offset, {Fetch, Offset});
}
- void PixelProgram::TEXGRAD(Registers &r, Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &src3)
+ void PixelProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &src3)
{
- UNIMPLEMENTED();
+ sampleTexture(dst, src1, src0, src2, src3, src0, Grad);
}
- void PixelProgram::TEXGRAD(Registers &r, Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &src3, Vector4f &offset)
+ void PixelProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &src3, Vector4f &offset)
{
- UNIMPLEMENTED();
+ sampleTexture(dst, src1, src0, src2, src3, offset, {Grad, Offset});
}
- void PixelProgram::TEXLDD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, Vector4f &src3, bool project, bool bias)
+ void PixelProgram::TEXLDD(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, Vector4f &src3)
{
- Vector4f tmp;
- sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src2, src3, project, bias, true);
-
- dst.x = tmp[(src1.swizzle >> 0) & 0x3];
- dst.y = tmp[(src1.swizzle >> 2) & 0x3];
- dst.z = tmp[(src1.swizzle >> 4) & 0x3];
- dst.w = tmp[(src1.swizzle >> 6) & 0x3];
+ sampleTexture(dst, src1, src0, src2, src3, src0, Grad);
}
- void PixelProgram::TEXLDL(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
+ void PixelProgram::TEXLDL(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f tmp;
- sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src0, src0, project, bias, false, true);
-
- dst.x = tmp[(src1.swizzle >> 0) & 0x3];
- dst.y = tmp[(src1.swizzle >> 2) & 0x3];
- dst.z = tmp[(src1.swizzle >> 4) & 0x3];
- dst.w = tmp[(src1.swizzle >> 6) & 0x3];
+ sampleTexture(dst, src1, src0, src0, src0, src0, Lod);
}
- void PixelProgram::TEXSIZE(Registers &r, Vector4f &dst, Float4 &lod, const Src &src1)
+ void PixelProgram::TEXSIZE(Vector4f &dst, Float4 &lod, const Src &src1)
{
- Pointer<Byte> textureMipmap = r.data + OFFSET(DrawData, mipmap) + src1.index * sizeof(Texture) + OFFSET(Texture, mipmap);
- for(int i = 0; i < 4; ++i)
- {
- Pointer<Byte> mipmap = textureMipmap + (As<Int>(Extract(lod, i)) + Int(1)) * sizeof(Mipmap);
- dst.x = Insert(dst.x, As<Float>(Int(*Pointer<Short>(mipmap + OFFSET(Mipmap, width)))), i);
- dst.y = Insert(dst.y, As<Float>(Int(*Pointer<Short>(mipmap + OFFSET(Mipmap, height)))), i);
- dst.z = Insert(dst.z, As<Float>(Int(*Pointer<Short>(mipmap + OFFSET(Mipmap, depth)))), i);
- }
+ Pointer<Byte> texture = data + OFFSET(DrawData, mipmap) + src1.index * sizeof(Texture);
+ sampler[src1.index]->textureSize(texture, dst, lod);
}
void PixelProgram::TEXKILL(Int cMask[4], Vector4f &src, unsigned char mask)
// FIXME: Dynamic branching affects TEXKILL?
// if(shader->containsDynamicBranching())
// {
- // kill = ~SignMask(enableMask(r));
+ // kill = ~SignMask(enableMask());
// }
for(unsigned int q = 0; q < state.multiSample; q++)
// FIXME: Branch to end of shader if all killed?
}
- void PixelProgram::DISCARD(Registers &r, Int cMask[4], const Shader::Instruction *instruction)
+ void PixelProgram::DISCARD(Int cMask[4], const Shader::Instruction *instruction)
{
Int kill = 0;
if(shader->containsDynamicBranching())
{
- kill = ~SignMask(enableMask(r, instruction));
+ kill = ~SignMask(enableMask(instruction));
}
for(unsigned int q = 0; q < state.multiSample; q++)
dst.w = Abs(src.w.yyww - src.w.xxzz) + Abs(src.w.zwzw - src.w.xyxy);
}
- void PixelProgram::BREAK(Registers &r)
+ void PixelProgram::BREAK()
{
- llvm::BasicBlock *deadBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+ BasicBlock *deadBlock = Nucleus::createBasicBlock();
+ BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
if(breakDepth == 0)
{
- r.enableIndex = r.enableIndex - breakDepth;
+ enableIndex = enableIndex - breakDepth;
Nucleus::createBr(endBlock);
}
else
{
- r.enableBreak = r.enableBreak & ~r.enableStack[r.enableIndex];
- Bool allBreak = SignMask(r.enableBreak) == 0x0;
+ enableBreak = enableBreak & ~enableStack[enableIndex];
+ Bool allBreak = SignMask(enableBreak) == 0x0;
- r.enableIndex = r.enableIndex - breakDepth;
+ enableIndex = enableIndex - breakDepth;
branch(allBreak, endBlock, deadBlock);
}
Nucleus::setInsertBlock(deadBlock);
- r.enableIndex = r.enableIndex + breakDepth;
+ enableIndex = enableIndex + breakDepth;
}
- void PixelProgram::BREAKC(Registers &r, Vector4f &src0, Vector4f &src1, Control control)
+ void PixelProgram::BREAKC(Vector4f &src0, Vector4f &src1, Control control)
{
Int4 condition;
ASSERT(false);
}
- BREAK(r, condition);
+ BREAK(condition);
}
- void PixelProgram::BREAKP(Registers &r, const Src &predicateRegister) // FIXME: Factor out parts common with BREAKC
+ void PixelProgram::BREAKP(const Src &predicateRegister) // FIXME: Factor out parts common with BREAKC
{
- Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+ Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]);
if(predicateRegister.modifier == Shader::MODIFIER_NOT)
{
condition = ~condition;
}
- BREAK(r, condition);
+ BREAK(condition);
}
- void PixelProgram::BREAK(Registers &r, Int4 &condition)
+ void PixelProgram::BREAK(Int4 &condition)
{
- condition &= r.enableStack[r.enableIndex];
+ condition &= enableStack[enableIndex];
- llvm::BasicBlock *continueBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+ BasicBlock *continueBlock = Nucleus::createBasicBlock();
+ BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
- r.enableBreak = r.enableBreak & ~condition;
- Bool allBreak = SignMask(r.enableBreak) == 0x0;
+ enableBreak = enableBreak & ~condition;
+ Bool allBreak = SignMask(enableBreak) == 0x0;
- r.enableIndex = r.enableIndex - breakDepth;
+ enableIndex = enableIndex - breakDepth;
branch(allBreak, endBlock, continueBlock);
Nucleus::setInsertBlock(continueBlock);
- r.enableIndex = r.enableIndex + breakDepth;
+ enableIndex = enableIndex + breakDepth;
}
- void PixelProgram::CONTINUE(Registers &r)
+ void PixelProgram::CONTINUE()
{
- r.enableContinue = r.enableContinue & ~r.enableStack[r.enableIndex];
+ enableContinue = enableContinue & ~enableStack[enableIndex];
}
void PixelProgram::TEST()
whileTest = true;
}
- void PixelProgram::CALL(Registers &r, int labelIndex, int callSiteIndex)
+ void PixelProgram::CALL(int labelIndex, int callSiteIndex)
{
if(!labelBlock[labelIndex])
{
if(callRetBlock[labelIndex].size() > 1)
{
- r.callStack[r.stackIndex++] = UInt(callSiteIndex);
+ callStack[stackIndex++] = UInt(callSiteIndex);
}
- Int4 restoreLeave = r.enableLeave;
+ Int4 restoreLeave = enableLeave;
Nucleus::createBr(labelBlock[labelIndex]);
Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
- r.enableLeave = restoreLeave;
+ enableLeave = restoreLeave;
}
- void PixelProgram::CALLNZ(Registers &r, int labelIndex, int callSiteIndex, const Src &src)
+ void PixelProgram::CALLNZ(int labelIndex, int callSiteIndex, const Src &src)
{
if(src.type == Shader::PARAMETER_CONSTBOOL)
{
- CALLNZb(r, labelIndex, callSiteIndex, src);
+ CALLNZb(labelIndex, callSiteIndex, src);
}
else if(src.type == Shader::PARAMETER_PREDICATE)
{
- CALLNZp(r, labelIndex, callSiteIndex, src);
+ CALLNZp(labelIndex, callSiteIndex, src);
}
else ASSERT(false);
}
- void PixelProgram::CALLNZb(Registers &r, int labelIndex, int callSiteIndex, const Src &boolRegister)
+ void PixelProgram::CALLNZb(int labelIndex, int callSiteIndex, const Src &boolRegister)
{
- Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData, ps.b[boolRegister.index])) != Byte(0)); // FIXME
+ Bool condition = (*Pointer<Byte>(data + OFFSET(DrawData, ps.b[boolRegister.index])) != Byte(0)); // FIXME
if(boolRegister.modifier == Shader::MODIFIER_NOT)
{
if(callRetBlock[labelIndex].size() > 1)
{
- r.callStack[r.stackIndex++] = UInt(callSiteIndex);
+ callStack[stackIndex++] = UInt(callSiteIndex);
}
- Int4 restoreLeave = r.enableLeave;
+ Int4 restoreLeave = enableLeave;
branch(condition, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
- r.enableLeave = restoreLeave;
+ enableLeave = restoreLeave;
}
- void PixelProgram::CALLNZp(Registers &r, int labelIndex, int callSiteIndex, const Src &predicateRegister)
+ void PixelProgram::CALLNZp(int labelIndex, int callSiteIndex, const Src &predicateRegister)
{
- Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+ Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]);
if(predicateRegister.modifier == Shader::MODIFIER_NOT)
{
condition = ~condition;
}
- condition &= r.enableStack[r.enableIndex];
+ condition &= enableStack[enableIndex];
if(!labelBlock[labelIndex])
{
if(callRetBlock[labelIndex].size() > 1)
{
- r.callStack[r.stackIndex++] = UInt(callSiteIndex);
+ callStack[stackIndex++] = UInt(callSiteIndex);
}
- r.enableIndex++;
- r.enableStack[r.enableIndex] = condition;
- Int4 restoreLeave = r.enableLeave;
+ enableIndex++;
+ enableStack[enableIndex] = condition;
+ Int4 restoreLeave = enableLeave;
Bool notAllFalse = SignMask(condition) != 0;
branch(notAllFalse, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
- r.enableIndex--;
- r.enableLeave = restoreLeave;
+ enableIndex--;
+ enableLeave = restoreLeave;
}
- void PixelProgram::ELSE(Registers &r)
+ void PixelProgram::ELSE()
{
ifDepth--;
- llvm::BasicBlock *falseBlock = ifFalseBlock[ifDepth];
- llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+ BasicBlock *falseBlock = ifFalseBlock[ifDepth];
+ BasicBlock *endBlock = Nucleus::createBasicBlock();
if(isConditionalIf[ifDepth])
{
- Int4 condition = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
+ Int4 condition = ~enableStack[enableIndex] & enableStack[enableIndex - 1];
Bool notAllFalse = SignMask(condition) != 0;
branch(notAllFalse, falseBlock, endBlock);
- r.enableStack[r.enableIndex] = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
+ enableStack[enableIndex] = ~enableStack[enableIndex] & enableStack[enableIndex - 1];
}
else
{
ifDepth++;
}
- void PixelProgram::ENDIF(Registers &r)
+ void PixelProgram::ENDIF()
{
ifDepth--;
- llvm::BasicBlock *endBlock = ifFalseBlock[ifDepth];
+ BasicBlock *endBlock = ifFalseBlock[ifDepth];
Nucleus::createBr(endBlock);
Nucleus::setInsertBlock(endBlock);
if(isConditionalIf[ifDepth])
{
breakDepth--;
- r.enableIndex--;
+ enableIndex--;
}
}
- void PixelProgram::ENDLOOP(Registers &r)
+ void PixelProgram::ENDLOOP()
{
loopRepDepth--;
- r.aL[r.loopDepth] = r.aL[r.loopDepth] + r.increment[r.loopDepth]; // FIXME: +=
+ aL[loopDepth] = aL[loopDepth] + increment[loopDepth]; // FIXME: +=
- llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
- llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+ BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+ BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
Nucleus::createBr(testBlock);
Nucleus::setInsertBlock(endBlock);
- r.loopDepth--;
- r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ loopDepth--;
+ enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
}
- void PixelProgram::ENDREP(Registers &r)
+ void PixelProgram::ENDREP()
{
loopRepDepth--;
- llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
- llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+ BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+ BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
Nucleus::createBr(testBlock);
Nucleus::setInsertBlock(endBlock);
- r.loopDepth--;
- r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ loopDepth--;
+ enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
}
- void PixelProgram::ENDWHILE(Registers &r)
+ void PixelProgram::ENDWHILE()
{
loopRepDepth--;
- llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
- llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+ BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+ BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
Nucleus::createBr(testBlock);
Nucleus::setInsertBlock(endBlock);
- r.enableIndex--;
- r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ enableIndex--;
+ enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
whileTest = false;
}
- void PixelProgram::IF(Registers &r, const Src &src)
+ void PixelProgram::ENDSWITCH()
+ {
+ loopRepDepth--;
+
+ BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+ Nucleus::createBr(loopRepEndBlock[loopRepDepth]);
+ Nucleus::setInsertBlock(endBlock);
+
+ enableIndex--;
+ enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ }
+
+ void PixelProgram::IF(const Src &src)
{
if(src.type == Shader::PARAMETER_CONSTBOOL)
{
- IFb(r, src);
+ IFb(src);
}
else if(src.type == Shader::PARAMETER_PREDICATE)
{
- IFp(r, src);
+ IFp(src);
}
else
{
- Int4 condition = As<Int4>(fetchRegisterF(r, src).x);
- IF(r, condition);
+ Int4 condition = As<Int4>(fetchRegister(src).x);
+ IF(condition);
}
}
- void PixelProgram::IFb(Registers &r, const Src &boolRegister)
+ void PixelProgram::IFb(const Src &boolRegister)
{
ASSERT(ifDepth < 24 + 4);
- Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData, ps.b[boolRegister.index])) != Byte(0)); // FIXME
+ Bool condition = (*Pointer<Byte>(data + OFFSET(DrawData, ps.b[boolRegister.index])) != Byte(0)); // FIXME
if(boolRegister.modifier == Shader::MODIFIER_NOT)
{
condition = !condition;
}
- llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+ BasicBlock *trueBlock = Nucleus::createBasicBlock();
+ BasicBlock *falseBlock = Nucleus::createBasicBlock();
branch(condition, trueBlock, falseBlock);
ifDepth++;
}
- void PixelProgram::IFp(Registers &r, const Src &predicateRegister)
+ void PixelProgram::IFp(const Src &predicateRegister)
{
- Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+ Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]);
if(predicateRegister.modifier == Shader::MODIFIER_NOT)
{
condition = ~condition;
}
- IF(r, condition);
+ IF(condition);
}
- void PixelProgram::IFC(Registers &r, Vector4f &src0, Vector4f &src1, Control control)
+ void PixelProgram::IFC(Vector4f &src0, Vector4f &src1, Control control)
{
Int4 condition;
ASSERT(false);
}
- IF(r, condition);
+ IF(condition);
}
- void PixelProgram::IF(Registers &r, Int4 &condition)
+ void PixelProgram::IF(Int4 &condition)
{
- condition &= r.enableStack[r.enableIndex];
+ condition &= enableStack[enableIndex];
- r.enableIndex++;
- r.enableStack[r.enableIndex] = condition;
+ enableIndex++;
+ enableStack[enableIndex] = condition;
- llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+ BasicBlock *trueBlock = Nucleus::createBasicBlock();
+ BasicBlock *falseBlock = Nucleus::createBasicBlock();
Bool notAllFalse = SignMask(condition) != 0;
currentLabel = labelIndex;
}
- void PixelProgram::LOOP(Registers &r, const Src &integerRegister)
+ void PixelProgram::LOOP(const Src &integerRegister)
{
- r.loopDepth++;
+ loopDepth++;
- r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData, ps.i[integerRegister.index][0]));
- r.aL[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData, ps.i[integerRegister.index][1]));
- r.increment[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData, ps.i[integerRegister.index][2]));
+ iteration[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData, ps.i[integerRegister.index][0]));
+ aL[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData, ps.i[integerRegister.index][1]));
+ increment[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData, ps.i[integerRegister.index][2]));
- // If(r.increment[r.loopDepth] == 0)
+ // If(increment[loopDepth] == 0)
// {
- // r.increment[r.loopDepth] = 1;
+ // increment[loopDepth] = 1;
// }
- llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+ BasicBlock *loopBlock = Nucleus::createBasicBlock();
+ BasicBlock *testBlock = Nucleus::createBasicBlock();
+ BasicBlock *endBlock = Nucleus::createBasicBlock();
loopRepTestBlock[loopRepDepth] = testBlock;
loopRepEndBlock[loopRepDepth] = endBlock;
Nucleus::createBr(testBlock);
Nucleus::setInsertBlock(testBlock);
- branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
+ branch(iteration[loopDepth] > 0, loopBlock, endBlock);
Nucleus::setInsertBlock(loopBlock);
- r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1; // FIXME: --
+ iteration[loopDepth] = iteration[loopDepth] - 1; // FIXME: --
loopRepDepth++;
breakDepth = 0;
}
- void PixelProgram::REP(Registers &r, const Src &integerRegister)
+ void PixelProgram::REP(const Src &integerRegister)
{
- r.loopDepth++;
+ loopDepth++;
- r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData, ps.i[integerRegister.index][0]));
- r.aL[r.loopDepth] = r.aL[r.loopDepth - 1];
+ iteration[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData, ps.i[integerRegister.index][0]));
+ aL[loopDepth] = aL[loopDepth - 1];
- llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+ BasicBlock *loopBlock = Nucleus::createBasicBlock();
+ BasicBlock *testBlock = Nucleus::createBasicBlock();
+ BasicBlock *endBlock = Nucleus::createBasicBlock();
loopRepTestBlock[loopRepDepth] = testBlock;
loopRepEndBlock[loopRepDepth] = endBlock;
Nucleus::createBr(testBlock);
Nucleus::setInsertBlock(testBlock);
- branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
+ branch(iteration[loopDepth] > 0, loopBlock, endBlock);
Nucleus::setInsertBlock(loopBlock);
- r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1; // FIXME: --
+ iteration[loopDepth] = iteration[loopDepth] - 1; // FIXME: --
loopRepDepth++;
breakDepth = 0;
}
- void PixelProgram::WHILE(Registers &r, const Src &temporaryRegister)
+ void PixelProgram::WHILE(const Src &temporaryRegister)
{
- r.enableIndex++;
+ enableIndex++;
- llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+ BasicBlock *loopBlock = Nucleus::createBasicBlock();
+ BasicBlock *testBlock = Nucleus::createBasicBlock();
+ BasicBlock *endBlock = Nucleus::createBasicBlock();
loopRepTestBlock[loopRepDepth] = testBlock;
loopRepEndBlock[loopRepDepth] = endBlock;
- Int4 restoreBreak = r.enableBreak;
- Int4 restoreContinue = r.enableContinue;
+ Int4 restoreBreak = enableBreak;
+ Int4 restoreContinue = enableContinue;
// FIXME: jump(testBlock)
Nucleus::createBr(testBlock);
Nucleus::setInsertBlock(testBlock);
- r.enableContinue = restoreContinue;
+ enableContinue = restoreContinue;
- const Vector4f &src = fetchRegisterF(r, temporaryRegister);
+ const Vector4f &src = fetchRegister(temporaryRegister);
Int4 condition = As<Int4>(src.x);
- condition &= r.enableStack[r.enableIndex - 1];
- r.enableStack[r.enableIndex] = condition;
+ condition &= enableStack[enableIndex - 1];
+ if(shader->containsLeaveInstruction()) condition &= enableLeave;
+ enableStack[enableIndex] = condition;
Bool notAllFalse = SignMask(condition) != 0;
branch(notAllFalse, loopBlock, endBlock);
Nucleus::setInsertBlock(endBlock);
- r.enableBreak = restoreBreak;
+ enableBreak = restoreBreak;
Nucleus::setInsertBlock(loopBlock);
breakDepth = 0;
}
- void PixelProgram::RET(Registers &r)
+ void PixelProgram::SWITCH()
+ {
+ enableIndex++;
+ enableStack[enableIndex] = Int4(0xFFFFFFFF);
+
+ BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+ loopRepTestBlock[loopRepDepth] = nullptr;
+ loopRepEndBlock[loopRepDepth] = endBlock;
+
+ loopRepDepth++;
+ breakDepth = 0;
+ }
+
+ void PixelProgram::RET()
{
if(currentLabel == -1)
{
}
else
{
- llvm::BasicBlock *unreachableBlock = Nucleus::createBasicBlock();
+ BasicBlock *unreachableBlock = Nucleus::createBasicBlock();
if(callRetBlock[currentLabel].size() > 1) // Pop the return destination from the call stack
{
// FIXME: Encapsulate
- UInt index = r.callStack[--r.stackIndex];
+ UInt index = callStack[--stackIndex];
- llvm::Value *value = index.loadValue();
- llvm::Value *switchInst = Nucleus::createSwitch(value, unreachableBlock, (int)callRetBlock[currentLabel].size());
+ Value *value = index.loadValue();
+ SwitchCases *switchCases = Nucleus::createSwitch(value, unreachableBlock, (int)callRetBlock[currentLabel].size());
for(unsigned int i = 0; i < callRetBlock[currentLabel].size(); i++)
{
- Nucleus::addSwitchCase(switchInst, i, callRetBlock[currentLabel][i]);
+ Nucleus::addSwitchCase(switchCases, i, callRetBlock[currentLabel][i]);
}
}
else if(callRetBlock[currentLabel].size() == 1) // Jump directly to the unique return destination
}
}
- void PixelProgram::LEAVE(Registers &r)
+ void PixelProgram::LEAVE()
{
- r.enableLeave = r.enableLeave & ~r.enableStack[r.enableIndex];
+ enableLeave = enableLeave & ~enableStack[enableIndex];
// FIXME: Return from function if all instances left
// FIXME: Use enableLeave in other control-flow constructs
}
-\r
-}\r
+}