static void dx11_fill_constant_table(ShaderConstantTable& out_constants, ShaderConstantTable& out_samplers, const ShaderCode& bytecode)
{
out_constants.clear();
out_samplers.clear();
ID3D11ShaderReflection* refl = NULL;
D3DReflect( bytecode.data(), bytecode.size(), IID_ID3D11ShaderReflection, (void**)&refl);
if( refl )
{
HRESULT hr = S_OK;
D3D11_SHADER_DESC refl_desc;
hr = refl->GetDesc(&refl_desc);
for( uint32 i=0; i<refl_desc.ConstantBuffers; ++i )
{
ID3D11ShaderReflectionConstantBuffer* cb = refl->GetConstantBufferByIndex(i);
D3D11_SHADER_BUFFER_DESC sb_desc;
cb->GetDesc(&sb_desc);
for( uint32 j=0; j<sb_desc.Variables; ++j )
{
ID3D11ShaderReflectionVariable* var = cb->GetVariableByIndex(j);
D3D11_SHADER_VARIABLE_DESC var_desc;
var->GetDesc(&var_desc);
ShaderConstantDescr scd;
scd.name = var_desc.Name;
scd.register_index = var_desc.StartOffset/16;
scd.register_count = var_desc.Size/16;
out_constants.push_back(scd);
}
}
for( uint32 i=0; i<refl_desc.BoundResources; ++i )
{
D3D11_SHADER_INPUT_BIND_DESC desc;
refl->GetResourceBindingDesc(i, &desc);
if( desc.Type == D3D10_SIT_SAMPLER )
{
ShaderConstantDescr scd;
scd.name = desc.Name;
scd.register_index = desc.BindPoint;
scd.register_count = desc.BindCount;
}
}
refl->Release();
}
}
static bool dx11_compile_shader( ShaderCode& out_shader, const ShaderCode& source, const char* entry, const char* profile_str, FileSystem* /*fs*/, const char* /*include_dir*/ )
{
LPD3DBLOB code_blob = NULL;
LPD3DBLOB error_blob = NULL;
uint32 flags = D3D10_SHADER_DEBUG | D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY;
HRESULT hr = D3DCompile(source.data(), source.size(), "", NULL, NULL, entry, profile_str, flags, 0, &code_blob, &error_blob);
out_shader.clear();
if( hr == S_OK )
{
size_t size = code_blob->GetBufferSize();
out_shader.resize(size);
memcpy(out_shader.data(), code_blob->GetBufferPointer(), size);
}
if( error_blob != NULL )
{
char* error_str = (char*)error_blob->GetBufferPointer();
Log::error("Failed to compile shader\n%s", error_str);
}
SafeRelease(code_blob);
SafeRelease(error_blob);
if( hr == S_OK )
{
return true;
}
else
{
return false;
}
}
static bool dx9_compile_shader(ShaderCode& out_shader, const ShaderCode& source, ShaderType::type type, FileSystem* fs=NULL, const char* include_dir=NULL)
{
R_ASSERT(source.type == ShaderCodeType_Text);
HRESULT hr = S_OK;
ID3DXBuffer* error_buffer = NULL;
ID3DXBuffer* shader_buffer = NULL;
ID3DXConstantTable* constant_table = NULL;
uint32 flags = D3DXSHADER_DEBUG;
const char* profile = shader_profile_string(type);
static const char dummy_vertex_shader[] = "float4 vertex() : POSITION { return 1; }";
static const char dummy_pixel_shader[] = "float4 pixel() : COLOR { return float4(1,0,1,1); }";
DX9ShaderIncluder includer(fs, include_dir);
hr = D3DXCompileShader(source.data(), (UINT)source.size(), NULL, &includer, "main", profile, flags, &shader_buffer, &error_buffer, &constant_table );
if( hr!=S_OK && error_buffer && error_buffer->GetBufferPointer() )
{
char* tmp = (char*)error_buffer->GetBufferPointer();
R_ERROR_MESSAGE_BOX(tmp, "Shader compile error");
shader_buffer = NULL;
error_buffer = NULL;
//create dummy shader
if( type == ShaderType::Pixel )
{
hr = D3DXCompileShader(
dummy_pixel_shader, uint32(strlen(dummy_pixel_shader)), NULL, NULL, "pixel", "ps_2_0",
flags, &shader_buffer, &error_buffer, NULL );
validate_d3d_result(hr, true);
}
else if( type == ShaderType::Vertex )
{
hr = D3DXCompileShader(
dummy_vertex_shader, uint32(strlen(dummy_vertex_shader)), NULL, NULL, "vertex", "vs_2_0",
flags, &shader_buffer, &error_buffer, NULL );
validate_d3d_result(hr, true);
}
}
out_shader.type = ShaderCodeType_Binary;
out_shader.clear();
uint32 size = shader_buffer->GetBufferSize();
if( size )
{
out_shader.resize(size);
memcpy(out_shader.data(), shader_buffer->GetBufferPointer(), size);
}
if(error_buffer) error_buffer->Release();
if(shader_buffer) shader_buffer->Release();
if(constant_table) constant_table->Release();
return true;
}
