vpResult vprShaderProgramDX11::init()
{
vprDeviceDX11* dx11Device = static_cast<vprDeviceDX11*>(m_device);
ID3D11Device* nativeDevice = dx11Device->getNativeDevice();
if (m_desc.hasVertexShader())
{
if (nativeDevice->CreateVertexShader(m_desc.m_bytecodes[vprShaderStage::VERTEX_SHADER]->getPointer(),
m_desc.m_bytecodes[vprShaderStage::VERTEX_SHADER]->getSize(), NULL, &m_nativeVertexShader))
{
return VP_FAILURE;
}
}
if (m_desc.hasGeometryShader())
{
if (nativeDevice->CreateGeometryShader(m_desc.m_bytecodes[vprShaderStage::GEOMETRY_SHADER]->getPointer(),
m_desc.m_bytecodes[vprShaderStage::GEOMETRY_SHADER]->getSize(), NULL, &m_nativeGeometryShader))
{
return VP_FAILURE;
}
}
if (m_desc.hasHullShader())
{
if (nativeDevice->CreateHullShader(m_desc.m_bytecodes[vprShaderStage::HULL_SHADER]->getPointer(),
m_desc.m_bytecodes[vprShaderStage::HULL_SHADER]->getSize(), NULL, &m_nativeHullShader))
{
return VP_FAILURE;
}
}
if (m_desc.hasDomainShader())
{
if (nativeDevice->CreateDomainShader(m_desc.m_bytecodes[vprShaderStage::DOMAIN_SHADER]->getPointer(),
m_desc.m_bytecodes[vprShaderStage::DOMAIN_SHADER]->getSize(), NULL, &m_nativeDomainShader))
{
return VP_FAILURE;
}
}
if (m_desc.hasPixelShader())
{
if (nativeDevice->CreatePixelShader(m_desc.m_bytecodes[vprShaderStage::PIXEL_SHADER]->getPointer(),
m_desc.m_bytecodes[vprShaderStage::PIXEL_SHADER]->getSize(), NULL, &m_nativePixelShader))
{
return VP_FAILURE;
}
}
if (m_desc.hasComputeShader())
{
if (nativeDevice->CreateComputeShader(m_desc.m_bytecodes[vprShaderStage::COMPUTE_SHADER]->getPointer(),
m_desc.m_bytecodes[vprShaderStage::COMPUTE_SHADER]->getSize(), NULL, &m_nativeComputeShader))
{
return VP_FAILURE;
}
}
return VP_SUCCESS;
}
bool Shader::create( GraphicsSystem& graphicsSystem, ShaderType type, const void* pInitData, uint dataSize )
{
TIKI_ASSERT( pInitData != nullptr );
TIKI_ASSERT( dataSize > 0u );
m_platformData.pShaderCode = pInitData;
m_platformData.shaderCodeLength = dataSize;
m_type = type;
m_hash = crcBytes( m_platformData.pShaderCode, m_platformData.shaderCodeLength );
ID3D11Device* pDevice = GraphicsSystemPlatform::getDevice( graphicsSystem );
HRESULT result = S_FALSE;
switch ( m_type )
{
case ShaderType_ComputeShader:
result = pDevice->CreateComputeShader( pInitData, dataSize, nullptr, &m_platformData.pComputeShader );
break;
case ShaderType_DomainShader:
result = pDevice->CreateDomainShader( pInitData, dataSize, nullptr, &m_platformData.pDomainShader );
break;
case ShaderType_GeometrieShader:
result = pDevice->CreateGeometryShader( pInitData, dataSize, nullptr, &m_platformData.pGeometryShader );
break;
case ShaderType_HullShader:
result = pDevice->CreateHullShader( pInitData, dataSize, nullptr, &m_platformData.pHullShader );
break;
case ShaderType_PixelShader:
result = pDevice->CreatePixelShader( pInitData, dataSize, nullptr, &m_platformData.pPixelShader );
break;
case ShaderType_VertexShader:
result = pDevice->CreateVertexShader( pInitData, dataSize, nullptr, &m_platformData.pVertexShader );
break;
default:
TIKI_BREAK( "[graphics] ShaderType not supported.\n" );
break;
}
if ( FAILED( result ) || m_platformData.pShaderObject == nullptr )
{
dispose( graphicsSystem );
return false;
}
return true;
}
void FMaterial::Compile(const FShaderProgramInfo* VertexShaderInfo, const FShaderProgramInfo* PixelShaderInfo, const FShaderProgramInfo* GeometryShaderInfo, const FShaderProgramInfo* HullShaderInfo, const FShaderProgramInfo* DomainShaderInfo)
{
ID3D11Device* Device = GraphicsContext->GetDevice();
// Core shaders blobs
FBlobPointer VertexShaderBlob, PixelShaderBlob;
// Optional shaders blobs
FBlobPointer GeometryShaderBlob, HullShaderBlob, DomainShaderBlob;
bool bCompilationSuccessful = VertexShaderInfo->Compile(VertexShaderBlob.GetReference()) && PixelShaderInfo->Compile(PixelShaderBlob.GetReference());
if (GeometryShaderInfo != nullptr)
{
GeometryShaderInfo->Compile(GeometryShaderBlob.GetReference());
}
if (DomainShaderInfo != nullptr && HullShaderInfo != nullptr)
{
DomainShaderInfo->Compile(DomainShaderBlob.GetReference());
HullShaderInfo->Compile(HullShaderBlob.GetReference());
}
if (bCompilationSuccessful)
{
Release(); // We release only if compilation was successful. (this makes hot reloading fault tolerant case because we can keep the older shaders running)
ID3D11ShaderReflection* VertexShaderReflection, *PixelShaderReflection;
ID3D11ShaderReflection* GeometryShaderReflection = nullptr, *HullShaderReflection = nullptr, *DomainShaderReflection = nullptr;
Device->CreateVertexShader(VertexShaderBlob->GetBufferPointer(), VertexShaderBlob->GetBufferSize(), nullptr, &VertexShader);
Device->CreatePixelShader(PixelShaderBlob->GetBufferPointer(), PixelShaderBlob->GetBufferSize(), nullptr, &PixelShader);
D3DSetDebugName(VertexShader, VertexShaderInfo->GetDebugName());
D3DSetDebugName(PixelShader, PixelShaderInfo->GetDebugName());
D3DReflect(VertexShaderBlob->GetBufferPointer(), VertexShaderBlob->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&VertexShaderReflection);
D3DReflect(PixelShaderBlob->GetBufferPointer(), PixelShaderBlob->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&PixelShaderReflection);
if (GeometryShaderBlob)
{
Device->CreateGeometryShader(GeometryShaderBlob->GetBufferPointer(), GeometryShaderBlob->GetBufferSize(), nullptr, &GeometryShader);
D3DSetDebugName(GeometryShader, GeometryShaderInfo->GetDebugName());
D3DReflect(GeometryShaderBlob->GetBufferPointer(), GeometryShaderBlob->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&GeometryShaderReflection);
}
if (DomainShaderBlob && HullShaderBlob)
{
Device->CreateHullShader(HullShaderBlob->GetBufferPointer(), HullShaderBlob->GetBufferSize(), nullptr, &HullShader);
Device->CreateDomainShader(DomainShaderBlob->GetBufferPointer(), DomainShaderBlob->GetBufferSize(), nullptr, &DomainShader);
D3DSetDebugName(HullShader, HullShaderInfo->GetDebugName());
D3DSetDebugName(DomainShader, DomainShaderInfo->GetDebugName());
D3DReflect(HullShaderBlob->GetBufferPointer(), HullShaderBlob->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&HullShaderReflection);
D3DReflect(DomainShaderBlob->GetBufferPointer(), DomainShaderBlob->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&DomainShaderReflection);
}
CreateInputLayoutDescFromVertexShaderSignature(VertexShaderReflection, VertexShaderBlob, Device);
MaterialParameters = Make_Unique<FMaterialParameters>(GraphicsContext, VertexShaderReflection, PixelShaderReflection, GeometryShaderReflection, HullShaderReflection, DomainShaderReflection);
VertexShaderReflection->Release();
PixelShaderReflection->Release();
if (GeometryShaderReflection != nullptr)
GeometryShaderReflection->Release();
if (DomainShaderReflection != nullptr)
DomainShaderReflection->Release();
if (HullShaderReflection != nullptr)
HullShaderReflection->Release();
}
}
