RasterStates::RasterStates( ID3D11Device *pd3dDevice )
{
HRESULT hr;
D3D11_RASTERIZER_DESC RasterDesc;
ZeroMemory( &RasterDesc, sizeof( D3D11_RASTERIZER_DESC ) );
RasterDesc.FillMode = D3D11_FILL_SOLID;
RasterDesc.CullMode = D3D11_CULL_NONE;
RasterDesc.DepthClipEnable = TRUE;
hr = pd3dDevice->CreateRasterizerState(&RasterDesc, &pRasterizerStates_[RASTERIZER_STATE::SOLID]);
if( hr != S_OK )
{
return;
}
DXUT_SetDebugName(pRasterizerStates_[RASTERIZER_STATE::SOLID], "Solid");
RasterDesc.FillMode = D3D11_FILL_WIREFRAME;
hr = pd3dDevice->CreateRasterizerState(&RasterDesc, &pRasterizerStates_[RASTERIZER_STATE::WIREFRAME]);
if( hr != S_OK )
{
return;
}
DXUT_SetDebugName(pRasterizerStates_[RASTERIZER_STATE::WIREFRAME], "Wireframe");
}
SamplerStates::SamplerStates(ID3D11Device *pd3dDevice)
{
HRESULT hr;
// Point
D3D11_SAMPLER_DESC SamDesc;
SamDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
SamDesc.AddressU = D3D11_TEXTURE_ADDRESS_BORDER;
SamDesc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
SamDesc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER;
SamDesc.MipLODBias = 0.0f;
SamDesc.MaxAnisotropy = 1;
SamDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
SamDesc.BorderColor[0] = SamDesc.BorderColor[1] = SamDesc.BorderColor[2] = SamDesc.BorderColor[3] = 1.0;
SamDesc.MinLOD = 0;
SamDesc.MaxLOD = D3D11_FLOAT32_MAX;
V(pd3dDevice->CreateSamplerState(&SamDesc, &pSamplerStates_[SAMPLER_STATE::POINT]));
DXUT_SetDebugName(pSamplerStates_[SAMPLER_STATE::POINT], "Point");
// Linear
SamDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
SamDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
V(pd3dDevice->CreateSamplerState(&SamDesc, &pSamplerStates_[SAMPLER_STATE::LINEAR]));
DXUT_SetDebugName(pSamplerStates_[SAMPLER_STATE::LINEAR], "Linear");
}
void CloudShader::createBuffers(ID3D11Device* pd3dDevice)
{
// Create the 3 constant buffers, using the same buffer descriptor to create all three
D3D11_BUFFER_DESC Desc;
ZeroMemory(&Desc, sizeof(Desc));
Desc.Usage = D3D11_USAGE_DEFAULT;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = 0;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof(CB_VS_PER_OBJECT);
pd3dDevice->CreateBuffer(&Desc, NULL, &cbVSPerObject);
DXUT_SetDebugName(cbVSPerObject, "CB_VS_PER_OBJECT_CLOUD");
Desc.ByteWidth = sizeof(CB_PS_PER_OBJECT);
pd3dDevice->CreateBuffer(&Desc, NULL, &cbPSPerObject);
DXUT_SetDebugName(cbPSPerObject, "CB_PS_PER_OBJECT_CLOUD");
// also initialize the wind textures
D3DX11CreateShaderResourceViewFromFile(pd3dDevice,
L"Media\\Grass\\Wind1.png",
NULL, NULL,
&txWind1,
NULL);
DXUT_SetDebugName(txWind1, "TEX_WIND1_CLOUD");
D3DX11CreateShaderResourceViewFromFile(pd3dDevice,
L"Media\\Grass\\Wind2.png",
NULL, NULL,
&txWind2,
NULL);
DXUT_SetDebugName(txWind2, "TEX_WIND2_CLOUD");
}
//-------------------------------------------------------------------------------------------------
HRESULT ClearView::Init(ID3D11Device* pd3dDevice, ApplicationContext *pContext)
{
HRESULT hr = S_OK;
m_pContext = pContext;
// Define screen quad vertex layout
D3D11_INPUT_ELEMENT_DESC QuadVertexLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
// Color VS
m_pContext->m_ShaderCache.AddShader((ID3D11DeviceChild**)&m_pColorVS, AMD::ShaderCache::SHADER_TYPE_VERTEX, L"vs_5_0", L"VSColor",
L"Shaders\\Source\\Color.hlsl", 0, NULL, &m_pColorVertexLayout, (D3D11_INPUT_ELEMENT_DESC*)QuadVertexLayout, ARRAYSIZE(QuadVertexLayout));
// Color PS
m_pContext->m_ShaderCache.AddShader((ID3D11DeviceChild**)&m_pColorPS, AMD::ShaderCache::SHADER_TYPE_PIXEL, L"ps_5_0", L"PSColor",
L"Shaders\\Source\\Color.hlsl", 0, NULL, NULL, NULL, 0);
D3D11_BUFFER_DESC Desc;
// Utility
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof(CB_PS_COLOR);
V_RETURN(pd3dDevice->CreateBuffer(&Desc, nullptr, &m_pcbPSColor));
DXUT_SetDebugName(m_pcbPSColor, "CB_PS_COLOR");
// Fill out a unit quad
QuadVertex QuadVertices[6];
QuadVertices[0].v3Pos = XMFLOAT3(-1.0f, -1.0f, 0.5f);
QuadVertices[0].v2TexCoord = XMFLOAT2(0.0f, 1.0f);
QuadVertices[1].v3Pos = XMFLOAT3(-1.0f, 1.0f, 0.5f);
QuadVertices[1].v2TexCoord = XMFLOAT2(0.0f, 0.0f);
QuadVertices[2].v3Pos = XMFLOAT3(1.0f, -1.0f, 0.5f);
QuadVertices[2].v2TexCoord = XMFLOAT2(1.0f, 1.0f);
QuadVertices[3].v3Pos = XMFLOAT3(-1.0f, 1.0f, 0.5f);
QuadVertices[3].v2TexCoord = XMFLOAT2(0.0f, 0.0f);
QuadVertices[4].v3Pos = XMFLOAT3(1.0f, 1.0f, 0.5f);
QuadVertices[4].v2TexCoord = XMFLOAT2(1.0f, 0.0f);
QuadVertices[5].v3Pos = XMFLOAT3(1.0f, -1.0f, 0.5f);
QuadVertices[5].v2TexCoord = XMFLOAT2(1.0f, 1.0f);
// Create the vertex buffer
D3D11_BUFFER_DESC BD;
BD.Usage = D3D11_USAGE_DYNAMIC;
BD.ByteWidth = sizeof(QuadVertex) * 6;
BD.BindFlags = D3D11_BIND_VERTEX_BUFFER;
BD.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
BD.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA InitData;
InitData.pSysMem = QuadVertices;
hr = pd3dDevice->CreateBuffer(&BD, &InitData, &m_pQuadVertexBuffer);
return S_OK;
}
void VertexAndPixelShaders::CreatePixelShader(ID3D11Device *device) {
HRESULT hr = S_OK;
pPixelShaderBuffer = NULL;
V(CompileShaderFromFile(L"Tutorial 09 - Meshes Using DXUT Helper Classes_PS.hlsl", "PS_DXUTSDKMesh", "ps_5_0", &pPixelShaderBuffer));
V(device->CreatePixelShader(pPixelShaderBuffer->GetBufferPointer(),
pPixelShaderBuffer->GetBufferSize(), NULL, &g_pPixelShader));
DXUT_SetDebugName(g_pPixelShader, "PS_DXUTSDKMesh");
}
void ObjMeshInfo::specialLoad(ID3D11Device* pd3dDevice)
{
// loads but not from file
// this is a bit of a hack used by mesh generation stuff
// create the texture resource
D3DX11CreateShaderResourceViewFromFile(pd3dDevice,
textureFilePath,
NULL, NULL,
&objMesh.subsets->txtr,
NULL);
DXUT_SetDebugName(objMesh.subsets->txtr, "GENERATED_MESH_TEXTURE");
// Create the vertex buffer
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(SimpleVertex) * objMesh.numVertices;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA InitData;
ZeroMemory(&InitData, sizeof(InitData));
InitData.pSysMem = objMesh.vertices;
pd3dDevice->CreateBuffer(&bd, &InitData, &objMesh.vb);
DXUT_SetDebugName(objMesh.vb, "GENERATED_VERTEX_BUFFER");
// create the index buffer
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(USHORT) * objMesh.numIndices;
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
InitData.pSysMem = objMesh.indexes;
pd3dDevice->CreateBuffer(&bd, &InitData, &objMesh.ib);
DXUT_SetDebugName(objMesh.ib, "GENERATED_INDEX_BUFFER");
}
//--------------------------------------------------------------------------------------------------------------------
void RDX11RenderHelper::RenderText(RENDER_TEXT_QUAD* pText)
{
FillFontVertex( pText );
ID3D11Device* pd3dDevice = GLOBAL::D3DDevice();
ID3D11DeviceContext* pd3dImmediateContext = GLOBAL::D3DContext();
// ensure our buffer size can hold our sprites
UINT FontDataBytes = m_FontVertices.GetSize() * sizeof( CVertexPCT );
if( m_FontBufferBytes < FontDataBytes )
{
SAFE_RELEASE( m_pFontBuffer );
m_FontBufferBytes = FontDataBytes;
D3D11_BUFFER_DESC BufferDesc;
BufferDesc.ByteWidth = m_FontBufferBytes;
BufferDesc.Usage = D3D11_USAGE_DYNAMIC;
BufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
BufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
BufferDesc.MiscFlags = 0;
pd3dDevice->CreateBuffer( &BufferDesc, NULL, &m_pFontBuffer );
DXUT_SetDebugName( m_pFontBuffer, "FontVertexBuffer" );
}
D3D11_MAPPED_SUBRESOURCE MappedResource;
if ( S_OK == pd3dImmediateContext->Map( m_pFontBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource ) )
{
CopyMemory( MappedResource.pData, (void*)m_FontVertices.GetData(), FontDataBytes );
pd3dImmediateContext->Unmap(m_pFontBuffer, 0);
}
IShaderMgr* pShaderMgr = GLOBAL::ShaderMgr();
pShaderMgr->SetTexture( m_pFontTexture, 0);
GLOBAL::ShaderMgr()->Begin(SHADER_FONT_VS, SHADER_FONT_PS);
GLOBAL::RenderStateMgr()->SetTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
GLOBAL::RenderStateMgr()->SetVertexInput(FVF_3FP_1DC_2HT);
// Draw
UINT Stride = sizeof( CVertexPCT );
UINT Offset = 0;
pd3dImmediateContext->IASetVertexBuffers( 0, 1, &m_pFontBuffer, &Stride, &Offset );
pd3dImmediateContext->Draw( m_FontVertices.GetSize(), 0 );
m_FontVertices.Reset();
}
// ID3D11DeviceContext *context has inbuild method called CreateInputLayout, so I chose a different name
void VertexAndPixelShaders::MakeInputLayout(ID3D11Device *device) {
HRESULT hr = S_OK;
const D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
V(device->CreateInputLayout(layout, ARRAYSIZE(layout), pVertexShaderBuffer->GetBufferPointer(),
pVertexShaderBuffer->GetBufferSize(), &g_pVertexLayout11));
DXUT_SetDebugName(g_pVertexLayout11, "Primary");
SAFE_RELEASE(pVertexShaderBuffer);
SAFE_RELEASE(pPixelShaderBuffer);
}
ConstantBuffer::ConstantBuffer( UINT size, ID3D11Device *pd3dDevice )
{
D3D11_BUFFER_DESC Desc;
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = size;
HRESULT hr = pd3dDevice->CreateBuffer( &Desc, NULL, &pCB_ );
if ( hr != S_OK )
{
return;
}
DXUT_SetDebugName( pCB_, "CB_DEFAULT" );
}
//--------------------------------------------------------------------------------------------------------------------
void RDX11RenderHelper::DrawLine()
{
UINT dataBytes = m_LineVertices.GetSize() * sizeof( CVertexPC );
if( m_LineBufferBytes < dataBytes )
{
SAFE_RELEASE( m_pLineBuffer );
m_LineBufferBytes = dataBytes;
D3D11_BUFFER_DESC BufferDesc;
BufferDesc.ByteWidth = m_LineBufferBytes;
BufferDesc.Usage = D3D11_USAGE_DYNAMIC;
BufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
BufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
BufferDesc.MiscFlags = 0;
GLOBAL::D3DDevice()->CreateBuffer( &BufferDesc, NULL, &m_pLineBuffer );
DXUT_SetDebugName( m_pLineBuffer, "LineBuffer" );
}
//////////////////////////////////////////////////////////////////////////
// refresh vertex buffer
ID3D11DeviceContext* pContext = GLOBAL::D3DContext();
D3D11_MAPPED_SUBRESOURCE MappedResource;
if ( S_OK == pContext->Map( m_pLineBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource ) )
{
CopyMemory( MappedResource.pData, (void*)m_LineVertices.GetData(), dataBytes );
pContext->Unmap(m_pLineBuffer, 0);
}
//////////////////////////////////////////////////////////////////////////
// Draw
UINT Stride = sizeof( CVertexPC );
UINT Offset = 0;
GLOBAL::RenderStateMgr()->SetTopology(D3D_PRIMITIVE_TOPOLOGY_LINELIST);
GLOBAL::RenderStateMgr()->SetVertexInput(FVF_3FP_1DC);
pContext->IASetVertexBuffers( 0, 1, &m_pLineBuffer, &Stride, &Offset );
pContext->Draw( m_LineVertices.GetSize(), 0 );
m_LineVertices.Reset();
}
bool OmniMaterial::D3DCreateDevice(ID3D11Device* d3dDevice, const DXGI_SURFACE_DESC* BackBufferSurfaceDesc)
{
materialVS = new VertexShader(d3dDevice, L"Shaders\\OmniMaterial.hlsl", "OmniMaterialVS");
materialPS = new PixelShader(d3dDevice, L"Shaders\\OmniMaterial.hlsl", "OmniMaterialPS");
if(!omniCBuffer->D3DCreateDevice(d3dDevice, BackBufferSurfaceDesc)) return false;
// Create mesh input layout
// isn't there an easier and better way to do this???
// We need the vertex shader bytecode for this... rather than try to wire that all through the
// shader interface, just recompile the vertex shader.
UINT shaderFlags = D3D10_SHADER_ENABLE_STRICTNESS | D3D10_SHADER_PACK_MATRIX_ROW_MAJOR;
ID3D10Blob *bytecode = 0;
HRESULT hr = D3DX11CompileFromFile(L"Shaders\\OmniMaterial.hlsl", NULL, 0, "OmniMaterialVS", "vs_5_0", shaderFlags, 0, 0, &bytecode, 0, 0);
if (FAILED(hr))
{
assert(false);
}
const D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
d3dDevice->CreateInputLayout(
layout, ARRAYSIZE(layout),
bytecode->GetBufferPointer(),
bytecode->GetBufferSize(),
&_InputLayout);
bytecode->Release();
DXUT_SetDebugName(_InputLayout, "OmniMaterial_InputLayout");
return hr == S_OK;
}
bool ParallelogramGeometry::D3DCreateDevice(ID3D11Device* Device, const DXGI_SURFACE_DESC* BackBufferSurfaceDesc)
{
_Stride = 32;
unsigned int numVerts = 4;
unsigned int sizeInBytes = _Stride * numVerts;
optix::float3 normal = normalize(cross(_Offset1, _Offset2));
VertexPosNormalTexCoord verts[] =
{
VertexPosNormalTexCoord(_Anchor, normal, optix::make_float2(0,0)),
VertexPosNormalTexCoord(_Anchor + _Offset1, normal, optix::make_float2(0,1)),
VertexPosNormalTexCoord(_Anchor + _Offset2, normal, optix::make_float2(1,0)),
VertexPosNormalTexCoord(_Anchor + _Offset1 + _Offset2, normal, optix::make_float2(1,1))
};
D3D11_BUFFER_DESC desc;
ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_DEFAULT;
desc.ByteWidth = sizeInBytes;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA init;
ZeroMemory(&init, sizeof(D3D11_SUBRESOURCE_DATA));
init.pSysMem = verts;
if (S_OK != Device->CreateBuffer(&desc, &init, &_VertexBuffer))
return false;
DXUT_SetDebugName(_VertexBuffer, "Parallelogram_VB");
_NumElements = numVerts;
_Topology = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
return true;
}
void RenderableTexture::SetDebugName(char* s)
{
DXUT_SetDebugName(m_ShaderResource, s);
DXUT_SetDebugName(m_RenderTarget, s);
DXUT_SetDebugName(m_Texture, s);
}
void RSMRenderer::OnCreateDevice( ID3D11Device* pd3dDevice )
{
HRESULT hr;
int width = gRSMSpotResolution * MAX_NUM_SHADOWCASTING_SPOTS;
int height = gRSMSpotResolution;
V( AMD::CreateDepthStencilSurface( &m_SpotAtlas.m_pDepthTexture, &m_SpotAtlas.m_pDepthSRV, &m_SpotAtlas.m_pDepthDSV, DXGI_FORMAT_D16_UNORM, DXGI_FORMAT_R16_UNORM, width, height, 1 ) );
V( AMD::CreateSurface( &m_SpotAtlas.m_pNormalTexture, &m_SpotAtlas.m_pNormalSRV, &m_SpotAtlas.m_pNormalRTV, 0, DXGI_FORMAT_R11G11B10_FLOAT, width, height, 1 ) );
V( AMD::CreateSurface( &m_SpotAtlas.m_pDiffuseTexture, &m_SpotAtlas.m_pDiffuseSRV, &m_SpotAtlas.m_pDiffuseRTV, 0, DXGI_FORMAT_R11G11B10_FLOAT, width, height, 1 ) );
int maxVPLs = width * height;
width = gRSMPointResolution * 6;
height = gRSMPointResolution * MAX_NUM_SHADOWCASTING_POINTS;
V( AMD::CreateDepthStencilSurface( &m_PointAtlas.m_pDepthTexture, &m_PointAtlas.m_pDepthSRV, &m_PointAtlas.m_pDepthDSV, DXGI_FORMAT_D16_UNORM, DXGI_FORMAT_R16_UNORM, width, height, 1 ) );
V( AMD::CreateSurface( &m_PointAtlas.m_pNormalTexture, &m_PointAtlas.m_pNormalSRV, &m_PointAtlas.m_pNormalRTV, 0, DXGI_FORMAT_R11G11B10_FLOAT, width, height, 1 ) );
V( AMD::CreateSurface( &m_PointAtlas.m_pDiffuseTexture, &m_PointAtlas.m_pDiffuseSRV, &m_PointAtlas.m_pDiffuseRTV, 0, DXGI_FORMAT_R11G11B10_FLOAT, width, height, 1 ) );
maxVPLs += width * height;
D3D11_BUFFER_DESC desc;
ZeroMemory( &desc, sizeof( desc ) );
desc.Usage = D3D11_USAGE_DEFAULT;
desc.StructureByteStride = 16;
desc.ByteWidth = desc.StructureByteStride * maxVPLs;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS;
desc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
V( pd3dDevice->CreateBuffer( &desc, 0, &m_pVPLBufferCenterAndRadius ) );
DXUT_SetDebugName( m_pVPLBufferCenterAndRadius, "VPLBufferCenterAndRadius" );
// see struct VPLData in CommonHeader.h
desc.StructureByteStride = 48;
desc.ByteWidth = desc.StructureByteStride * maxVPLs;
V( pd3dDevice->CreateBuffer( &desc, 0, &m_pVPLBufferData ) );
DXUT_SetDebugName( m_pVPLBufferData, "VPLBufferData" );
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
ZeroMemory( &SRVDesc, sizeof( SRVDesc ) );
SRVDesc.Format = DXGI_FORMAT_UNKNOWN;
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
SRVDesc.Buffer.ElementOffset = 0;
SRVDesc.Buffer.ElementWidth = maxVPLs;
V( pd3dDevice->CreateShaderResourceView( m_pVPLBufferCenterAndRadius, &SRVDesc, &m_pVPLBufferCenterAndRadiusSRV ) );
V( pd3dDevice->CreateShaderResourceView( m_pVPLBufferData, &SRVDesc, &m_pVPLBufferDataSRV ) );
D3D11_UNORDERED_ACCESS_VIEW_DESC UAVDesc;
UAVDesc.Format = SRVDesc.Format;
UAVDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
UAVDesc.Buffer.FirstElement = 0;
UAVDesc.Buffer.NumElements = maxVPLs;
UAVDesc.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_COUNTER;
V( pd3dDevice->CreateUnorderedAccessView( m_pVPLBufferCenterAndRadius, &UAVDesc, &m_pVPLBufferCenterAndRadiusUAV ) );
V( pd3dDevice->CreateUnorderedAccessView( m_pVPLBufferData, &UAVDesc, &m_pVPLBufferDataUAV ) );
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.StructureByteStride = 16*4;
desc.ByteWidth = desc.StructureByteStride * MAX_NUM_SHADOWCASTING_SPOTS;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
V( pd3dDevice->CreateBuffer( &desc, 0, &m_pSpotInvViewProjBuffer ) );
DXUT_SetDebugName( m_pSpotInvViewProjBuffer, "SpotInvViewProjBuffer" );
SRVDesc.Buffer.ElementWidth = MAX_NUM_SHADOWCASTING_SPOTS;
V( pd3dDevice->CreateShaderResourceView( m_pSpotInvViewProjBuffer, &SRVDesc, &m_pSpotInvViewProjBufferSRV ) );
desc.ByteWidth = desc.StructureByteStride * MAX_NUM_SHADOWCASTING_POINTS * 6;
V( pd3dDevice->CreateBuffer( &desc, 0, &m_pPointInvViewProjBuffer ) );
DXUT_SetDebugName( m_pPointInvViewProjBuffer, "PointInvViewProjBuffer" );
SRVDesc.Buffer.ElementWidth = 6*MAX_NUM_SHADOWCASTING_POINTS;
V( pd3dDevice->CreateShaderResourceView( m_pPointInvViewProjBuffer, &SRVDesc, &m_pPointInvViewProjBufferSRV ) );
ZeroMemory( &desc, sizeof( desc ) );
desc.Usage = D3D11_USAGE_DEFAULT;
desc.ByteWidth = 16;
desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
V( pd3dDevice->CreateBuffer( &desc, 0, &m_pNumVPLsConstantBuffer ) );
DXUT_SetDebugName( m_pNumVPLsConstantBuffer, "NumVPLsConstantBuffer" );
desc.BindFlags = 0;
desc.Usage = D3D11_USAGE_STAGING;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
V( pd3dDevice->CreateBuffer( &desc, 0, &m_pCPUReadbackConstantBuffer ) );
DXUT_SetDebugName( m_pCPUReadbackConstantBuffer, "CPUReadbackConstantBuffer" );
}
Shader::Shader( ID3D11Device *pd3dDevice, ID3D11DeviceContext *pd3dImmediateContext )
{
vs_current_ = VS::MAX;
// Compile shaders
ID3DBlob* pBlobVS = NULL;
ID3DBlob* pBlobHSInt = NULL;
ID3DBlob* pBlobHSFracEven = NULL;
ID3DBlob* pBlobHSFracOdd = NULL;
ID3DBlob* pBlobDS = NULL;
ID3DBlob* pBlobPS = NULL;
ID3DBlob* pBlobPSSolid = NULL;
// This macro is used to compile the hull shader with different partition modes
// Please see the partitioning mode attribute for the hull shader for more information
D3D_SHADER_MACRO integerPartitioning[] = { { "BEZIER_HS_PARTITION", "\"integer\"" }, { 0 } };
D3D_SHADER_MACRO fracEvenPartitioning[] = { { "BEZIER_HS_PARTITION", "\"fractional_even\"" }, { 0 } };
D3D_SHADER_MACRO fracOddPartitioning[] = { { "BEZIER_HS_PARTITION", "\"fractional_odd\"" }, { 0 } };
HRESULT hr;
V( CompileShaderFromFile( L"sample.hlsl", NULL, "BezierVS", "vs_5_0", &pBlobVS ) );
V( CompileShaderFromFile( L"sample.hlsl", integerPartitioning, "BezierHS", "hs_5_0", &pBlobHSInt ) );
V( CompileShaderFromFile( L"sample.hlsl", fracEvenPartitioning, "BezierHS", "hs_5_0", &pBlobHSFracEven ) );
V( CompileShaderFromFile( L"sample.hlsl", fracOddPartitioning, "BezierHS", "hs_5_0", &pBlobHSFracOdd ) );
V( CompileShaderFromFile( L"sample.hlsl", NULL, "BezierDS", "ds_5_0", &pBlobDS ) );
V( CompileShaderFromFile( L"sample.hlsl", NULL, "BezierPS", "ps_5_0", &pBlobPS ) );
V( CompileShaderFromFile( L"sample.hlsl", NULL, "SolidColorPS", "ps_5_0", &pBlobPSSolid ) );
// Create shaders
V(pd3dDevice->CreateVertexShader(pBlobVS->GetBufferPointer(), pBlobVS->GetBufferSize(), NULL, &pVertexShader_[VS::BEZIER]));
DXUT_SetDebugName(pVertexShader_[VS::BEZIER], "BezierVS");
V(pd3dDevice->CreateHullShader(pBlobHSInt->GetBufferPointer(), pBlobHSInt->GetBufferSize(), NULL, &pHullShader_[HS::PARTITION_INTEGER]));
DXUT_SetDebugName( pHullShader_[HS::PARTITION_INTEGER], "BezierHS int" );
V(pd3dDevice->CreateHullShader(pBlobHSFracEven->GetBufferPointer(), pBlobHSFracEven->GetBufferSize(), NULL, &pHullShader_[HS::PARTITION_FRACTIONAL_EVEN]));
DXUT_SetDebugName(pHullShader_[HS::PARTITION_FRACTIONAL_EVEN], "BezierHS frac even");
V(pd3dDevice->CreateHullShader(pBlobHSFracOdd->GetBufferPointer(), pBlobHSFracOdd->GetBufferSize(), NULL, &pHullShader_[HS::PARTITION_FRACTIONAL_ODD]));
DXUT_SetDebugName(pHullShader_[HS::PARTITION_FRACTIONAL_ODD], "BezierHS frac odd");
V(pd3dDevice->CreateDomainShader(pBlobDS->GetBufferPointer(), pBlobDS->GetBufferSize(), NULL, &pDomainShader_[DS::BEZIER]));
DXUT_SetDebugName(pDomainShader_[DS::BEZIER], "BezierDS");
V(pd3dDevice->CreatePixelShader(pBlobPS->GetBufferPointer(), pBlobPS->GetBufferSize(), NULL, &pPixelShader_[PS::BEZIER]));
DXUT_SetDebugName(pPixelShader_[PS::BEZIER], "BezierPS");
V(pd3dDevice->CreatePixelShader(pBlobPSSolid->GetBufferPointer(), pBlobPSSolid->GetBufferSize(), NULL, &pPixelShader_[PS::SOLID_COLOR]));
DXUT_SetDebugName(pPixelShader_[PS::SOLID_COLOR], "SolidColorPS");
// Create our vertex input layout - this matches the BEZIER_CONTROL_POINT structure
const D3D11_INPUT_ELEMENT_DESC layout_BEZIER[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
V(pd3dDevice->CreateInputLayout(layout_BEZIER, ARRAYSIZE(layout_BEZIER), pBlobVS->GetBufferPointer(),
pBlobVS->GetBufferSize(), &pLayout_[VS::BEZIER]));
DXUT_SetDebugName(pLayout_[VS::BEZIER], "Primary");
SAFE_RELEASE( pBlobVS );
SAFE_RELEASE( pBlobHSInt );
SAFE_RELEASE( pBlobHSFracEven );
SAFE_RELEASE( pBlobHSFracOdd );
SAFE_RELEASE( pBlobDS );
SAFE_RELEASE( pBlobPS );
SAFE_RELEASE( pBlobPSSolid );
pCB_[VS::BEZIER] = new ConstantBuffer(sizeof(CB_BEZIER), pd3dDevice);
// Render Scene
V(CompileShaderFromFile(L"scene.hlsl", NULL, "VS_RenderScene", "vs_5_0", &pBlobVS));
V(CompileShaderFromFile(L"scene.hlsl", NULL, "PS_RenderScene", "ps_5_0", &pBlobPS));
V(pd3dDevice->CreateVertexShader(pBlobVS->GetBufferPointer(), pBlobVS->GetBufferSize(), NULL, &pVertexShader_[VS::SCENE]));
DXUT_SetDebugName(pVertexShader_[VS::SCENE], "SceneVS");
V(pd3dDevice->CreatePixelShader(pBlobPS->GetBufferPointer(), pBlobPS->GetBufferSize(), NULL, &pPixelShader_[PS::SCENE]));
DXUT_SetDebugName(pPixelShader_[PS::SCENE], "ScenePS");
const D3D11_INPUT_ELEMENT_DESC SceneLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXTURE", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
hr = pd3dDevice->CreateInputLayout(SceneLayout, ARRAYSIZE(SceneLayout), pBlobVS->GetBufferPointer(),
pBlobVS->GetBufferSize(), &pLayout_[VS::SCENE]);
DXUT_SetDebugName(pLayout_[VS::SCENE], "SceneLayout");
SAFE_RELEASE(pBlobVS);
SAFE_RELEASE(pBlobPS);
pCB_[VS::SCENE] = new ConstantBuffer(sizeof(CB_SCENE), pd3dDevice);
// Render Decal
V(CompileShaderFromFile(L"decal.hlsl", NULL, "VS", "vs_5_0", &pBlobVS));
V(CompileShaderFromFile(L"decal.hlsl", NULL, "PS", "ps_5_0", &pBlobPS));
V(pd3dDevice->CreateVertexShader(pBlobVS->GetBufferPointer(), pBlobVS->GetBufferSize(), NULL, &pVertexShader_[VS::DECAL]));
DXUT_SetDebugName(pVertexShader_[VS::DECAL], "DecalVS");
V(pd3dDevice->CreatePixelShader(pBlobPS->GetBufferPointer(), pBlobPS->GetBufferSize(), NULL, &pPixelShader_[PS::DECAL]));
DXUT_SetDebugName(pPixelShader_[PS::DECAL], "DecalPS");
const D3D11_INPUT_ELEMENT_DESC DecalLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXTURE", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
hr = pd3dDevice->CreateInputLayout(DecalLayout, ARRAYSIZE(DecalLayout), pBlobVS->GetBufferPointer(),
pBlobVS->GetBufferSize(), &pLayout_[VS::DECAL]);
DXUT_SetDebugName(pLayout_[VS::DECAL], "DecalLayout");
SAFE_RELEASE(pBlobVS);
SAFE_RELEASE(pBlobPS);
pCB_[VS::DECAL] = new ConstantBuffer(sizeof(CB_DECAL), pd3dDevice);
// Render Shadow maps
V(CompileShaderFromFile(L"shadow.hlsl", NULL, "VSMain", "vs_5_0", &pBlobVS));
V(CompileShaderFromFile(L"shadow.hlsl", NULL, "PSMain", "ps_5_0", &pBlobPS));
V(pd3dDevice->CreateVertexShader(pBlobVS->GetBufferPointer(), pBlobVS->GetBufferSize(), NULL, &pVertexShader_[VS::SHADOW]));
DXUT_SetDebugName(pVertexShader_[VS::SHADOW], "ShadowVS");
V(pd3dDevice->CreatePixelShader(pBlobPS->GetBufferPointer(), pBlobPS->GetBufferSize(), NULL, &pPixelShader_[PS::SHADOW]));
DXUT_SetDebugName(pPixelShader_[PS::SHADOW], "ShadowPS");
const D3D11_INPUT_ELEMENT_DESC LayoutShadow[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
hr = pd3dDevice->CreateInputLayout(LayoutShadow, ARRAYSIZE(LayoutShadow), pBlobVS->GetBufferPointer(),
pBlobVS->GetBufferSize(), &pLayout_[VS::SHADOW]);
DXUT_SetDebugName(pLayout_[VS::SHADOW], "ShadowLayout");
SAFE_RELEASE(pBlobVS);
SAFE_RELEASE(pBlobPS);
pCB_[VS::SHADOW] = new ConstantBuffer(sizeof(CB_SHADOW), pd3dDevice);
// TAA
V(CompileShaderFromFile(L"taa.hlsl", NULL, "VS", "vs_5_0", &pBlobVS));
V(CompileShaderFromFile(L"taa.hlsl", NULL, "PS", "ps_5_0", &pBlobPS));
V(pd3dDevice->CreateVertexShader(pBlobVS->GetBufferPointer(), pBlobVS->GetBufferSize(), NULL, &pVertexShader_[VS::TAA]));
DXUT_SetDebugName(pVertexShader_[VS::TAA], "TAA VS");
V(pd3dDevice->CreatePixelShader(pBlobPS->GetBufferPointer(), pBlobPS->GetBufferSize(), NULL, &pPixelShader_[PS::TAA]));
DXUT_SetDebugName(pPixelShader_[PS::TAA], "TAA PS");
const D3D11_INPUT_ELEMENT_DESC LayoutTaa[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXTURE", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
hr = pd3dDevice->CreateInputLayout(LayoutTaa, ARRAYSIZE(LayoutTaa), pBlobVS->GetBufferPointer(),
pBlobVS->GetBufferSize(), &pLayout_[VS::TAA]);
DXUT_SetDebugName(pLayout_[VS::TAA], "TAA Layout");
SAFE_RELEASE(pBlobVS);
SAFE_RELEASE(pBlobPS);
pCB_[VS::TAA] = new ConstantBuffer(sizeof(CB_TAA), pd3dDevice);
}
bool SphereGeometry::D3DCreateDevice(ID3D11Device* Device, const DXGI_SURFACE_DESC* BackBufferSurfaceDesc)
{
int Slices = 20;
int Stacks = 15;
if (Slices < 3)
Slices = 3;
if (Stacks < 2)
Stacks = 2;
int numVertices = (Stacks + 1) * (Slices + 1);
int numIndices = 6 * Stacks * (Slices + 1);
bool useShort = numIndices < SHRT_MAX;
int floatsPerVert = 3*2; // float3 * 2 (pos, normal)
int sizeInBytes = numVertices * floatsPerVert * sizeof(float);
float* verts = new float[numVertices * floatsPerVert];
int* indices = NULL;
short* indices16 = NULL;
if (useShort)
indices16 = new short[numIndices];
else
indices = new int[numIndices];
float deltaRingAngle = (float)D3DX_PI / Stacks;
float deltaSegmentAngle = 2.0f * (float)D3DX_PI / Slices;
// Generate the group of rings for the sphere
int vertexIndex = 0;
int indexIndex = 0;
for (int i = 0; i <= Stacks; i++)
{
float ring = sinf(i * deltaRingAngle);
float y = cosf(i * deltaRingAngle);
// Generate the group of segments for the current ring
for (int j = 0; j <= Slices; j++)
{
float x = ring * sinf(j * deltaSegmentAngle);
float z = ring * cosf(j * deltaSegmentAngle);
// Add one vertex to the strip which makes up the sphere
optix::float3 position = optix::make_float3(x, y, z);
optix::float3 normal = optix::normalize(position);
// float2 textureCoordinate = make_float2((float)j / Slices, (float)i / Stacks);
verts[vertexIndex * floatsPerVert + 0] = position.x * _Radius + _Center.x;
verts[vertexIndex * floatsPerVert + 1] = position.y * _Radius + _Center.y;
verts[vertexIndex * floatsPerVert + 2] = position.z * _Radius + _Center.z;
verts[vertexIndex * floatsPerVert + 3] = normal.x;
verts[vertexIndex * floatsPerVert + 4] = normal.y;
verts[vertexIndex * floatsPerVert + 5] = normal.z;
if (i != Stacks)
{
if (useShort)
{
// each vertex (except the last) has six indices pointing to it
indices16[indexIndex++] = (short)(vertexIndex + Slices);
indices16[indexIndex++] = (short)(vertexIndex + Slices + 1);
indices16[indexIndex++] = (short)(vertexIndex);
indices16[indexIndex++] = (short)(vertexIndex);
indices16[indexIndex++] = (short)(vertexIndex + Slices + 1);
indices16[indexIndex++] = (short)(vertexIndex + 1);
}
else
{
// each vertex (except the last) has six indices pointing to it
indices[indexIndex++] = vertexIndex + Slices;
indices[indexIndex++] = vertexIndex + Slices + 1;
indices[indexIndex++] = vertexIndex;
indices[indexIndex++] = vertexIndex;
indices[indexIndex++] = vertexIndex + Slices + 1;
indices[indexIndex++] = vertexIndex + 1;
}
}
vertexIndex++;
}
}
_Stride = 24;
D3D11_BUFFER_DESC desc;
ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_DEFAULT;
desc.ByteWidth = sizeInBytes;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA init;
ZeroMemory(&init, sizeof(D3D11_SUBRESOURCE_DATA));
init.pSysMem = verts;
if (S_OK != Device->CreateBuffer(&desc, &init, &_VertexBuffer))
{
SAFE_DELETE_ARRAY(verts);
SAFE_DELETE_ARRAY(indices);
SAFE_DELETE_ARRAY(indices16);
return false;
}
DXUT_SetDebugName(_VertexBuffer, "Sphere_VB");
ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_DEFAULT;
desc.ByteWidth = numIndices * ( useShort ? sizeof(short) : sizeof(int) );
desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
ZeroMemory(&init, sizeof(D3D11_SUBRESOURCE_DATA));
init.pSysMem = useShort ? (void*)indices16 : (void*)indices;
if (S_OK != Device->CreateBuffer(&desc, &init, &_IndexBuffer))
{
SAFE_DELETE_ARRAY(verts);
SAFE_DELETE_ARRAY(indices);
SAFE_DELETE_ARRAY(indices16);
return false;
}
DXUT_SetDebugName(_IndexBuffer, "Sphere_IB");
SAFE_DELETE_ARRAY(verts);
SAFE_DELETE_ARRAY(indices);
SAFE_DELETE_ARRAY(indices16);
_IndexFormat = useShort ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT;
_NumElements = numIndices;
_Topology = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
return true;
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
V_RETURN( g_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) );
g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 );
g_pTxtHelper1 = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 35 );
// textures / rts
D3D11_TEXTURE2D_DESC TDesc;
TDesc.Width = UINT(g_fShadowMapWidth);
TDesc.Height = UINT(g_fShadowMapHeight);
TDesc.MipLevels = 1;
TDesc.ArraySize = 1;
TDesc.Format = DXGI_FORMAT_R16_TYPELESS;
TDesc.SampleDesc.Count = 1;
TDesc.SampleDesc.Quality = 0;
TDesc.Usage = D3D11_USAGE_DEFAULT;
TDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE;
TDesc.CPUAccessFlags = 0;
TDesc.MiscFlags = 0;
pd3dDevice->CreateTexture2D( &TDesc, 0, &g_pRSMDepthStencilTexture);
DXUT_SetDebugName( g_pRSMDepthStencilTexture, "RSM" );
D3D11_DEPTH_STENCIL_VIEW_DESC DSVDesc;
DSVDesc.Format = DXGI_FORMAT_D16_UNORM;
DSVDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
DSVDesc.Flags = 0;
DSVDesc.Texture2D.MipSlice = 0;
pd3dDevice->CreateDepthStencilView( g_pRSMDepthStencilTexture, &DSVDesc, & g_pDepthStencilTextureDSV );
DXUT_SetDebugName( g_pDepthStencilTextureDSV, "RSM DSV" );
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
SRVDesc.Format = DXGI_FORMAT_R16_UNORM;
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
SRVDesc.Texture2D.MipLevels = 1;
SRVDesc.Texture2D.MostDetailedMip = 0;
pd3dDevice->CreateShaderResourceView( g_pRSMDepthStencilTexture, &SRVDesc, &g_pDepthTextureSRV );
DXUT_SetDebugName( g_pDepthTextureSRV, "RSM SRV" );
// Setup constant buffers
D3D11_BUFFER_DESC Desc;
// Utility
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof( CB_CONSTANTS );
V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &g_pcbConstants ) );
DXUT_SetDebugName( g_pcbConstants, "CB_CONSTANTS" );
// Load the scene mesh
WCHAR str[256];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, 256, L"ColumnScene\\scene.sdkmesh" ) );
g_SceneMesh.Create( pd3dDevice, str, false );
V_RETURN( DXUTFindDXSDKMediaFileCch( str, 256, L"ColumnScene\\poles.sdkmesh" ) );
g_Poles.Create( pd3dDevice, str, false );
// Setup the camera
D3DXVECTOR3 vecEye( 0.95f, 5.83f, -14.48f );
D3DXVECTOR3 vecAt ( 0.90f, 5.44f, -13.56f );
g_Camera.SetViewParams( &vecEye, &vecAt );
D3DXVECTOR3 vecEyeL = D3DXVECTOR3( 0,0,0 );
D3DXVECTOR3 vecAtL ( 0, -0.5, 1 );
g_LCamera.SetViewParams( &vecEyeL, &vecAtL );
// Create sampler states for point and linear
// PointCmp
D3D11_SAMPLER_DESC SamDesc;
SamDesc.Filter = D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT;
SamDesc.AddressU = D3D11_TEXTURE_ADDRESS_BORDER;
SamDesc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
SamDesc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER;
SamDesc.MipLODBias = 0.0f;
SamDesc.MaxAnisotropy = 1;
SamDesc.ComparisonFunc = D3D11_COMPARISON_LESS_EQUAL;
SamDesc.BorderColor[0] = SamDesc.BorderColor[1] = SamDesc.BorderColor[2] = SamDesc.BorderColor[3] = 1.0;
SamDesc.MinLOD = 0;
SamDesc.MaxLOD = D3D11_FLOAT32_MAX;
V_RETURN( pd3dDevice->CreateSamplerState( &SamDesc, &g_pSamplePointCmp ) );
DXUT_SetDebugName( g_pSamplePointCmp, "PointCmp" );
// Point
SamDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
SamDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
V_RETURN( pd3dDevice->CreateSamplerState( &SamDesc, &g_pSamplePoint ) );
DXUT_SetDebugName( g_pSamplePoint, "Point" );
// Linear
SamDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
SamDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
V_RETURN( pd3dDevice->CreateSamplerState( &SamDesc, &g_pSampleLinear ) );
DXUT_SetDebugName( g_pSampleLinear, "Linear" );
// Create a blend state to disable alpha blending
D3D11_BLEND_DESC BlendState;
ZeroMemory(&BlendState, sizeof(D3D11_BLEND_DESC));
BlendState.IndependentBlendEnable = FALSE;
BlendState.RenderTarget[0].BlendEnable = FALSE;
BlendState.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
hr = pd3dDevice->CreateBlendState(&BlendState, &g_pBlendStateNoBlend);
DXUT_SetDebugName( g_pBlendStateNoBlend, "No Blend" );
BlendState.RenderTarget[0].RenderTargetWriteMask = 0;
hr = pd3dDevice->CreateBlendState(&BlendState, &g_pBlendStateColorWritesOff);
DXUT_SetDebugName( g_pBlendStateColorWritesOff, "Color Writes Off");
return S_OK;
}
//--------------------------------------------------------------------------------------
// FillGrid_Indexed_WithTangentSpace
// Creates a regular grid of indexed triangles
// Includes tangent space vectors: NORMAL, TANGENT & BINORMAL
//
// Parameters:
//
// IN
// pd3dDevice: The D3D device
// dwWidth, dwLength: Number of grid vertices in X and Z direction
// fGridSizeX, fGridSizeZ: Grid extents in local space units
//
// OUT
// lplpVB: A pointer to the vertex buffer containing grid vertices
// lplpIB: A pointer to the index buffer containing grid indices
//--------------------------------------------------------------------------------------
void FillGrid_Indexed_WithTangentSpace( ID3D11Device* pd3dDevice, DWORD dwWidth, DWORD dwLength,
float fGridSizeX, float fGridSizeZ,
ID3D11Buffer** lplpVB, ID3D11Buffer** lplpIB )
{
HRESULT hr;
DWORD nNumVertex = ( dwWidth + 1 ) * ( dwLength + 1 );
DWORD nNumIndex = 3 * 2 * dwWidth * dwLength;
float fStepX = fGridSizeX / dwWidth;
float fStepZ = fGridSizeZ / dwLength;
// Allocate memory for buffer of vertices in system memory
TANGENTSPACEVERTEX* pVertexBuffer = new TANGENTSPACEVERTEX[nNumVertex];
TANGENTSPACEVERTEX* pVertex = &pVertexBuffer[0];
// Fill vertex buffer
for ( DWORD i=0; i<=dwLength; ++i )
{
for ( DWORD j=0; j<=dwWidth; ++j )
{
pVertex->x = -fGridSizeX/2.0f + j*fStepX;
pVertex->y = 0.0f;
pVertex->z = fGridSizeZ/2.0f - i*fStepZ;
pVertex->u = 0.0f + ( (float)j / dwWidth );
pVertex->v = 0.0f + ( (float)i / dwLength );
// Flat grid so tangent space is very basic; with more complex geometry
// you would have to export calculated tangent space vectors
pVertex->nx = 0.0f;
pVertex->ny = 1.0f;
pVertex->nz = 0.0f;
pVertex->bx = 0.0f;
pVertex->by = 0.0f;
pVertex->bz = -1.0f;
pVertex->tx = 1.0f;
pVertex->ty = 0.0f;
pVertex->tz = 0.0f;
pVertex++;
}
}
// Allocate memory for buffer of indices in system memory
WORD* pIndexBuffer = new WORD [nNumIndex];
WORD* pIndex = &pIndexBuffer[0];
// Fill index buffer
for ( DWORD i=0; i<dwLength; ++i )
{
for ( DWORD j=0; j<dwWidth; ++j )
{
*pIndex++ = (WORD)( i * (dwWidth+1) + j );
*pIndex++ = (WORD)( i * (dwWidth+1) + j + 1 );
*pIndex++ = (WORD)( (i+1) * (dwWidth+1) + j );
*pIndex++ = (WORD)( (i+1) * (dwWidth+1) + j );
*pIndex++ = (WORD)( i * (dwWidth+1) + j + 1 );
*pIndex++ = (WORD)( (i+1) * (dwWidth+1) + j + 1 );
}
}
#ifdef GRID_OPTIMIZE_INDICES
GridOptimizeIndices(pIndexBuffer, nNumIndex, nNumVertex);
#endif
#ifdef GRID_OPTIMIZE_VERTICES
GridOptimizeVertices(pIndexBuffer, pVertexBuffer, sizeof(TANGENTSPACEVERTEX),
nNumIndex, nNumVertex);
#endif
// Actual VB creation
// Set initial data info
D3D11_SUBRESOURCE_DATA InitData;
InitData.pSysMem = pVertexBuffer;
// Fill DX11 vertex buffer description
D3D11_BUFFER_DESC bd;
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( TANGENTSPACEVERTEX ) * nNumVertex;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
// Create DX11 vertex buffer specifying initial data
hr = pd3dDevice->CreateBuffer( &bd, &InitData, lplpVB );
if( FAILED( hr ) )
{
OutputDebugString( L"FillGrid_Indexed_WithTangentSpace: Failed to create vertex buffer.\n" );
return;
}
DXUT_SetDebugName( *lplpVB, "FillGrid VB Tan Idx" );
// Actual IB creation
// Set initial data info
InitData.pSysMem = pIndexBuffer;
// Fill DX11 vertex buffer description
bd.ByteWidth = sizeof( WORD ) * nNumIndex;
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
// Create DX11 index buffer specifying initial data
hr = pd3dDevice->CreateBuffer( &bd, &InitData, lplpIB );
if( FAILED( hr ) )
{
OutputDebugString( L"FillGrid_Indexed_WithTangentSpace: Failed to create index buffer.\n" );
return;
}
DXUT_SetDebugName( *lplpIB, "FillGrid IB Tan" );
// Release host memory vertex buffer
delete [] pIndexBuffer;
// Release host memory vertex buffer
delete [] pVertexBuffer;
}
//--------------------------------------------------------------------------------------
// FillGrid_Quads_NonIndexed
// Creates a regular grid using non-indexed quads.
//
// Parameters:
//
// IN
// pd3dDevice: The D3D device
// dwWidth, dwLength: Number of grid vertices in X and Z direction
// fGridSizeX, fGridSizeZ: Grid extents in local space units
//
// OUT
// lplpVB: A pointer to the vertex buffer containing grid vertices
//
//--------------------------------------------------------------------------------------
void FillGrid_Quads_NonIndexed( ID3D11Device* pd3dDevice, DWORD dwWidth, DWORD dwLength,
float fGridSizeX, float fGridSizeZ,
ID3D11Buffer** lplpVB )
{
HRESULT hr;
DWORD nNumQuads = dwWidth * dwLength;
DWORD nNumVertex = 4 * nNumQuads;
float fStepX = fGridSizeX / dwWidth;
float fStepZ = fGridSizeZ / dwLength;
// Allocate memory for buffer of vertices in system memory
SIMPLEVERTEX* pVertexBuffer = new SIMPLEVERTEX[nNumVertex];
SIMPLEVERTEX* pVertex = &pVertexBuffer[0];
for ( DWORD i=0; i<dwLength; ++i )
{
for ( DWORD j=0; j<dwWidth; ++j )
{
// Vertex 0
pVertex->x = -fGridSizeX/2.0f + j*fStepX;
pVertex->y = 0.0f;
pVertex->z = fGridSizeZ/2.0f - i*fStepZ;
pVertex->u = 0.0f + ( (float)j / dwWidth );
pVertex->v = 0.0f + ( (float)i / dwLength );
pVertex++;
// Vertex 1
pVertex->x = -fGridSizeX/2.0f + (j+1)*fStepX;
pVertex->y = 0.0f;
pVertex->z = fGridSizeZ/2.0f - i*fStepZ;
pVertex->u = 0.0f + ( (float)(j+1)/ dwWidth);
pVertex->v = 0.0f + ( (float) i / dwLength);
pVertex++;
// Vertex 2
pVertex->x = -fGridSizeX/2.0f + (j+1)*fStepX;
pVertex->y = 0.0f;
pVertex->z = fGridSizeZ/2.0f - (i+1)*fStepZ;
pVertex->u = 0.0f + ( (float)(j+1) / dwWidth );
pVertex->v = 0.0f + ( (float)(i+1) / dwLength );
pVertex++;
// Vertex 3
pVertex->x = -fGridSizeX/2.0f + j*fStepX;
pVertex->y = 0.0f;
pVertex->z = fGridSizeZ/2.0f - (i+1)*fStepZ;
pVertex->u = 0.0f + ( (float) j / dwWidth );
pVertex->v = 0.0f + ( (float)(i+1)/ dwLength );
pVertex++;
}
}
// Set initial data info
D3D11_SUBRESOURCE_DATA InitData;
InitData.pSysMem = pVertexBuffer;
// Fill DX11 vertex buffer description
D3D11_BUFFER_DESC bd;
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( SIMPLEVERTEX ) * nNumVertex;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
// Create DX11 vertex buffer specifying initial data
hr = pd3dDevice->CreateBuffer( &bd, &InitData, lplpVB );
if( FAILED( hr ) )
{
OutputDebugString( L"FillGrid_Quads_NonIndexed: Failed to create vertex buffer.\n" );
return;
}
DXUT_SetDebugName( *lplpVB, "FillGrid VB Quads" );
// Release host memory vertex buffer
delete [] pVertexBuffer;
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
DXUT_SetDebugName( pd3dDevice, "Main Device" );
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
V_RETURN( g_SettingsDlg.OnD3D11CreateDevice( pd3dDevice ) );
g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 );
IDXGIDevice* pDXGIDevice;
hr = pd3dDevice->QueryInterface( __uuidof(IDXGIDevice), (VOID**)&pDXGIDevice );
if( SUCCEEDED(hr) )
{
IDXGIAdapter* pAdapter;
hr = pDXGIDevice->GetAdapter( &pAdapter );
if( SUCCEEDED(hr) )
{
DXGI_ADAPTER_DESC AdapterDesc;
pAdapter->GetDesc( &AdapterDesc );
SetAdapterInfoForShaderCompilation( AdapterDesc.Description );
SAFE_RELEASE( pAdapter );
}
SAFE_RELEASE( pDXGIDevice );
}
ID3D10Blob* pVSBlob = NULL;
g_pVSTransform = CompileVertexShader( pd3dDevice, L"SceneRender.hlsl", "VSTransform", &pVSBlob );
g_pPSSceneRender = CompilePixelShader( pd3dDevice, L"SceneRender.hlsl", "PSSceneRender" );
g_pPSSceneRenderArray = CompilePixelShader( pd3dDevice, L"SceneRender.hlsl", "PSSceneRenderArray" );
g_pPSSceneRenderQuilt = CompilePixelShader( pd3dDevice, L"SceneRender.hlsl", "PSSceneRenderQuilt" );
// Create a layout for the object data
const D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
V_RETURN( pd3dDevice->CreateInputLayout( layout, ARRAYSIZE( layout ), pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), &g_pDefaultInputLayout ) );
// No longer need the shader blobs
SAFE_RELEASE( pVSBlob );
// Create state objects
D3D11_SAMPLER_DESC samDesc;
ZeroMemory( &samDesc, sizeof(samDesc) );
samDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samDesc.AddressU = samDesc.AddressV = samDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samDesc.MaxAnisotropy = 1;
samDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samDesc.MaxLOD = D3D11_FLOAT32_MAX;
V_RETURN( pd3dDevice->CreateSamplerState( &samDesc, &g_pSamLinear ) );
DXUT_SetDebugName( g_pSamLinear, "Linear" );
D3D11_BLEND_DESC BlendDesc;
ZeroMemory( &BlendDesc, sizeof( D3D11_BLEND_DESC ) );
BlendDesc.RenderTarget[0].BlendEnable = FALSE;
BlendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
BlendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
BlendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
BlendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
BlendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
BlendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
BlendDesc.RenderTarget[0].RenderTargetWriteMask = D3D10_COLOR_WRITE_ENABLE_ALL;
hr = pd3dDevice->CreateBlendState( &BlendDesc, &g_pBlendState );
ASSERT( SUCCEEDED(hr) );
D3D11_DEPTH_STENCIL_DESC DSDesc;
ZeroMemory( &DSDesc, sizeof(D3D11_DEPTH_STENCIL_DESC) );
DSDesc.DepthEnable = FALSE;
DSDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
DSDesc.DepthFunc = D3D11_COMPARISON_LESS;
DSDesc.StencilEnable = FALSE;
DSDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
DSDesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
hr = pd3dDevice->CreateDepthStencilState( &DSDesc, &g_pDepthStencilState );
ASSERT( SUCCEEDED(hr) );
D3D11_RASTERIZER_DESC RSDesc;
ZeroMemory( &RSDesc, sizeof(RSDesc) );
RSDesc.AntialiasedLineEnable = FALSE;
RSDesc.CullMode = D3D11_CULL_BACK;
RSDesc.DepthBias = 0;
RSDesc.DepthBiasClamp = 0.0f;
RSDesc.DepthClipEnable = TRUE;
RSDesc.FillMode = D3D11_FILL_SOLID;
RSDesc.FrontCounterClockwise = FALSE;
RSDesc.MultisampleEnable = TRUE;
RSDesc.ScissorEnable = FALSE;
RSDesc.SlopeScaledDepthBias = 0.0f;
hr = pd3dDevice->CreateRasterizerState( &RSDesc, &g_pRasterizerState );
ASSERT( SUCCEEDED(hr) );
g_pcbVSPerObject11 = CreateConstantBuffer( pd3dDevice, sizeof(CB_VS_PER_OBJECT) );
DXUT_SetDebugName( g_pcbVSPerObject11, "CB_VS_PER_OBJECT" );
// Create other render resources here
D3D11_TILED_EMULATION_PARAMETERS EmulationParams;
EmulationParams.DefaultPhysicalTileFormat = DXGI_FORMAT_R8G8B8A8_UNORM;
EmulationParams.MaxPhysicalTileCount = 1000;
D3D11CreateTiledResourceDevice( pd3dDevice, pd3dImmediateContext, &EmulationParams, &g_pd3dDeviceEx );
g_pd3dDeviceEx->CreateTilePool( &g_pTilePool );
g_pTitleResidencyManager = new TitleResidencyManager( pd3dDevice, pd3dImmediateContext, 1, EmulationParams.MaxPhysicalTileCount, g_pTilePool );
ResidencySampleRender::Initialize( pd3dDevice );
g_PageDebugRender.Initialize( pd3dDevice );
CreateSceneGeometry( pd3dDevice );
// Setup the camera's view parameters
XMMATRIX matProjection = XMMatrixPerspectiveFovLH( XM_PIDIV4, (FLOAT)pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height, 0.001f, 100.0f );
XMStoreFloat4x4A( &g_matProjection, matProjection );
UpdateViewMatrix();
g_pTitleResidencyManager->StartThreads();
return S_OK;
}
void ObjMeshInfo::loadMesh(ID3D11Device* pd3dDevice)
{
if (!fromFile)
{
specialLoad(pd3dDevice);
return;
}
std::wifstream fileStream;
std::wstring line;
std::vector <XMFLOAT3> vectorVertices(0);
std::vector <XMFLOAT3> vectorNormals(0);
std::vector <XMFLOAT2> vectorUVs(0);
std::vector <Index> vectorIndices(0);
std::vector <Material> vectorTextureFiles(0);
fileStream.open(file);
bool isOpen = fileStream.is_open(); //debugging only.
// convert LPCTSTR to WCHAR
WCHAR wfile[200];
wcscpy(wfile, file);
// get the folder so we can prepend it to filenames later
WCHAR folder[200];
getFolder(folder, wfile);
bool newMaterial = false;
WCHAR materialName[200];
// now we can start to read the obj file!
while (std::getline(fileStream, line))
{
line = TrimStart(line);
// materials
if (line.compare(0, 7, L"usemtl ") == 0)
{
WCHAR first[20];
// I'm actually treating a 'material' as a submesh. not sure if this is correct
WCHAR oldStyleStr[200];
wcscpy(oldStyleStr, line.c_str());
swscanf(oldStyleStr, L"%7s%s", first, materialName);
// we want the next index to have the newMaterial flag
newMaterial = true;
continue;
}
//******************************************************************//
// If true, we have found a vertex. Read it in as a 2 character //
// string, followed by 3 decimal numbers. Suprisingly the C++ //
// string has no split() method. I am using really old stuff, //
// fscanf. There must be a better way, use regular expressions? //
//******************************************************************//
if (line.compare(0, 2, L"v ") == 0) //"v space"
{
WCHAR first[10];
float x, y, z;
WCHAR oldStyleStr[200];
wcscpy(oldStyleStr, line.c_str());
swscanf(oldStyleStr, L"%2s%f%f%f", first, &x, &y, &z);
XMFLOAT3 v = XMFLOAT3(x, y, z);
vectorVertices.push_back(v);
continue;
}
// normals
if (line.compare(0, 3, L"vn ") == 0) //"vn space"
{
WCHAR first[10];
float x, y, z;
WCHAR oldStyleStr[200];
wcscpy(oldStyleStr, line.c_str());
swscanf(oldStyleStr, L"%3s%f%f%f", first, &x, &y, &z);
XMFLOAT3 v = XMFLOAT3(x, y, z);
vectorNormals.push_back(v);
continue;
}
// texture coordinates
if (line.compare(0, 3, L"vt ") == 0) //"vt space"
{
WCHAR first[10];
float u, v;
WCHAR oldStyleStr[200];
wcscpy(oldStyleStr, line.c_str());
swscanf(oldStyleStr, L"%3s%f%f", first, &u, &v);
XMFLOAT2 vert = XMFLOAT2(u, v);
vectorUVs.push_back(vert);
continue;
}
//******************************************************************//
// If true, we have found a face. Read it in as a 2 character //
// string, followed by 3 decimal numbers. Suprisingly the C++ //
// string has no split() method. I am using really old stuff, //
// fscanf. There must be a better way, use regular expressions? //
// //
// It assumes the line is in the format //
// f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3 ... //
//******************************************************************//
if (line.compare(0, 2, L"f ") == 0) //"f space"
{
WCHAR first[10];
WCHAR slash1[10];
WCHAR slash2[10];
WCHAR slash3[10];
WCHAR slash4[10];
WCHAR slash5[10];
WCHAR slash6[10];
UINT v1, vt1, vn1, v2, vt2, vn2, v3, vt3, vn3;
WCHAR oldStyleStr[200];
wcscpy(oldStyleStr, line.c_str());
swscanf(oldStyleStr, L"%2s%d%1s%d%1s%d%d%1s%d%1s%d%d%1s%d%1s%d", first,
&v1, slash1, &vt1, slash2, &vn1,
&v2, slash3, &vt2, slash4, &vn2,
&v3, slash5, &vt3, slash6, &vn3);
Index input;
input.v = v1 - 1;
input.vt = vt1 - 1;
input.vn = vn1 - 1;
if (newMaterial)
{
input.newMaterial = true;
wcscpy(input.materialName, materialName);
newMaterial = false;
}
vectorIndices.push_back(input);
input.newMaterial = false;
input.v = v2 - 1;
input.vt = vt2 - 1;
input.vn = vn2 - 1;
vectorIndices.push_back(input);
input.v = v3 - 1;
input.vt = vt3 - 1;
input.vn = vn3 - 1;
vectorIndices.push_back(input);
continue;
}
// get mtl file name
if (line.compare(0, 7, L"mtllib ") == 0)
{
WCHAR first[10], mtlFileName[200];
WCHAR oldStyleStr[200];
wcscpy(oldStyleStr, line.c_str());
swscanf(oldStyleStr, L"%7s%s", first, &mtlFileName);
// read the mtl file
// we need to prepend the folder name and stuff to the mtl file name
WCHAR fullMtlFilePath[200];
wcscpy(fullMtlFilePath, folder);
wcsncat(fullMtlFilePath, mtlFileName, 200);
readMtlFile(&vectorTextureFiles, fullMtlFilePath, folder);
continue;
}
}
//******************************************************************//
// SIMPLIFICATION //
//******************************************************************//
// so the problem with obj files is that the indices are stored as v/vt/vn
// whereas directx can only handle indices of ...vertices (as far as I'm aware)
// so what we need to do is find the indices that are completely unique (completely original combination of v/vt/vn)
// and make them vertices, referencing them with 1 number instead of 3
std::vector <SimpleVertex> simplifiedVertices(0);
std::vector <Index> uniqueIndices(0);
std::vector <MeshMaterial> vectorSubsets(0);
USHORT uniqueIndexCount = 0;
USHORT subsetIndexCount = 0;
USHORT totalIndexCount = 0;
// for each index
for (int i = 0; i < vectorIndices.size(); i++)
{
Index idx = vectorIndices[i];
// if idx is the first index of a new material
if (idx.newMaterial)
{
// if this is not the first subset, we need to set the index count of the previous subset
if (vectorSubsets.size() > 0)
{
vectorSubsets.back().subset.ic = subsetIndexCount;
subsetIndexCount = 0;
}
// create a new subset
// this means we're creating a new subset even if we've already created one for the same material earlier on
// (and if the obj file doesn't start with a material this will go horribly wrong)
MeshMaterial meshMaterial;
meshMaterial.subset.is = totalIndexCount;
meshMaterial.subset.vs = simplifiedVertices.size();
// also, we need to wipe the uniqueIndices vector, because we don't want indices from different subsets referencing the same vertices
uniqueIndices.clear();
uniqueIndexCount = 0;
// find the material properties
// which at the moment consists of just the texture
for (int i = 0; i < vectorTextureFiles.size(); i++)
{
// if the material name matches
if (wcscmp(idx.materialName, vectorTextureFiles[i].materialName) == 0)
{
Material * material = &vectorTextureFiles[i];
if (material->hasTexture)
{
wcscpy(meshMaterial.textureFilePath, material->textureFilePath);
meshMaterial.hasTexture = true;
}
//meshMaterial.subset.color = vectorTextureFiles[i].color;
}
}
vectorSubsets.push_back(meshMaterial);
}
std::vector <Index> matchingV(0);
// of uniqueIndices, find matching v
for (size_t i = 0; i < uniqueIndices.size(); i++)
{
Index vert = uniqueIndices[i];
if (idx.v == vert.v)
{
// add to matchingV
matchingV.push_back(vert);
}
}
std::vector <Index> matchingVn(0);
// of the ones we found, find matching vn
for (size_t i = 0; i < matchingV.size(); i++)
{
Index vert = matchingV[i];
if (idx.vn == vert.vn)
{
// add to matchingVn
matchingVn.push_back(vert);
}
}
std::vector <Index> matchingVt(0);
// of the ones we found, find matching vt
for (size_t i = 0; i < matchingVn.size(); i++)
{
Index vert = matchingVn[i];
if (idx.vt == vert.vt)
{
// add to matchingVn
matchingVt.push_back(vert);
}
}
USHORT thisIndex;
// if matchingVt is empty then this is unique
if (matchingVt.size() == 0)
{
// create a uniqueIndex
Index uniqueIndex = idx;
uniqueIndex.vertex = uniqueIndexCount;
uniqueIndices.push_back(uniqueIndex);
// this is where we also create the vertex
SimpleVertex newVertex;
// we have to get the data from the vectors
newVertex.Pos = vectorVertices[idx.v];
newVertex.TexUV = vectorUVs[idx.vt];
newVertex.VecNormal = vectorNormals[idx.vn];
simplifiedVertices.push_back(newVertex);
// also do this
thisIndex = uniqueIndexCount;
uniqueIndexCount++;
}
else
{
// otherwise there should be one left, meaning we got a complete match
// now we can reference that vertex instead
thisIndex = matchingVt[0].vertex;
}
vectorIndices[i].vertex = thisIndex;
subsetIndexCount++;
totalIndexCount++;
}
// we need to set the index count of the final subset here
// we're not checking if vectorSubsets.size() is zero because that should never happen!
vectorSubsets.back().subset.ic = subsetIndexCount;
//******************************************************************//
// SUBSETS //
//******************************************************************//
objMesh.numSs = vectorSubsets.size();
objMesh.subsets = new ObjMeshSubset[objMesh.numSs];
for (int i = 0; i < objMesh.numSs; i++)
{
objMesh.subsets[i] = vectorSubsets[i].subset;
// also do the textures while we're here
ObjMeshSubset * subset = &objMesh.subsets[i];
subset->hastxtrz = vectorSubsets[i].hasTexture;
if (subset->hastxtrz)
{
// create the texture resource
D3DX11CreateShaderResourceViewFromFile(pd3dDevice,
vectorSubsets[i].textureFilePath,
NULL, NULL,
&subset->txtr, // This is returned.
NULL);
DXUT_SetDebugName(subset->txtr, "MESH_TEXTURE");
}
}
//******************************************************************//
// VERTICES //
//******************************************************************//
objMesh.numVertices = simplifiedVertices.size();
objMesh.vertices = new SimpleVertex[objMesh.numVertices];
for (int i = 0; i < objMesh.numVertices; i++)
objMesh.vertices[i] = simplifiedVertices[i];
//******************************************************************//
// INDICES //
//******************************************************************//
objMesh.numIndices = vectorIndices.size();
objMesh.indexes = new USHORT[objMesh.numIndices];
for (int i = 0; i < objMesh.numIndices; i++)
objMesh.indexes[i] = vectorIndices[i].vertex;
//******************************************************************//
// BUFFERS //
//******************************************************************//
// Create the vertex buffer
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(SimpleVertex) * objMesh.numVertices;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA InitData;
ZeroMemory(&InitData, sizeof(InitData));
InitData.pSysMem = objMesh.vertices;
pd3dDevice->CreateBuffer(&bd, &InitData, &objMesh.vb);
DXUT_SetDebugName(objMesh.vb, "VERTEX_BUFFER");
// create the index buffer
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(USHORT) * objMesh.numIndices;
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
InitData.pSysMem = objMesh.indexes;
pd3dDevice->CreateBuffer(&bd, &InitData, &objMesh.ib);
DXUT_SetDebugName(objMesh.ib, "INDEX_BUFFER");
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
V_RETURN( g_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) );
g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 );
// D3DXVECTOR3 vCenter( 0.25767413f, -28.503521f, 111.00689f );
FLOAT fObjectRadius = 378.15607f;
lightpos = D3DXVECTOR3(300,300,-200);
//test = new testing();
hr = test.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = tessplane.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = tesscube.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,80,D3DXVECTOR3(300,50,-200));//D3DXVECTOR3(300,50,-200
hr = lightsphere.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,10,lightpos);
hr = fuse.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = board1.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(300,-300,-1000));
hr = deboard.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(-300,-300,-1000));
hr = geo_alien.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = FirePart.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,80,0); //0 = fire
hr = sky.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(0,0,0));
hr = buildings.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = MissilePart.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,20,1);
g_LightControl.SetRadius( 2000 );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 50.0f, -1000.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
g_Camera.SetRotateButtons(true,false,false);
g_Camera.SetViewParams( &vecEye, &vecAt );
g_Camera.SetEnablePositionMovement( true );
g_Camera.SetScalers( 0.005f, 500.0f );
D3D11_DEPTH_STENCIL_DESC descDS;
ZeroMemory(&descDS, sizeof(descDS));
descDS.DepthEnable = false;
descDS.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
descDS.DepthFunc = D3D11_COMPARISON_LESS;
descDS.StencilEnable = FALSE;
hr = pd3dDevice->CreateDepthStencilState( &descDS, &g_DepthState);
//setup stuff for post process
ID3DBlob* pVertexShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"PP1.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) );
ID3DBlob* pPixelShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"PP1.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) );
V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPFirstPass ) );
DXUT_SetDebugName( VSPPFirstPass, "VSPost1" );
V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPFirstPass ) );
DXUT_SetDebugName( PSPPFirstPass, "PSPost1" );
pVertexShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"Gaussblur.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) );
pPixelShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"Gaussblur.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) );
V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPBlur ) );
DXUT_SetDebugName( VSPPBlur, "VSBlur" );
V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPBlur ) );
DXUT_SetDebugName( PSPPBlur, "PSBlur" );
pVertexShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"bloom_combine.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) );
pPixelShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"bloom_combine.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) );
V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPComb ) );
DXUT_SetDebugName( VSPPComb, "VSComb" );
V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPComb ) );
DXUT_SetDebugName( PSPPComb, "PSComb" );
D3D11_BUFFER_DESC Desc;
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof( blur_cbuffer );
V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &blur_cb_buffer ) );
DXUT_SetDebugName( blur_cb_buffer, "blur_cb" );
//g_Camera.SetRadius( fObjectRadius * 3.0f, fObjectRadius * 0.5f, fObjectRadius * 10.0f );
return S_OK;
}
//--------------------------------------------------------------------------------------
// FillGrid_WithNormals_Indexed
// Creates a regular grid of indexed triangles, including normals.
//
// Parameters:
//
// IN
// pd3dDevice: The D3D device
// dwWidth, dwLength: Number of grid vertices in X and Z direction
// fGridSizeX, fGridSizeZ: Grid extents in local space units
//
// OUT
// lplpVB: A pointer to the vertex buffer containing grid vertices
// lplpIB: A pointer to the index buffer containing grid indices
//--------------------------------------------------------------------------------------
void FillGrid_WithNormals_Indexed( ID3D11Device* pd3dDevice, DWORD dwWidth, DWORD dwLength,
float fGridSizeX, float fGridSizeZ,
ID3D11Buffer** lplpVB, ID3D11Buffer** lplpIB )
{
HRESULT hr;
DWORD nNumVertex = ( dwWidth + 1 ) * ( dwLength + 1 );
DWORD nNumIndex = 3 * 2 * dwWidth * dwLength;
float fStepX = fGridSizeX / dwWidth;
float fStepZ = fGridSizeZ / dwLength;
// Allocate memory for buffer of vertices in system memory
EXTENDEDVERTEX* pVertexBuffer = new EXTENDEDVERTEX[nNumVertex];
EXTENDEDVERTEX* pVertex = &pVertexBuffer[0];
// Fill vertex buffer
for ( DWORD i=0; i<=dwLength; ++i )
{
for ( DWORD j=0; j<=dwWidth; ++j )
{
pVertex->x = -fGridSizeX/2.0f + j*fStepX;
pVertex->y = 0.0f;
pVertex->z = fGridSizeZ/2.0f - i*fStepZ;
pVertex->nx = 0.0f;
pVertex->ny = 0.0f;
pVertex->nz = 0.0f;
pVertex->u = 0.0f + ( (float)j / dwWidth );
pVertex->v = 0.0f + ( (float)i / dwLength );
pVertex++;
}
}
// Allocate memory for buffer of indices in system memory
WORD* pIndexBuffer = new WORD [nNumIndex];
WORD* pIndex = &pIndexBuffer[0];
// Fill index buffer
for ( DWORD i=0; i<dwLength; ++i )
{
for ( DWORD j=0; j<dwWidth; ++j )
{
*pIndex++ = (WORD)( i * ( dwWidth+1 ) + j );
*pIndex++ = (WORD)( i * ( dwWidth+1 ) + j + 1 );
*pIndex++ = (WORD)( ( i+1 ) * ( dwWidth+1 ) + j );
*pIndex++ = (WORD)( ( i+1 ) * (dwWidth+1) + j );
*pIndex++ = (WORD)( i * (dwWidth+1) + j + 1 );
*pIndex++ = (WORD)( ( i+1 ) * (dwWidth+1) + j + 1 );
}
}
// Set initial data info
D3D11_SUBRESOURCE_DATA InitData;
InitData.pSysMem = pIndexBuffer;
// Fill DX11 index buffer description
D3D11_BUFFER_DESC bd;
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( WORD ) * nNumIndex;
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
// Create DX11 index buffer specifying initial data
hr = pd3dDevice->CreateBuffer( &bd, &InitData, lplpIB );
if( FAILED( hr ) )
{
OutputDebugString( L"FillGrid_WithNormals_Indexed: Failed to create index buffer.\n" );
return;
}
DXUT_SetDebugName( *lplpIB, "FillGrid IB Nrmls" );
// Write normals into vertex buffer
pVertex = &pVertexBuffer[0];
// Loop through all indices
for ( DWORD i=0; i<nNumIndex/3; ++i )
{
WORD i1 = pIndexBuffer[3*i + 0];
WORD i2 = pIndexBuffer[3*i + 1];
WORD i3 = pIndexBuffer[3*i + 2];
D3DXVECTOR3 Normal = CalculateTriangleNormal( (D3DXVECTOR3 *)&pVertexBuffer[i1].x,
(D3DXVECTOR3 *)&pVertexBuffer[i2].x,
(D3DXVECTOR3 *)&pVertexBuffer[i3].x );
// Add normal to each vertex for this triangle
*( (D3DXVECTOR3 *)&pVertexBuffer[i1].nx ) += Normal;
*( (D3DXVECTOR3 *)&pVertexBuffer[i2].nx ) += Normal;
*( (D3DXVECTOR3 *)&pVertexBuffer[i3].nx ) += Normal;
}
// Final normalization pass
for ( DWORD i=0; i<nNumVertex; ++i )
{
D3DXVec3Normalize( (D3DXVECTOR3 *)&pVertexBuffer[i].nx, (D3DXVECTOR3 *)&pVertexBuffer[i].nx );
}
// Set initial data info
InitData.pSysMem = pVertexBuffer;
// Fill DX11 vertex buffer description
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( EXTENDEDVERTEX ) * nNumVertex;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
// Create DX11 vertex buffer specifying initial data
hr = pd3dDevice->CreateBuffer( &bd, &InitData, lplpVB );
if( FAILED( hr ) )
{
OutputDebugString( L"FillGrid_WithNormals_Indexed: Failed to create vertex buffer.\n" );
return;
}
DXUT_SetDebugName( *lplpVB, "FillGrid VB Nrmls Idx" );
// Release host memory index buffer
delete [] pIndexBuffer;
// Release host memory vertex buffer
delete [] pVertexBuffer;
}
//--------------------------------------------------------------------------------------
// render callback
//--------------------------------------------------------------------------------------
void CALLBACK OnD3D11FrameRender( ID3D11Device* pd3dDevice,
ID3D11DeviceContext* pd3dImmediateContext,
double fTime,
float fElapsedTime, void* pUserContext )
{
static int s_iCounter = 0;
// If the settings dialog is being shown, then render it instead of rendering the app's scene
if( g_D3DSettingsDlg.IsActive() )
{
g_D3DSettingsDlg.OnRender( fElapsedTime );
return;
}
if( g_pScenePS == NULL && s_iCounter == 0 )
{
s_iCounter = 4;
}
if( s_iCounter > 0 )
s_iCounter --;
if( s_iCounter == 1 && g_pScenePS == NULL )
{
HRESULT hr = S_OK;
// Create the shaders
ID3DBlob* pBlob = NULL;
// VS
hr = CompileShaderFromFile( L"ContactHardeningShadows11.hlsl", "VS_RenderScene", "vs_5_0", &pBlob );
hr = pd3dDevice->CreateVertexShader( pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &g_pSceneVS );
DXUT_SetDebugName( g_pSceneVS, "VS_RenderScene" );
// Define our scene vertex data layout
const D3D11_INPUT_ELEMENT_DESC SceneLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXTURE", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
hr = pd3dDevice->CreateInputLayout( SceneLayout, ARRAYSIZE( SceneLayout ), pBlob->GetBufferPointer(),
pBlob->GetBufferSize(), &g_pSceneVertexLayout );
SAFE_RELEASE( pBlob );
DXUT_SetDebugName( g_pSceneVertexLayout, "SceneLayout" );
hr = CompileShaderFromFile( L"ContactHardeningShadows11.hlsl", "VS_RenderSceneSM", "vs_5_0", &pBlob );
hr = pd3dDevice->CreateVertexShader( pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &g_pSM_VS );
SAFE_RELEASE( pBlob );
DXUT_SetDebugName( g_pSM_VS, "VS_RenderSceneSM" );
// PS
hr = CompileShaderFromFile( L"ContactHardeningShadows11.hlsl", "PS_RenderScene", "ps_5_0", &pBlob );
hr = pd3dDevice->CreatePixelShader( pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &g_pScenePS );
SAFE_RELEASE( pBlob );
DXUT_SetDebugName( g_pScenePS, "PS_RenderScene" );
s_iCounter = 0;
}
else if( g_pScenePS != NULL )
{
ID3D11RenderTargetView* pRTV[2] = { NULL,NULL };
ID3D11ShaderResourceView* pSRV[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
// Array of our samplers
ID3D11SamplerState* ppSamplerStates[3] = { g_pSamplePoint, g_pSampleLinear, g_pSamplePointCmp };
pd3dImmediateContext->PSSetSamplers( 0, 3, ppSamplerStates );
// Store off original render target, this is the back buffer of the swap chain
ID3D11RenderTargetView* pOrigRTV = DXUTGetD3D11RenderTargetView();
ID3D11DepthStencilView* pOrigDSV = DXUTGetD3D11DepthStencilView();
// Clear the render target
float ClearColor[4] = { 0.0f, 0.25f, 0.25f, 0.55f };
pd3dImmediateContext->ClearRenderTargetView( DXUTGetD3D11RenderTargetView(),
ClearColor );
pd3dImmediateContext->ClearDepthStencilView( DXUTGetD3D11DepthStencilView(),
D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL,
1.0, 0 );
// Get the projection & view matrix from the camera class
D3DXMATRIXA16 mWorld;
D3DXMATRIXA16 mView;
D3DXMATRIXA16 mProj;
D3DXMATRIXA16 mViewProjLight;
D3DXMATRIXA16 mWorldViewProjection;
D3DXVECTOR3 vLightDir;
// disable color writes
pd3dImmediateContext->OMSetBlendState(g_pBlendStateColorWritesOff, 0, 0xffffffff);
RenderShadowMap( pd3dDevice, pd3dImmediateContext, mViewProjLight, vLightDir );
// enable color writes
pd3dImmediateContext->OMSetBlendState(g_pBlendStateNoBlend, 0, 0xffffffff);
mView = *g_Camera.GetViewMatrix();
mProj = *g_Camera.GetProjMatrix();
mWorldViewProjection = mView * mProj;
// Setup the constant buffer for the scene vertex shader
D3D11_MAPPED_SUBRESOURCE MappedResource;
pd3dImmediateContext->Map( g_pcbConstants, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource );
CB_CONSTANTS* pConstants = ( CB_CONSTANTS* )MappedResource.pData;
D3DXMatrixTranspose( &pConstants->f4x4WorldViewProjection, &mWorldViewProjection );
D3DXMatrixTranspose( &pConstants->f4x4WorldViewProjLight, &mViewProjLight );
pConstants->vShadowMapDimensions = D3DXVECTOR4(g_fShadowMapWidth, g_fShadowMapHeight,
1.0f/g_fShadowMapWidth,
1.0f/g_fShadowMapHeight);
pConstants->vLightDir = D3DXVECTOR4( vLightDir.x, vLightDir.y,
vLightDir.z, 0.0f );
pConstants->fSunWidth = g_fSunWidth;
pd3dImmediateContext->Unmap( g_pcbConstants, 0 );
pd3dImmediateContext->VSSetConstantBuffers( g_iCONSTANTSCBBind, 1, &g_pcbConstants );
pd3dImmediateContext->PSSetConstantBuffers( g_iCONSTANTSCBBind, 1, &g_pcbConstants );
// Set the shaders
pd3dImmediateContext->VSSetShader( g_pSceneVS, NULL, 0 );
pd3dImmediateContext->PSSetShader( g_pScenePS, NULL, 0 );
// Set the vertex buffer format
pd3dImmediateContext->IASetInputLayout( g_pSceneVertexLayout );
// Rebind to original back buffer and depth buffer
pRTV[0] = pOrigRTV;
pd3dImmediateContext->OMSetRenderTargets(1, pRTV, pOrigDSV );
// set the shadow map
pd3dImmediateContext->PSSetShaderResources( 1, 1, &g_pDepthTextureSRV );
// Render the scene
g_SceneMesh.Render( pd3dImmediateContext, 0 );
g_Poles.Render( pd3dImmediateContext, 0 );
// restore resources
pd3dImmediateContext->PSSetShaderResources( 0, 8, pSRV );
}
// Render GUI
DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"HUD / Stats" );
if( g_bGuiVisible )
{
g_HUD.OnRender( fElapsedTime );
g_SampleUI.OnRender( fElapsedTime );
}
RenderText();
DXUT_EndPerfEvent();
}
