ComputeShaderPtr CompileCSFromFile(const wchar* path,
const char* functionName,
ShaderProfile profile,
const CompileOptions& compileOptions,
bool forceOptimization)
{
return CompileFromFile(path, functionName, ShaderType::Compute, profile, compileOptions, forceOptimization);
}
void PostProcessHelper::Initialize()
{
// Load the shaders
std::wstring fullScreenTriPath = SampleFrameworkDir() + L"Shaders\\FullScreenTriangle.hlsl";
fullScreenTriVS = CompileFromFile(fullScreenTriPath.c_str(), "FullScreenTriangleVS", ShaderType::Vertex);
{
D3D12_ROOT_PARAMETER1 rootParameters[NumRootParams] = {};
rootParameters[RootParam_StandardDescriptors].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
rootParameters[RootParam_StandardDescriptors].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
rootParameters[RootParam_StandardDescriptors].DescriptorTable.pDescriptorRanges = DX12::StandardDescriptorRanges();
rootParameters[RootParam_StandardDescriptors].DescriptorTable.NumDescriptorRanges = DX12::NumStandardDescriptorRanges;
rootParameters[RootParam_SRVIndices].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
rootParameters[RootParam_SRVIndices].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
rootParameters[RootParam_SRVIndices].Descriptor.RegisterSpace = 0;
rootParameters[RootParam_SRVIndices].Descriptor.ShaderRegister = 0;
rootParameters[RootParam_AppSettings].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
rootParameters[RootParam_AppSettings].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
rootParameters[RootParam_AppSettings].Descriptor.RegisterSpace = 0;
rootParameters[RootParam_AppSettings].Descriptor.ShaderRegister = AppSettings::CBufferRegister;
D3D12_STATIC_SAMPLER_DESC staticSamplers[4] = {};
staticSamplers[0] = DX12::GetStaticSamplerState(SamplerState::Point, 0);
staticSamplers[1] = DX12::GetStaticSamplerState(SamplerState::LinearClamp, 1);
staticSamplers[2] = DX12::GetStaticSamplerState(SamplerState::Linear, 2);
staticSamplers[3] = DX12::GetStaticSamplerState(SamplerState::LinearBorder, 3);
D3D12_ROOT_SIGNATURE_DESC1 rootSignatureDesc = {};
rootSignatureDesc.NumParameters = ArraySize_(rootParameters);
rootSignatureDesc.pParameters = rootParameters;
rootSignatureDesc.NumStaticSamplers = ArraySize_(staticSamplers);
rootSignatureDesc.pStaticSamplers = staticSamplers;
rootSignatureDesc.Flags = D3D12_ROOT_SIGNATURE_FLAG_NONE;
DX12::CreateRootSignature(&rootSignature, rootSignatureDesc);
rootSignature->SetName(L"PostProcessHelper");
}
}
bool CShader::CreateFromCompiledFile(EInputLayoutType type, const wchar* psPath, const wchar* vsPath, const wchar* gsPath, const wchar* dsPath, const wchar* hsPath)
{
HRESULT hr;
CompileFromFile(type, L"../assets/parallaxPS.fx", L"../assets/parallaxVS.fx");
// D3DReadFileToBlob(vsPath, &m_vsBlob);
std::ifstream vsStream(vsPath, std::ifstream::binary);
if(vsStream.fail()) assert(false);
std::string vsString((std::istreambuf_iterator<char>(vsStream)), std::istreambuf_iterator<char>());
int vsSize = vsString.size();
// hr = GetDevice()->CreateVertexShader(m_vsBlob->GetBufferPointer(), m_vsBlob->GetBufferSize(), NULL, &m_vs);
hr = GetDX11Device()->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_vs);
if(FAILED(hr)) assert(false);
switch(type)
{
case EInputLayoutType::Position:
hr = GetDX11Device()->CreateInputLayout(layoutPos, ARRAYSIZE(layoutPos), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::PositionTexture:
hr = GetDX11Device()->CreateInputLayout(layoutPosTex, ARRAYSIZE(layoutPosTex), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::PositionTextureNormal:
hr = GetDX11Device()->CreateInputLayout(layoutPosTexNorm, ARRAYSIZE(layoutPosTexNorm), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::PositionTextureNormalTangentBinormal:
hr = GetDX11Device()->CreateInputLayout(layoutPosTexNormalBitangentTangent, ARRAYSIZE(layoutPosTexNormalBitangentTangent), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::PositionTextureNormalTangentSkinned:
hr = GetDX11Device()->CreateInputLayout(layoutPosTexNormalTangentSkinned, ARRAYSIZE(layoutPosTexNormalTangentSkinned), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::BasicParticle:
hr = GetDX11Device()->CreateInputLayout(basicParticlelayout, ARRAYSIZE(basicParticlelayout), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::TerrainLayout:
hr = GetDX11Device()->CreateInputLayout(layoutTerrain, ARRAYSIZE(layoutTerrain), vsString.c_str(), vsSize, &m_inputLayout);
break;
}
if(FAILED(hr)) assert(false);
vsStream.close();
////////////////////////////////////////////
std::ifstream psStream(psPath, std::ifstream::binary);
if(psStream.fail()) assert(false);
std::string psString((std::istreambuf_iterator<char>(psStream)), std::istreambuf_iterator<char>());
int psSize = psString.size();
hr = GetDX11Device()->CreatePixelShader(psString.c_str(), psSize, NULL, &m_ps);
if(FAILED(hr)) assert(false);
psStream.close();
/////////////////////////////////////////////
if(gsPath != nullptr)
{
std::ifstream gsStream(gsPath, std::ifstream::binary);
if(gsStream.fail()) assert(false);
std::string gsString((std::istreambuf_iterator<char>(gsStream)), std::istreambuf_iterator<char>());
int gsSize = gsString.size();
hr = GetDX11Device()->CreateGeometryShader(gsString.c_str(), gsSize, NULL, &m_gs);
if(FAILED(hr)) assert(false);
gsStream.close();
}
if(hsPath != nullptr)
{
std::ifstream hsStream(hsPath, std::ifstream::binary);
if(hsStream.fail()) assert(false);
std::string hsString((std::istreambuf_iterator<char>(hsStream)), std::istreambuf_iterator<char>());
int hsSize = hsString.size();
hr = GetDX11Device()->CreateHullShader(hsString.c_str(), hsSize, NULL, &m_hs);
if(FAILED(hr)) assert(false);
hsStream.close();
}
if(dsPath != nullptr)
{
std::ifstream dsStream(dsPath, std::ifstream::binary);
if(dsStream.fail()) assert(false);
std::string dsString((std::istreambuf_iterator<char>(dsStream)), std::istreambuf_iterator<char>());
int dsSize = dsString.size();
hr = GetDX11Device()->CreateDomainShader(dsString.c_str(), dsSize, NULL, &m_ds);
if(FAILED(hr)) assert(false);
dsStream.close();
}
return true;
}
/*************************************************************//**
*
* @brief 初期化処理を行う
* @param カメラ
* @param テクスチャ情報
* @param 最大スプライト数
* @return 正常終了：true
* @return 異常終了：false
*
****************************************************************/
bool C_SpriteCreater::Initialize(const Camera::CameraPtr& prCamera,
const Texture::TextureDataPtr& prTextureData,
uint32_t maxSpriteCount)
{
// GLSLオブジェクトを作成し、保持
if (!Shader::GLSL::C_GlslObjectManager::s_GetInstance()->GetGlslObject(Fixed::Shader::s_pGLSL_OBJECT_ID))
{
auto pGlslObject = Shader::GLSL::C_GlslObject::s_Create();
if (pGlslObject->CompileFromFile(Fixed::Shader::s_pVERTEX_FILE_PATH, Shader::GLSL::Type::s_VERTEX) == false)
{
PrintLog("[ C_SpriteCreater::Initialize ] : 頂点シェーダーのコンパイルに失敗しました。\n");
return false;
}
if (pGlslObject->CompileFromFile(Fixed::Shader::s_pGEOMETRY_FILE_PATH, Shader::GLSL::Type::s_GEOMETRY) == false)
{
PrintLog("[ C_SpriteCreater::Initialize ] : ジオメトリシェーダーのコンパイルに失敗しました。\n");
return false;
}
if (pGlslObject->CompileFromFile(Fixed::Shader::s_pFRAGMENT_FILE_PATH, Shader::GLSL::Type::s_FRAGMENT) == false)
{
PrintLog("[ C_SpriteCreater::Initialize ] : フラグメントシェーダーのコンパイルに失敗しました。\n");
return false;
}
if (pGlslObject->Link() == false)
{
PrintLog("[ C_SpriteCreater::Initialize ] : シェーダーのリンクに失敗しました。\n");
return false;
}
pGlslObject_ = pGlslObject;
Shader::GLSL::C_GlslObjectManager::s_GetInstance()->Entry(pGlslObject_, Fixed::Shader::s_pGLSL_OBJECT_ID);
// サブルーチンのインデックスを取得
subroutineIndices_[Camera::PERSPECTIVE] = pGlslObject_->GetSubroutineIndex(Shader::GLSL::Type::s_GEOMETRY, "PerspectiveProcess");
subroutineIndices_[Camera::ORTHOGRAPHIC] = pGlslObject_->GetSubroutineIndex(Shader::GLSL::Type::s_GEOMETRY, "OrthographicProcess");
}
else
{
pGlslObject_ = Shader::GLSL::C_GlslObjectManager::s_GetInstance()->GetGlslObject(Fixed::Shader::s_pGLSL_OBJECT_ID).get();
// サブルーチンのインデックスを取得
subroutineIndices_[Camera::PERSPECTIVE] = pGlslObject_->GetSubroutineIndex(Shader::GLSL::Type::s_GEOMETRY, "PerspectiveProcess");
subroutineIndices_[Camera::ORTHOGRAPHIC] = pGlslObject_->GetSubroutineIndex(Shader::GLSL::Type::s_GEOMETRY, "OrthographicProcess");
}
// 頂点のメモリを確保
vertices_.resize(maxSpriteCount);
// プリミティブを作成し、取得
if (!OpenGL::C_PrimitiveBufferManager::s_GetInstance()->GetPrimitiveBuffer(Fixed::Primitive::s_pSPRITE_ID))
{
uint32_t vertexAttributeElementCountList[] = { 3, 2, 1, 4, 2, 2, 2 };
std::array<OpenGL::DataEnum, 7> vertexAttributeDataTypeList;
vertexAttributeDataTypeList.fill(OpenGL::DataType::s_FLOAT);
uint32_t vertexByteOffsetList[] = { 4, 4, 4, 4, 4, 4, 4 };
bool vertexTransferFlagList[] = { true, true, true, true, true, true, true };
pPointDatas_ = OpenGL::C_PrimitiveBuffer::s_Create(vertices_.data(),
vertices_.size(),
7,
vertexAttributeElementCountList,
vertexAttributeDataTypeList.data(),
OpenGL::Modify::s_DYNAMIC,
vertexByteOffsetList,
vertexTransferFlagList);
OpenGL::C_PrimitiveBufferManager::s_GetInstance()->Entry(pPointDatas_, Fixed::Primitive::s_pSPRITE_ID);
}
else
{
pPointDatas_ = OpenGL::C_PrimitiveBufferManager::s_GetInstance()->GetPrimitiveBuffer(Fixed::Primitive::s_pSPRITE_ID).get();
}
// カメラとテクスチャ情報を設定
pCamera_ = prCamera;
pTextureData_ = prTextureData;
// テクスチャユニットを設定
pGlslObject_->Begin();
pGlslObject_->SetUniform1i("texture", Fixed::Texture::s_UNIT_NUMBER);
pGlslObject_->End();
return true;
}
void Initialize_Upload()
{
for(uint64 i = 0; i < MaxUploadSubmissions; ++i)
DXCall(Device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_COPY, IID_PPV_ARGS(&UploadSubmissions[i].CmdAllocator)));
DXCall(Device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COPY, UploadSubmissions[0].CmdAllocator, nullptr, IID_PPV_ARGS(&UploadCmdList)));
DXCall(UploadCmdList->Close());
D3D12_COMMAND_QUEUE_DESC queueDesc = { };
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_COPY;
DXCall(Device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&UploadCmdQueue)));
UploadFence.Init(0);
D3D12_RESOURCE_DESC resourceDesc = { };
resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
resourceDesc.Width = uint32(UploadBufferSize);
resourceDesc.Height = 1;
resourceDesc.DepthOrArraySize = 1;
resourceDesc.MipLevels = 1;
resourceDesc.Format = DXGI_FORMAT_UNKNOWN;
resourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
resourceDesc.SampleDesc.Count = 1;
resourceDesc.SampleDesc.Quality = 0;
resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
resourceDesc.Alignment = 0;
DXCall(Device->CreateCommittedResource(DX12::GetUploadHeapProps(), D3D12_HEAP_FLAG_NONE, &resourceDesc,
D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&UploadBuffer)));
D3D12_RANGE readRange = { };
DXCall(UploadBuffer->Map(0, &readRange, reinterpret_cast<void**>(&UploadBufferCPUAddr)));
// Temporary buffer memory that swaps every frame
resourceDesc.Width = uint32(TempBufferSize);
for(uint64 i = 0; i < RenderLatency; ++i)
{
DXCall(Device->CreateCommittedResource(DX12::GetUploadHeapProps(), D3D12_HEAP_FLAG_NONE, &resourceDesc,
D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&TempFrameBuffers[i])));
DXCall(TempFrameBuffers[i]->Map(0, &readRange, reinterpret_cast<void**>(&TempFrameCPUMem[i])));
TempFrameGPUMem[i] = TempFrameBuffers[i]->GetGPUVirtualAddress();
}
// Texture conversion resources
DXCall(Device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_COMPUTE, IID_PPV_ARGS(&convertCmdAllocator)));
DXCall(Device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COMPUTE, convertCmdAllocator, nullptr, IID_PPV_ARGS(&convertCmdList)));
DXCall(convertCmdList->Close());
DXCall(convertCmdList->Reset(convertCmdAllocator, nullptr));
D3D12_COMMAND_QUEUE_DESC convertQueueDesc = {};
convertQueueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
convertQueueDesc.Type = D3D12_COMMAND_LIST_TYPE_COMPUTE;
DXCall(Device->CreateCommandQueue(&convertQueueDesc, IID_PPV_ARGS(&convertCmdQueue)));
CompileOptions opts;
opts.Add("TGSize_", convertTGSize);
const std::wstring shaderPath = SampleFrameworkDir() + L"Shaders\\DecodeTextureCS.hlsl";
convertCS = CompileFromFile(shaderPath.c_str(), "DecodeTextureCS", ShaderType::Compute, ShaderProfile::SM51, opts);
convertArrayCS = CompileFromFile(shaderPath.c_str(), "DecodeTextureArrayCS", ShaderType::Compute, ShaderProfile::SM51, opts);
{
D3D12_DESCRIPTOR_RANGE ranges[2] = {};
ranges[0].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
ranges[0].NumDescriptors = 1;
ranges[0].BaseShaderRegister = 0;
ranges[0].RegisterSpace = 0;
ranges[0].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
ranges[1].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_UAV;
ranges[1].NumDescriptors = 1;
ranges[1].BaseShaderRegister = 0;
ranges[1].RegisterSpace = 0;
ranges[1].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
D3D12_ROOT_PARAMETER rootParameters[1] = {};
rootParameters[0].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
rootParameters[0].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
rootParameters[0].DescriptorTable.pDescriptorRanges = ranges;
rootParameters[0].DescriptorTable.NumDescriptorRanges = ArraySize_(ranges);
D3D12_ROOT_SIGNATURE_DESC rootSignatureDesc = {};
rootSignatureDesc.NumParameters = ArraySize_(rootParameters);
rootSignatureDesc.pParameters = rootParameters;
rootSignatureDesc.Flags = D3D12_ROOT_SIGNATURE_FLAG_NONE;
DX12::CreateRootSignature(&convertRootSignature, rootSignatureDesc);
}
{
D3D12_COMPUTE_PIPELINE_STATE_DESC psoDesc = { };
psoDesc.CS = convertCS.ByteCode();
psoDesc.pRootSignature = convertRootSignature;
psoDesc.Flags = D3D12_PIPELINE_STATE_FLAG_NONE;
Device->CreateComputePipelineState(&psoDesc, IID_PPV_ARGS(&convertPSO));
psoDesc.CS = convertArrayCS.ByteCode();
Device->CreateComputePipelineState(&psoDesc, IID_PPV_ARGS(&convertArrayPSO));
}
convertFence.Init(0);
// Readback resources
DXCall(Device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_COPY, IID_PPV_ARGS(&readbackCmdAllocator)));
DXCall(Device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COPY, readbackCmdAllocator, nullptr, IID_PPV_ARGS(&readbackCmdList)));
DXCall(readbackCmdList->Close());
DXCall(readbackCmdList->Reset(readbackCmdAllocator, nullptr));
readbackFence.Init(0);
}
