else
{
const TextureFunction textureFunction(node->getName());
+ TIntermTyped *s = arg[0]->getAsTyped();
TIntermTyped *t = arg[1]->getAsTyped();
Temporary coord(this);
Instruction *mul = emit(sw::Shader::OPCODE_MUL, &coord, arg[1], &coord);
mul->dst.mask = 0x7;
+
+ if(IsShadowSampler(s->getBasicType()))
+ {
+ ASSERT(s->getBasicType() == EbtSampler2DShadow);
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, &coord, &coord);
+ mov->src[0].swizzle = 0xA4;
+ }
}
else
{
- emit(sw::Shader::OPCODE_MOV, &coord, arg[1]);
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, &coord, arg[1]);
+
+ if(IsShadowSampler(s->getBasicType()) && t->getNominalSize() == 3)
+ {
+ ASSERT(s->getBasicType() == EbtSampler2DShadow);
+ mov->src[0].swizzle = 0xA4;
+ }
}
switch(textureFunction.method)
{
case TextureFunction::IMPLICIT:
+ if(!textureFunction.offset)
{
- TIntermNode* offset = textureFunction.offset ? arg[2] : 0;
-
- if(argumentCount == 2 || (textureFunction.offset && argumentCount == 3))
+ if(argumentCount == 2)
{
- emit(textureFunction.offset ? sw::Shader::OPCODE_TEXOFFSET : sw::Shader::OPCODE_TEX,
- result, &coord, arg[0], offset);
+ emit(sw::Shader::OPCODE_TEX, result, &coord, s);
}
- else if(argumentCount == 3 || (textureFunction.offset && argumentCount == 4)) // bias
+ else if(argumentCount == 3) // Bias
{
- Instruction *bias = emit(sw::Shader::OPCODE_MOV, &coord, arg[textureFunction.offset ? 3 : 2]);
- bias->dst.mask = 0x8;
-
- Instruction *tex = emit(textureFunction.offset ? sw::Shader::OPCODE_TEXOFFSET : sw::Shader::OPCODE_TEX,
- result, &coord, arg[0], offset); // FIXME: Implement an efficient TEXLDB instruction
- tex->bias = true;
+ emit(sw::Shader::OPCODE_TEXBIAS, result, &coord, s, arg[2]);
+ }
+ else UNREACHABLE(argumentCount);
+ }
+ else // Offset
+ {
+ if(argumentCount == 3)
+ {
+ emit(sw::Shader::OPCODE_TEXOFFSET, result, &coord, s, arg[2]);
+ }
+ else if(argumentCount == 4) // Bias
+ {
+ emit(sw::Shader::OPCODE_TEXOFFSETBIAS, result, &coord, s, arg[2], arg[3]);
}
else UNREACHABLE(argumentCount);
}
break;
case TextureFunction::LOD:
+ if(!textureFunction.offset && argumentCount == 3)
{
- Instruction *lod = emit(sw::Shader::OPCODE_MOV, &coord, arg[2]);
- lod->dst.mask = 0x8;
-
- emit(textureFunction.offset ? sw::Shader::OPCODE_TEXLDLOFFSET : sw::Shader::OPCODE_TEXLDL,
- result, &coord, arg[0], textureFunction.offset ? arg[3] : nullptr);
+ emit(sw::Shader::OPCODE_TEXLOD, result, &coord, s, arg[2]);
}
+ else if(argumentCount == 4) // Offset
+ {
+ emit(sw::Shader::OPCODE_TEXLODOFFSET, result, &coord, s, arg[3], arg[2]);
+ }
+ else UNREACHABLE(argumentCount);
break;
case TextureFunction::FETCH:
+ if(!textureFunction.offset && argumentCount == 3)
{
- if(argumentCount == 3 || (textureFunction.offset && argumentCount == 4))
- {
- Instruction *lod = emit(sw::Shader::OPCODE_MOV, &coord, arg[2]);
- lod->dst.mask = 0x8;
-
- TIntermNode *offset = textureFunction.offset ? arg[3] : nullptr;
-
- emit(textureFunction.offset ? sw::Shader::OPCODE_TEXELFETCHOFFSET : sw::Shader::OPCODE_TEXELFETCH,
- result, &coord, arg[0], offset);
- }
- else UNREACHABLE(argumentCount);
+ emit(sw::Shader::OPCODE_TEXELFETCH, result, &coord, s, arg[2]);
}
+ else if(argumentCount == 4) // Offset
+ {
+ emit(sw::Shader::OPCODE_TEXELFETCHOFFSET, result, &coord, s, arg[3], arg[2]);
+ }
+ else UNREACHABLE(argumentCount);
break;
case TextureFunction::GRAD:
+ if(!textureFunction.offset && argumentCount == 4)
{
- if(argumentCount == 4 || (textureFunction.offset && argumentCount == 5))
- {
- TIntermNode *offset = textureFunction.offset ? arg[4] : nullptr;
-
- emit(textureFunction.offset ? sw::Shader::OPCODE_TEXGRADOFFSET : sw::Shader::OPCODE_TEXGRAD,
- result, &coord, arg[0], arg[2], arg[3], offset);
- }
- else UNREACHABLE(argumentCount);
+ emit(sw::Shader::OPCODE_TEXGRAD, result, &coord, s, arg[2], arg[3]);
+ }
+ else if(argumentCount == 5) // Offset
+ {
+ emit(sw::Shader::OPCODE_TEXGRADOFFSET, result, &coord, s, arg[2], arg[3], arg[4]);
}
+ else UNREACHABLE(argumentCount);
break;
case TextureFunction::SIZE:
- emit(sw::Shader::OPCODE_TEXSIZE, result, arg[1], arg[0]);
+ emit(sw::Shader::OPCODE_TEXSIZE, result, arg[1], s);
break;
default:
UNREACHABLE(textureFunction.method);
if(!project)
{
- c = SamplerCore(constants, state.sampler[stage]).sampleTexture(texture, u, v, w, q, dsx, dsy);
+ c = SamplerCore(constants, state.sampler[stage]).sampleTexture(texture, u, v, w, q, q, dsx, dsy);
}
else
{
Float4 v_q = v * rq;
Float4 w_q = w * rq;
- c = SamplerCore(constants, state.sampler[stage]).sampleTexture(texture, u_q, v_q, w_q, q, dsx, dsy);
+ c = SamplerCore(constants, state.sampler[stage]).sampleTexture(texture, u_q, v_q, w_q, q, q, dsx, dsy);
}
#if PERF_PROFILE
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_TEX: TEX(d, s0, src1, project, bias); break;
+ case Shader::OPCODE_TEXLDD: TEXGRAD(d, s0, src1, s2, s3); break;
+ case Shader::OPCODE_TEXLDL: TEXLOD(d, s0, src1, s0.w); break;
+ case Shader::OPCODE_TEXLOD: TEXLOD(d, s0, src1, s2.x); 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, 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_TEXOFFSET: TEXOFFSET(d, s0, src1, s2); break;
+ case Shader::OPCODE_TEXLODOFFSET: TEXLODOFFSET(d, s0, src1, s2, s3.x); break;
+ case Shader::OPCODE_TEXELFETCH: TEXELFETCH(d, s0, src1, s2.x); break;
+ case Shader::OPCODE_TEXELFETCHOFFSET: TEXELFETCHOFFSET(d, s0, src1, s2, s3.x); 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_TEXGRADOFFSET: TEXGRADOFFSET(d, s0, src1, s2, s3, s4); break;
+ case Shader::OPCODE_TEXBIAS: TEXBIAS(d, s0, src1, s2.x); break;
+ case Shader::OPCODE_TEXOFFSETBIAS: TEXOFFSETBIAS(d, s0, src1, s2, s3.x); 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;
}
}
- Vector4f PixelProgram::sampleTexture(const Src &sampler, Vector4f &uvwq, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
+ Vector4f PixelProgram::sampleTexture(const Src &sampler, Vector4f &uvwq, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
{
Vector4f tmp;
if(sampler.type == Shader::PARAMETER_SAMPLER && sampler.rel.type == Shader::PARAMETER_VOID)
{
- tmp = sampleTexture(sampler.index, uvwq, dsx, dsy, offset, function);
+ tmp = sampleTexture(sampler.index, uvwq, bias, dsx, dsy, offset, function);
}
else
{
{
If(index == i)
{
- tmp = sampleTexture(i, uvwq, dsx, dsy, offset, function);
+ tmp = sampleTexture(i, uvwq, bias, dsx, dsy, offset, function);
// FIXME: When the sampler states are the same, we could use one sampler and just index the texture
}
}
return c;
}
- Vector4f PixelProgram::sampleTexture(int samplerIndex, Vector4f &uvwq, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
+ Vector4f PixelProgram::sampleTexture(int samplerIndex, Vector4f &uvwq, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
{
#if PERF_PROFILE
Long texTime = Ticks();
#endif
Pointer<Byte> texture = data + OFFSET(DrawData, mipmap) + samplerIndex * sizeof(Texture);
- Vector4f c = SamplerCore(constants, state.sampler[samplerIndex]).sampleTexture(texture, uvwq.x, uvwq.y, uvwq.z, uvwq.w, dsx, dsy, offset, function);
+ Vector4f c = SamplerCore(constants, state.sampler[samplerIndex]).sampleTexture(texture, uvwq.x, uvwq.y, uvwq.z, uvwq.w, bias, dsx, dsy, offset, function);
#if PERF_PROFILE
cycles[PERF_TEX] += Ticks() - texTime;
dst.w = dot4(src0, row3);
}
- void PixelProgram::TEXLD(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
+ void PixelProgram::TEX(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
{
if(project)
{
proj.y = src0.y * rw;
proj.z = src0.z * rw;
- dst = sampleTexture(src1, proj, src0, src0, src0, Implicit);
+ dst = sampleTexture(src1, proj, src0.x, (src0), (src0), (src0), Implicit);
}
else
{
- dst = sampleTexture(src1, src0, src0, src0, src0, bias ? Bias : Implicit);
+ dst = sampleTexture(src1, src0, src0.x, (src0), (src0), (src0), bias ? Bias : Implicit);
}
}
- void PixelProgram::TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, bool bias)
+ void PixelProgram::TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset)
{
- dst = sampleTexture(src1, src0, src0, src0, src2, {bias ? Bias : Implicit, Offset});
+ dst = sampleTexture(src1, src0, (src0.x), (src0), (src0), offset, {Implicit, Offset});
}
- void PixelProgram::TEXLDL(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, bool bias)
+ void PixelProgram::TEXLODOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, Float4 &lod)
{
- dst = sampleTexture(src1, src0, src0, src0, offset, {Lod, Offset});
+ dst = sampleTexture(src1, src0, lod, (src0), (src0), offset, {Lod, Offset});
}
- void PixelProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1)
+ void PixelProgram::TEXBIAS(Vector4f &dst, Vector4f &src0, const Src &src1, Float4 &bias)
{
- dst = sampleTexture(src1, src0, src0, src0, src0, Fetch);
+ dst = sampleTexture(src1, src0, bias, (src0), (src0), (src0), Bias);
+ }
+
+ void PixelProgram::TEXOFFSETBIAS(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, Float4 &bias)
+ {
+ dst = sampleTexture(src1, src0, bias, (src0), (src0), offset, {Bias, Offset});
}
- void PixelProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset)
+ void PixelProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1, Float4 &lod)
{
- dst = sampleTexture(src1, src0, src0, src0, offset, {Fetch, Offset});
+ dst = sampleTexture(src1, src0, lod, (src0), (src0), (src0), Fetch);
}
- void PixelProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &src3)
+ void PixelProgram::TEXELFETCHOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset, Float4 &lod)
{
- dst = sampleTexture(src1, src0, src2, src3, src0, Grad);
+ dst = sampleTexture(src1, src0, lod, (src0), (src0), offset, {Fetch, Offset});
}
- void PixelProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &src3, Vector4f &offset)
+ void PixelProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &dsx, Vector4f &dsy)
{
- dst = sampleTexture(src1, src0, src2, src3, offset, {Grad, Offset});
+ dst = sampleTexture(src1, src0, (src0.x), dsx, dsy, (src0), Grad);
}
- void PixelProgram::TEXLDD(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, Vector4f &src3)
+ void PixelProgram::TEXGRADOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &dsx, Vector4f &dsy, Vector4f &offset)
{
- dst = sampleTexture(src1, src0, src2, src3, src0, Grad);
+ dst = sampleTexture(src1, src0, (src0.x), dsx, dsy, offset, {Grad, Offset});
}
- void PixelProgram::TEXLDL(Vector4f &dst, Vector4f &src0, const Src &src1)
+ void PixelProgram::TEXLOD(Vector4f &dst, Vector4f &src0, const Src &src1, Float4 &lod)
{
- dst = sampleTexture(src1, src0, src0, src0, src0, Lod);
+ dst = sampleTexture(src1, src0, lod, (src0), (src0), (src0), Lod);
}
void PixelProgram::TEXSIZE(Vector4f &dst, Float4 &lod, const Src &src1)
Int4 enableContinue;
Int4 enableLeave;
- Vector4f sampleTexture(const Src &sampler, Vector4f &uvwq, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
- Vector4f sampleTexture(int samplerIndex, Vector4f &uvwq, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
+ Vector4f sampleTexture(const Src &sampler, Vector4f &uvwq, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
+ Vector4f sampleTexture(int samplerIndex, Vector4f &uvwq, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
// Raster operations
void clampColor(Vector4f oC[RENDERTARGETS]);
void M3X4(Vector4f &dst, Vector4f &src0, const Src &src1);
void M4X3(Vector4f &dst, Vector4f &src0, const Src &src1);
void M4X4(Vector4f &dst, Vector4f &src0, const Src &src1);
- void TEXLD(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias);
- void TEXLDD(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, Vector4f &src3);
- void TEXLDL(Vector4f &dst, Vector4f &src0, const Src &src1);
+ void TEX(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias);
+ void TEXLOD(Vector4f &dst, Vector4f &src0, const Src &src1, Float4 &lod);
+ void TEXBIAS(Vector4f &dst, Vector4f &src0, const Src &src1, Float4 &bias);
void TEXSIZE(Vector4f &dst, Float4 &lod, const Src &src1);
void TEXKILL(Int cMask[4], Vector4f &src, unsigned char mask);
- void TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, bool bias);
- void TEXLDL(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, bool bias);
- void TEXELFETCH(Vector4f &dst, Vector4f &src, const Src&);
- void TEXELFETCH(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2);
- void TEXGRAD(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3);
- void TEXGRAD(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3, Vector4f &src4);
+ void TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset);
+ void TEXOFFSETBIAS(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, Float4 &bias);
+ void TEXLODOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, Float4 &lod);
+ void TEXELFETCH(Vector4f &dst, Vector4f &src, const Src &, Float4 &lod);
+ void TEXELFETCHOFFSET(Vector4f &dst, Vector4f &src, const Src &, Vector4f &offset, Float4 &lod);
+ void TEXGRAD(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &dsx, Vector4f &dsy);
+ void TEXGRADOFFSET(Vector4f &dst, Vector4f &src, const Src &, Vector4f &dsx, Vector4f &dsy, Vector4f &offset);
void DISCARD(Int cMask[4], const Shader::Instruction *instruction);
void DFDX(Vector4f &dst, Vector4f &src);
void DFDY(Vector4f &dst, Vector4f &src);
case Shader::OPCODE_TEX:
case Shader::OPCODE_TEXLDD:
case Shader::OPCODE_TEXLDL:
+ case Shader::OPCODE_TEXLOD:
+ case Shader::OPCODE_TEXBIAS:
case Shader::OPCODE_TEXOFFSET:
- case Shader::OPCODE_TEXLDLOFFSET:
+ case Shader::OPCODE_TEXOFFSETBIAS:
+ case Shader::OPCODE_TEXLODOFFSET:
case Shader::OPCODE_TEXELFETCH:
case Shader::OPCODE_TEXELFETCHOFFSET:
case Shader::OPCODE_TEXGRAD:
{
}
- Vector4s SamplerCore::sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy)
+ Vector4s SamplerCore::sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy)
{
- return sampleTexture(texture, u, v, w, q, dsx, dsy, dsx, Implicit, true);
+ return sampleTexture(texture, u, v, w, q, q, dsx, dsy, (dsx), Implicit, true);
}
- Vector4s SamplerCore::sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function, bool fixed12)
+ Vector4s SamplerCore::sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function, bool fixed12)
{
Vector4s c;
Float4 uuuu = u;
Float4 vvvv = v;
Float4 wwww = w;
+ Float4 qqqq = q;
if(state.textureType == TEXTURE_NULL)
{
Float anisotropy;
Float4 uDelta;
Float4 vDelta;
- Float lodBias = (function == Fetch) ? Float4(As<Int4>(q)).x : q.x;
if(state.textureType != TEXTURE_3D)
{
if(state.textureType != TEXTURE_CUBE)
{
- computeLod(texture, lod, anisotropy, uDelta, vDelta, uuuu, vvvv, lodBias, dsx, dsy, function);
+ computeLod(texture, lod, anisotropy, uDelta, vDelta, uuuu, vvvv, bias.x, dsx, dsy, function);
}
else
{
- computeLodCube(texture, lod, lodX, lodY, lodZ, lodBias, dsx, dsy, function);
+ computeLodCube(texture, lod, lodX, lodY, lodZ, bias.x, dsx, dsy, function);
}
}
else
{
- computeLod3D(texture, lod, uuuu, vvvv, wwww, lodBias, dsx, dsy, function);
+ computeLod3D(texture, lod, uuuu, vvvv, wwww, bias.x, dsx, dsy, function);
}
if(!hasFloatTexture())
}
else
{
- Vector4f cf = sampleFloatFilter(texture, uuuu, vvvv, wwww, offset, lod, anisotropy, uDelta, vDelta, face, function);
+ Vector4f cf = sampleFloatFilter(texture, uuuu, vvvv, wwww, qqqq, offset, lod, anisotropy, uDelta, vDelta, face, function);
convertFixed12(c, cf);
}
return c;
}
- Vector4f SamplerCore::sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
+ Vector4f SamplerCore::sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
{
Vector4f c;
Float4 uuuu = u;
Float4 vvvv = v;
Float4 wwww = w;
+ Float4 qqqq = q;
Int face[4];
Float4 lodX;
Float anisotropy;
Float4 uDelta;
Float4 vDelta;
- Float lodBias = (function == Fetch) ? Float4(As<Int4>(q)).x : q.x;
if(state.textureType != TEXTURE_3D)
{
if(state.textureType != TEXTURE_CUBE)
{
- computeLod(texture, lod, anisotropy, uDelta, vDelta, uuuu, vvvv, lodBias, dsx, dsy, function);
+ computeLod(texture, lod, anisotropy, uDelta, vDelta, uuuu, vvvv, bias.x, dsx, dsy, function);
}
else
{
- computeLodCube(texture, lod, lodX, lodY, lodZ, lodBias, dsx, dsy, function);
+ computeLodCube(texture, lod, lodX, lodY, lodZ, bias.x, dsx, dsy, function);
}
}
else
{
- computeLod3D(texture, lod, uuuu, vvvv, wwww, lodBias, dsx, dsy, function);
+ computeLod3D(texture, lod, uuuu, vvvv, wwww, bias.x, dsx, dsy, function);
}
- c = sampleFloatFilter(texture, uuuu, vvvv, wwww, offset, lod, anisotropy, uDelta, vDelta, face, function);
+ c = sampleFloatFilter(texture, uuuu, vvvv, wwww, qqqq, offset, lod, anisotropy, uDelta, vDelta, face, function);
if(!hasFloatTexture() && !hasUnnormalizedIntegerTexture())
{
}
else
{
- Vector4s cs = sampleTexture(texture, u, v, w, q, dsx, dsy, offset, function, false);
+ Vector4s cs = sampleTexture(texture, u, v, w, q, bias, dsx, dsy, offset, function, false);
if(has16bitTextureFormat())
{
return c_;
}
- Vector4f SamplerCore::sampleFloatFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], SamplerFunction function)
+ Vector4f SamplerCore::sampleFloatFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], SamplerFunction function)
{
- Vector4f c = sampleFloatAniso(texture, u, v, w, offset, lod, anisotropy, uDelta, vDelta, face, false, function);
+ Vector4f c = sampleFloatAniso(texture, u, v, w, q, offset, lod, anisotropy, uDelta, vDelta, face, false, function);
if(function == Fetch)
{
if(state.mipmapFilter > MIPMAP_POINT)
{
- Vector4f cc = sampleFloatAniso(texture, u, v, w, offset, lod, anisotropy, uDelta, vDelta, face, true, function);
+ Vector4f cc = sampleFloatAniso(texture, u, v, w, q, offset, lod, anisotropy, uDelta, vDelta, face, true, function);
Float4 lod4 = Float4(Frac(lod));
return c;
}
- Vector4f SamplerCore::sampleFloatAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, SamplerFunction function)
+ Vector4f SamplerCore::sampleFloatAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, SamplerFunction function)
{
Vector4f c;
if(state.textureFilter != FILTER_ANISOTROPIC || function == Lod || function == Fetch)
{
- c = sampleFloat(texture, u, v, w, offset, lod, face, secondLOD, function);
+ c = sampleFloat(texture, u, v, w, q, offset, lod, face, secondLOD, function);
}
else
{
Do
{
- c = sampleFloat(texture, u0, v0, w, offset, lod, face, secondLOD, function);
+ c = sampleFloat(texture, u0, v0, w, q, offset, lod, face, secondLOD, function);
u0 += du;
v0 += dv;
return c;
}
- Vector4f SamplerCore::sampleFloat(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function)
+ Vector4f SamplerCore::sampleFloat(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function)
{
if(state.textureType != TEXTURE_3D)
{
- return sampleFloat2D(texture, u, v, w, offset, lod, face, secondLOD, function);
+ return sampleFloat2D(texture, u, v, w, q, offset, lod, face, secondLOD, function);
}
else
{
}
}
- Vector4f SamplerCore::sampleFloat2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function)
+ Vector4f SamplerCore::sampleFloat2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function)
{
Vector4f c;
if(state.textureFilter == FILTER_POINT || (function == Fetch))
{
- c = sampleTexel(x0, y0, z0, w, mipmap, buffer, function);
+ c = sampleTexel(x0, y0, z0, q, mipmap, buffer, function);
}
else
{
y1 *= pitchP;
- Vector4f c0 = sampleTexel(x0, y0, z0, w, mipmap, buffer, function);
- Vector4f c1 = sampleTexel(x1, y0, z0, w, mipmap, buffer, function);
- Vector4f c2 = sampleTexel(x0, y1, z0, w, mipmap, buffer, function);
- Vector4f c3 = sampleTexel(x1, y1, z0, w, mipmap, buffer, function);
+ Vector4f c0 = sampleTexel(x0, y0, z0, q, mipmap, buffer, function);
+ Vector4f c1 = sampleTexel(x1, y0, z0, q, mipmap, buffer, function);
+ Vector4f c2 = sampleTexel(x0, y1, z0, q, mipmap, buffer, function);
+ Vector4f c3 = sampleTexel(x1, y1, z0, q, mipmap, buffer, function);
if(!gather) // Blend
{
lod += lodBias;
}
}
- else
+ else if(function == Lod)
{
lod = lodBias + Float(*Pointer<Int>(texture + OFFSET(Texture,baseLevel)));
}
+ else if(function == Fetch)
+ {
+ // TODO: Eliminate int-float-int conversion.
+ lod = Float(As<Int>(lodBias)) + Float(*Pointer<Int>(texture + OFFSET(Texture,baseLevel)));
+ }
+ else if(function == Base)
+ {
+ lod = Float(*Pointer<Int>(texture + OFFSET(Texture,baseLevel)));
+ }
+ else assert(false);
lod = Max(lod, *Pointer<Float>(texture + OFFSET(Texture, minLod)));
lod = Min(lod, *Pointer<Float>(texture + OFFSET(Texture, maxLod)));
lod += lodBias;
}
}
- else
+ else if(function == Lod)
{
lod = lodBias + Float(*Pointer<Int>(texture + OFFSET(Texture,baseLevel)));
}
+ else if(function == Fetch)
+ {
+ // TODO: Eliminate int-float-int conversion.
+ lod = Float(As<Int>(lodBias)) + Float(*Pointer<Int>(texture + OFFSET(Texture,baseLevel)));
+ }
+ else if(function == Base)
+ {
+ lod = Float(*Pointer<Int>(texture + OFFSET(Texture,baseLevel)));
+ }
+ else assert(false);
lod = Max(lod, *Pointer<Float>(texture + OFFSET(Texture, minLod)));
lod = Min(lod, *Pointer<Float>(texture + OFFSET(Texture, maxLod)));
{
if(function != Lod && function != Fetch)
{
- Float4 dudxy;
- Float4 dvdxy;
- Float4 dsdxy;
+ Float4 dudxy, dvdxy, dsdxy;
if(function != Grad)
{
}
else
{
- dudxy = dsx.x;
- dvdxy = dsx.y;
- dsdxy = dsx.z;
-
- dudxy = Float4(dudxy.xx, dsy.x.xx);
- dvdxy = Float4(dvdxy.xx, dsy.y.xx);
- dsdxy = Float4(dsdxy.xx, dsy.z.xx);
+ dudxy = Float4(dsx.x.xx, dsy.x.xx);
+ dvdxy = Float4(dsx.y.xx, dsy.y.xx);
+ dsdxy = Float4(dsx.z.xx, dsy.z.xx);
dudxy = Float4(dudxy.xz, dudxy.xz);
dvdxy = Float4(dvdxy.xz, dvdxy.xz);
lod += lodBias;
}
}
- else
+ else if(function == Lod)
{
lod = lodBias + Float(*Pointer<Int>(texture + OFFSET(Texture,baseLevel)));
}
+ else if(function == Fetch)
+ {
+ // TODO: Eliminate int-float-int conversion.
+ lod = Float(As<Int>(lodBias)) + Float(*Pointer<Int>(texture + OFFSET(Texture,baseLevel)));
+ }
+ else if(function == Base)
+ {
+ lod = Float(*Pointer<Int>(texture + OFFSET(Texture,baseLevel)));
+ }
+ else assert(false);
lod = Max(lod, *Pointer<Float>(texture + OFFSET(Texture, minLod)));
lod = Min(lod, *Pointer<Float>(texture + OFFSET(Texture, maxLod)));
{
enum SamplerMethod
{
- Implicit,
- Bias,
- Lod,
- Grad,
- Fetch
+ Implicit, // Compute gradients (pixel shader only).
+ Bias, // Compute gradients and add provided bias.
+ Lod, // Use provided LOD.
+ Grad, // Use provided gradients.
+ Fetch, // Use provided integer coordinates.
+ Base // Sample base level.
};
enum SamplerOption
{
None,
- Offset
+ Offset // Offset sample location by provided integer coordinates.
};
struct SamplerFunction
public:
SamplerCore(Pointer<Byte> &constants, const Sampler::State &state);
- Vector4s sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy);
- Vector4f sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
+ Vector4s sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy);
+ Vector4f sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
static Vector4f textureSize(Pointer<Byte> &mipmap, Float4 &lod);
private:
- Vector4s sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function, bool fixed12);
+ Vector4s sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function, bool fixed12);
void border(Short4 &mask, Float4 &coordinates);
void border(Int4 &mask, Float4 &coordinates);
Vector4s sampleQuad(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function);
Vector4s sampleQuad2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function);
Vector4s sample3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, bool secondLOD, SamplerFunction function);
- Vector4f sampleFloatFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], SamplerFunction function);
- Vector4f sampleFloatAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, SamplerFunction function);
- Vector4f sampleFloat(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function);
- Vector4f sampleFloat2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function);
+ Vector4f sampleFloatFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], SamplerFunction function);
+ Vector4f sampleFloatAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, SamplerFunction function);
+ Vector4f sampleFloat(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function);
+ Vector4f sampleFloat2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function);
Vector4f sampleFloat3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, bool secondLOD, SamplerFunction function);
Float log2sqrt(Float lod);
void computeLod(Pointer<Byte> &texture, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Float4 &u, Float4 &v, const Float &lodBias, Vector4f &dsx, Vector4f &dsy, SamplerFunction function);
{
switch(opcode)
{
- case OPCODE_NULL: return "null";
- case OPCODE_NOP: return "nop";
- case OPCODE_MOV: return "mov";
- case OPCODE_ADD: return "add";
- case OPCODE_IADD: return "iadd";
- case OPCODE_SUB: return "sub";
- case OPCODE_ISUB: return "isub";
- case OPCODE_MAD: return "mad";
- case OPCODE_IMAD: return "imad";
- case OPCODE_MUL: return "mul";
- case OPCODE_IMUL: return "imul";
- case OPCODE_RCPX: return "rcpx";
- case OPCODE_DIV: return "div";
- case OPCODE_IDIV: return "idiv";
- case OPCODE_UDIV: return "udiv";
- case OPCODE_MOD: return "mod";
- case OPCODE_IMOD: return "imod";
- case OPCODE_UMOD: return "umod";
- case OPCODE_SHL: return "shl";
- case OPCODE_ISHR: return "ishr";
- case OPCODE_USHR: return "ushr";
- case OPCODE_RSQX: return "rsqx";
- case OPCODE_SQRT: return "sqrt";
- case OPCODE_RSQ: return "rsq";
- case OPCODE_LEN2: return "len2";
- case OPCODE_LEN3: return "len3";
- case OPCODE_LEN4: return "len4";
- case OPCODE_DIST1: return "dist1";
- case OPCODE_DIST2: return "dist2";
- case OPCODE_DIST3: return "dist3";
- case OPCODE_DIST4: return "dist4";
- case OPCODE_DP3: return "dp3";
- case OPCODE_DP4: return "dp4";
- case OPCODE_DET2: return "det2";
- case OPCODE_DET3: return "det3";
- case OPCODE_DET4: return "det4";
- case OPCODE_MIN: return "min";
- case OPCODE_IMIN: return "imin";
- case OPCODE_UMIN: return "umin";
- case OPCODE_MAX: return "max";
- case OPCODE_IMAX: return "imax";
- case OPCODE_UMAX: return "umax";
- case OPCODE_SLT: return "slt";
- case OPCODE_SGE: return "sge";
- case OPCODE_EXP2X: return "exp2x";
- case OPCODE_LOG2X: return "log2x";
- case OPCODE_LIT: return "lit";
- case OPCODE_ATT: return "att";
- case OPCODE_LRP: return "lrp";
- case OPCODE_STEP: return "step";
- case OPCODE_SMOOTH: return "smooth";
- case OPCODE_FLOATBITSTOINT: return "floatBitsToInt";
+ case OPCODE_NULL: return "null";
+ case OPCODE_NOP: return "nop";
+ case OPCODE_MOV: return "mov";
+ case OPCODE_ADD: return "add";
+ case OPCODE_IADD: return "iadd";
+ case OPCODE_SUB: return "sub";
+ case OPCODE_ISUB: return "isub";
+ case OPCODE_MAD: return "mad";
+ case OPCODE_IMAD: return "imad";
+ case OPCODE_MUL: return "mul";
+ case OPCODE_IMUL: return "imul";
+ case OPCODE_RCPX: return "rcpx";
+ case OPCODE_DIV: return "div";
+ case OPCODE_IDIV: return "idiv";
+ case OPCODE_UDIV: return "udiv";
+ case OPCODE_MOD: return "mod";
+ case OPCODE_IMOD: return "imod";
+ case OPCODE_UMOD: return "umod";
+ case OPCODE_SHL: return "shl";
+ case OPCODE_ISHR: return "ishr";
+ case OPCODE_USHR: return "ushr";
+ case OPCODE_RSQX: return "rsqx";
+ case OPCODE_SQRT: return "sqrt";
+ case OPCODE_RSQ: return "rsq";
+ case OPCODE_LEN2: return "len2";
+ case OPCODE_LEN3: return "len3";
+ case OPCODE_LEN4: return "len4";
+ case OPCODE_DIST1: return "dist1";
+ case OPCODE_DIST2: return "dist2";
+ case OPCODE_DIST3: return "dist3";
+ case OPCODE_DIST4: return "dist4";
+ case OPCODE_DP3: return "dp3";
+ case OPCODE_DP4: return "dp4";
+ case OPCODE_DET2: return "det2";
+ case OPCODE_DET3: return "det3";
+ case OPCODE_DET4: return "det4";
+ case OPCODE_MIN: return "min";
+ case OPCODE_IMIN: return "imin";
+ case OPCODE_UMIN: return "umin";
+ case OPCODE_MAX: return "max";
+ case OPCODE_IMAX: return "imax";
+ case OPCODE_UMAX: return "umax";
+ case OPCODE_SLT: return "slt";
+ case OPCODE_SGE: return "sge";
+ case OPCODE_EXP2X: return "exp2x";
+ case OPCODE_LOG2X: return "log2x";
+ case OPCODE_LIT: return "lit";
+ case OPCODE_ATT: return "att";
+ case OPCODE_LRP: return "lrp";
+ case OPCODE_STEP: return "step";
+ case OPCODE_SMOOTH: return "smooth";
+ case OPCODE_FLOATBITSTOINT: return "floatBitsToInt";
case OPCODE_FLOATBITSTOUINT: return "floatBitsToUInt";
- case OPCODE_INTBITSTOFLOAT: return "intBitsToFloat";
+ case OPCODE_INTBITSTOFLOAT: return "intBitsToFloat";
case OPCODE_UINTBITSTOFLOAT: return "uintBitsToFloat";
- case OPCODE_PACKSNORM2x16: return "packSnorm2x16";
- case OPCODE_PACKUNORM2x16: return "packUnorm2x16";
- case OPCODE_PACKHALF2x16: return "packHalf2x16";
+ case OPCODE_PACKSNORM2x16: return "packSnorm2x16";
+ case OPCODE_PACKUNORM2x16: return "packUnorm2x16";
+ case OPCODE_PACKHALF2x16: return "packHalf2x16";
case OPCODE_UNPACKSNORM2x16: return "unpackSnorm2x16";
case OPCODE_UNPACKUNORM2x16: return "unpackUnorm2x16";
- case OPCODE_UNPACKHALF2x16: return "unpackHalf2x16";
- case OPCODE_FRC: return "frc";
- case OPCODE_M4X4: return "m4x4";
- case OPCODE_M4X3: return "m4x3";
- case OPCODE_M3X4: return "m3x4";
- case OPCODE_M3X3: return "m3x3";
- case OPCODE_M3X2: return "m3x2";
- case OPCODE_CALL: return "call";
- case OPCODE_CALLNZ: return "callnz";
- case OPCODE_LOOP: return "loop";
- case OPCODE_RET: return "ret";
- case OPCODE_ENDLOOP: return "endloop";
- case OPCODE_LABEL: return "label";
- case OPCODE_DCL: return "dcl";
- case OPCODE_POWX: return "powx";
- case OPCODE_CRS: return "crs";
- case OPCODE_SGN: return "sgn";
- case OPCODE_ISGN: return "isgn";
- case OPCODE_ABS: return "abs";
- case OPCODE_IABS: return "iabs";
- case OPCODE_NRM2: return "nrm2";
- case OPCODE_NRM3: return "nrm3";
- case OPCODE_NRM4: return "nrm4";
- case OPCODE_SINCOS: return "sincos";
- case OPCODE_REP: return "rep";
- case OPCODE_ENDREP: return "endrep";
- case OPCODE_IF: return "if";
- case OPCODE_IFC: return "ifc";
- case OPCODE_ELSE: return "else";
- case OPCODE_ENDIF: return "endif";
- case OPCODE_BREAK: return "break";
- case OPCODE_BREAKC: return "breakc";
- case OPCODE_MOVA: return "mova";
- case OPCODE_DEFB: return "defb";
- case OPCODE_DEFI: return "defi";
- case OPCODE_TEXCOORD: return "texcoord";
- case OPCODE_TEXKILL: return "texkill";
- case OPCODE_DISCARD: return "discard";
+ case OPCODE_UNPACKHALF2x16: return "unpackHalf2x16";
+ case OPCODE_FRC: return "frc";
+ case OPCODE_M4X4: return "m4x4";
+ case OPCODE_M4X3: return "m4x3";
+ case OPCODE_M3X4: return "m3x4";
+ case OPCODE_M3X3: return "m3x3";
+ case OPCODE_M3X2: return "m3x2";
+ case OPCODE_CALL: return "call";
+ case OPCODE_CALLNZ: return "callnz";
+ case OPCODE_LOOP: return "loop";
+ case OPCODE_RET: return "ret";
+ case OPCODE_ENDLOOP: return "endloop";
+ case OPCODE_LABEL: return "label";
+ case OPCODE_DCL: return "dcl";
+ case OPCODE_POWX: return "powx";
+ case OPCODE_CRS: return "crs";
+ case OPCODE_SGN: return "sgn";
+ case OPCODE_ISGN: return "isgn";
+ case OPCODE_ABS: return "abs";
+ case OPCODE_IABS: return "iabs";
+ case OPCODE_NRM2: return "nrm2";
+ case OPCODE_NRM3: return "nrm3";
+ case OPCODE_NRM4: return "nrm4";
+ case OPCODE_SINCOS: return "sincos";
+ case OPCODE_REP: return "rep";
+ case OPCODE_ENDREP: return "endrep";
+ case OPCODE_IF: return "if";
+ case OPCODE_IFC: return "ifc";
+ case OPCODE_ELSE: return "else";
+ case OPCODE_ENDIF: return "endif";
+ case OPCODE_BREAK: return "break";
+ case OPCODE_BREAKC: return "breakc";
+ case OPCODE_MOVA: return "mova";
+ case OPCODE_DEFB: return "defb";
+ case OPCODE_DEFI: return "defi";
+ case OPCODE_TEXCOORD: return "texcoord";
+ case OPCODE_TEXKILL: return "texkill";
+ case OPCODE_DISCARD: return "discard";
case OPCODE_TEX:
- if(version < 0x0104) return "tex";
- else return "texld";
- case OPCODE_TEXBEM: return "texbem";
- case OPCODE_TEXBEML: return "texbeml";
- case OPCODE_TEXREG2AR: return "texreg2ar";
- case OPCODE_TEXREG2GB: return "texreg2gb";
- case OPCODE_TEXM3X2PAD: return "texm3x2pad";
- case OPCODE_TEXM3X2TEX: return "texm3x2tex";
- case OPCODE_TEXM3X3PAD: return "texm3x3pad";
- case OPCODE_TEXM3X3TEX: return "texm3x3tex";
- case OPCODE_RESERVED0: return "reserved0";
- case OPCODE_TEXM3X3SPEC: return "texm3x3spec";
- case OPCODE_TEXM3X3VSPEC: return "texm3x3vspec";
- case OPCODE_EXPP: return "expp";
- case OPCODE_LOGP: return "logp";
- case OPCODE_CND: return "cnd";
- case OPCODE_DEF: return "def";
- case OPCODE_TEXREG2RGB: return "texreg2rgb";
- case OPCODE_TEXDP3TEX: return "texdp3tex";
- case OPCODE_TEXM3X2DEPTH: return "texm3x2depth";
- case OPCODE_TEXDP3: return "texdp3";
- case OPCODE_TEXM3X3: return "texm3x3";
- case OPCODE_TEXDEPTH: return "texdepth";
- case OPCODE_CMP0: return "cmp0";
- case OPCODE_ICMP: return "icmp";
- case OPCODE_UCMP: return "ucmp";
- case OPCODE_SELECT: return "select";
- case OPCODE_EXTRACT: return "extract";
- case OPCODE_INSERT: return "insert";
- case OPCODE_BEM: return "bem";
- case OPCODE_DP2ADD: return "dp2add";
- case OPCODE_DFDX: return "dFdx";
- case OPCODE_DFDY: return "dFdy";
- case OPCODE_FWIDTH: return "fwidth";
- case OPCODE_TEXLDD: return "texldd";
- case OPCODE_CMP: return "cmp";
- case OPCODE_TEXLDL: return "texldl";
- case OPCODE_TEXOFFSET: return "texoffset";
- case OPCODE_TEXLDLOFFSET: return "texldloffset";
- case OPCODE_TEXELFETCH: return "texelfetch";
+ if(version < 0x0104) return "tex";
+ else return "texld";
+ case OPCODE_TEXBEM: return "texbem";
+ case OPCODE_TEXBEML: return "texbeml";
+ case OPCODE_TEXREG2AR: return "texreg2ar";
+ case OPCODE_TEXREG2GB: return "texreg2gb";
+ case OPCODE_TEXM3X2PAD: return "texm3x2pad";
+ case OPCODE_TEXM3X2TEX: return "texm3x2tex";
+ case OPCODE_TEXM3X3PAD: return "texm3x3pad";
+ case OPCODE_TEXM3X3TEX: return "texm3x3tex";
+ case OPCODE_RESERVED0: return "reserved0";
+ case OPCODE_TEXM3X3SPEC: return "texm3x3spec";
+ case OPCODE_TEXM3X3VSPEC: return "texm3x3vspec";
+ case OPCODE_EXPP: return "expp";
+ case OPCODE_LOGP: return "logp";
+ case OPCODE_CND: return "cnd";
+ case OPCODE_DEF: return "def";
+ case OPCODE_TEXREG2RGB: return "texreg2rgb";
+ case OPCODE_TEXDP3TEX: return "texdp3tex";
+ case OPCODE_TEXM3X2DEPTH: return "texm3x2depth";
+ case OPCODE_TEXDP3: return "texdp3";
+ case OPCODE_TEXM3X3: return "texm3x3";
+ case OPCODE_TEXDEPTH: return "texdepth";
+ case OPCODE_CMP0: return "cmp0";
+ case OPCODE_ICMP: return "icmp";
+ case OPCODE_UCMP: return "ucmp";
+ case OPCODE_SELECT: return "select";
+ case OPCODE_EXTRACT: return "extract";
+ case OPCODE_INSERT: return "insert";
+ case OPCODE_BEM: return "bem";
+ case OPCODE_DP2ADD: return "dp2add";
+ case OPCODE_DFDX: return "dFdx";
+ case OPCODE_DFDY: return "dFdy";
+ case OPCODE_FWIDTH: return "fwidth";
+ case OPCODE_TEXLDD: return "texldd";
+ case OPCODE_CMP: return "cmp";
+ case OPCODE_TEXLDL: return "texldl";
+ case OPCODE_TEXBIAS: return "texbias";
+ case OPCODE_TEXOFFSET: return "texoffset";
+ case OPCODE_TEXOFFSETBIAS: return "texoffsetbias";
+ case OPCODE_TEXLODOFFSET: return "texlodoffset";
+ case OPCODE_TEXELFETCH: return "texelfetch";
case OPCODE_TEXELFETCHOFFSET: return "texelfetchoffset";
- case OPCODE_TEXGRAD: return "texgrad";
- case OPCODE_TEXGRADOFFSET: return "texgradoffset";
- case OPCODE_BREAKP: return "breakp";
- case OPCODE_TEXSIZE: return "texsize";
- case OPCODE_PHASE: return "phase";
- case OPCODE_COMMENT: return "comment";
- case OPCODE_END: return "end";
- case OPCODE_PS_1_0: return "ps_1_0";
- case OPCODE_PS_1_1: return "ps_1_1";
- case OPCODE_PS_1_2: return "ps_1_2";
- case OPCODE_PS_1_3: return "ps_1_3";
- case OPCODE_PS_1_4: return "ps_1_4";
- case OPCODE_PS_2_0: return "ps_2_0";
- case OPCODE_PS_2_x: return "ps_2_x";
- case OPCODE_PS_3_0: return "ps_3_0";
- case OPCODE_VS_1_0: return "vs_1_0";
- case OPCODE_VS_1_1: return "vs_1_1";
- case OPCODE_VS_2_0: return "vs_2_0";
- case OPCODE_VS_2_x: return "vs_2_x";
- case OPCODE_VS_2_sw: return "vs_2_sw";
- case OPCODE_VS_3_0: return "vs_3_0";
- case OPCODE_VS_3_sw: return "vs_3_sw";
- case OPCODE_WHILE: return "while";
- case OPCODE_ENDWHILE: return "endwhile";
- case OPCODE_COS: return "cos";
- case OPCODE_SIN: return "sin";
- case OPCODE_TAN: return "tan";
- case OPCODE_ACOS: return "acos";
- case OPCODE_ASIN: return "asin";
- case OPCODE_ATAN: return "atan";
- case OPCODE_ATAN2: return "atan2";
- case OPCODE_COSH: return "cosh";
- case OPCODE_SINH: return "sinh";
- case OPCODE_TANH: return "tanh";
- case OPCODE_ACOSH: return "acosh";
- case OPCODE_ASINH: return "asinh";
- case OPCODE_ATANH: return "atanh";
- case OPCODE_DP1: return "dp1";
- case OPCODE_DP2: return "dp2";
- case OPCODE_TRUNC: return "trunc";
- case OPCODE_FLOOR: return "floor";
- case OPCODE_ROUND: return "round";
- case OPCODE_ROUNDEVEN: return "roundEven";
- case OPCODE_CEIL: return "ceil";
- case OPCODE_EXP2: return "exp2";
- case OPCODE_LOG2: return "log2";
- case OPCODE_EXP: return "exp";
- case OPCODE_LOG: return "log";
- case OPCODE_POW: return "pow";
- case OPCODE_F2B: return "f2b";
- case OPCODE_B2F: return "b2f";
- case OPCODE_F2I: return "f2i";
- case OPCODE_I2F: return "i2f";
- case OPCODE_F2U: return "f2u";
- case OPCODE_U2F: return "u2f";
- case OPCODE_B2I: return "b2i";
- case OPCODE_I2B: return "i2b";
- case OPCODE_ALL: return "all";
- case OPCODE_ANY: return "any";
- case OPCODE_NEG: return "neg";
- case OPCODE_INEG: return "ineg";
- case OPCODE_ISNAN: return "isnan";
- case OPCODE_ISINF: return "isinf";
- case OPCODE_NOT: return "not";
- case OPCODE_OR: return "or";
- case OPCODE_XOR: return "xor";
- case OPCODE_AND: return "and";
- case OPCODE_EQ: return "eq";
- case OPCODE_NE: return "neq";
- case OPCODE_FORWARD1: return "forward1";
- case OPCODE_FORWARD2: return "forward2";
- case OPCODE_FORWARD3: return "forward3";
- case OPCODE_FORWARD4: return "forward4";
- case OPCODE_REFLECT1: return "reflect1";
- case OPCODE_REFLECT2: return "reflect2";
- case OPCODE_REFLECT3: return "reflect3";
- case OPCODE_REFLECT4: return "reflect4";
- case OPCODE_REFRACT1: return "refract1";
- case OPCODE_REFRACT2: return "refract2";
- case OPCODE_REFRACT3: return "refract3";
- case OPCODE_REFRACT4: return "refract4";
- case OPCODE_LEAVE: return "leave";
- case OPCODE_CONTINUE: return "continue";
- case OPCODE_TEST: return "test";
- case OPCODE_SWITCH: return "switch";
- case OPCODE_ENDSWITCH: return "endswitch";
+ case OPCODE_TEXGRAD: return "texgrad";
+ case OPCODE_TEXGRADOFFSET: return "texgradoffset";
+ case OPCODE_BREAKP: return "breakp";
+ case OPCODE_TEXSIZE: return "texsize";
+ case OPCODE_PHASE: return "phase";
+ case OPCODE_COMMENT: return "comment";
+ case OPCODE_END: return "end";
+ case OPCODE_PS_1_0: return "ps_1_0";
+ case OPCODE_PS_1_1: return "ps_1_1";
+ case OPCODE_PS_1_2: return "ps_1_2";
+ case OPCODE_PS_1_3: return "ps_1_3";
+ case OPCODE_PS_1_4: return "ps_1_4";
+ case OPCODE_PS_2_0: return "ps_2_0";
+ case OPCODE_PS_2_x: return "ps_2_x";
+ case OPCODE_PS_3_0: return "ps_3_0";
+ case OPCODE_VS_1_0: return "vs_1_0";
+ case OPCODE_VS_1_1: return "vs_1_1";
+ case OPCODE_VS_2_0: return "vs_2_0";
+ case OPCODE_VS_2_x: return "vs_2_x";
+ case OPCODE_VS_2_sw: return "vs_2_sw";
+ case OPCODE_VS_3_0: return "vs_3_0";
+ case OPCODE_VS_3_sw: return "vs_3_sw";
+ case OPCODE_WHILE: return "while";
+ case OPCODE_ENDWHILE: return "endwhile";
+ case OPCODE_COS: return "cos";
+ case OPCODE_SIN: return "sin";
+ case OPCODE_TAN: return "tan";
+ case OPCODE_ACOS: return "acos";
+ case OPCODE_ASIN: return "asin";
+ case OPCODE_ATAN: return "atan";
+ case OPCODE_ATAN2: return "atan2";
+ case OPCODE_COSH: return "cosh";
+ case OPCODE_SINH: return "sinh";
+ case OPCODE_TANH: return "tanh";
+ case OPCODE_ACOSH: return "acosh";
+ case OPCODE_ASINH: return "asinh";
+ case OPCODE_ATANH: return "atanh";
+ case OPCODE_DP1: return "dp1";
+ case OPCODE_DP2: return "dp2";
+ case OPCODE_TRUNC: return "trunc";
+ case OPCODE_FLOOR: return "floor";
+ case OPCODE_ROUND: return "round";
+ case OPCODE_ROUNDEVEN: return "roundEven";
+ case OPCODE_CEIL: return "ceil";
+ case OPCODE_EXP2: return "exp2";
+ case OPCODE_LOG2: return "log2";
+ case OPCODE_EXP: return "exp";
+ case OPCODE_LOG: return "log";
+ case OPCODE_POW: return "pow";
+ case OPCODE_F2B: return "f2b";
+ case OPCODE_B2F: return "b2f";
+ case OPCODE_F2I: return "f2i";
+ case OPCODE_I2F: return "i2f";
+ case OPCODE_F2U: return "f2u";
+ case OPCODE_U2F: return "u2f";
+ case OPCODE_B2I: return "b2i";
+ case OPCODE_I2B: return "i2b";
+ case OPCODE_ALL: return "all";
+ case OPCODE_ANY: return "any";
+ case OPCODE_NEG: return "neg";
+ case OPCODE_INEG: return "ineg";
+ case OPCODE_ISNAN: return "isnan";
+ case OPCODE_ISINF: return "isinf";
+ case OPCODE_NOT: return "not";
+ case OPCODE_OR: return "or";
+ case OPCODE_XOR: return "xor";
+ case OPCODE_AND: return "and";
+ case OPCODE_EQ: return "eq";
+ case OPCODE_NE: return "neq";
+ case OPCODE_FORWARD1: return "forward1";
+ case OPCODE_FORWARD2: return "forward2";
+ case OPCODE_FORWARD3: return "forward3";
+ case OPCODE_FORWARD4: return "forward4";
+ case OPCODE_REFLECT1: return "reflect1";
+ case OPCODE_REFLECT2: return "reflect2";
+ case OPCODE_REFLECT3: return "reflect3";
+ case OPCODE_REFLECT4: return "reflect4";
+ case OPCODE_REFRACT1: return "refract1";
+ case OPCODE_REFRACT2: return "refract2";
+ case OPCODE_REFRACT3: return "refract3";
+ case OPCODE_REFRACT4: return "refract4";
+ case OPCODE_LEAVE: return "leave";
+ case OPCODE_CONTINUE: return "continue";
+ case OPCODE_TEST: return "test";
+ case OPCODE_SWITCH: return "switch";
+ case OPCODE_ENDSWITCH: return "endswitch";
default:
ASSERT(false);
}
case OPCODE_TEXM3X2DEPTH:
case OPCODE_TEXLDD:
case OPCODE_TEXLDL:
+ case OPCODE_TEXLOD:
case OPCODE_TEXOFFSET:
- case OPCODE_TEXLDLOFFSET:
+ case OPCODE_TEXOFFSETBIAS:
+ case OPCODE_TEXLODOFFSET:
case OPCODE_TEXELFETCH:
case OPCODE_TEXELFETCHOFFSET:
case OPCODE_TEXGRAD:
OPCODE_CMP, // D3DSIO_SETP
OPCODE_TEXLDL,
OPCODE_BREAKP,
- OPCODE_TEXSIZE,
OPCODE_PHASE = 0xFFFD,
OPCODE_COMMENT = 0xFFFE,
OPCODE_ISNAN,
OPCODE_ISINF,
OPCODE_TEXOFFSET,
- OPCODE_TEXLDLOFFSET,
+ OPCODE_TEXLODOFFSET,
OPCODE_TEXELFETCH,
OPCODE_TEXELFETCHOFFSET,
OPCODE_TEXGRAD,
OPCODE_TEXGRADOFFSET,
+ OPCODE_TEXBIAS,
+ OPCODE_TEXLOD,
+ OPCODE_TEXOFFSETBIAS,
+ OPCODE_TEXSIZE,
OPCODE_FLOATBITSTOINT,
OPCODE_FLOATBITSTOUINT,
OPCODE_INTBITSTOFLOAT,
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_TEXLDL: TEXLDL(d, s0, src1); break;
+ case Shader::OPCODE_TEXLDL: TEXLOD(d, s0, src1, s0.w); break;
+ case Shader::OPCODE_TEXLOD: TEXLOD(d, s0, src1, s2.x); break;
case Shader::OPCODE_TEX: TEX(d, s0, src1); break;
case Shader::OPCODE_TEXOFFSET: TEXOFFSET(d, s0, src1, s2); break;
- case Shader::OPCODE_TEXLDLOFFSET: TEXLDL(d, s0, src1, s2); break;
- case Shader::OPCODE_TEXELFETCH: TEXELFETCH(d, s0, src1); break;
- case Shader::OPCODE_TEXELFETCHOFFSET: TEXELFETCH(d, s0, src1, s2); break;
+ case Shader::OPCODE_TEXLODOFFSET: TEXLODOFFSET(d, s0, src1, s2, s3.x); break;
+ case Shader::OPCODE_TEXELFETCH: TEXELFETCH(d, s0, src1, s2.x); break;
+ case Shader::OPCODE_TEXELFETCHOFFSET: TEXELFETCHOFFSET(d, s0, src1, s2, s3.x); 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_TEXGRADOFFSET: TEXGRADOFFSET(d, s0, src1, s2, s3, s4); break;
case Shader::OPCODE_TEXSIZE: TEXSIZE(d, s0.x, src1); break;
case Shader::OPCODE_END: break;
default:
// FIXME: Use enableLeave in other control-flow constructs
}
- void VertexProgram::TEXLDL(Vector4f &dst, Vector4f &src0, const Src &src1)
+ void VertexProgram::TEX(Vector4f &dst, Vector4f &src0, const Src &src1)
{
- dst = sampleTexture(src1, src0, a0, a0, src0, Lod);
+ dst = sampleTexture(src1, src0, (src0.x), (src0), (src0), (src0), Base);
}
- void VertexProgram::TEX(Vector4f &dst, Vector4f &src0, const Src &src1)
+ void VertexProgram::TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset)
{
- src0.w = Float(0.0f);
- dst = sampleTexture(src1, src0, a0, a0, src0, Lod);
+ dst = sampleTexture(src1, src0, (src0.x), (src0), (src0), offset, {Base, Offset});
}
- void VertexProgram::TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2)
+ void VertexProgram::TEXLOD(Vector4f &dst, Vector4f &src0, const Src& src1, Float4 &lod)
{
- src0.w = Float(0.0f);
- dst = sampleTexture(src1, src0, a0, a0, src2, {Lod, Offset});
+ dst = sampleTexture(src1, src0, lod, (src0), (src0), (src0), Lod);
}
- void VertexProgram::TEXLDL(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset)
+ void VertexProgram::TEXLODOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset, Float4 &lod)
{
- dst = sampleTexture(src1, src0, a0, a0, offset, {Lod, Offset});
+ dst = sampleTexture(src1, src0, lod, (src0), (src0), offset, {Lod, Offset});
}
- void VertexProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1)
+ void VertexProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1, Float4 &lod)
{
- dst = sampleTexture(src1, src0, src0, src0, src0, Fetch);
+ dst = sampleTexture(src1, src0, lod, (src0), (src0), (src0), Fetch);
}
- void VertexProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset)
+ void VertexProgram::TEXELFETCHOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset, Float4 &lod)
{
- dst = sampleTexture(src1, src0, src0, src0, offset, {Fetch, Offset});
+ dst = sampleTexture(src1, src0, lod, (src0), (src0), offset, {Fetch, Offset});
}
- void VertexProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &src3)
+ void VertexProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &dsx, Vector4f &dsy)
{
- dst = sampleTexture(src1, src0, src2, src3, src0, Grad);
+ dst = sampleTexture(src1, src0, (src0.x), dsx, dsy, src0, Grad);
}
- void VertexProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &src2, Vector4f &src3, Vector4f &offset)
+ void VertexProgram::TEXGRADOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &dsx, Vector4f &dsy, Vector4f &offset)
{
- dst = sampleTexture(src1, src0, src2, src3, offset, {Grad, Offset});
+ dst = sampleTexture(src1, src0, (src0.x), dsx, dsy, offset, {Grad, Offset});
}
void VertexProgram::TEXSIZE(Vector4f &dst, Float4 &lod, const Src &src1)
dst = SamplerCore::textureSize(texture, lod);
}
- Vector4f VertexProgram::sampleTexture(const Src &s, Vector4f &uvwq, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
+ Vector4f VertexProgram::sampleTexture(const Src &s, Vector4f &uvwq, Float4 &lod, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
{
Vector4f tmp;
if(s.type == Shader::PARAMETER_SAMPLER && s.rel.type == Shader::PARAMETER_VOID)
{
- tmp = sampleTexture(s.index, uvwq, dsx, dsy, offset, function);
+ tmp = sampleTexture(s.index, uvwq, lod, dsx, dsy, offset, function);
}
else
{
{
If(index == i)
{
- tmp = sampleTexture(i, uvwq, dsx, dsy, offset, function);
+ tmp = sampleTexture(i, uvwq, lod, dsx, dsy, offset, function);
// FIXME: When the sampler states are the same, we could use one sampler and just index the texture
}
}
return c;
}
- Vector4f VertexProgram::sampleTexture(int sampler, Vector4f &uvwq, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
+ Vector4f VertexProgram::sampleTexture(int sampler, Vector4f &uvwq, Float4 &lod, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
{
Pointer<Byte> texture = data + OFFSET(DrawData, mipmap[TEXTURE_IMAGE_UNITS]) + sampler * sizeof(Texture);
- return SamplerCore(constants, state.sampler[sampler]).sampleTexture(texture, uvwq.x, uvwq.y, uvwq.z, uvwq.w, dsx, dsy, offset, function);
+ return SamplerCore(constants, state.sampler[sampler]).sampleTexture(texture, uvwq.x, uvwq.y, uvwq.z, uvwq.w, lod, dsx, dsy, offset, function);
}
}
void SWITCH();
void RET();
void LEAVE();
- void TEXLDL(Vector4f &dst, Vector4f &src, const Src&);
void TEX(Vector4f &dst, Vector4f &src, const Src&);
- void TEXOFFSET(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2);
- void TEXLDL(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2);
- void TEXELFETCH(Vector4f &dst, Vector4f &src, const Src&);
- void TEXELFETCH(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2);
- void TEXGRAD(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3);
- void TEXGRAD(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3, Vector4f &src4);
+ void TEXOFFSET(Vector4f &dst, Vector4f &src, const Src&, Vector4f &offset);
+ void TEXLOD(Vector4f &dst, Vector4f &src, const Src&, Float4 &lod);
+ void TEXLODOFFSET(Vector4f &dst, Vector4f &src, const Src&, Vector4f &offset, Float4 &lod);
+ void TEXELFETCH(Vector4f &dst, Vector4f &src, const Src&, Float4 &lod);
+ void TEXELFETCHOFFSET(Vector4f &dst, Vector4f &src, const Src&, Vector4f &offset, Float4 &lod);
+ void TEXGRAD(Vector4f &dst, Vector4f &src, const Src&, Vector4f &dsx, Vector4f &dsy);
+ void TEXGRADOFFSET(Vector4f &dst, Vector4f &src, const Src&, Vector4f &dsx, Vector4f &dsy, Vector4f &offset);
void TEXSIZE(Vector4f &dst, Float4 &lod, const Src&);
- Vector4f sampleTexture(const Src &s, Vector4f &uvwq, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
- Vector4f sampleTexture(int sampler, Vector4f &uvwq, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
+ Vector4f sampleTexture(const Src &s, Vector4f &uvwq, Float4 &lod, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
+ Vector4f sampleTexture(int sampler, Vector4f &uvwq, Float4 &lod, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
int ifDepth;
int loopRepDepth;
OSDN Git Service
