summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/tools/shaderc/shaderc_d3d11.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/tools/shaderc/shaderc_d3d11.cpp')
-rw-r--r--3rdparty/bgfx/tools/shaderc/shaderc_d3d11.cpp450
1 files changed, 450 insertions, 0 deletions
diff --git a/3rdparty/bgfx/tools/shaderc/shaderc_d3d11.cpp b/3rdparty/bgfx/tools/shaderc/shaderc_d3d11.cpp
new file mode 100644
index 00000000000..4dcbb75bedd
--- /dev/null
+++ b/3rdparty/bgfx/tools/shaderc/shaderc_d3d11.cpp
@@ -0,0 +1,450 @@
+/*
+ * Copyright 2011-2015 Branimir Karadzic. All rights reserved.
+ * License: http://www.opensource.org/licenses/BSD-2-Clause
+ */
+
+#include "shaderc.h"
+
+#if SHADERC_CONFIG_DIRECT3D11
+
+#include <d3dcompiler.h>
+#include <d3d11shader.h>
+
+#ifndef D3D_SVF_USED
+# define D3D_SVF_USED 2
+#endif // D3D_SVF_USED
+
+#ifndef IID_ID3D11ShaderReflection
+static const GUID GUID_ID3D11ShaderReflection = { 0x0a233719, 0x3960, 0x4578, { 0x9d, 0x7c, 0x20, 0x3b, 0x8b, 0x1d, 0x9c, 0xc1 } };
+# define IID_ID3D11ShaderReflection GUID_ID3D11ShaderReflection
+#endif // IID_ID3D11ShaderReflection
+
+struct RemapInputSemantic
+{
+ bgfx::Attrib::Enum m_attr;
+ const char* m_name;
+ uint8_t m_index;
+};
+
+static const RemapInputSemantic s_remapInputSemantic[bgfx::Attrib::Count+1] =
+{
+ { bgfx::Attrib::Position, "POSITION", 0 },
+ { bgfx::Attrib::Normal, "NORMAL", 0 },
+ { bgfx::Attrib::Tangent, "TANGENT", 0 },
+ { bgfx::Attrib::Bitangent, "BITANGENT", 0 },
+ { bgfx::Attrib::Color0, "COLOR", 0 },
+ { bgfx::Attrib::Color1, "COLOR", 1 },
+ { bgfx::Attrib::Indices, "BLENDINDICES", 0 },
+ { bgfx::Attrib::Weight, "BLENDWEIGHT", 0 },
+ { bgfx::Attrib::TexCoord0, "TEXCOORD", 0 },
+ { bgfx::Attrib::TexCoord1, "TEXCOORD", 1 },
+ { bgfx::Attrib::TexCoord2, "TEXCOORD", 2 },
+ { bgfx::Attrib::TexCoord3, "TEXCOORD", 3 },
+ { bgfx::Attrib::TexCoord4, "TEXCOORD", 4 },
+ { bgfx::Attrib::TexCoord5, "TEXCOORD", 5 },
+ { bgfx::Attrib::TexCoord6, "TEXCOORD", 6 },
+ { bgfx::Attrib::TexCoord7, "TEXCOORD", 7 },
+ { bgfx::Attrib::Count, "", 0 },
+};
+
+const RemapInputSemantic& findInputSemantic(const char* _name, uint8_t _index)
+{
+ for (uint32_t ii = 0; ii < bgfx::Attrib::Count; ++ii)
+ {
+ const RemapInputSemantic& ris = s_remapInputSemantic[ii];
+ if (0 == strcmp(ris.m_name, _name)
+ && ris.m_index == _index)
+ {
+ return ris;
+ }
+ }
+
+ return s_remapInputSemantic[bgfx::Attrib::Count];
+}
+
+struct UniformRemapDx11
+{
+ UniformType::Enum id;
+ D3D_SHADER_VARIABLE_CLASS paramClass;
+ D3D_SHADER_VARIABLE_TYPE paramType;
+ uint8_t columns;
+ uint8_t rows;
+};
+
+static const UniformRemapDx11 s_constRemapDx11[7] =
+{
+ { UniformType::Uniform1iv, D3D_SVC_SCALAR, D3D_SVT_INT, 0, 0 },
+ { UniformType::Uniform1fv, D3D_SVC_SCALAR, D3D_SVT_FLOAT, 0, 0 },
+ { UniformType::Uniform2fv, D3D_SVC_VECTOR, D3D_SVT_FLOAT, 0, 0 },
+ { UniformType::Uniform3fv, D3D_SVC_VECTOR, D3D_SVT_FLOAT, 0, 0 },
+ { UniformType::Uniform4fv, D3D_SVC_VECTOR, D3D_SVT_FLOAT, 0, 0 },
+ { UniformType::Uniform3x3fv, D3D_SVC_MATRIX_COLUMNS, D3D_SVT_FLOAT, 3, 3 },
+ { UniformType::Uniform4x4fv, D3D_SVC_MATRIX_COLUMNS, D3D_SVT_FLOAT, 4, 4 },
+};
+
+UniformType::Enum findUniformTypeDx11(const D3D11_SHADER_TYPE_DESC& constDesc)
+{
+ for (uint32_t ii = 0; ii < BX_COUNTOF(s_constRemapDx11); ++ii)
+ {
+ const UniformRemapDx11& remap = s_constRemapDx11[ii];
+
+ if (remap.paramClass == constDesc.Class
+ && remap.paramType == constDesc.Type)
+ {
+ if (D3D_SVC_MATRIX_COLUMNS != constDesc.Class)
+ {
+ return remap.id;
+ }
+
+ if (remap.columns == constDesc.Columns
+ && remap.rows == constDesc.Rows)
+ {
+ return remap.id;
+ }
+ }
+ }
+
+ return UniformType::Count;
+}
+
+static uint32_t s_optimizationLevelDx11[4] =
+{
+ D3DCOMPILE_OPTIMIZATION_LEVEL0,
+ D3DCOMPILE_OPTIMIZATION_LEVEL1,
+ D3DCOMPILE_OPTIMIZATION_LEVEL2,
+ D3DCOMPILE_OPTIMIZATION_LEVEL3,
+};
+
+bool compileHLSLShaderDx11(bx::CommandLine& _cmdLine, const std::string& _code, bx::WriterI* _writer)
+{
+ BX_TRACE("DX11");
+
+ const char* profile = _cmdLine.findOption('p', "profile");
+ if (NULL == profile)
+ {
+ fprintf(stderr, "Shader profile must be specified.\n");
+ return false;
+ }
+
+ bool debug = _cmdLine.hasArg('\0', "debug");
+
+ uint32_t flags = D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
+ flags |= debug ? D3DCOMPILE_DEBUG : 0;
+ flags |= _cmdLine.hasArg('\0', "avoid-flow-control") ? D3DCOMPILE_AVOID_FLOW_CONTROL : 0;
+ flags |= _cmdLine.hasArg('\0', "no-preshader") ? D3DCOMPILE_NO_PRESHADER : 0;
+ flags |= _cmdLine.hasArg('\0', "partial-precision") ? D3DCOMPILE_PARTIAL_PRECISION : 0;
+ flags |= _cmdLine.hasArg('\0', "prefer-flow-control") ? D3DCOMPILE_PREFER_FLOW_CONTROL : 0;
+ flags |= _cmdLine.hasArg('\0', "backwards-compatibility") ? D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY : 0;
+
+ bool werror = _cmdLine.hasArg('\0', "Werror");
+
+ if (werror)
+ {
+ flags |= D3DCOMPILE_WARNINGS_ARE_ERRORS;
+ }
+
+ uint32_t optimization = 3;
+ if (_cmdLine.hasArg(optimization, 'O') )
+ {
+ optimization = bx::uint32_min(optimization, BX_COUNTOF(s_optimizationLevelDx11)-1);
+ flags |= s_optimizationLevelDx11[optimization];
+ }
+ else
+ {
+ flags |= D3DCOMPILE_SKIP_OPTIMIZATION;
+ }
+
+ BX_TRACE("Profile: %s", profile);
+ BX_TRACE("Flags: 0x%08x", flags);
+
+ ID3DBlob* code;
+ ID3DBlob* errorMsg;
+
+ // Output preprocessed shader so that HLSL can be debugged via GPA
+ // or PIX. Compiling through memory won't embed preprocessed shader
+ // file path.
+ std::string hlslfp;
+
+ if (debug)
+ {
+ hlslfp = _cmdLine.findOption('o');
+ hlslfp += ".hlsl";
+ writeFile(hlslfp.c_str(), _code.c_str(), (int32_t)_code.size() );
+ }
+
+ HRESULT hr = D3DCompile(_code.c_str()
+ , _code.size()
+ , hlslfp.c_str()
+ , NULL
+ , NULL
+ , "main"
+ , profile
+ , flags
+ , 0
+ , &code
+ , &errorMsg
+ );
+ if (FAILED(hr)
+ || (werror && NULL != errorMsg) )
+ {
+ const char* log = (char*)errorMsg->GetBufferPointer();
+
+ int32_t line = 0;
+ int32_t column = 0;
+ int32_t start = 0;
+ int32_t end = INT32_MAX;
+
+ if (2 == sscanf(log, "(%u,%u):", &line, &column)
+ && 0 != line)
+ {
+ start = bx::uint32_imax(1, line-10);
+ end = start + 20;
+ }
+
+ printCode(_code.c_str(), line, start, end);
+ fprintf(stderr, "Error: 0x%08x %s\n", (uint32_t)hr, log);
+ errorMsg->Release();
+ return false;
+ }
+
+ UniformArray uniforms;
+
+ ID3D11ShaderReflection* reflect = NULL;
+ hr = D3DReflect(code->GetBufferPointer()
+ , code->GetBufferSize()
+ , IID_ID3D11ShaderReflection
+ , (void**)&reflect
+ );
+ if (FAILED(hr) )
+ {
+ fprintf(stderr, "Error: 0x%08x\n", (uint32_t)hr);
+ return false;
+ }
+
+ D3D11_SHADER_DESC desc;
+ hr = reflect->GetDesc(&desc);
+ if (FAILED(hr) )
+ {
+ fprintf(stderr, BX_FILE_LINE_LITERAL "Error: 0x%08x\n", (uint32_t)hr);
+ return false;
+ }
+
+ BX_TRACE("Creator: %s 0x%08x", desc.Creator, desc.Version);
+ BX_TRACE("Num constant buffers: %d", desc.ConstantBuffers);
+
+ BX_TRACE("Input:");
+ uint8_t numAttrs = 0;
+ uint16_t attrs[bgfx::Attrib::Count];
+
+ if (profile[0] == 'v') // Only care about input semantic on vertex shaders
+ {
+ for (uint32_t ii = 0; ii < desc.InputParameters; ++ii)
+ {
+ D3D11_SIGNATURE_PARAMETER_DESC spd;
+ reflect->GetInputParameterDesc(ii, &spd);
+ BX_TRACE("\t%2d: %s%d, vt %d, ct %d, mask %x, reg %d"
+ , ii
+ , spd.SemanticName
+ , spd.SemanticIndex
+ , spd.SystemValueType
+ , spd.ComponentType
+ , spd.Mask
+ , spd.Register
+ );
+
+ const RemapInputSemantic& ris = findInputSemantic(spd.SemanticName, spd.SemanticIndex);
+ if (ris.m_attr != bgfx::Attrib::Count)
+ {
+ attrs[numAttrs] = bgfx::attribToId(ris.m_attr);
+ ++numAttrs;
+ }
+ }
+ }
+
+ BX_TRACE("Output:");
+ for (uint32_t ii = 0; ii < desc.OutputParameters; ++ii)
+ {
+ D3D11_SIGNATURE_PARAMETER_DESC spd;
+ reflect->GetOutputParameterDesc(ii, &spd);
+ BX_TRACE("\t%2d: %s%d, %d, %d", ii, spd.SemanticName, spd.SemanticIndex, spd.SystemValueType, spd.ComponentType);
+ }
+
+ uint16_t size = 0;
+
+ for (uint32_t ii = 0; ii < bx::uint32_min(1, desc.ConstantBuffers); ++ii)
+ {
+ ID3D11ShaderReflectionConstantBuffer* cbuffer = reflect->GetConstantBufferByIndex(ii);
+ D3D11_SHADER_BUFFER_DESC bufferDesc;
+ hr = cbuffer->GetDesc(&bufferDesc);
+
+ size = (uint16_t)bufferDesc.Size;
+
+ if (SUCCEEDED(hr) )
+ {
+ BX_TRACE("%s, %d, vars %d, size %d"
+ , bufferDesc.Name
+ , bufferDesc.Type
+ , bufferDesc.Variables
+ , bufferDesc.Size
+ );
+
+ for (uint32_t jj = 0; jj < bufferDesc.Variables; ++jj)
+ {
+ ID3D11ShaderReflectionVariable* var = cbuffer->GetVariableByIndex(jj);
+ ID3D11ShaderReflectionType* type = var->GetType();
+ D3D11_SHADER_VARIABLE_DESC varDesc;
+ hr = var->GetDesc(&varDesc);
+ if (SUCCEEDED(hr) )
+ {
+ D3D11_SHADER_TYPE_DESC constDesc;
+ hr = type->GetDesc(&constDesc);
+ if (SUCCEEDED(hr) )
+ {
+ UniformType::Enum uniformType = findUniformTypeDx11(constDesc);
+
+ if (UniformType::Count != uniformType
+ && 0 != (varDesc.uFlags & D3D_SVF_USED) )
+ {
+ Uniform un;
+ un.name = varDesc.Name;
+ un.type = uniformType;
+ un.num = constDesc.Elements;
+ un.regIndex = varDesc.StartOffset;
+ un.regCount = BX_ALIGN_16(varDesc.Size)/16;
+ uniforms.push_back(un);
+
+ BX_TRACE("\t%s, %d, size %d, flags 0x%08x, %d"
+ , varDesc.Name
+ , varDesc.StartOffset
+ , varDesc.Size
+ , varDesc.uFlags
+ , uniformType
+ );
+ }
+ else
+ {
+ BX_TRACE("\t%s, unknown type", varDesc.Name);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ BX_TRACE("Bound:");
+ for (uint32_t ii = 0; ii < desc.BoundResources; ++ii)
+ {
+ D3D11_SHADER_INPUT_BIND_DESC bindDesc;
+
+ hr = reflect->GetResourceBindingDesc(ii, &bindDesc);
+ if (SUCCEEDED(hr) )
+ {
+ // if (bindDesc.Type == D3D_SIT_SAMPLER)
+ {
+ BX_TRACE("\t%s, %d, %d, %d"
+ , bindDesc.Name
+ , bindDesc.Type
+ , bindDesc.BindPoint
+ , bindDesc.BindCount
+ );
+ }
+ }
+ }
+
+ uint16_t count = (uint16_t)uniforms.size();
+ bx::write(_writer, count);
+
+ uint32_t fragmentBit = profile[0] == 'p' ? BGFX_UNIFORM_FRAGMENTBIT : 0;
+ for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
+ {
+ const Uniform& un = *it;
+ uint8_t nameSize = (uint8_t)un.name.size();
+ bx::write(_writer, nameSize);
+ bx::write(_writer, un.name.c_str(), nameSize);
+ uint8_t type = un.type|fragmentBit;
+ bx::write(_writer, type);
+ bx::write(_writer, un.num);
+ bx::write(_writer, un.regIndex);
+ bx::write(_writer, un.regCount);
+
+ BX_TRACE("%s, %s, %d, %d, %d"
+ , un.name.c_str()
+ , getUniformTypeName(un.type)
+ , un.num
+ , un.regIndex
+ , un.regCount
+ );
+ }
+
+ {
+ ID3DBlob* stripped;
+ hr = D3DStripShader(code->GetBufferPointer()
+ , code->GetBufferSize()
+ , D3DCOMPILER_STRIP_REFLECTION_DATA
+ | D3DCOMPILER_STRIP_TEST_BLOBS
+ , &stripped
+ );
+
+ if (SUCCEEDED(hr) )
+ {
+ code->Release();
+ code = stripped;
+ }
+ }
+
+ uint16_t shaderSize = (uint16_t)code->GetBufferSize();
+ bx::write(_writer, shaderSize);
+ bx::write(_writer, code->GetBufferPointer(), shaderSize);
+ uint8_t nul = 0;
+ bx::write(_writer, nul);
+
+ bx::write(_writer, numAttrs);
+ bx::write(_writer, attrs, numAttrs*sizeof(uint16_t) );
+
+ bx::write(_writer, size);
+
+ if (_cmdLine.hasArg('\0', "disasm") )
+ {
+ ID3DBlob* disasm;
+ D3DDisassemble(code->GetBufferPointer()
+ , code->GetBufferSize()
+ , 0
+ , NULL
+ , &disasm
+ );
+
+ if (NULL != disasm)
+ {
+ std::string disasmfp = _cmdLine.findOption('o');
+ disasmfp += ".disasm";
+
+ writeFile(disasmfp.c_str(), disasm->GetBufferPointer(), (uint32_t)disasm->GetBufferSize() );
+ disasm->Release();
+ }
+ }
+
+ if (NULL != reflect)
+ {
+ reflect->Release();
+ }
+
+ if (NULL != errorMsg)
+ {
+ errorMsg->Release();
+ }
+
+ code->Release();
+
+ return true;
+}
+
+#else
+
+bool compileHLSLShaderDx11(bx::CommandLine& _cmdLine, const std::string& _code, bx::WriterI* _writer)
+{
+ BX_UNUSED(_cmdLine, _code, _writer);
+ fprintf(stderr, "HLSL compiler is not supported on this platform.\n");
+ return false;
+}
+
+#endif // SHADERC_CONFIG_DIRECT3D11