void CRtwShadowRenderer::InitImportanceShaders()
{
HRESULT hr;
{
std::ifstream vsStream("..\\assets\\importanceMapVS.cso", 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 = Globals::Get().device.m_device->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_importanceVS);
ASSERT_ON_FAIL(hr);
hr = Globals::Get().device.m_device->CreateInputLayout(layoutPosTexNormalBitangentTangent, ARRAYSIZE(layoutPosTexNormalBitangentTangent), vsString.c_str(), vsSize, &m_inputLayout);
ASSERT_ON_FAIL(hr);
}
////////////////////////////////////////////
{
std::ifstream psStream("..\\assets\\importanceMapPS.cso", 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_importancePS);
ASSERT_ON_FAIL(hr);
psStream.close();
}
/////////////////////////////////////////////
{
std::ifstream vsStream("..\\assets\\shadowmapRtwVS.cso", 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 = Globals::Get().device.m_device->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_shadowMapRtwVS);
ASSERT_ON_FAIL(hr);
}
////////////////////////////////////////////
{
std::ifstream psStream("..\\assets\\shadowmapRtwPS.cso", 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_shadowMapRtwPS);
ASSERT_ON_FAIL(hr);
psStream.close();
}
///////////////////////////////////////////
{
std::ifstream vsStream("..\\assets\\renderFinalVS.cso", 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 = Globals::Get().device.m_device->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_finalVS);
ASSERT_ON_FAIL(hr);
}
////////////////////////////////////////////
{
std::ifstream psStream("..\\assets\\renderFinalPS.cso", 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_finalPS);
ASSERT_ON_FAIL(hr);
psStream.close();
}
{
std::ifstream psStream("..\\assets\\warpMapPS.cso", 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_calculateWarpPS);
ASSERT_ON_FAIL(hr);
psStream.close();
}
////////////////////////////////////////////
{
std::ifstream vsStream("..\\assets\\depthOnly.cso", 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 = Globals::Get().device.m_device->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_depthVS);
if(FAILED(hr)) assert(false);
}
}
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;
}
CShader_GBuffer::CShader_GBuffer(std::string vs_path, std::string ps_path)
{
GLuint vsID = glCreateShader(GL_VERTEX_SHADER);
GLuint psID = glCreateShader(GL_FRAGMENT_SHADER);
std::string vsCode;
std::ifstream vsStream(vs_path.c_str(), std::ios::in);
if (vsStream.is_open())
{
std::string line = "";
while (getline(vsStream, line))
{
vsCode += "\n" + line;
}
vsStream.close();
}
std::string psCode;
std::ifstream psStream(ps_path.c_str(), std::ios::in);
if (psStream.is_open())
{
std::string line = "";
while (getline(psStream, line))
{
psCode += "\n" + line;
}
psStream.close();
}
GLint result = GL_FALSE;
int logLength;
// Compile vertex shader
log(LOG_TYPE_DEFAULT, "Compiling Shader: " + vs_path + "..");
const char* vsPointer = vsCode.c_str();
glShaderSource(vsID, 1, &vsPointer, NULL);
glCompileShader(vsID);
// Check shader status
glGetShaderiv(vsID, GL_COMPILE_STATUS, &result);
if (!result)
{
glGetShaderiv(vsID, GL_INFO_LOG_LENGTH, &logLength);
std::vector<char> vsError(logLength);
glGetShaderInfoLog(vsID, logLength, NULL, &vsError[0]);
if (vsError.size() - 1 >= 0)
{
vsError[vsError.size() - 1] = '\0';
}
log(LOG_TYPE_ERROR, std::string((char*)&vsError[0]));
}
// Compile pixel shader
log(LOG_TYPE_DEFAULT, "Compiling Shader: " + ps_path + "..");
const char* psPointer = psCode.c_str();
glShaderSource(psID, 1, &psPointer, NULL);
glCompileShader(psID);
// Check shader status
glGetShaderiv(psID, GL_COMPILE_STATUS, &result);
if (!result)
{
glGetShaderiv(psID, GL_INFO_LOG_LENGTH, &logLength);
std::vector<char> psError(logLength);
glGetShaderInfoLog(psID, logLength, NULL, &psError[0]);
if (psError.size() - 1 >= 0)
{
psError[psError.size() - 1] = '\0';
}
log(LOG_TYPE_ERROR, std::string((char*)&psError[0]));
}
// Link shader
log(LOG_TYPE_DEFAULT, "Linking shader ..");
GLuint shaderID = glCreateProgram();
glAttachShader(shaderID, vsID);
glAttachShader(shaderID, psID);
glLinkProgram(shaderID);
// Check final shader
glGetProgramiv(shaderID, GL_LINK_STATUS, &result);
if (!result)
{
glGetProgramiv(shaderID, GL_INFO_LOG_LENGTH, &logLength);
std::vector<char> shaderError(logLength);
glGetProgramInfoLog(shaderID, logLength, NULL, &shaderError[0]);
if (shaderError.size() - 1 >= 0)
{
shaderError[shaderError.size() - 1] = '\0';
}
log(LOG_TYPE_ERROR, std::string((char*)&shaderError[0]));
}
// Clean up
glDeleteShader(vsID);
glDeleteShader(psID);
// Save the ID
m_Id = shaderID;
}
