int Release() { if (VS) VS->Release(); if (PS) PS->Release(); if (inputLayout) inputLayout->Release(); if (vertexBuffer) vertexBuffer->Release(); return 0; }
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; }
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; }