-// SwiftShader Software Renderer
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
-// Copyright(c) 2015 Google Inc.
+// 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
//
-// All rights reserved. No part of this software may be copied, distributed, transmitted,
-// transcribed, stored in a retrieval system, translated into any human or computer
-// language by any means, or disclosed to third parties without the explicit written
-// agreement of Google Inc. Without such an agreement, no rights or licenses, express
-// or implied, including but not limited to any patent rights, are granted to you.
+// 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"
{
if(shader->getVersion() >= 0x0300)
{
- if(shader->vPosDeclared)
+ if(shader->isVPosDeclared())
{
if(!halfIntegerCoordinates)
{
}
}
- if(shader->vFaceDeclared)
+ if(shader->isVFaceDeclared())
{
Float4 area = *Pointer<Float>(primitive + OFFSET(Primitive, area));
Float4 face = booleanFaceRegister ? Float4(As<Float4>(CmpNLT(area, Float4(0.0f)))) : area;
}
}
+ bool broadcastColor0 = true;
+
for(size_t i = 0; i < shader->getLength(); i++)
{
const Shader::Instruction *instruction = shader->getInstruction(i);
}
}
- if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegisterF(src0);
- if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegisterF(src1);
- if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegisterF(src2);
- if(src3.type != Shader::PARAMETER_VOID) s3 = fetchRegisterF(src3);
- if(src4.type != Shader::PARAMETER_VOID) s4 = fetchRegisterF(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_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_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, project, bias); break;
- case Shader::OPCODE_TEXLDL: TEXLDL(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(d, s0, src1, s2, s3, project, bias); break;
- case Shader::OPCODE_TEXLDLOFFSET: TEXLDL(d, s0, src1, s2, project, bias); break;
- case Shader::OPCODE_TEXELFETCH: TEXELFETCH(d, s0, src1, s2); break;
- case Shader::OPCODE_TEXELFETCHOFFSET: TEXELFETCH(d, s0, src1, s2, s3); 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_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(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_COLOROUT:
if(dst.rel.type == Shader::PARAMETER_VOID)
{
+ 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; }
}
else
{
+ broadcastColor0 = false;
Int a = relativeAddress(dst) + dst.index;
if(dst.x) { oC[a].x = d.x; }
Nucleus::setInsertBlock(returnBlock);
}
- for(int i = 0; i < RENDERTARGETS; i++)
+ if(broadcastColor0)
{
- c[i] = oC[i];
+ for(int i = 0; i < RENDERTARGETS; i++)
+ {
+ c[i] = oC[0];
+ }
+ }
+ else
+ {
+ for(int i = 0; i < RENDERTARGETS; i++)
+ {
+ c[i] = oC[i];
+ }
}
}
continue;
}
- if(!postBlendSRGB && state.writeSRGB)
+ if(!postBlendSRGB && state.writeSRGB && !isSRGB(index))
{
c[index].x = linearToSRGB(c[index].x);
c[index].y = linearToSRGB(c[index].y);
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:
Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(data + OFFSET(DrawData, colorSliceB[index]));
Vector4s color;
- 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.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))
{
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>(data + OFFSET(DrawData, colorSliceB[index]));
}
}
- void PixelProgram::sampleTexture(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(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(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(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(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
-
- Pointer<Byte> texture = data + OFFSET(DrawData, mipmap) + stage * sizeof(Texture);
+ #if PERF_PROFILE
+ Long texTime = Ticks();
+ #endif
- if(!project)
- {
- sampler[stage]->sampleTexture(texture, c, u, v, w, q, dsx, dsy, bias, gradients, lodProvided);
- }
- else
- {
- Float4 rq = reciprocal(q);
+ 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);
- 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
- 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);
return enable;
}
- Vector4f PixelProgram::fetchRegisterF(const Src &src, unsigned int offset)
+ Vector4f PixelProgram::fetchRegister(const Src &src, unsigned int offset)
{
Vector4f reg;
unsigned int i = src.index + offset;
reg = v[2 + i];
break;
case Shader::PARAMETER_MISCTYPE:
- if(src.index == 0) reg = vPos;
- if(src.index == 1) reg = 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(var.rel.type == Shader::PARAMETER_CONST)
{
- RValue<Int4> c = *Pointer<Int4>(uniformAddress(bufferIndex, 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)
{
void PixelProgram::M3X2(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f row0 = fetchRegisterF(src1, 0);
- Vector4f row1 = fetchRegisterF(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(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f row0 = fetchRegisterF(src1, 0);
- Vector4f row1 = fetchRegisterF(src1, 1);
- Vector4f row2 = fetchRegisterF(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);
void PixelProgram::M3X4(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f row0 = fetchRegisterF(src1, 0);
- Vector4f row1 = fetchRegisterF(src1, 1);
- Vector4f row2 = fetchRegisterF(src1, 2);
- Vector4f row3 = fetchRegisterF(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);
void PixelProgram::M4X3(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f row0 = fetchRegisterF(src1, 0);
- Vector4f row1 = fetchRegisterF(src1, 1);
- Vector4f row2 = fetchRegisterF(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);
void PixelProgram::M4X4(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f row0 = fetchRegisterF(src1, 0);
- Vector4f row1 = fetchRegisterF(src1, 1);
- Vector4f row2 = fetchRegisterF(src1, 2);
- Vector4f row3 = fetchRegisterF(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);
void PixelProgram::TEXLD(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
{
- Vector4f tmp;
- sampleTexture(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(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(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(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(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(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &src3)
{
- UNIMPLEMENTED();
+ sampleTexture(dst, src1, src0, src2, src3, src0, Grad);
}
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(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(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(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
+ void PixelProgram::TEXLDL(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- Vector4f tmp;
- sampleTexture(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(Vector4f &dst, Float4 &lod, const Src &src1)
{
- Pointer<Byte> textureMipmap = 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)
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)
{
{
condition &= enableStack[enableIndex];
- llvm::BasicBlock *continueBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+ BasicBlock *continueBlock = Nucleus::createBasicBlock();
+ BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
enableBreak = enableBreak & ~condition;
Bool allBreak = SignMask(enableBreak) == 0x0;
{
ifDepth--;
- llvm::BasicBlock *falseBlock = ifFalseBlock[ifDepth];
- llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+ BasicBlock *falseBlock = ifFalseBlock[ifDepth];
+ BasicBlock *endBlock = Nucleus::createBasicBlock();
if(isConditionalIf[ifDepth])
{
{
ifDepth--;
- llvm::BasicBlock *endBlock = ifFalseBlock[ifDepth];
+ BasicBlock *endBlock = ifFalseBlock[ifDepth];
Nucleus::createBr(endBlock);
Nucleus::setInsertBlock(endBlock);
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);
{
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);
{
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);
whileTest = false;
}
+ 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)
}
else
{
- Int4 condition = As<Int4>(fetchRegisterF(src).x);
+ Int4 condition = As<Int4>(fetchRegister(src).x);
IF(condition);
}
}
condition = !condition;
}
- llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
- llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+ BasicBlock *trueBlock = Nucleus::createBasicBlock();
+ BasicBlock *falseBlock = Nucleus::createBasicBlock();
branch(condition, trueBlock, falseBlock);
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;
// 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;
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;
{
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;
Nucleus::setInsertBlock(testBlock);
enableContinue = restoreContinue;
- const Vector4f &src = fetchRegisterF(temporaryRegister);
+ const Vector4f &src = fetchRegister(temporaryRegister);
Int4 condition = As<Int4>(src.x);
condition &= enableStack[enableIndex - 1];
+ if(shader->containsLeaveInstruction()) condition &= enableLeave;
enableStack[enableIndex] = condition;
Bool notAllFalse = SignMask(condition) != 0;
breakDepth = 0;
}
+ 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 = 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
OSDN Git Service
