Ok, so I'm just going to post all the code in case that I did something stupid as usual.
Back, Front map rendering:
cbuffer ConstantObjectBuffer : register (b0)
{
matrix worldMatrix;
float pad_f;
float instance;
float2 pad_v2;
};
cbuffer ConstantFrameBuffer : register (b1)
{
matrix viewMatrix;
matrix projectionMatrix;
};
struct VOut
{
float4 position : SV_POSITION;
float3 texC : TEXCOORD0;
float4 pos : TEXCOORD1;
};
Texture2D t_alphamap : register(t0);
Texture2D t_dffalpha : register(t1);
SamplerState ss;
VOut VShader(float4 position : POSITION, float4 normal : NORMAL, float2 texcoord : TEXCOORD, float3 instancePosition : INSTANCEPOS)
{
VOut output;
if (instance == 1)
{
position.x += instancePosition.x;
position.y += instancePosition.y;
position.z += instancePosition.z;
}
position.w = 1.0f;
position = position * float4(1, 1, 1, 1);
// Calculate the position of the vertex against the world, view, and projection matrices.
output.position = mul(position, worldMatrix);
output.position = mul(output.position, viewMatrix);
output.position = mul(output.position, projectionMatrix);
output.texC = position;
output.pos = output.position;
return output;
}
float4 PShader(VOut input) : SV_TARGET
{
return float4(input.texC, 1.0f);
}
Code for volume rendering:
//*******CONFIGURE OBJECT BUFFER
bff_PrObject.worldMatrix = world;
bff_PrObject.Iterations = 24;
//*******CALCULATE PROPERTIES
float mStepScale = 1.0f;
float maxSize = (float)max(volume->m_pVolumeData.m_Width, max(volume->m_pVolumeData.m_Height, volume->m_pVolumeData.m_Depth));
bff_PrObject.StepSize = D3DXVECTOR3(1.0f / volume->m_pVolumeData.m_Width, 1.0f / volume->m_pVolumeData.m_Height, 1.0f / volume->m_pVolumeData.m_Depth);
bff_PrObject.Iterations = (int)maxSize * (1.0f / mStepScale);
D3DXVECTOR3 sizes = D3DXVECTOR3(volume->m_pVolumeData.m_Width, volume->m_pVolumeData.m_Height, volume->m_pVolumeData.m_Depth);
D3DXVECTOR3 ratios = D3DXVECTOR3(1, 1, 1);
D3DXVECTOR3 r(sizes.x * ratios.x, sizes.y * ratios.y, sizes.z * ratios.z);
D3DXVECTOR3 c1 = (D3DXVECTOR3(1, 1, 1) * maxSize);
D3DXVECTOR3 d(c1.x / r.x, c1.y / r.y, c1.z / r.z);
bff_PrObject.ScaleFactor = D3DXVECTOR4( 1.0f / d.x, 1.0f / d.y, 1.0f / d.z, 1.0f );
//*******SMART SEND ALL BUFFERS
devcon->UpdateSubresource(pCBuffer[0], 0, 0, &bff_PrObject, NULL, NULL);
devcon->UpdateSubresource(pCBuffer[1], 0, 0, &bff_PrFrame, NULL, NULL);
devcon->VSSetConstantBuffers(0, 2, pCBuffer);
devcon->PSSetConstantBuffers(0, 2, pCBuffer);
//*******SEND RESOURCES
ID3D11ShaderResourceView
*front = volume->transHolder.m_pFront.GetShaderResourceView(),
*back = volume->transHolder.m_pBack.GetShaderResourceView();
devcon->PSSetShaderResources(0, 1, &volume->m_pVolumeData.pTexture);
devcon->PSSetShaderResources(1, 1, &front);
devcon->PSSetShaderResources(2, 1, &back);
FOREACH (volume->Parameters.Parameters.size())
{
devcon->PSSetShaderResources(volume->Parameters.Parameters[i].slot, 1, &volume->Parameters.Parameters[i].resource);
}
//*******PREPARE PASS
Pass.Prepare(devcon, rastManager);
devcon->DrawIndexed(bf.IndexCount, 0, 0);
//*******CLEAN UP
ID3D11ShaderResourceView *n = NULL;
FOREACH (volume->Parameters.Parameters.size())
{
devcon->PSSetShaderResources(volume->Parameters.Parameters[i].slot, 1, &n);
}
devcon->PSSetShaderResources(0, 1, &n);
devcon->DSSetShaderResources(1, 1, &n);
devcon->DSSetShaderResources(2, 1, &n);
Shader code for volume:
cbuffer ConstantObjectBuffer : register (b0)
{
matrix worldMatrix;
float3 StepSize;
float Iterations;
float4 ScaleFactor;
};
#define Side 2
cbuffer ConstantFrameBuffer : register (b1)
{
matrix viewMatrix;
matrix projectionMatrix;
float3 eyepos;
float cppad;
float4 lightvec;
float4 lightcol;
float FogStart;
float FogEnd;
float2 __space;
float3 FogColor;
float shadows;
float SpecularIntensity;
float3 pad3;
float4 SpecularColor;
}
//***************************************************//
// VERTEX SHADER //
//***************************************************//
struct VOut
{
float4 position : SV_POSITION;
float3 texC : TEXCOORD0;
float4 pos : TEXCOORD1;
float2 texcoord : TEXCOORD2;
float3 normal : NORM;
**CE_RESERVED_SHADER[LINKAGE]**
};
struct GlobalIn
{
float4 position : POSITION;
float4 normal : NORMAL;
float2 texcoord : TEXCOORD;
float4 tangent : TANGENT;
};
**CE_RESERVED_SHADER[INPUTS]**
Texture3D t_VolData : register(t0);
Texture2D t_TransFront : register(t1);
Texture2D t_TransBack : register(t2);
sampler3D VolumeS = sampler_state
{
Texture = <t_VolData>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = Border; // border sampling in U
AddressV = Border; // border sampling in V
AddressW = Border;
BorderColor = float4(0,0,0,0); // outside of border should be black
};
SamplerState ss;
VOut VShader(GlobalIn input)
{
VOut output;
input.position.w = 1.0f;
output.texcoord = input.texcoord;
**CE_RESERVED_SHADER[PREVERTEX]**
// Calculate the position of the vertex against the world, view, and projection matrices.
output.position = mul(input.position, worldMatrix);
output.position = mul(output.position, viewMatrix);
output.position = mul(output.position, projectionMatrix);
output.texC = input.position;
output.pos = output.position;
output.normal = mul(float4(input.normal.xyz,0), worldMatrix);
**CE_RESERVED_SHADER[VERTEX]**
return output;
}
//***************************************************//
// PIXEL SHADER //
//***************************************************//
struct POut
{
float4 Diffuse : SV_Target0;
float4 Position : SV_Target1;
float4 Depth : SV_Target2;
float4 Normals : SV_Target3;
float4 Lighting : SV_Target4;
};
// Functions
float4 GetVRaycast(VOut input)
{
//calculate projective texture coordinates
//used to project the front and back position textures onto the cube
float2 texC = input.pos.xy /= input.pos.w;
texC.x = 0.5f*texC.x + 0.5f;
texC.y = -0.5f*texC.y + 0.5f;
float3 front = t_TransFront.Sample(ss, texC).xyz;
float3 back = t_TransBack.Sample(ss, texC).xyz;
float3 dir = normalize(back - front);
float4 pos = float4(front, 0);
float4 dst = float4(0, 0, 0, 0);
float4 src = 0;
float value = 0;
float3 Step = dir * StepSize;
for(int i = 0; i < 32; i++)
{
pos.w = 0;
value = t_VolData.Sample(ss, pos).r;
src = (float4)value;
src.a *= .5f; //reduce the alpha to have a more transparent result
//Front to back blending
// dst.rgb = dst.rgb + (1 - dst.a) * src.a * src.rgb
// dst.a = dst.a + (1 - dst.a) * src.a
src.rgb *= src.a;
dst = (1.0f - dst.a)*src + dst;
//break from the loop when alpha gets high enough
if(dst.a >= .95f)
break;
//advance the current position
pos.xyz += Step;
//break if the position is greater than <1, 1, 1>
if(pos.x > 1.0f || pos.y > 1.0f || pos.z > 1.0f)
break;
}
return dst;
}
POut PShader(VOut input)
{
POut output;
// Depth
output.Depth = float4(0, 0, 0, 1.0f);
// Normals
output.Normals = float4(normalize(input.normal), 1);
output.Position = float4(0, 0, 0, 1);
output.Lighting = float4(1, 1, 1, 1);
**CE_RESERVED_SHADER[PIXEL]**
output.Diffuse = GetVRaycast(input);
return output;
}
PS. Don't mind the weird things like **CE...