{
for(int i = 0; i < 4; i++)
{
- Float4 B = r.v[BlendIndices].x;
+ Float4 B = v[BlendIndices].x;
UInt indices;
switch(i)
switch(state.vertexBlendMatrixCount)
{
- case 4: weight2 = r.v[BlendWeight].z;
- case 3: weight1 = r.v[BlendWeight].y;
- case 2: weight0 = r.v[BlendWeight].x;
+ case 4: weight2 = v[BlendWeight].z;
+ case 3: weight1 = v[BlendWeight].y;
+ case 2: weight0 = v[BlendWeight].x;
case 1:
break;
}
if(!state.preTransformed)
{
- position = transformBlend(r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.transformT)), true);
+ position = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.transformT)), true);
}
else
{
- position = r.v[PositionT];
+ position = v[PositionT];
}
- r.o[Pos].x = position.x;
- r.o[Pos].y = position.y;
- r.o[Pos].z = position.z;
- r.o[Pos].w = position.w;
+ o[Pos].x = position.x;
+ o[Pos].y = position.y;
+ o[Pos].z = position.z;
+ o[Pos].w = position.w;
- Vector4f vertexPosition = transformBlend(r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.cameraTransformT)), true);
+ Vector4f vertexPosition = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.cameraTransformT)), true);
if(state.vertexNormalActive)
{
- normal = transformBlend(r.v[Normal], Pointer<Byte>(r.data + OFFSET(DrawData,ff.normalTransformT)), false);
+ normal = transformBlend(v[Normal], Pointer<Byte>(data + OFFSET(DrawData,ff.normalTransformT)), false);
if(state.normalizeNormals)
{
// FIXME: Don't process if not used at all
if(state.diffuseActive && state.input[Color0])
{
- Vector4f diffuse = r.v[Color0];
+ Vector4f diffuse = v[Color0];
- r.o[D0].x = diffuse.x;
- r.o[D0].y = diffuse.y;
- r.o[D0].z = diffuse.z;
- r.o[D0].w = diffuse.w;
+ o[D0].x = diffuse.x;
+ o[D0].y = diffuse.y;
+ o[D0].z = diffuse.z;
+ o[D0].w = diffuse.w;
}
else
{
- r.o[D0].x = Float4(1.0f);
- r.o[D0].y = Float4(1.0f);
- r.o[D0].z = Float4(1.0f);
- r.o[D0].w = Float4(1.0f);
+ o[D0].x = Float4(1.0f);
+ o[D0].y = Float4(1.0f);
+ o[D0].z = Float4(1.0f);
+ o[D0].w = Float4(1.0f);
}
// FIXME: Don't process if not used at all
if(state.specularActive && state.input[Color1])
{
- Vector4f specular = r.v[Color1];
+ Vector4f specular = v[Color1];
- r.o[D1].x = specular.x;
- r.o[D1].y = specular.y;
- r.o[D1].z = specular.z;
- r.o[D1].w = specular.w;
+ o[D1].x = specular.x;
+ o[D1].y = specular.y;
+ o[D1].z = specular.z;
+ o[D1].w = specular.w;
}
else
{
- r.o[D1].x = Float4(0.0f);
- r.o[D1].y = Float4(0.0f);
- r.o[D1].z = Float4(0.0f);
- r.o[D1].w = Float4(1.0f);
+ o[D1].x = Float4(0.0f);
+ o[D1].y = Float4(0.0f);
+ o[D1].z = Float4(0.0f);
+ o[D1].w = Float4(1.0f);
}
}
else
{
- r.o[D0].x = Float4(0.0f);
- r.o[D0].y = Float4(0.0f);
- r.o[D0].z = Float4(0.0f);
- r.o[D0].w = Float4(0.0f);
+ o[D0].x = Float4(0.0f);
+ o[D0].y = Float4(0.0f);
+ o[D0].z = Float4(0.0f);
+ o[D0].w = Float4(0.0f);
- r.o[D1].x = Float4(0.0f);
- r.o[D1].y = Float4(0.0f);
- r.o[D1].z = Float4(0.0f);
- r.o[D1].w = Float4(0.0f);
+ o[D1].x = Float4(0.0f);
+ o[D1].y = Float4(0.0f);
+ o[D1].z = Float4(0.0f);
+ o[D1].w = Float4(0.0f);
Vector4f ambient;
- Float4 globalAmbient = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.globalAmbient)); // FIXME: Unpack
+ Float4 globalAmbient = *Pointer<Float4>(data + OFFSET(DrawData,ff.globalAmbient)); // FIXME: Unpack
ambient.x = globalAmbient.x;
ambient.y = globalAmbient.y;
{
Float4 d; // Distance
- L.x = L.y = L.z = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.lightPosition[i])); // FIXME: Unpack
+ L.x = L.y = L.z = *Pointer<Float4>(data + OFFSET(DrawData,ff.lightPosition[i])); // FIXME: Unpack
L.x = L.x.xxxx;
L.y = L.y.yyyy;
L.z = L.z.zzzz;
L.z *= d;
d = Rcp_pp(d); // FIXME: Sufficient precision?
- Float4 q = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.attenuationQuadratic[i]));
- Float4 l = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.attenuationLinear[i]));
- Float4 c = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.attenuationConstant[i]));
+ Float4 q = *Pointer<Float4>(data + OFFSET(DrawData,ff.attenuationQuadratic[i]));
+ Float4 l = *Pointer<Float4>(data + OFFSET(DrawData,ff.attenuationLinear[i]));
+ Float4 c = *Pointer<Float4>(data + OFFSET(DrawData,ff.attenuationConstant[i]));
att = Rcp_pp((q * d + l) * d + c);
}
// Ambient per light
{
- Float4 lightAmbient = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.lightAmbient[i])); // FIXME: Unpack
+ Float4 lightAmbient = *Pointer<Float4>(data + OFFSET(DrawData,ff.lightAmbient[i])); // FIXME: Unpack
ambient.x = ambient.x + lightAmbient.x * att;
ambient.y = ambient.y + lightAmbient.y * att;
if(state.vertexDiffuseMaterialSourceActive == MATERIAL_MATERIAL)
{
- diff.x = diff.y = diff.z = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialDiffuse)); // FIXME: Unpack
+ diff.x = diff.y = diff.z = *Pointer<Float4>(data + OFFSET(DrawData,ff.materialDiffuse)); // FIXME: Unpack
diff.x = diff.x.xxxx;
diff.y = diff.y.yyyy;
diff.z = diff.z.zzzz;
}
else if(state.vertexDiffuseMaterialSourceActive == MATERIAL_COLOR1)
{
- diff = r.v[Color0];
+ diff = v[Color0];
}
else if(state.vertexDiffuseMaterialSourceActive == MATERIAL_COLOR2)
{
- diff = r.v[Color1];
+ diff = v[Color1];
}
else ASSERT(false);
- Float4 lightDiffuse = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.lightDiffuse[i]));
+ Float4 lightDiffuse = *Pointer<Float4>(data + OFFSET(DrawData,ff.lightDiffuse[i]));
- r.o[D0].x = r.o[D0].x + diff.x * dot * lightDiffuse.x; // FIXME: Clamp first?
- r.o[D0].y = r.o[D0].y + diff.y * dot * lightDiffuse.y; // FIXME: Clamp first?
- r.o[D0].z = r.o[D0].z + diff.z * dot * lightDiffuse.z; // FIXME: Clamp first?
+ o[D0].x = o[D0].x + diff.x * dot * lightDiffuse.x; // FIXME: Clamp first?
+ o[D0].y = o[D0].y + diff.y * dot * lightDiffuse.y; // FIXME: Clamp first?
+ o[D0].z = o[D0].z + diff.z * dot * lightDiffuse.z; // FIXME: Clamp first?
}
// Specular
Vector4f C; // Camera vector
Float4 pow;
- pow = *Pointer<Float>(r.data + OFFSET(DrawData,ff.materialShininess));
+ pow = *Pointer<Float>(data + OFFSET(DrawData,ff.materialShininess));
S.x = Float4(0.0f) - vertexPosition.x;
S.y = Float4(0.0f) - vertexPosition.y;
if(state.vertexSpecularMaterialSourceActive == MATERIAL_MATERIAL)
{
- Float4 materialSpecular = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialSpecular)); // FIXME: Unpack
+ Float4 materialSpecular = *Pointer<Float4>(data + OFFSET(DrawData,ff.materialSpecular)); // FIXME: Unpack
spec.x = materialSpecular.x;
spec.y = materialSpecular.y;
}
else if(state.vertexSpecularMaterialSourceActive == MATERIAL_COLOR1)
{
- spec = r.v[Color0];
+ spec = v[Color0];
}
else if(state.vertexSpecularMaterialSourceActive == MATERIAL_COLOR2)
{
- spec = r.v[Color1];
+ spec = v[Color1];
}
else ASSERT(false);
- Float4 lightSpecular = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.lightSpecular[i]));
+ Float4 lightSpecular = *Pointer<Float4>(data + OFFSET(DrawData,ff.lightSpecular[i]));
spec.x *= lightSpecular.x;
spec.y *= lightSpecular.y;
if(secondaryColor)
{
- r.o[D1].x = r.o[D1].x + spec.x;
- r.o[D1].y = r.o[D1].y + spec.y;
- r.o[D1].z = r.o[D1].z + spec.z;
+ o[D1].x = o[D1].x + spec.x;
+ o[D1].y = o[D1].y + spec.y;
+ o[D1].z = o[D1].z + spec.z;
}
else
{
- r.o[D0].x = r.o[D0].x + spec.x;
- r.o[D0].y = r.o[D0].y + spec.y;
- r.o[D0].z = r.o[D0].z + spec.z;
+ o[D0].x = o[D0].x + spec.x;
+ o[D0].y = o[D0].y + spec.y;
+ o[D0].z = o[D0].z + spec.z;
}
}
}
if(state.vertexAmbientMaterialSourceActive == MATERIAL_MATERIAL)
{
- Float4 materialAmbient = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialAmbient)); // FIXME: Unpack
+ Float4 materialAmbient = *Pointer<Float4>(data + OFFSET(DrawData,ff.materialAmbient)); // FIXME: Unpack
ambient.x = ambient.x * materialAmbient.x;
ambient.y = ambient.y * materialAmbient.y;
}
else if(state.vertexAmbientMaterialSourceActive == MATERIAL_COLOR1)
{
- Vector4f materialDiffuse = r.v[Color0];
+ Vector4f materialDiffuse = v[Color0];
ambient.x = ambient.x * materialDiffuse.x;
ambient.y = ambient.y * materialDiffuse.y;
}
else if(state.vertexAmbientMaterialSourceActive == MATERIAL_COLOR2)
{
- Vector4f materialSpecular = r.v[Color1];
+ Vector4f materialSpecular = v[Color1];
ambient.x = ambient.x * materialSpecular.x;
ambient.y = ambient.y * materialSpecular.y;
}
else ASSERT(false);
- r.o[D0].x = r.o[D0].x + ambient.x;
- r.o[D0].y = r.o[D0].y + ambient.y;
- r.o[D0].z = r.o[D0].z + ambient.z;
+ o[D0].x = o[D0].x + ambient.x;
+ o[D0].y = o[D0].y + ambient.y;
+ o[D0].z = o[D0].z + ambient.z;
// Emissive
if(state.vertexEmissiveMaterialSourceActive == MATERIAL_MATERIAL)
{
- Float4 materialEmission = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialEmission)); // FIXME: Unpack
+ Float4 materialEmission = *Pointer<Float4>(data + OFFSET(DrawData,ff.materialEmission)); // FIXME: Unpack
- r.o[D0].x = r.o[D0].x + materialEmission.x;
- r.o[D0].y = r.o[D0].y + materialEmission.y;
- r.o[D0].z = r.o[D0].z + materialEmission.z;
+ o[D0].x = o[D0].x + materialEmission.x;
+ o[D0].y = o[D0].y + materialEmission.y;
+ o[D0].z = o[D0].z + materialEmission.z;
}
else if(state.vertexEmissiveMaterialSourceActive == MATERIAL_COLOR1)
{
- Vector4f materialSpecular = r.v[Color0];
+ Vector4f materialSpecular = v[Color0];
- r.o[D0].x = r.o[D0].x + materialSpecular.x;
- r.o[D0].y = r.o[D0].y + materialSpecular.y;
- r.o[D0].z = r.o[D0].z + materialSpecular.z;
+ o[D0].x = o[D0].x + materialSpecular.x;
+ o[D0].y = o[D0].y + materialSpecular.y;
+ o[D0].z = o[D0].z + materialSpecular.z;
}
else if(state.vertexEmissiveMaterialSourceActive == MATERIAL_COLOR2)
{
- Vector4f materialSpecular = r.v[Color1];
+ Vector4f materialSpecular = v[Color1];
- r.o[D0].x = r.o[D0].x + materialSpecular.x;
- r.o[D0].y = r.o[D0].y + materialSpecular.y;
- r.o[D0].z = r.o[D0].z + materialSpecular.z;
+ o[D0].x = o[D0].x + materialSpecular.x;
+ o[D0].y = o[D0].y + materialSpecular.y;
+ o[D0].z = o[D0].z + materialSpecular.z;
}
else ASSERT(false);
// Diffuse alpha component
if(state.vertexDiffuseMaterialSourceActive == MATERIAL_MATERIAL)
{
- r.o[D0].w = Float4(*Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialDiffuse[0]))).wwww; // FIXME: Unpack
+ o[D0].w = Float4(*Pointer<Float4>(data + OFFSET(DrawData,ff.materialDiffuse[0]))).wwww; // FIXME: Unpack
}
else if(state.vertexDiffuseMaterialSourceActive == MATERIAL_COLOR1)
{
- Vector4f alpha = r.v[Color0];
- r.o[D0].w = alpha.w;
+ Vector4f alpha = v[Color0];
+ o[D0].w = alpha.w;
}
else if(state.vertexDiffuseMaterialSourceActive == MATERIAL_COLOR2)
{
- Vector4f alpha = r.v[Color1];
- r.o[D0].w = alpha.w;
+ Vector4f alpha = v[Color1];
+ o[D0].w = alpha.w;
}
else ASSERT(false);
// Specular alpha component
if(state.vertexSpecularMaterialSourceActive == MATERIAL_MATERIAL)
{
- r.o[D1].w = Float4(*Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialSpecular[3]))).wwww; // FIXME: Unpack
+ o[D1].w = Float4(*Pointer<Float4>(data + OFFSET(DrawData,ff.materialSpecular[3]))).wwww; // FIXME: Unpack
}
else if(state.vertexSpecularMaterialSourceActive == MATERIAL_COLOR1)
{
- Vector4f alpha = r.v[Color0];
- r.o[D1].w = alpha.w;
+ Vector4f alpha = v[Color0];
+ o[D1].w = alpha.w;
}
else if(state.vertexSpecularMaterialSourceActive == MATERIAL_COLOR2)
{
- Vector4f alpha = r.v[Color1];
- r.o[D1].w = alpha.w;
+ Vector4f alpha = v[Color1];
+ o[D1].w = alpha.w;
}
else ASSERT(false);
}
case FOG_NONE:
if(state.specularActive)
{
- r.o[Fog].x = r.o[D1].w;
+ o[Fog].x = o[D1].w;
}
else
{
- r.o[Fog].x = Float4(0.0f);
+ o[Fog].x = Float4(0.0f);
}
break;
case FOG_LINEAR:
- r.o[Fog].x = f * *Pointer<Float4>(r.data + OFFSET(DrawData,fog.scale)) + *Pointer<Float4>(r.data + OFFSET(DrawData,fog.offset));
+ o[Fog].x = f * *Pointer<Float4>(data + OFFSET(DrawData,fog.scale)) + *Pointer<Float4>(data + OFFSET(DrawData,fog.offset));
break;
case FOG_EXP:
- r.o[Fog].x = exponential2(f * *Pointer<Float4>(r.data + OFFSET(DrawData,fog.densityE)), true);
+ o[Fog].x = exponential2(f * *Pointer<Float4>(data + OFFSET(DrawData,fog.densityE)), true);
break;
case FOG_EXP2:
- r.o[Fog].x = exponential2((f * f) * *Pointer<Float4>(r.data + OFFSET(DrawData,fog.density2E)), true);
+ o[Fog].x = exponential2((f * f) * *Pointer<Float4>(data + OFFSET(DrawData,fog.density2E)), true);
break;
default:
ASSERT(false);
{
case TEXGEN_NONE:
{
- Vector4f v = r.v[TexCoord0 + i];
+ Vector4f &&varying = v[TexCoord0 + i];
- r.o[T0 + stage].x = v.x;
- r.o[T0 + stage].y = v.y;
- r.o[T0 + stage].z = v.z;
- r.o[T0 + stage].w = v.w;
+ o[T0 + stage].x = varying.x;
+ o[T0 + stage].y = varying.y;
+ o[T0 + stage].z = varying.z;
+ o[T0 + stage].w = varying.w;
}
break;
case TEXGEN_PASSTHRU:
{
- Vector4f v = r.v[TexCoord0 + i];
+ Vector4f &&varying = v[TexCoord0 + i];
- r.o[T0 + stage].x = v.x;
- r.o[T0 + stage].y = v.y;
- r.o[T0 + stage].z = v.z;
- r.o[T0 + stage].w = v.w;
+ o[T0 + stage].x = varying.x;
+ o[T0 + stage].y = varying.y;
+ o[T0 + stage].z = varying.z;
+ o[T0 + stage].w = varying.w;
if(state.input[TexCoord0 + i])
{
switch(state.input[TexCoord0 + i].count)
{
case 1:
- r.o[T0 + stage].y = Float4(1.0f);
- r.o[T0 + stage].z = Float4(0.0f);
- r.o[T0 + stage].w = Float4(0.0f);
+ o[T0 + stage].y = Float4(1.0f);
+ o[T0 + stage].z = Float4(0.0f);
+ o[T0 + stage].w = Float4(0.0f);
break;
case 2:
- r.o[T0 + stage].z = Float4(1.0f);
- r.o[T0 + stage].w = Float4(0.0f);
+ o[T0 + stage].z = Float4(1.0f);
+ o[T0 + stage].w = Float4(0.0f);
break;
case 3:
- r.o[T0 + stage].w = Float4(1.0f);
+ o[T0 + stage].w = Float4(1.0f);
break;
case 4:
break;
Nc.w = Float4(1.0f);
- r.o[T0 + stage].x = Nc.x;
- r.o[T0 + stage].y = Nc.y;
- r.o[T0 + stage].z = Nc.z;
- r.o[T0 + stage].w = Nc.w;
+ o[T0 + stage].x = Nc.x;
+ o[T0 + stage].y = Nc.y;
+ o[T0 + stage].z = Nc.z;
+ o[T0 + stage].w = Nc.w;
}
break;
case TEXGEN_POSITION:
{
- Vector4f Pn = transformBlend(r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.cameraTransformT)), true); // Position in camera space
+ Vector4f Pn = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.cameraTransformT)), true); // Position in camera space
Pn.w = Float4(1.0f);
- r.o[T0 + stage].x = Pn.x;
- r.o[T0 + stage].y = Pn.y;
- r.o[T0 + stage].z = Pn.z;
- r.o[T0 + stage].w = Pn.w;
+ o[T0 + stage].x = Pn.x;
+ o[T0 + stage].y = Pn.y;
+ o[T0 + stage].z = Pn.z;
+ o[T0 + stage].w = Pn.w;
}
break;
case TEXGEN_REFLECTION:
Vector4f Ec; // Eye vector in camera space
Vector4f N2;
- Ec = transformBlend(r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.cameraTransformT)), true);
+ Ec = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.cameraTransformT)), true);
Ec = normalize(Ec);
// R = E - 2 * N * (E . N)
R.w = Float4(1.0f);
- r.o[T0 + stage].x = R.x;
- r.o[T0 + stage].y = R.y;
- r.o[T0 + stage].z = R.z;
- r.o[T0 + stage].w = R.w;
+ o[T0 + stage].x = R.x;
+ o[T0 + stage].y = R.y;
+ o[T0 + stage].z = R.z;
+ o[T0 + stage].w = R.w;
}
break;
case TEXGEN_SPHEREMAP:
Vector4f Ec; // Eye vector in camera space
Vector4f N2;
- Ec = transformBlend(r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.cameraTransformT)), true);
+ Ec = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.cameraTransformT)), true);
Ec = normalize(Ec);
// R = E - 2 * N * (E . N)
R.z = Float4(1.0f);
R.w = Float4(0.0f);
- r.o[T0 + stage].x = R.x;
- r.o[T0 + stage].y = R.y;
- r.o[T0 + stage].z = R.z;
- r.o[T0 + stage].w = R.w;
+ o[T0 + stage].x = R.x;
+ o[T0 + stage].y = R.y;
+ o[T0 + stage].z = R.z;
+ o[T0 + stage].w = R.w;
}
break;
default:
Vector4f T;
Vector4f t;
- T.x = r.o[T0 + stage].x;
- T.y = r.o[T0 + stage].y;
- T.z = r.o[T0 + stage].z;
- T.w = r.o[T0 + stage].w;
+ T.x = o[T0 + stage].x;
+ T.y = o[T0 + stage].y;
+ T.z = o[T0 + stage].z;
+ T.w = o[T0 + stage].w;
switch(state.textureState[stage].textureTransformCountActive)
{
case 4:
- texTrans3.x = texTrans3.y = texTrans3.z = texTrans3.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.textureTransform[stage][3])); // FIXME: Unpack
+ texTrans3.x = texTrans3.y = texTrans3.z = texTrans3.w = *Pointer<Float4>(data + OFFSET(DrawData,ff.textureTransform[stage][3])); // FIXME: Unpack
texTrans3.x = texTrans3.x.xxxx;
texTrans3.y = texTrans3.y.yyyy;
texTrans3.z = texTrans3.z.zzzz;
texTrans3.w = texTrans3.w.wwww;
t.w = dot4(T, texTrans3);
case 3:
- texTrans2.x = texTrans2.y = texTrans2.z = texTrans2.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.textureTransform[stage][2])); // FIXME: Unpack
+ texTrans2.x = texTrans2.y = texTrans2.z = texTrans2.w = *Pointer<Float4>(data + OFFSET(DrawData,ff.textureTransform[stage][2])); // FIXME: Unpack
texTrans2.x = texTrans2.x.xxxx;
texTrans2.y = texTrans2.y.yyyy;
texTrans2.z = texTrans2.z.zzzz;
texTrans2.w = texTrans2.w.wwww;
t.z = dot4(T, texTrans2);
case 2:
- texTrans1.x = texTrans1.y = texTrans1.z = texTrans1.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.textureTransform[stage][1])); // FIXME: Unpack
+ texTrans1.x = texTrans1.y = texTrans1.z = texTrans1.w = *Pointer<Float4>(data + OFFSET(DrawData,ff.textureTransform[stage][1])); // FIXME: Unpack
texTrans1.x = texTrans1.x.xxxx;
texTrans1.y = texTrans1.y.yyyy;
texTrans1.z = texTrans1.z.zzzz;
texTrans1.w = texTrans1.w.wwww;
t.y = dot4(T, texTrans1);
case 1:
- texTrans0.x = texTrans0.y = texTrans0.z = texTrans0.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.textureTransform[stage][0])); // FIXME: Unpack
+ texTrans0.x = texTrans0.y = texTrans0.z = texTrans0.w = *Pointer<Float4>(data + OFFSET(DrawData,ff.textureTransform[stage][0])); // FIXME: Unpack
texTrans0.x = texTrans0.x.xxxx;
texTrans0.y = texTrans0.y.yyyy;
texTrans0.z = texTrans0.z.zzzz;
texTrans0.w = texTrans0.w.wwww;
t.x = dot4(T, texTrans0);
- r.o[T0 + stage].x = t.x;
- r.o[T0 + stage].y = t.y;
- r.o[T0 + stage].z = t.z;
- r.o[T0 + stage].w = t.w;
+ o[T0 + stage].x = t.x;
+ o[T0 + stage].y = t.y;
+ o[T0 + stage].z = t.z;
+ o[T0 + stage].w = t.w;
case 0:
break;
default:
if(state.input[PointSize])
{
- r.o[Pts].y = r.v[PointSize].x;
+ o[Pts].y = v[PointSize].x;
}
else
{
- r.o[Pts].y = *Pointer<Float4>(r.data + OFFSET(DrawData,point.pointSize));
+ o[Pts].y = *Pointer<Float4>(data + OFFSET(DrawData,point.pointSize));
}
if(state.pointScaleActive && !state.preTransformed)
{
- Vector4f p = transformBlend(r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.cameraTransformT)), true);
+ Vector4f p = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.cameraTransformT)), true);
Float4 d = Sqrt(dot3(p, p)); // FIXME: length(p);
- Float4 A = *Pointer<Float>(r.data + OFFSET(DrawData,point.pointScaleA)); // FIXME: Unpack
- Float4 B = *Pointer<Float>(r.data + OFFSET(DrawData,point.pointScaleB)); // FIXME: Unpack
- Float4 C = *Pointer<Float>(r.data + OFFSET(DrawData,point.pointScaleC)); // FIXME: Unpack
+ Float4 A = *Pointer<Float>(data + OFFSET(DrawData,point.pointScaleA)); // FIXME: Unpack
+ Float4 B = *Pointer<Float>(data + OFFSET(DrawData,point.pointScaleB)); // FIXME: Unpack
+ Float4 C = *Pointer<Float>(data + OFFSET(DrawData,point.pointScaleC)); // FIXME: Unpack
A = RcpSqrt_pp(A + d * (B + d * C));
- r.o[Pts].y = r.o[Pts].y * Float4(*Pointer<Float>(r.data + OFFSET(DrawData,viewportHeight))) * A; // FIXME: Unpack
+ o[Pts].y = o[Pts].y * Float4(*Pointer<Float>(data + OFFSET(DrawData,viewportHeight))) * A; // FIXME: Unpack
}
}
namespace sw
{
- VertexProgram::VertexProgram(const VertexProcessor::State &state, const VertexShader *shader) : VertexRoutine(state, shader)
+ VertexProgram::VertexProgram(const VertexProcessor::State &state, const VertexShader *shader)
+ : VertexRoutine(state, shader), shader(shader), r(shader->dynamicallyIndexedTemporaries)
{
ifDepth = 0;
loopRepDepth = 0;
{
labelBlock[i] = 0;
}
+
+ loopDepth = -1;
+ enableStack[0] = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+
+ if(shader && shader->containsBreakInstruction())
+ {
+ enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ }
+
+ if(shader && shader->containsContinueInstruction())
+ {
+ enableContinue = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ }
+
+ if(shader->instanceIdDeclared)
+ {
+ instanceID = *Pointer<Int>(data + OFFSET(DrawData,instanceID));
+ }
}
VertexProgram::~VertexProgram()
{
for(int i = 0; i < VERTEX_TEXTURE_IMAGE_UNITS; i++)
{
- sampler[i] = new SamplerCore(r.constants, state.samplerState[i]);
+ sampler[i] = new SamplerCore(constants, state.samplerState[i]);
}
if(!state.preTransformed)
unsigned short version = shader->getVersion();
- r.enableIndex = 0;
- r.stackIndex = 0;
+ enableIndex = 0;
+ stackIndex = 0;
if(shader->containsLeaveInstruction())
{
- r.enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
}
// Create all call site return blocks up front
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(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_ADDR: pDst = r.a0; break;
+ case Shader::PARAMETER_ADDR: pDst = a0; break;
case Shader::PARAMETER_RASTOUT:
switch(dst.index)
{
case 0:
- if(dst.x) pDst.x = r.o[Pos].x;
- if(dst.y) pDst.y = r.o[Pos].y;
- if(dst.z) pDst.z = r.o[Pos].z;
- if(dst.w) pDst.w = r.o[Pos].w;
+ if(dst.x) pDst.x = o[Pos].x;
+ if(dst.y) pDst.y = o[Pos].y;
+ if(dst.z) pDst.z = o[Pos].z;
+ if(dst.w) pDst.w = o[Pos].w;
break;
case 1:
- pDst.x = r.o[Fog].x;
+ pDst.x = o[Fog].x;
break;
case 2:
- pDst.x = r.o[Pts].y;
+ pDst.x = o[Pts].y;
break;
default:
ASSERT(false);
}
break;
case Shader::PARAMETER_ATTROUT:
- if(dst.x) pDst.x = r.o[D0 + dst.index].x;
- if(dst.y) pDst.y = r.o[D0 + dst.index].y;
- if(dst.z) pDst.z = r.o[D0 + dst.index].z;
- if(dst.w) pDst.w = r.o[D0 + dst.index].w;
+ if(dst.x) pDst.x = o[D0 + dst.index].x;
+ if(dst.y) pDst.y = o[D0 + dst.index].y;
+ if(dst.z) pDst.z = o[D0 + dst.index].z;
+ if(dst.w) pDst.w = o[D0 + dst.index].w;
break;
case Shader::PARAMETER_TEXCRDOUT:
// case Shader::PARAMETER_OUTPUT:
if(version < 0x0300)
{
- if(dst.x) pDst.x = r.o[T0 + dst.index].x;
- if(dst.y) pDst.y = r.o[T0 + dst.index].y;
- if(dst.z) pDst.z = r.o[T0 + dst.index].z;
- if(dst.w) pDst.w = r.o[T0 + dst.index].w;
+ if(dst.x) pDst.x = o[T0 + dst.index].x;
+ if(dst.y) pDst.y = o[T0 + dst.index].y;
+ if(dst.z) pDst.z = o[T0 + dst.index].z;
+ if(dst.w) pDst.w = o[T0 + dst.index].w;
}
else
{
if(dst.rel.type == Shader::PARAMETER_VOID) // Not relative
{
- if(dst.x) pDst.x = r.o[dst.index].x;
- if(dst.y) pDst.y = r.o[dst.index].y;
- if(dst.z) pDst.z = r.o[dst.index].z;
- if(dst.w) pDst.w = r.o[dst.index].w;
+ if(dst.x) pDst.x = o[dst.index].x;
+ if(dst.y) pDst.y = o[dst.index].y;
+ if(dst.z) pDst.z = o[dst.index].z;
+ if(dst.w) pDst.w = o[dst.index].w;
}
else
{
Int a = relativeAddress(dst);
- if(dst.x) pDst.x = r.o[dst.index + a].x;
- if(dst.y) pDst.y = r.o[dst.index + a].y;
- if(dst.z) pDst.z = r.o[dst.index + a].z;
- if(dst.w) pDst.w = r.o[dst.index + a].w;
+ if(dst.x) pDst.x = o[dst.index + a].x;
+ if(dst.y) pDst.y = o[dst.index + a].y;
+ if(dst.z) pDst.z = o[dst.index + a].z;
+ if(dst.w) pDst.w = o[dst.index + a].w;
}
}
break;
- case Shader::PARAMETER_LABEL: break;
- case Shader::PARAMETER_PREDICATE: pDst = r.p0; break;
- case Shader::PARAMETER_INPUT: break;
+ case Shader::PARAMETER_LABEL: break;
+ case Shader::PARAMETER_PREDICATE: pDst = p0; break;
+ case Shader::PARAMETER_INPUT: break;
default:
ASSERT(false);
}
{
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(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_ADDR:
- if(dst.x) r.a0.x = d.x;
- if(dst.y) r.a0.y = d.y;
- if(dst.z) r.a0.z = d.z;
- if(dst.w) r.a0.w = d.w;
+ if(dst.x) a0.x = d.x;
+ if(dst.y) a0.y = d.y;
+ if(dst.z) a0.z = d.z;
+ if(dst.w) a0.w = d.w;
break;
case Shader::PARAMETER_RASTOUT:
switch(dst.index)
{
case 0:
- if(dst.x) r.o[Pos].x = d.x;
- if(dst.y) r.o[Pos].y = d.y;
- if(dst.z) r.o[Pos].z = d.z;
- if(dst.w) r.o[Pos].w = d.w;
+ if(dst.x) o[Pos].x = d.x;
+ if(dst.y) o[Pos].y = d.y;
+ if(dst.z) o[Pos].z = d.z;
+ if(dst.w) o[Pos].w = d.w;
break;
case 1:
- r.o[Fog].x = d.x;
+ o[Fog].x = d.x;
break;
case 2:
- r.o[Pts].y = d.x;
+ o[Pts].y = d.x;
break;
default: ASSERT(false);
}
break;
case Shader::PARAMETER_ATTROUT:
- if(dst.x) r.o[D0 + dst.index].x = d.x;
- if(dst.y) r.o[D0 + dst.index].y = d.y;
- if(dst.z) r.o[D0 + dst.index].z = d.z;
- if(dst.w) r.o[D0 + dst.index].w = d.w;
+ if(dst.x) o[D0 + dst.index].x = d.x;
+ if(dst.y) o[D0 + dst.index].y = d.y;
+ if(dst.z) o[D0 + dst.index].z = d.z;
+ if(dst.w) o[D0 + dst.index].w = d.w;
break;
case Shader::PARAMETER_TEXCRDOUT:
// case Shader::PARAMETER_OUTPUT:
if(version < 0x0300)
{
- if(dst.x) r.o[T0 + dst.index].x = d.x;
- if(dst.y) r.o[T0 + dst.index].y = d.y;
- if(dst.z) r.o[T0 + dst.index].z = d.z;
- if(dst.w) r.o[T0 + dst.index].w = d.w;
+ if(dst.x) o[T0 + dst.index].x = d.x;
+ if(dst.y) o[T0 + dst.index].y = d.y;
+ if(dst.z) o[T0 + dst.index].z = d.z;
+ if(dst.w) o[T0 + dst.index].w = d.w;
}
else
{
if(dst.rel.type == Shader::PARAMETER_VOID) // Not relative
{
- if(dst.x) r.o[dst.index].x = d.x;
- if(dst.y) r.o[dst.index].y = d.y;
- if(dst.z) r.o[dst.index].z = d.z;
- if(dst.w) r.o[dst.index].w = d.w;
+ if(dst.x) o[dst.index].x = d.x;
+ if(dst.y) o[dst.index].y = d.y;
+ if(dst.z) o[dst.index].z = d.z;
+ if(dst.w) o[dst.index].w = d.w;
}
else
{
Int a = relativeAddress(dst);
- if(dst.x) r.o[dst.index + a].x = d.x;
- if(dst.y) r.o[dst.index + a].y = d.y;
- if(dst.z) r.o[dst.index + a].z = d.z;
- if(dst.w) r.o[dst.index + a].w = d.w;
+ if(dst.x) o[dst.index + a].x = d.x;
+ if(dst.y) o[dst.index + a].y = d.y;
+ if(dst.z) o[dst.index + a].z = d.z;
+ if(dst.w) o[dst.index + a].w = d.w;
}
}
break;
- case Shader::PARAMETER_LABEL: break;
- case Shader::PARAMETER_PREDICATE: r.p0 = d; break;
- case Shader::PARAMETER_INPUT: break;
+ case Shader::PARAMETER_LABEL: break;
+ case Shader::PARAMETER_PREDICATE: p0 = d; break;
+ case Shader::PARAMETER_INPUT: break;
default:
ASSERT(false);
}
case 0xFF:
continue;
case Shader::USAGE_PSIZE:
- r.o[i].y = r.v[i].x;
+ o[i].y = v[i].x;
break;
case Shader::USAGE_TEXCOORD:
- r.o[i].x = r.v[i].x;
- r.o[i].y = r.v[i].y;
- r.o[i].z = r.v[i].z;
- r.o[i].w = r.v[i].w;
+ o[i].x = v[i].x;
+ o[i].y = v[i].y;
+ o[i].z = v[i].z;
+ o[i].w = v[i].w;
break;
case Shader::USAGE_POSITION:
- r.o[i].x = r.v[i].x;
- r.o[i].y = r.v[i].y;
- r.o[i].z = r.v[i].z;
- r.o[i].w = r.v[i].w;
+ o[i].x = v[i].x;
+ o[i].y = v[i].y;
+ o[i].z = v[i].z;
+ o[i].w = v[i].w;
break;
case Shader::USAGE_COLOR:
- r.o[i].x = r.v[i].x;
- r.o[i].y = r.v[i].y;
- r.o[i].z = r.v[i].z;
- r.o[i].w = r.v[i].w;
+ o[i].x = v[i].x;
+ o[i].y = v[i].y;
+ o[i].z = v[i].z;
+ o[i].w = v[i].w;
break;
case Shader::USAGE_FOG:
- r.o[i].x = r.v[i].x;
+ o[i].x = v[i].x;
break;
default:
ASSERT(false);
}
else
{
- r.o[Pos].x = r.v[PositionT].x;
- r.o[Pos].y = r.v[PositionT].y;
- r.o[Pos].z = r.v[PositionT].z;
- r.o[Pos].w = r.v[PositionT].w;
+ o[Pos].x = v[PositionT].x;
+ o[Pos].y = v[PositionT].y;
+ o[Pos].z = v[PositionT].z;
+ o[Pos].w = v[PositionT].w;
for(int i = 0; i < 2; i++)
{
- r.o[D0 + i].x = r.v[Color0 + i].x;
- r.o[D0 + i].y = r.v[Color0 + i].y;
- r.o[D0 + i].z = r.v[Color0 + i].z;
- r.o[D0 + i].w = r.v[Color0 + i].w;
+ o[D0 + i].x = v[Color0 + i].x;
+ o[D0 + i].y = v[Color0 + i].y;
+ o[D0 + i].z = v[Color0 + i].z;
+ o[D0 + i].w = v[Color0 + i].w;
}
for(int i = 0; i < 8; i++)
{
- r.o[T0 + i].x = r.v[TexCoord0 + i].x;
- r.o[T0 + i].y = r.v[TexCoord0 + i].y;
- r.o[T0 + i].z = r.v[TexCoord0 + i].z;
- r.o[T0 + i].w = r.v[TexCoord0 + i].w;
+ o[T0 + i].x = v[TexCoord0 + i].x;
+ o[T0 + i].y = v[TexCoord0 + i].y;
+ o[T0 + i].z = v[TexCoord0 + i].z;
+ o[T0 + i].w = v[TexCoord0 + i].w;
}
- r.o[Pts].y = r.v[PointSize].x;
+ o[Pts].y = v[PointSize].x;
}
}
case Shader::PARAMETER_TEMP:
if(src.rel.type == Shader::PARAMETER_VOID)
{
- reg = r.r[i];
+ reg = r[i];
}
else
{
- reg = r.r[i + relativeAddress(src)];
+ reg = r[i + relativeAddress(src)];
}
break;
case Shader::PARAMETER_CONST:
case Shader::PARAMETER_INPUT:
if(src.rel.type == Shader::PARAMETER_VOID)
{
- reg = r.v[i];
+ reg = v[i];
}
else
{
- reg = r.v[i + relativeAddress(src)];
+ reg = v[i + relativeAddress(src)];
}
break;
- case Shader::PARAMETER_VOID: return r.r[0]; // Dummy
+ case Shader::PARAMETER_VOID: return r[0]; // Dummy
case Shader::PARAMETER_FLOAT4LITERAL:
reg.x = Float4(src.value[0]);
reg.y = Float4(src.value[1]);
reg.z = Float4(src.value[2]);
reg.w = Float4(src.value[3]);
break;
- case Shader::PARAMETER_ADDR: reg = r.a0; break;
- case Shader::PARAMETER_CONSTBOOL: return r.r[0]; // Dummy
- case Shader::PARAMETER_CONSTINT: return r.r[0]; // Dummy
- case Shader::PARAMETER_LOOP: return r.r[0]; // Dummy
- case Shader::PARAMETER_PREDICATE: return r.r[0]; // Dummy
+ case Shader::PARAMETER_ADDR: reg = a0; break;
+ case Shader::PARAMETER_CONSTBOOL: return r[0]; // Dummy
+ case Shader::PARAMETER_CONSTINT: return r[0]; // Dummy
+ case Shader::PARAMETER_LOOP: return r[0]; // Dummy
+ case Shader::PARAMETER_PREDICATE: return r[0]; // Dummy
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_OUTPUT:
if(src.rel.type == Shader::PARAMETER_VOID)
{
- reg = r.o[i];
+ reg = o[i];
}
else
{
- reg = r.o[i + relativeAddress(src)];
+ reg = o[i + relativeAddress(src)];
}
break;
case Shader::PARAMETER_MISCTYPE:
- reg.x = As<Float>(Int(r.instanceID));
+ reg.x = As<Float>(Int(instanceID));
return reg;
default:
ASSERT(false);
if(src.rel.type == Shader::PARAMETER_VOID) // Not relative
{
- c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c[i]));
+ c.x = c.y = c.z = c.w = *Pointer<Float4>(data + OFFSET(DrawData,vs.c[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,vs.c[i]) + loopCounter * 16);
+ c.x = c.y = c.z = c.w = *Pointer<Float4>(data + OFFSET(DrawData,vs.c[i]) + loopCounter * 16);
c.x = c.x.xxxx;
c.y = c.y.yyyy;
{
Int a = relativeAddress(src);
- c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c[i]) + a * 16);
+ c.x = c.y = c.z = c.w = *Pointer<Float4>(data + OFFSET(DrawData,vs.c[i]) + a * 16);
c.x = c.x.xxxx;
c.y = c.y.yyyy;
switch(src.rel.type)
{
- case Shader::PARAMETER_ADDR: a = r.a0[component]; break;
- case Shader::PARAMETER_TEMP: a = r.r[src.rel.index][component]; break;
- case Shader::PARAMETER_INPUT: a = r.v[src.rel.index][component]; break;
- case Shader::PARAMETER_OUTPUT: a = r.o[src.rel.index][component]; break;
- case Shader::PARAMETER_CONST: a = *Pointer<Float>(r.data + OFFSET(DrawData,vs.c[src.rel.index][component])); break;
+ case Shader::PARAMETER_ADDR: a = a0[component]; break;
+ case Shader::PARAMETER_TEMP: a = r[src.rel.index][component]; break;
+ case Shader::PARAMETER_INPUT: a = v[src.rel.index][component]; break;
+ case Shader::PARAMETER_OUTPUT: a = o[src.rel.index][component]; break;
+ case Shader::PARAMETER_CONST: a = *Pointer<Float>(data + OFFSET(DrawData,vs.c[src.rel.index][component])); break;
default: ASSERT(false);
}
Int index2 = Extract(index, 2);
Int index3 = Extract(index, 3);
- c.x = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c) + index0 * 16, 16);
- c.y = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c) + index1 * 16, 16);
- c.z = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c) + index2 * 16, 16);
- c.w = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c) + index3 * 16, 16);
+ c.x = *Pointer<Float4>(data + OFFSET(DrawData,vs.c) + index0 * 16, 16);
+ c.y = *Pointer<Float4>(data + OFFSET(DrawData,vs.c) + index1 * 16, 16);
+ c.z = *Pointer<Float4>(data + OFFSET(DrawData,vs.c) + index2 * 16, 16);
+ c.w = *Pointer<Float4>(data + OFFSET(DrawData,vs.c) + index3 * 16, 16);
transpose4x4(c.x, c.y, c.z, c.w);
}
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.o[var.rel.index].x, 0)) * var.rel.scale;
+ return As<Int>(Extract(o[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, vs.c[var.rel.index]));
+ RValue<Int4> c = *Pointer<Int4>(data + OFFSET(DrawData, vs.c[var.rel.index]));
return Extract(c, 0) * var.rel.scale;
}
else if(var.rel.type == Shader::PARAMETER_LOOP)
{
- return r.aL[r.loopDepth];
+ return aL[loopDepth];
}
else ASSERT(false);
Int4 VertexProgram::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;
}
}
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 VertexProgram::BREAKC(Vector4f &src0, Vector4f &src1, Control control)
void VertexProgram::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)
{
void VertexProgram::BREAK(Int4 &condition)
{
- condition &= r.enableStack[r.enableIndex];
+ condition &= enableStack[enableIndex];
llvm::BasicBlock *continueBlock = Nucleus::createBasicBlock();
llvm::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 VertexProgram::CONTINUE()
{
- r.enableContinue = r.enableContinue & ~r.enableStack[r.enableIndex];
+ enableContinue = enableContinue & ~enableStack[enableIndex];
}
void VertexProgram::TEST()
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 VertexProgram::CALLNZ(int labelIndex, int callSiteIndex, const Src &src)
void VertexProgram::CALLNZb(int labelIndex, int callSiteIndex, const Src &boolRegister)
{
- Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData,vs.b[boolRegister.index])) != Byte(0)); // FIXME
+ Bool condition = (*Pointer<Byte>(data + OFFSET(DrawData,vs.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 VertexProgram::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 VertexProgram::ELSE()
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
{
if(isConditionalIf[ifDepth])
{
breakDepth--;
- r.enableIndex--;
+ enableIndex--;
}
}
{
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];
Nucleus::createBr(testBlock);
Nucleus::setInsertBlock(endBlock);
- r.loopDepth--;
- r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ loopDepth--;
+ enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
}
void VertexProgram::ENDREP()
Nucleus::createBr(testBlock);
Nucleus::setInsertBlock(endBlock);
- r.loopDepth--;
- r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ loopDepth--;
+ enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
}
void VertexProgram::ENDWHILE()
Nucleus::createBr(testBlock);
Nucleus::setInsertBlock(endBlock);
- r.enableIndex--;
- r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ enableIndex--;
+ enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
whileTest = false;
}
{
ASSERT(ifDepth < 24 + 4);
- Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData,vs.b[boolRegister.index])) != Byte(0)); // FIXME
+ Bool condition = (*Pointer<Byte>(data + OFFSET(DrawData,vs.b[boolRegister.index])) != Byte(0)); // FIXME
if(boolRegister.modifier == Shader::MODIFIER_NOT)
{
void VertexProgram::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)
{
void VertexProgram::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();
void VertexProgram::LOOP(const Src &integerRegister)
{
- r.loopDepth++;
+ loopDepth++;
- r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,vs.i[integerRegister.index][0]));
- r.aL[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,vs.i[integerRegister.index][1]));
- r.increment[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,vs.i[integerRegister.index][2]));
+ iteration[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][0]));
+ aL[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][1]));
+ increment[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][2]));
// FIXME: Compiles to two instructions?
- If(r.increment[r.loopDepth] == 0)
+ If(increment[loopDepth] == 0)
{
- r.increment[r.loopDepth] = 1;
+ increment[loopDepth] = 1;
}
llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
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 VertexProgram::REP(const Src &integerRegister)
{
- r.loopDepth++;
+ loopDepth++;
- r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,vs.i[integerRegister.index][0]));
- r.aL[r.loopDepth] = r.aL[r.loopDepth - 1];
+ iteration[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][0]));
+ aL[loopDepth] = aL[loopDepth - 1];
llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
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 VertexProgram::WHILE(const Src &temporaryRegister)
{
- r.enableIndex++;
+ enableIndex++;
llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
llvm::BasicBlock *testBlock = 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(temporaryRegister);
Int4 condition = As<Int4>(src.x);
- condition &= r.enableStack[r.enableIndex - 1];
- r.enableStack[r.enableIndex] = condition;
+ condition &= enableStack[enableIndex - 1];
+ enableStack[enableIndex] = condition;
Bool notAllFalse = SignMask(condition) != 0;
branch(notAllFalse, loopBlock, endBlock);
Nucleus::setInsertBlock(endBlock);
- r.enableBreak = restoreBreak;
+ enableBreak = restoreBreak;
Nucleus::setInsertBlock(loopBlock);
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());
void VertexProgram::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
void VertexProgram::TEXSIZE(Vector4f &dst, Float4 &lod, const Src &src1)
{
- Pointer<Byte> textureMipmap = r.data + OFFSET(DrawData, mipmap[16]) + src1.index * sizeof(Texture) + OFFSET(Texture, mipmap);
+ Pointer<Byte> textureMipmap = data + OFFSET(DrawData, mipmap[16]) + 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);
{
if(s.type == Shader::PARAMETER_SAMPLER && s.rel.type == Shader::PARAMETER_VOID)
{
- Pointer<Byte> texture = r.data + OFFSET(DrawData,mipmap[16]) + s.index * sizeof(Texture);
- sampler[s.index]->sampleTexture(texture, c, u, v, w, q, r.a0, r.a0, false, false, true);
+ Pointer<Byte> texture = data + OFFSET(DrawData,mipmap[16]) + s.index * sizeof(Texture);
+ sampler[s.index]->sampleTexture(texture, c, u, v, w, q, a0, a0, false, false, true);
}
else
{
{
If(index == i)
{
- Pointer<Byte> texture = r.data + OFFSET(DrawData,mipmap[16]) + i * sizeof(Texture);
- sampler[i]->sampleTexture(texture, c, u, v, w, q, r.a0, r.a0, false, false, true);
+ Pointer<Byte> texture = data + OFFSET(DrawData,mipmap[16]) + i * sizeof(Texture);
+ sampler[i]->sampleTexture(texture, c, u, v, w, q, a0, a0, false, false, true);
// FIXME: When the sampler states are the same, we could use one sampler and just index the texture
}
}
virtual ~VertexProgram();
private:
+ const VertexShader *const shader;
+
+ RegisterArray<4096> r; // Temporary registers
+ Vector4f a0;
+ Array<Int, 4> aL;
+ Vector4f p0;
+
+ Array<Int, 4> increment;
+ Array<Int, 4> iteration;
+
+ Int loopDepth;
+ Int stackIndex; // FIXME: Inc/decrement callStack
+ Array<UInt, 16> callStack;
+
+ Int enableIndex;
+ Array<Int4, 1 + 24> enableStack;
+ Int4 enableBreak;
+ Int4 enableContinue;
+ Int4 enableLeave;
+
+ Int instanceID;
+
typedef Shader::DestinationParameter Dst;
typedef Shader::SourceParameter Src;
typedef Shader::Control Control;
extern bool halfIntegerCoordinates; // Pixel centers are not at integer coordinates
extern bool symmetricNormalizedDepth; // [-1, 1] instead of [0, 1]
- VertexRoutine::VertexRoutine(const VertexProcessor::State &state, const VertexShader *shader) : r(shader), state(state), shader(shader)
+ VertexRoutine::VertexRoutine(const VertexProcessor::State &state, const VertexShader *shader)
+ : v(shader && shader->dynamicallyIndexedInput),
+ o(shader && shader->dynamicallyIndexedOutput),
+ state(state)
{
}
UInt vertexCount = *Pointer<UInt>(task + OFFSET(VertexTask,vertexCount));
- r.data = data;
- r.constants = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,constants));
- if(shader && shader->instanceIdDeclared)
- {
- r.instanceID = *Pointer<Int>(data + OFFSET(DrawData, instanceID));
- }
+ constants = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,constants));
Do
{
{
for(int i = 0; i < VERTEX_ATTRIBUTES; i++)
{
- Pointer<Byte> input = *Pointer<Pointer<Byte>>(r.data + OFFSET(DrawData,input) + sizeof(void*) * i);
- UInt stride = *Pointer<UInt>(r.data + OFFSET(DrawData,stride) + sizeof(unsigned int) * i);
+ Pointer<Byte> input = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,input) + sizeof(void*) * i);
+ UInt stride = *Pointer<UInt>(data + OFFSET(DrawData,stride) + sizeof(unsigned int) * i);
- r.v[i] = readStream(input, stride, state.input[i], index);
+ v[i] = readStream(input, stride, state.input[i], index);
}
}
{
int pos = state.positionRegister;
- Int4 maxX = CmpLT(r.o[pos].w, r.o[pos].x);
- Int4 maxY = CmpLT(r.o[pos].w, r.o[pos].y);
- Int4 maxZ = CmpLT(r.o[pos].w, r.o[pos].z);
+ Int4 maxX = CmpLT(o[pos].w, o[pos].x);
+ Int4 maxY = CmpLT(o[pos].w, o[pos].y);
+ Int4 maxZ = CmpLT(o[pos].w, o[pos].z);
- Int4 minX = CmpNLE(-r.o[pos].w, r.o[pos].x);
- Int4 minY = CmpNLE(-r.o[pos].w, r.o[pos].y);
- Int4 minZ = CmpNLE(Float4(0.0f), r.o[pos].z);
+ Int4 minX = CmpNLE(-o[pos].w, o[pos].x);
+ Int4 minY = CmpNLE(-o[pos].w, o[pos].y);
+ Int4 minZ = CmpNLE(Float4(0.0f), o[pos].z);
Int flags;
flags = SignMask(maxX);
- r.clipFlags = *Pointer<Int>(r.constants + OFFSET(Constants,maxX) + flags * 4); // FIXME: Array indexing
+ clipFlags = *Pointer<Int>(constants + OFFSET(Constants,maxX) + flags * 4); // FIXME: Array indexing
flags = SignMask(maxY);
- r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,maxY) + flags * 4);
+ clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,maxY) + flags * 4);
flags = SignMask(maxZ);
- r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,maxZ) + flags * 4);
+ clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,maxZ) + flags * 4);
flags = SignMask(minX);
- r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,minX) + flags * 4);
+ clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,minX) + flags * 4);
flags = SignMask(minY);
- r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,minY) + flags * 4);
+ clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,minY) + flags * 4);
flags = SignMask(minZ);
- r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,minZ) + flags * 4);
+ clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,minZ) + flags * 4);
- Int4 finiteX = CmpLE(Abs(r.o[pos].x), *Pointer<Float4>(r.constants + OFFSET(Constants,maxPos)));
- Int4 finiteY = CmpLE(Abs(r.o[pos].y), *Pointer<Float4>(r.constants + OFFSET(Constants,maxPos)));
- Int4 finiteZ = CmpLE(Abs(r.o[pos].z), *Pointer<Float4>(r.constants + OFFSET(Constants,maxPos)));
+ Int4 finiteX = CmpLE(Abs(o[pos].x), *Pointer<Float4>(constants + OFFSET(Constants,maxPos)));
+ Int4 finiteY = CmpLE(Abs(o[pos].y), *Pointer<Float4>(constants + OFFSET(Constants,maxPos)));
+ Int4 finiteZ = CmpLE(Abs(o[pos].z), *Pointer<Float4>(constants + OFFSET(Constants,maxPos)));
flags = SignMask(finiteX & finiteY & finiteZ);
- r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,fini) + flags * 4);
+ clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,fini) + flags * 4);
if(state.preTransformed)
{
- r.clipFlags &= 0xFBFBFBFB; // Don't clip against far clip plane
+ clipFlags &= 0xFBFBFBFB; // Don't clip against far clip plane
}
}
if(stream.normalized)
{
- if(stream.count >= 1) v.x *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
- if(stream.count >= 2) v.y *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
- if(stream.count >= 3) v.z *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
- if(stream.count >= 4) v.w *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
+ if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+ if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+ if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+ if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
}
}
break;
if(stream.normalized)
{
- if(stream.count >= 1) v.x *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleSByte));
- if(stream.count >= 2) v.y *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleSByte));
- if(stream.count >= 3) v.z *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleSByte));
- if(stream.count >= 4) v.w *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleSByte));
+ if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
+ if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
+ if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
+ if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
}
}
break;
case STREAMTYPE_COLOR:
{
- v.x = Float4(*Pointer<Byte4>(source0)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
- v.y = Float4(*Pointer<Byte4>(source1)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
- v.z = Float4(*Pointer<Byte4>(source2)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
- v.w = Float4(*Pointer<Byte4>(source3)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
+ v.x = Float4(*Pointer<Byte4>(source0)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+ v.y = Float4(*Pointer<Byte4>(source1)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+ v.z = Float4(*Pointer<Byte4>(source2)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+ v.w = Float4(*Pointer<Byte4>(source3)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
transpose4x4(v.x, v.y, v.z, v.w);
if(stream.normalized)
{
- if(stream.count >= 1) v.x *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleShort));
- if(stream.count >= 2) v.y *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleShort));
- if(stream.count >= 3) v.z *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleShort));
- if(stream.count >= 4) v.w *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleShort));
+ if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
+ if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
+ if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
+ if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
}
}
break;
if(stream.normalized)
{
- if(stream.count >= 1) v.x *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleUShort));
- if(stream.count >= 2) v.y *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleUShort));
- if(stream.count >= 3) v.z *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleUShort));
- if(stream.count >= 4) v.w *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleUShort));
+ if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
+ if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
+ if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
+ if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
}
}
break;
break;
case STREAMTYPE_FIXED:
{
- v.x = Float4(*Pointer<Int4>(source0)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleFixed));
- v.y = Float4(*Pointer<Int4>(source1)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleFixed));
- v.z = Float4(*Pointer<Int4>(source2)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleFixed));
- v.w = Float4(*Pointer<Int4>(source3)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleFixed));
+ v.x = Float4(*Pointer<Int4>(source0)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
+ v.y = Float4(*Pointer<Int4>(source1)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
+ v.z = Float4(*Pointer<Int4>(source2)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
+ v.w = Float4(*Pointer<Int4>(source3)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
transpose4xN(v.x, v.y, v.z, v.w, stream.count);
}
UShort x2 = *Pointer<UShort>(source2 + 0);
UShort x3 = *Pointer<UShort>(source3 + 0);
- v.x.x = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(x0) * 4);
- v.x.y = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(x1) * 4);
- v.x.z = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(x2) * 4);
- v.x.w = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(x3) * 4);
+ v.x.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x0) * 4);
+ v.x.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x1) * 4);
+ v.x.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x2) * 4);
+ v.x.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x3) * 4);
}
if(stream.count >= 2)
UShort y2 = *Pointer<UShort>(source2 + 2);
UShort y3 = *Pointer<UShort>(source3 + 2);
- v.y.x = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(y0) * 4);
- v.y.y = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(y1) * 4);
- v.y.z = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(y2) * 4);
- v.y.w = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(y3) * 4);
+ v.y.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y0) * 4);
+ v.y.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y1) * 4);
+ v.y.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y2) * 4);
+ v.y.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y3) * 4);
}
if(stream.count >= 3)
UShort z2 = *Pointer<UShort>(source2 + 4);
UShort z3 = *Pointer<UShort>(source3 + 4);
- v.z.x = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(z0) * 4);
- v.z.y = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(z1) * 4);
- v.z.z = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(z2) * 4);
- v.z.w = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(z3) * 4);
+ v.z.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z0) * 4);
+ v.z.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z1) * 4);
+ v.z.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z2) * 4);
+ v.z.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z3) * 4);
}
if(stream.count >= 4)
UShort w2 = *Pointer<UShort>(source2 + 6);
UShort w3 = *Pointer<UShort>(source3 + 6);
- v.w.x = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(w0) * 4);
- v.w.y = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(w1) * 4);
- v.w.z = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(w2) * 4);
- v.w.w = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(w3) * 4);
+ v.w.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w0) * 4);
+ v.w.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w1) * 4);
+ v.w.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w2) * 4);
+ v.w.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w3) * 4);
}
}
break;
// Backtransform
if(state.preTransformed)
{
- Float4 rhw = Float4(1.0f) / r.o[pos].w;
+ Float4 rhw = Float4(1.0f) / o[pos].w;
- Float4 W = *Pointer<Float4>(r.data + OFFSET(DrawData,Wx16)) * Float4(1.0f / 16.0f);
- Float4 H = *Pointer<Float4>(r.data + OFFSET(DrawData,Hx16)) * Float4(1.0f / 16.0f);
- Float4 L = *Pointer<Float4>(r.data + OFFSET(DrawData,X0x16)) * Float4(1.0f / 16.0f);
- Float4 T = *Pointer<Float4>(r.data + OFFSET(DrawData,Y0x16)) * Float4(1.0f / 16.0f);
+ Float4 W = *Pointer<Float4>(data + OFFSET(DrawData,Wx16)) * Float4(1.0f / 16.0f);
+ Float4 H = *Pointer<Float4>(data + OFFSET(DrawData,Hx16)) * Float4(1.0f / 16.0f);
+ Float4 L = *Pointer<Float4>(data + OFFSET(DrawData,X0x16)) * Float4(1.0f / 16.0f);
+ Float4 T = *Pointer<Float4>(data + OFFSET(DrawData,Y0x16)) * Float4(1.0f / 16.0f);
- r.o[pos].x = (r.o[pos].x - L) / W * rhw;
- r.o[pos].y = (r.o[pos].y - T) / H * rhw;
- r.o[pos].z = r.o[pos].z * rhw;
- r.o[pos].w = rhw;
+ o[pos].x = (o[pos].x - L) / W * rhw;
+ o[pos].y = (o[pos].y - T) / H * rhw;
+ o[pos].z = o[pos].z * rhw;
+ o[pos].w = rhw;
}
if(!halfIntegerCoordinates && !state.preTransformed)
{
- r.o[pos].x = r.o[pos].x + *Pointer<Float4>(r.data + OFFSET(DrawData,halfPixelX)) * r.o[pos].w;
- r.o[pos].y = r.o[pos].y + *Pointer<Float4>(r.data + OFFSET(DrawData,halfPixelY)) * r.o[pos].w;
+ o[pos].x = o[pos].x + *Pointer<Float4>(data + OFFSET(DrawData,halfPixelX)) * o[pos].w;
+ o[pos].y = o[pos].y + *Pointer<Float4>(data + OFFSET(DrawData,halfPixelY)) * o[pos].w;
}
if(state.superSampling)
{
- r.o[pos].x = r.o[pos].x + *Pointer<Float4>(r.data + OFFSET(DrawData,XXXX)) * r.o[pos].w;
- r.o[pos].y = r.o[pos].y + *Pointer<Float4>(r.data + OFFSET(DrawData,YYYY)) * r.o[pos].w;
+ o[pos].x = o[pos].x + *Pointer<Float4>(data + OFFSET(DrawData,XXXX)) * o[pos].w;
+ o[pos].y = o[pos].y + *Pointer<Float4>(data + OFFSET(DrawData,YYYY)) * o[pos].w;
}
if(symmetricNormalizedDepth && !state.fixedFunction)
{
- r.o[pos].z = (r.o[pos].z + r.o[pos].w) * Float4(0.5f);
+ o[pos].z = (o[pos].z + o[pos].w) * Float4(0.5f);
}
}
{
if(state.output[i].write)
{
- v.x = r.o[i].x;
- v.y = r.o[i].y;
- v.z = r.o[i].z;
- v.w = r.o[i].w;
+ v.x = o[i].x;
+ v.y = o[i].y;
+ v.z = o[i].z;
+ v.w = o[i].w;
if(state.output[i].xClamp)
{
}
}
- *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 0) = (r.clipFlags >> 0) & 0x0000000FF; // FIXME: unsigned char Vertex::clipFlags
- *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 1) = (r.clipFlags >> 8) & 0x0000000FF;
- *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 2) = (r.clipFlags >> 16) & 0x0000000FF;
- *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 3) = (r.clipFlags >> 24) & 0x0000000FF;
+ *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 0) = (clipFlags >> 0) & 0x0000000FF; // FIXME: unsigned char Vertex::clipFlags
+ *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 1) = (clipFlags >> 8) & 0x0000000FF;
+ *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 2) = (clipFlags >> 16) & 0x0000000FF;
+ *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 3) = (clipFlags >> 24) & 0x0000000FF;
int pos = state.positionRegister;
- v.x = r.o[pos].x;
- v.y = r.o[pos].y;
- v.z = r.o[pos].z;
- v.w = r.o[pos].w;
+ v.x = o[pos].x;
+ v.y = o[pos].y;
+ v.z = o[pos].z;
+ v.w = o[pos].w;
Float4 w = As<Float4>(As<Int4>(v.w) | (As<Int4>(CmpEQ(v.w, Float4(0.0f))) & As<Int4>(Float4(1.0f))));
Float4 rhw = Float4(1.0f) / w;
- v.x = As<Float4>(RoundInt(*Pointer<Float4>(r.data + OFFSET(DrawData,X0x16)) + v.x * rhw * *Pointer<Float4>(r.data + OFFSET(DrawData,Wx16))));
- v.y = As<Float4>(RoundInt(*Pointer<Float4>(r.data + OFFSET(DrawData,Y0x16)) + v.y * rhw * *Pointer<Float4>(r.data + OFFSET(DrawData,Hx16))));
+ v.x = As<Float4>(RoundInt(*Pointer<Float4>(data + OFFSET(DrawData,X0x16)) + v.x * rhw * *Pointer<Float4>(data + OFFSET(DrawData,Wx16))));
+ v.y = As<Float4>(RoundInt(*Pointer<Float4>(data + OFFSET(DrawData,Y0x16)) + v.y * rhw * *Pointer<Float4>(data + OFFSET(DrawData,Hx16))));
v.z = v.z * rhw;
v.w = rhw;
void generate();
protected:
- struct Registers
- {
- Registers(const VertexShader *shader) :
- v(shader && shader->dynamicallyIndexedInput),
- r(shader && shader->dynamicallyIndexedTemporaries),
- o(shader && shader->dynamicallyIndexedOutput)
- {
- loopDepth = -1;
- enableStack[0] = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ Pointer<Byte> constants;
- if(shader && shader->containsBreakInstruction())
- {
- enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
- }
+ Int clipFlags;
- if(shader && shader->containsContinueInstruction())
- {
- enableContinue = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
- }
- }
-
- Pointer<Byte> data;
- Pointer<Byte> constants;
-
- Int clipFlags;
-
- RegisterArray<16> v;
- RegisterArray<4096> r;
- RegisterArray<12> o;
- Vector4f a0;
- Array<Int, 4> aL;
- Vector4f p0;
-
- Array<Int, 4> increment;
- Array<Int, 4> iteration;
-
- Int loopDepth;
- Int stackIndex; // FIXME: Inc/decrement callStack
- Array<UInt, 16> callStack;
-
- Int enableIndex;
- Array<Int4, 1 + 24> enableStack;
- Int4 enableBreak;
- Int4 enableContinue;
- Int4 enableLeave;
-
- Int instanceID;
- };
-
- Registers r;
+ RegisterArray<16> v; // Varying registers
+ RegisterArray<12> o; // Output registers
const VertexProcessor::State &state;
- const VertexShader *const shader;
private:
virtual void pipeline() = 0;
OSDN Git Service
