void init(ID3D11Device& device, Shaders& shaders)
{
assert(shaders.mTerrainDS == nullptr);
assert(shaders.mTerrainVS == nullptr);
assert(shaders.mTerrainHS == nullptr);
assert(shaders.mTerrainIL == nullptr);
assert(shaders.mTerrainPS == nullptr);
assert(shaders.mTerrainCS == nullptr);
// Store shader byte code, used to create a shader.
std::vector<char> shaderByteCode;
// Vertex shader
computeShaderByteCode(L"HLSL/TerrainVS.cso", shaderByteCode);
buildShapesVertexLayout(device, shaderByteCode, shaders.mTerrainIL);
HRESULT result = device.CreateVertexShader(
&shaderByteCode[0],
shaderByteCode.size(),
nullptr,
&shaders.mTerrainVS);
DxErrorChecker(result);
// Pixel shader
computeShaderByteCode(L"HLSL/TerrainPS.cso", shaderByteCode);
result = device.CreatePixelShader(
&shaderByteCode[0],
shaderByteCode.size(),
nullptr,
&shaders.mTerrainPS);
DxErrorChecker(result);
// Hull shader
computeShaderByteCode(L"HLSL/TerrainHS.cso", shaderByteCode);
result = device.CreateHullShader(
&shaderByteCode[0],
shaderByteCode.size(),
nullptr,
&shaders.mTerrainHS);
DxErrorChecker(result);
// Pixel shader
computeShaderByteCode(L"HLSL/TerrainDS.cso", shaderByteCode);
result = device.CreateDomainShader(
&shaderByteCode[0],
shaderByteCode.size(),
nullptr,
&shaders.mTerrainDS);
DxErrorChecker(result);
// Compute Shader
computeShaderByteCode(L"HLSL/TerrainCS.cso", shaderByteCode);
result = device.CreateComputeShader(
&shaderByteCode[0],
shaderByteCode.size(),
nullptr,
&shaders.mTerrainCS);
DxErrorChecker(result);
}
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;
}
bool init(ID3D11Device* dev, int argc, char** argv)
{
this->dev = dev;
ensure(dev->CreateVertexShader(g_vs, sizeof(g_vs), NULL, &vs));
ensure(dev->CreateHullShader(g_hs, sizeof(g_hs), NULL, &hs));
ensure(dev->CreateDomainShader(g_ds, sizeof(g_ds), NULL, &ds));
ensure(dev->CreatePixelShader(g_ps, sizeof(g_ps), NULL, &ps));
D3D11_INPUT_ELEMENT_DESC elements[1] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,
0, D3D11_INPUT_PER_VERTEX_DATA, 0},
};
ensure(dev->CreateInputLayout(elements, 1, g_vs, sizeof(g_vs), &layout));
D3D11_BUFFER_DESC bufferd;
bufferd.ByteWidth = sizeof(vertex_data);
bufferd.Usage = D3D11_USAGE_IMMUTABLE;
bufferd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferd.CPUAccessFlags = 0;
bufferd.MiscFlags = 0;
bufferd.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA buffersd;
buffersd.pSysMem = vertex_data;
ensure(dev->CreateBuffer(&bufferd, &buffersd, &vb));
D3D11_BUFFER_DESC cbd;
cbd.ByteWidth = (sizeof(cb_frame_t) + 15) & ~15;
cbd.Usage = D3D11_USAGE_DYNAMIC;
cbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cbd.MiscFlags = 0;
cbd.StructureByteStride = 0;
ensure(dev->CreateBuffer(&cbd, NULL, &cb_frame));
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();
}
}
