std::shared_ptr<GraphicsPipelineState> Device::createGraphicsPipelineState(const GraphicsPipelineStateParams& params)
{
ID3D11VertexShader* vertexShader = nullptr;
if (SUCCEEDED(m_device->CreateVertexShader(params.m_vsParams.m_shaderBytecode, params.m_vsParams.m_bytecodeLength, nullptr, &vertexShader)))
{
ID3D11ShaderReflection* vertexShaderReflector = nullptr;
if (SUCCEEDED(D3DReflect(params.m_vsParams.m_shaderBytecode, params.m_vsParams.m_bytecodeLength, IID_ID3D11ShaderReflection, (void**)&vertexShaderReflector)))
{
ID3D11PixelShader* pixelShader = nullptr;
if (SUCCEEDED(m_device->CreatePixelShader(params.m_psParams.m_shaderBytecode, params.m_psParams.m_bytecodeLength, nullptr, &pixelShader)))
{
ID3D11ShaderReflection* pixelShaderReflector = nullptr;
if (SUCCEEDED(D3DReflect(params.m_psParams.m_shaderBytecode, params.m_psParams.m_bytecodeLength, IID_ID3D11ShaderReflection, (void**)&pixelShaderReflector)))
{
CD3D11_DEPTH_STENCIL_DESC depthStencilDesc(D3D11_DEFAULT);
depthStencilDesc.DepthEnable = params.m_depthStencilParams.m_depthEnable;
ID3D11DepthStencilState* depthStencilState = nullptr;
if (SUCCEEDED(m_device->CreateDepthStencilState(&depthStencilDesc, &depthStencilState)))
{
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 },
};
ID3D11InputLayout* inputLayout = nullptr;
if (SUCCEEDED(m_device->CreateInputLayout(layout, ARRAYSIZE(layout), params.m_vsParams.m_shaderBytecode, params.m_vsParams.m_bytecodeLength, &inputLayout)))
{
return std::make_shared<GraphicsPipelineState>(vertexShader, vertexShaderReflector, pixelShader, pixelShaderReflector, depthStencilState, params.m_stencilRef, inputLayout, params.m_primitiveTopologyType);
}
depthStencilState->Release();
}
pixelShaderReflector->Release();
}
pixelShader->Release();
}
vertexShaderReflector->Release();
}
vertexShader->Release();
}
return nullptr;
}
int Release() {
if (VS)
VS->Release();
if (PS)
PS->Release();
if (inputLayout)
inputLayout->Release();
if (vertexBuffer)
vertexBuffer->Release();
return 0;
}
bool
DX11ResourceManager::initializeDefaultSurfaceEffect( const MString& effectsLocation, ID3D11Device* D3D,
const MString& effectName,
const MString& vsName, const MString& psName,
const D3D11_INPUT_ELEMENT_DESC* layout, int numLayoutElements )
//
// Description:
// Initialize default surface effects found in a given directory.
//
{
HRESULT hres;
MString effectLocation = effectsLocation + "\\" + effectName + ".hlsl";
ID3DBlob* pVSBlob = NULL;
hres = CompileShaderFromFile( effectLocation.asChar(), vsName.asChar(), "vs_4_0", &pVSBlob );
if (FAILED(hres))
{
MGlobal::displayInfo("Failed to compile vertex shader " + vsName + " in file: " + effectLocation);
return false;
}
ID3D11VertexShader* pVertexShader = NULL;
hres = D3D->CreateVertexShader( pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), NULL, &pVertexShader );
if (FAILED(hres))
{
MGlobal::displayInfo("Failed to create vertex shader " + vsName + " in file: " + effectLocation);
pVSBlob->Release();
return false;
}
ID3D11InputLayout* pVertexLayout = NULL;
hres = D3D->CreateInputLayout( layout, numLayoutElements, pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), &pVertexLayout );
pVSBlob->Release();
if (FAILED(hres))
{
MGlobal::displayInfo("Failed to create input layout for file: " + effectLocation);
return false;
}
ID3DBlob* pPSBlob = NULL;
hres = CompileShaderFromFile( effectLocation.asChar(), psName.asChar(), "ps_4_0", &pPSBlob );
if (FAILED(hres))
{
MGlobal::displayInfo("Failed to compile pixel shader " + psName + " in file: " + effectLocation);
pVertexShader->Release();
pVertexLayout->Release();
return false;
}
ID3D11PixelShader* pPixelShader = NULL;
hres = D3D->CreatePixelShader( pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, &pPixelShader );
pPSBlob->Release();
if (FAILED(hres))
{
MGlobal::displayInfo("Failed to create pixel shader " + psName + " in file: " + effectLocation);
pVertexShader->Release();
pVertexLayout->Release();
return false;
}
// Create a new effect item
//
MGlobal::displayInfo("Maya default pixel shader loaded: " + effectLocation);
SurfaceEffectItem *pei = new SurfaceEffectItem;
if (pei)
{
pei->fVertexShader = pVertexShader;
pei->fPixelShader = pPixelShader;
pei->fInputLayout = pVertexLayout;
m_SurfaceEffectItemList[ effectName.asChar() ] = pei;
}
return true;
}
// Create point to quad geometry shader
HRESULT CFW1GlyphRenderStates::createGlyphShaders() {
if(m_featureLevel < D3D_FEATURE_LEVEL_10_0)
return E_FAIL;
// Geometry shader constructing glyphs from point input and texture buffer
const char gsSimpleStr[] =
"cbuffer ShaderConstants : register(b0) {\r\n"
" float4x4 TransformMatrix : packoffset(c0);\r\n"
"};\r\n"
"\r\n"
"Buffer<float4> tex0 : register(t0);\r\n"
"\r\n"
"struct GSIn {\r\n"
" float3 PositionIndex : POSITIONINDEX;\r\n"
" float4 GlyphColor : GLYPHCOLOR;\r\n"
"};\r\n"
"\r\n"
"struct GSOut {\r\n"
" float4 Position : SV_Position;\r\n"
" float4 GlyphColor : COLOR;\r\n"
" float2 TexCoord : TEXCOORD;\r\n"
"};\r\n"
"\r\n"
"[maxvertexcount(4)]\r\n"
"void GS(point GSIn Input[1], inout TriangleStream<GSOut> TriStream) {\r\n"
" const float2 basePosition = Input[0].PositionIndex.xy;\r\n"
" const uint glyphIndex = asuint(Input[0].PositionIndex.z);\r\n"
" \r\n"
" float4 texCoords = tex0.Load(uint2(glyphIndex*2, 0));\r\n"
" float4 offsets = tex0.Load(uint2(glyphIndex*2+1, 0));\r\n"
" \r\n"
" GSOut Output;\r\n"
" Output.GlyphColor = Input[0].GlyphColor;\r\n"
" \r\n"
" float4 positions = basePosition.xyxy + offsets;\r\n"
" \r\n"
" Output.Position = mul(TransformMatrix, float4(positions.xy, 0.0f, 1.0f));\r\n"
" Output.TexCoord = texCoords.xy;\r\n"
" TriStream.Append(Output);\r\n"
" \r\n"
" Output.Position = mul(TransformMatrix, float4(positions.zy, 0.0f, 1.0f));\r\n"
" Output.TexCoord = texCoords.zy;\r\n"
" TriStream.Append(Output);\r\n"
" \r\n"
" Output.Position = mul(TransformMatrix, float4(positions.xw, 0.0f, 1.0f));\r\n"
" Output.TexCoord = texCoords.xw;\r\n"
" TriStream.Append(Output);\r\n"
" \r\n"
" Output.Position = mul(TransformMatrix, float4(positions.zw, 0.0f, 1.0f));\r\n"
" Output.TexCoord = texCoords.zw;\r\n"
" TriStream.Append(Output);\r\n"
" \r\n"
" TriStream.RestartStrip();\r\n"
"}\r\n"
"";
// Geometry shader with rect clipping
const char gsClipStr[] =
"cbuffer ShaderConstants : register(b0) {\r\n"
" float4x4 TransformMatrix : packoffset(c0);\r\n"
" float4 ClipRect : packoffset(c4);\r\n"
"};\r\n"
"\r\n"
"Buffer<float4> tex0 : register(t0);\r\n"
"\r\n"
"struct GSIn {\r\n"
" float3 PositionIndex : POSITIONINDEX;\r\n"
" float4 GlyphColor : GLYPHCOLOR;\r\n"
"};\r\n"
"\r\n"
"struct GSOut {\r\n"
" float4 Position : SV_Position;\r\n"
" float4 GlyphColor : COLOR;\r\n"
" float2 TexCoord : TEXCOORD;\r\n"
" float4 ClipDistance : SV_ClipDistance;\r\n"
"};\r\n"
"\r\n"
"[maxvertexcount(4)]\r\n"
"void GS(point GSIn Input[1], inout TriangleStream<GSOut> TriStream) {\r\n"
" const float2 basePosition = Input[0].PositionIndex.xy;\r\n"
" const uint glyphIndex = asuint(Input[0].PositionIndex.z);\r\n"
" \r\n"
" float4 texCoords = tex0.Load(uint2(glyphIndex*2, 0));\r\n"
" float4 offsets = tex0.Load(uint2(glyphIndex*2+1, 0));\r\n"
" \r\n"
" GSOut Output;\r\n"
" Output.GlyphColor = Input[0].GlyphColor;\r\n"
" \r\n"
" float4 positions = basePosition.xyxy + offsets;\r\n"
" \r\n"
" Output.Position = mul(TransformMatrix, float4(positions.xy, 0.0f, 1.0f));\r\n"
" Output.TexCoord = texCoords.xy;\r\n"
" Output.ClipDistance = ClipRect + float4(positions.xy, -positions.xy);\r\n"
" TriStream.Append(Output);\r\n"
" \r\n"
" Output.Position = mul(TransformMatrix, float4(positions.zy, 0.0f, 1.0f));\r\n"
" Output.TexCoord = texCoords.zy;\r\n"
" Output.ClipDistance = ClipRect + float4(positions.zy, -positions.zy);\r\n"
" TriStream.Append(Output);\r\n"
" \r\n"
" Output.Position = mul(TransformMatrix, float4(positions.xw, 0.0f, 1.0f));\r\n"
" Output.TexCoord = texCoords.xw;\r\n"
" Output.ClipDistance = ClipRect + float4(positions.xw, -positions.xw);\r\n"
" TriStream.Append(Output);\r\n"
" \r\n"
" Output.Position = mul(TransformMatrix, float4(positions.zw, 0.0f, 1.0f));\r\n"
" Output.TexCoord = texCoords.zw;\r\n"
" Output.ClipDistance = ClipRect + float4(positions.zw, -positions.zw);\r\n"
" TriStream.Append(Output);\r\n"
" \r\n"
" TriStream.RestartStrip();\r\n"
"}\r\n"
"";
// Vertex shader
const char vsEmptyStr[] =
"struct GSIn {\r\n"
" float3 PositionIndex : POSITIONINDEX;\r\n"
" float4 GlyphColor : GLYPHCOLOR;\r\n"
"};\r\n"
"\r\n"
"GSIn VS(GSIn Input) {\r\n"
" return Input;\r\n"
"}\r\n"
"";
// Shader compile profiles
const char *vs_profile = "vs_4_0";
const char *gs_profile = "gs_4_0";
if(m_featureLevel >= D3D_FEATURE_LEVEL_11_0) {
vs_profile = "vs_5_0";
gs_profile = "gs_5_0";
}
// Compile geometry shader
ID3DBlob *pGSCode;
HRESULT hResult = m_pfnD3DCompile(
gsSimpleStr,
sizeof(gsSimpleStr),
NULL,
NULL,
NULL,
"GS",
gs_profile,
D3DCOMPILE_OPTIMIZATION_LEVEL3,
0,
&pGSCode,
NULL
);
if(FAILED(hResult)) {
m_lastError = L"Failed to compile geometry shader";
}
else {
// Create geometry shader
ID3D11GeometryShader *pGS;
hResult = m_pDevice->CreateGeometryShader(pGSCode->GetBufferPointer(), pGSCode->GetBufferSize(), NULL, &pGS);
if(FAILED(hResult)) {
m_lastError = L"Failed to create geometry shader";
}
else {
// Compile clipping geometry shader
ID3DBlob *pGSClipCode;
hResult = m_pfnD3DCompile(
gsClipStr,
sizeof(gsClipStr),
NULL,
NULL,
NULL,
"GS",
gs_profile,
D3DCOMPILE_OPTIMIZATION_LEVEL3,
0,
&pGSClipCode,
NULL
);
if(FAILED(hResult)) {
m_lastError = L"Failed to compile clipping geometry shader";
}
else {
// Create clipping geometry shader
ID3D11GeometryShader *pGSClip;
hResult = m_pDevice->CreateGeometryShader(
pGSClipCode->GetBufferPointer(),
pGSClipCode->GetBufferSize(),
NULL,
&pGSClip
);
if(FAILED(hResult)) {
m_lastError = L"Failed to create clipping geometry shader";
}
else {
ID3DBlob *pVSEmptyCode;
// Compile vertex shader
hResult = m_pfnD3DCompile(
vsEmptyStr,
sizeof(vsEmptyStr),
NULL,
NULL,
NULL,
"VS",
vs_profile,
D3DCOMPILE_OPTIMIZATION_LEVEL3,
0,
&pVSEmptyCode,
NULL
);
if(FAILED(hResult)) {
m_lastError = L"Failed to compile empty vertex shader";
}
else {
// Create vertex shader
ID3D11VertexShader *pVSEmpty;
hResult = m_pDevice->CreateVertexShader(
pVSEmptyCode->GetBufferPointer(),
pVSEmptyCode->GetBufferSize(),
NULL,
&pVSEmpty
);
if(FAILED(hResult)) {
m_lastError = L"Failed to create empty vertex shader";
}
else {
ID3D11InputLayout *pInputLayout;
// Input layout for geometry shader
D3D11_INPUT_ELEMENT_DESC inputElements[] = {
{"POSITIONINDEX", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"GLYPHCOLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0}
};
hResult = m_pDevice->CreateInputLayout(
inputElements,
2,
pVSEmptyCode->GetBufferPointer(),
pVSEmptyCode->GetBufferSize(),
&pInputLayout
);
if(FAILED(hResult)) {
m_lastError = L"Failed to create input layout for geometry shader";
}
else {
// Success
m_pVertexShaderPoint = pVSEmpty;
m_pGeometryShaderPoint = pGS;
m_pGeometryShaderClipPoint = pGSClip;
m_pPointInputLayout = pInputLayout;
m_hasGeometryShader = true;
hResult = S_OK;
}
if(FAILED(hResult))
pVSEmpty->Release();
}
pVSEmptyCode->Release();
}
if(FAILED(hResult))
pGSClip->Release();
}
pGSClipCode->Release();
}
if(FAILED(hResult))
pGS->Release();
}
pGSCode->Release();
}
return hResult;
}
// Create quad shaders
HRESULT CFW1GlyphRenderStates::createQuadShaders() {
// Vertex shaders
const char vsSimpleStr[] =
"cbuffer ShaderConstants : register(b0) {\r\n"
" float4x4 TransformMatrix : packoffset(c0);\r\n"
"};\r\n"
"\r\n"
"struct VSIn {\r\n"
" float4 Position : POSITION;\r\n"
" float4 GlyphColor : GLYPHCOLOR;\r\n"
"};\r\n"
"\r\n"
"struct VSOut {\r\n"
" float4 Position : SV_Position;\r\n"
" float4 GlyphColor : COLOR;\r\n"
" float2 TexCoord : TEXCOORD;\r\n"
"};\r\n"
"\r\n"
"VSOut VS(VSIn Input) {\r\n"
" VSOut Output;\r\n"
" \r\n"
" Output.Position = mul(TransformMatrix, float4(Input.Position.xy, 0.0f, 1.0f));\r\n"
" Output.GlyphColor = Input.GlyphColor;\r\n"
" Output.TexCoord = Input.Position.zw;\r\n"
" \r\n"
" return Output;\r\n"
"}\r\n"
"";
const char vsClipStr[] =
"cbuffer ShaderConstants : register(b0) {\r\n"
" float4x4 TransformMatrix : packoffset(c0);\r\n"
" float4 ClipRect : packoffset(c4);\r\n"
"};\r\n"
"\r\n"
"struct VSIn {\r\n"
" float4 Position : POSITION;\r\n"
" float4 GlyphColor : GLYPHCOLOR;\r\n"
"};\r\n"
"\r\n"
"struct VSOut {\r\n"
" float4 Position : SV_Position;\r\n"
" float4 GlyphColor : COLOR;\r\n"
" float2 TexCoord : TEXCOORD;\r\n"
" float4 ClipDistance : CLIPDISTANCE;\r\n"
"};\r\n"
"\r\n"
"VSOut VS(VSIn Input) {\r\n"
" VSOut Output;\r\n"
" \r\n"
" Output.Position = mul(TransformMatrix, float4(Input.Position.xy, 0.0f, 1.0f));\r\n"
" Output.GlyphColor = Input.GlyphColor;\r\n"
" Output.TexCoord = Input.Position.zw;\r\n"
" Output.ClipDistance = ClipRect + float4(Input.Position.xy, -Input.Position.xy);\r\n"
" \r\n"
" return Output;\r\n"
"}\r\n"
"";
// Shader compile profile
const char *vs_profile = "vs_4_0_level_9_1";
if(m_featureLevel >= D3D_FEATURE_LEVEL_11_0)
vs_profile = "vs_5_0";
else if(m_featureLevel >= D3D_FEATURE_LEVEL_10_0)
vs_profile = "vs_4_0";
else if(m_featureLevel >= D3D_FEATURE_LEVEL_9_3)
vs_profile = "vs_4_0_level_9_3";
// Compile vertex shader
ID3DBlob *pVSCode;
HRESULT hResult = m_pfnD3DCompile(
vsSimpleStr,
sizeof(vsSimpleStr),
NULL,
NULL,
NULL,
"VS",
vs_profile,
D3DCOMPILE_OPTIMIZATION_LEVEL3,
0,
&pVSCode,
NULL
);
if(FAILED(hResult)) {
m_lastError = L"Failed to compile vertex shader";
}
else {
// Create vertex shader
ID3D11VertexShader *pVS;
hResult = m_pDevice->CreateVertexShader(pVSCode->GetBufferPointer(), pVSCode->GetBufferSize(), NULL, &pVS);
if(FAILED(hResult)) {
m_lastError = L"Failed to create vertex shader";
}
else {
// Compile clipping vertex shader
ID3DBlob *pVSClipCode;
hResult = m_pfnD3DCompile(
vsClipStr,
sizeof(vsClipStr),
NULL,
NULL,
NULL,
"VS",
vs_profile,
D3DCOMPILE_OPTIMIZATION_LEVEL3,
0,
&pVSClipCode,
NULL
);
if(FAILED(hResult)) {
m_lastError = L"Failed to compile clipping vertex shader";
}
else {
// Create vertex shader
ID3D11VertexShader *pVSClip;
hResult = m_pDevice->CreateVertexShader(
pVSClipCode->GetBufferPointer(),
pVSClipCode->GetBufferSize(),
NULL,
&pVSClip
);
if(FAILED(hResult)) {
m_lastError = L"Failed to create clipping vertex shader";
}
else {
// Create input layout
ID3D11InputLayout *pInputLayout;
// Quad vertex input layout
D3D11_INPUT_ELEMENT_DESC inputElements[] = {
{"POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"GLYPHCOLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0}
};
hResult = m_pDevice->CreateInputLayout(
inputElements,
2,
pVSCode->GetBufferPointer(),
pVSCode->GetBufferSize(),
&pInputLayout
);
if(FAILED(hResult)) {
m_lastError = L"Failed to create input layout";
}
else {
// Success
m_pVertexShaderQuad = pVS;
m_pVertexShaderClipQuad = pVSClip;
m_pQuadInputLayout = pInputLayout;
hResult = S_OK;
}
if(FAILED(hResult))
pVSClip->Release();
}
pVSClipCode->Release();
}
if(FAILED(hResult))
pVS->Release();
}
pVSCode->Release();
}
return hResult;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR cmdLine, int cmdShow)
{
DXTInputHandlerDefault inputHandler;
DXTWindowEventHandlerDefault eventHandler;
DXTWindow window(hInstance, &inputHandler, &eventHandler);
DXTRenderParams params;
params.Extent = { 800, 600 };
params.UseVSync = true;
params.Windowed = true;
HRESULT result;
result = window.Initialize(params, "DXT Example (DirectX 11)");
if (SUCCEEDED(result))
{
ID3D11Device* device;
ID3D11DeviceContext* context;
IDXGISwapChain* swapChain;
result = DXTInitDevice(params, &window, &swapChain, &device, &context);
if (SUCCEEDED(result))
{
eventHandler.SetSwapChain(swapChain);
FLOAT clearColor[] = { 0.5f, 0.5f, 1.0f, 1.0f };
D3D11_INPUT_ELEMENT_DESC inputDesc[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, sizeof(float) * 3, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, sizeof(float) * 5, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT elementCount = 3;
UINT stride = 8 * sizeof(FLOAT);
UINT offset = 0;
UINT indexCount = 0;
FLOAT deltaTime = 0.016f;
DXTSphericalCamera camera;
DXTFirstPersonCameraController cameraController(&camera, &inputHandler);
inputHandler.AddInputInterface(&cameraController);
cameraController.Velocity = 40.0f;
cameraController.RotationVelocity = 0.005f;
camera.Position = DirectX::XMFLOAT3(20.0f, 20.0f, 20.0f);
camera.LookAt(DirectX::XMFLOAT3(0.0f, 0.0f, 0.0f));
ID3D11RenderTargetView* renderTargetView;
ID3D11Texture2D* depthBuffer;
ID3D11DepthStencilView* depthBufferView;
ID3D11VertexShader* vertexShader;
ID3D11PixelShader* pixelShader;
DXTBytecodeBlob vertexBytecode;
ID3D11DepthStencilState* depthState;
ID3D11RasterizerState* rasterizerState;
ID3D11Buffer* vertexBuffer;
ID3D11Buffer* indexBuffer;
ID3D11InputLayout* inputLayout;
ID3D11Buffer* transformBuffer;
DXTCreateRenderTargetFromBackBuffer(swapChain, device, &renderTargetView);
DXTCreateDepthStencilBuffer(device, params.Extent.Width, params.Extent.Height, DXGI_FORMAT_D24_UNORM_S8_UINT, &depthBuffer, &depthBufferView);
DXTVertexShaderFromFile(device, "VertexShader.cso", &vertexShader, &vertexBytecode);
DXTPixelShaderFromFile(device, "PixelShader.cso", &pixelShader);
DXTCreateDepthStencilStateDepthTestEnabled(device, &depthState);
DXTCreateRasterizerStateSolid(device, &rasterizerState);
DXTLoadStaticMeshFromFile(device, "mesh.ase", DXTVertexAttributePosition | DXTVertexAttributeUV | DXTVertexAttributeNormal,
DXTIndexTypeShort, &vertexBuffer, &indexBuffer, &indexCount);
DXTCreateBuffer(device, sizeof(DirectX::XMFLOAT4X4) * 2, D3D11_BIND_CONSTANT_BUFFER, D3D11_CPU_ACCESS_WRITE, D3D11_USAGE_DYNAMIC, &transformBuffer);
device->CreateInputLayout(inputDesc, elementCount, vertexBytecode.Bytecode, vertexBytecode.BytecodeLength, &inputLayout);
vertexBytecode.Destroy();
window.Present(false);
while (!window.QuitMessageReceived())
{
window.MessagePump();
if (inputHandler.IsKeyDown(VK_ESCAPE))
break;
cameraController.Update(deltaTime);
XMFLOAT4X4 ViewProj;
XMFLOAT4X4 World;
camera.GetViewProjectionMatrix(&ViewProj, params.Extent);
XMStoreFloat4x4(&World, XMMatrixIdentity());
D3D11_MAPPED_SUBRESOURCE subres;
context->Map(transformBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &subres);
XMFLOAT4X4* ptr = (XMFLOAT4X4*)subres.pData;
ptr[0] = World;
ptr[1] = ViewProj;
context->Unmap(transformBuffer, 0);
D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (FLOAT)params.Extent.Width, (FLOAT)params.Extent.Height, 0.0f, 1.0f };
context->ClearRenderTargetView(renderTargetView, clearColor);
context->ClearDepthStencilView(depthBufferView, D3D11_CLEAR_DEPTH, 1.0f, 0);
context->OMSetDepthStencilState(depthState, 0);
context->OMSetRenderTargets(1, &renderTargetView, depthBufferView);
context->RSSetState(rasterizerState);
context->RSSetViewports(1, &viewport);
context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
context->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
context->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R16_UINT, 0);
context->IASetInputLayout(inputLayout);
context->VSSetShader(vertexShader, nullptr, 0);
context->PSSetShader(pixelShader, nullptr, 0);
context->VSSetConstantBuffers(0, 1, &transformBuffer);
context->DrawIndexed(indexCount, 0, 0);
swapChain->Present(1, 0);
}
swapChain->SetFullscreenState(false, nullptr);
transformBuffer->Release();
depthBufferView->Release();
depthBuffer->Release();
inputLayout->Release();
vertexBuffer->Release();
indexBuffer->Release();
depthState->Release();
rasterizerState->Release();
vertexShader->Release();
pixelShader->Release();
renderTargetView->Release();
swapChain->Release();
context->Release();
device->Release();
}
window.Destroy();
}
}
ID3D11VertexShader* DXShaderManager::loadVertexShaderFromFile( const string& filename )
{
DWORD shaderFlags = D3DCOMPILE_ENABLE_STRICTNESS;
// Convert filename to wide string
int filenameLen = (int)filename.length() + 1;
int newLen = MultiByteToWideChar(CP_ACP, 0, filename.c_str(), filenameLen, 0, 0);
wchar_t* buf = new wchar_t[filenameLen];
MultiByteToWideChar(CP_ACP, 0, filename.c_str(), filenameLen, buf, newLen);
std::wstring wFilename(buf);
delete[] buf;
#if defined(_WOE_DEBUG)
// Set the D3DCOMPILE_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
shaderFlags |= D3DCOMPILE_DEBUG;
#endif // _WOE_DEBUG
ID3DBlob* pErrorBlob = nullptr;
ID3DBlob* pOutputBlob = nullptr;
HRESULT hr;
hr = D3DCompileFromFile(wFilename.c_str(), nullptr, nullptr, "VS", "vs_4_0", shaderFlags, 0, &pOutputBlob, &pErrorBlob);
if (FAILED(hr))
{
if (pErrorBlob)
{
Log::ErrorFmt(getClassName(), "Failed to compile HLSL: %s", reinterpret_cast<const char*>(pErrorBlob->GetBufferPointer()));
pErrorBlob->Release();
}
else
{
if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
{
Log::Error(getClassName(), "Failed to compile HLSL, File not found");
}
else
{
Log::Error(getClassName(), "Failed to compile HLSL, Unknown Error");
}
}
return nullptr;
}
if (pErrorBlob)
pErrorBlob->Release();
ID3D11VertexShader* pVertexShader = nullptr;
hr = Game::Instance()->getGraphicsSystem()->getDXDevice()->CreateVertexShader(pOutputBlob->GetBufferPointer(), pOutputBlob->GetBufferSize(), nullptr, &pVertexShader);
if (FAILED(hr))
{
Log::Error(getClassName(), "Failed to create vertex shader");
pOutputBlob->Release();
pVertexShader->Release();
return nullptr;
}
ID3D11InputLayout* pVertexLayout = nullptr;
// Define the input layout
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = ARRAYSIZE( layout );
// Create the input layout
hr = Game::Instance()->getGraphicsSystem()->getDXDevice()->CreateInputLayout(layout, numElements, pOutputBlob->GetBufferPointer(), pOutputBlob->GetBufferSize(), &pVertexLayout);
pOutputBlob->Release();
if (FAILED( hr ))
{
Log::Error(getClassName(), "Failed to attach vertex shader");
return nullptr;
}
// Set the input layout
Game::Instance()->getGraphicsSystem()->getDXDeviceContext()->IASetInputLayout(pVertexLayout);
return pVertexShader;
}
