void OGL4ShaderProgram::Use()
{
glUseProgram(m_program);
BindUniformBlocks();
BindTextures();
}
//-----------------------------------------------------------------------------------------------
void Material::Enable()
{
OpenGLRenderer::UseShaderProgram( m_glShaderProgram->m_programID );
BindTextures();
SendUniformValues();
SendAttribValues();
EnableAttribArrays();
}
void Shader::Bind() const
{
if (myShaderProgram)
{
// Enable the program
GLCheck(glUseProgramObjectARB(myShaderProgram));
// Bind the textures
BindTextures();
// Bind the current texture
if (myCurrentTexture != -1)
GLCheck(glUniform1iARB(myCurrentTexture, 0));
}
}
GLvoid CTerrainRenderer::PrepareTerrain(Terrains::CTerrain terrain)
{
glBindVertexArray(terrain.GetRawModel().GetVaoId());
BindTextures(terrain);
}
//-----------------------------------------------------------------------------
CPUTResult CPUTMaterialDX11::LoadMaterial(const cString &fileName, const CPUTModel *pModel, int meshIndex)
{
CPUTResult result = CPUT_SUCCESS;
mMaterialName = fileName;
mMaterialNameHash = CPUTComputeHash( mMaterialName );
// Open/parse the file
CPUTConfigFile file;
result = file.LoadFile(fileName);
if(CPUTFAILED(result))
{
return result;
}
// Make a local copy of all the parameters
mConfigBlock = *file.GetBlock(0);
// get necessary device and AssetLibrary pointers
ID3D11Device *pD3dDevice = CPUT_DX11::GetDevice();
CPUTAssetLibraryDX11 *pAssetLibrary = (CPUTAssetLibraryDX11*)CPUTAssetLibrary::GetAssetLibrary();
// TODO: The following code is very repetitive. Consider generalizing so we can call a function instead.
// see if there are any pixel/vertex/geo shaders to load
CPUTConfigEntry *pValue, *pEntryPointName, *pProfileName;
pValue = mConfigBlock.GetValueByName(_L("VertexShaderFile"));
if( pValue->IsValid() )
{
pEntryPointName = mConfigBlock.GetValueByName(_L("VertexShaderMain"));
pProfileName = mConfigBlock.GetValueByName(_L("VertexShaderProfile"));
pAssetLibrary->GetVertexShader(pValue->ValueAsString(), pD3dDevice, pEntryPointName->ValueAsString(), pProfileName->ValueAsString(), &mpVertexShader );
ReadShaderSamplersAndTextures( mpVertexShader->GetBlob(), &mVertexShaderParameters );
}
// load and store the pixel shader if it was specified
pValue = mConfigBlock.GetValueByName(_L("PixelShaderFile"));
if( pValue->IsValid() )
{
pEntryPointName = mConfigBlock.GetValueByName(_L("PixelShaderMain"));
pProfileName = mConfigBlock.GetValueByName(_L("PixelShaderProfile"));
pAssetLibrary->GetPixelShader(pValue->ValueAsString(), pD3dDevice, pEntryPointName->ValueAsString(), pProfileName->ValueAsString(), &mpPixelShader);
ReadShaderSamplersAndTextures( mpPixelShader->GetBlob(), &mPixelShaderParameters );
}
// load and store the compute shader if it was specified
pValue = mConfigBlock.GetValueByName(_L("ComputeShaderFile"));
if( pValue->IsValid() )
{
pEntryPointName = mConfigBlock.GetValueByName(_L("ComputeShaderMain"));
pProfileName = mConfigBlock.GetValueByName(_L("ComputeShaderProfile"));
pAssetLibrary->GetComputeShader(pValue->ValueAsString(), pD3dDevice, pEntryPointName->ValueAsString(), pProfileName->ValueAsString(), &mpComputeShader);
ReadShaderSamplersAndTextures( mpComputeShader->GetBlob(), &mComputeShaderParameters );
}
// load and store the geometry shader if it was specified
pValue = mConfigBlock.GetValueByName(_L("GeometryShaderFile"));
if( pValue->IsValid() )
{
pEntryPointName = mConfigBlock.GetValueByName(_L("GeometryShaderMain"));
pProfileName = mConfigBlock.GetValueByName(_L("GeometryShaderProfile"));
pAssetLibrary->GetGeometryShader(pValue->ValueAsString(), pD3dDevice, pEntryPointName->ValueAsString(), pProfileName->ValueAsString(), &mpGeometryShader);
ReadShaderSamplersAndTextures( mpGeometryShader->GetBlob(), &mGeometryShaderParameters );
}
// load and store the hull shader if it was specified
pValue = mConfigBlock.GetValueByName(_L("HullShaderFile"));
if( pValue->IsValid() )
{
pEntryPointName = mConfigBlock.GetValueByName(_L("HullShaderMain"));
pProfileName = mConfigBlock.GetValueByName(_L("HullShaderProfile"));
pAssetLibrary->GetHullShader(pValue->ValueAsString(), pD3dDevice, pEntryPointName->ValueAsString(), pProfileName->ValueAsString(), &mpHullShader);
ReadShaderSamplersAndTextures( mpHullShader->GetBlob(), &mHullShaderParameters );
}
// load and store the domain shader if it was specified
pValue = mConfigBlock.GetValueByName(_L("DomainShaderFile"));
if( pValue->IsValid() )
{
pEntryPointName = mConfigBlock.GetValueByName(_L("DomainShaderMain"));
pProfileName = mConfigBlock.GetValueByName(_L("DomainShaderProfile"));
pAssetLibrary->GetDomainShader(pValue->ValueAsString(), pD3dDevice, pEntryPointName->ValueAsString(), pProfileName->ValueAsString(), &mpDomainShader);
ReadShaderSamplersAndTextures( mpDomainShader->GetBlob(), &mDomainShaderParameters );
}
// load and store the render state file if it was specified
pValue = mConfigBlock.GetValueByName(_L("RenderStateFile"));
if( pValue->IsValid() )
{
mpRenderStateBlock = pAssetLibrary->GetRenderStateBlock(pValue->ValueAsString());
}
// For each of the shader stages, bind shaders and buffers
for( CPUTShaderParameters **pCur = mpShaderParametersList; *pCur; pCur++ ) // Bind textures and buffersfor each shader stage
{
BindTextures( **pCur, pModel, meshIndex );
BindBuffers( **pCur, pModel, meshIndex );
BindUAVs( **pCur, pModel, meshIndex );
BindConstantBuffers( **pCur, pModel, meshIndex );
}
return result;
}
CPUTResult CPUTMaterialEffectOGL::LoadMaterialEffect(
const cString &fileName,
const CPUTModel *pModel,
int meshIndex,
const char **pShaderMacros,
int externalCount,
cString *pExternalName,
float4 *pExternals,
int *pExternalOffset,
int *pExternalSize
){
CPUTResult result = CPUT_SUCCESS;
CPUTConfigEntry *pValue;
mMaterialName = fileName;
mMaterialNameHash = CPUTComputeHash( mMaterialName );
// Open/parse the file
CPUTConfigFile file;
result = file.LoadFile(fileName);
if(CPUTFAILED(result))
{
return result;
}
// Make a local copy of all the parameters
CPUTConfigBlock *pBlock = file.GetBlock(0);
ASSERT( pBlock, _L("Error getting parameter block") );
if( !pBlock )
{
return CPUT_ERROR_PARAMETER_BLOCK_NOT_FOUND;
}
mConfigBlock = *pBlock;
// get necessary device and AssetLibrary pointers
//ID3D11Device *pD3dDevice = CPUT_DX11::GetDevice();
CPUTAssetLibraryOGL *pAssetLibrary = (CPUTAssetLibraryOGL*)CPUTAssetLibrary::GetAssetLibrary();
{
CPUTConfigEntry *pEntryPointName, *pProfileName;
int numFiles = 0;
cString pBase = _L("VertexShaderFileOGL_");
cString pName = pBase + to_cString(numFiles+1);
std::vector<cString> filenames;
while (mConfigBlock.GetValueByName(pName)->IsValid())
{
filenames.push_back(mConfigBlock.GetValueByName(pName)->ValueAsString());
numFiles++;
pName = pBase + to_cString(numFiles+1);
}
if(numFiles > 0)
{
pEntryPointName = mConfigBlock.GetValueByName(_L("VertexShaderMain"));
pProfileName = mConfigBlock.GetValueByName(_L("VertexShaderProfile"));
pAssetLibrary->GetVertexShader(
filenames,
/*pD3dDevice,*/
_L("VertexShaderMain"),
pProfileName->ValueAsString(),
&mpVertexShader,
false,
(CPUT_SHADER_MACRO*)pShaderMacros
);
}
}
#ifdef CPUT_SUPPORT_TESSELLATION
{
int numFiles = 0;
cString pBase = _L("ControlShaderFileOGL_");
cString pName = pBase + to_cString(numFiles+1);
std::vector<cString> filenames;
while (mConfigBlock.GetValueByName(pName)->IsValid())
{
filenames.push_back(mConfigBlock.GetValueByName(pName)->ValueAsString());
numFiles++;
pName = pBase + to_cString(numFiles+1);
}
if(numFiles > 0)
{
pAssetLibrary->GetHullShader(
filenames,
/* pD3dDevice,*/
_L("ControlShaderMain"),
_L(""),
&mpControlShader,
false,
(CPUT_SHADER_MACRO*)pShaderMacros
);
}
}
{
int numFiles = 0;
cString pBase = _L("EvaluationShaderFileOGL_");
cString pName = pBase + to_cString(numFiles+1);
std::vector<cString> filenames;
while (mConfigBlock.GetValueByName(pName)->IsValid())
{
filenames.push_back(mConfigBlock.GetValueByName(pName)->ValueAsString());
numFiles++;
pName = pBase + to_cString(numFiles+1);
}
if(numFiles > 0)
{
pAssetLibrary->GetDomainShader(
filenames,
/* pD3dDevice,*/
_L("EvaluationShaderMain"),
_L(""),
&mpEvaluationShader,
false,
(CPUT_SHADER_MACRO*)pShaderMacros
);
}
}
#endif
{
int numFiles = 0;
cString pBase = _L("GeometryShaderFileOGL_");
cString pName = pBase + to_cString(numFiles+1);
std::vector<cString> filenames;
while (mConfigBlock.GetValueByName(pName)->IsValid())
{
filenames.push_back(mConfigBlock.GetValueByName(pName)->ValueAsString());
numFiles++;
pName = pBase + to_cString(numFiles+1);
}
if(numFiles > 0)
{
pAssetLibrary->GetGeometryShader(
filenames,
/* pD3dDevice,*/
_L("GeometryShaderMain"),
_L(""),
&mpGeometryShader,
false,
(CPUT_SHADER_MACRO*)pShaderMacros
);
}
}
// load and store the pixel shader if it was specified
{
int numFiles = 0;
cString pBase = _L("FragmentShaderFileOGL_");
cString pName = pBase + to_cString(numFiles+1);
std::vector<cString> filenames;
while (mConfigBlock.GetValueByName(pName)->IsValid())
{
filenames.push_back(mConfigBlock.GetValueByName(pName)->ValueAsString());
numFiles++;
pName = pBase + to_cString(numFiles+1);
}
if(numFiles > 0)
{
pAssetLibrary->GetPixelShader(
filenames,
/* pD3dDevice,*/
_L("FragmentShaderMain"), //mConfigBlock.GetValueByName(_L("FragmentShaderMain"))->ValueAsString(),
mConfigBlock.GetValueByName(_L("FragmentShaderProfile"))->ValueAsString(),
&mpFragmentShader,
false,
(CPUT_SHADER_MACRO*)pShaderMacros
);
}
}
// load and store the render state file if it was specified
pValue = mConfigBlock.GetValueByName(_L("RenderStateFile"));
if( pValue->IsValid() )
{
mpRenderStateBlock = pAssetLibrary->GetRenderStateBlock(pValue->ValueAsString());
}
int IsLinked;
char *shaderProgramInfoLog;
int maxLength;
mShaderProgram = glCreateProgram();
// Attach our shaders to our program
// Attach our shaders to our program
if (mpVertexShader) {
GL_CHECK(glAttachShader(mShaderProgram, mpVertexShader->GetShaderID()));
}
if (mpFragmentShader) {
GL_CHECK(glAttachShader(mShaderProgram, mpFragmentShader->GetShaderID()));
}
if (mpControlShader) {
GL_CHECK(glAttachShader(mShaderProgram, mpControlShader->GetShaderID()));
}
if (mpEvaluationShader) {
GL_CHECK(glAttachShader(mShaderProgram, mpEvaluationShader->GetShaderID()));
}
if (mpGeometryShader) {
GL_CHECK(glAttachShader(mShaderProgram, mpGeometryShader->GetShaderID()));
}
/*
GL_CHECK(glBindAttribLocation(mShaderProgram, 0, "in_Position"));
GL_CHECK(glBindAttribLocation(mShaderProgram, 1, "inNormal"));
GL_CHECK(glBindAttribLocation(mShaderProgram, 2, "inBinormal"));
GL_CHECK(glBindAttribLocation(mShaderProgram, 3, "inTangent"));
GL_CHECK(glBindAttribLocation(mShaderProgram, 4, "inTex"));
*/
// Link our program
// At this stage, the vertex and fragment programs are inspected, optimized and a binary code is generated for the shader.
// The binary code is uploaded to the GPU, if there is no error.
GL_CHECK(glLinkProgram(mShaderProgram));
// Again, we must check and make sure that it linked. If it fails, it would mean either there is a mismatch between the vertex
// and fragment shaders. It might be that you have surpassed your GPU's abilities. Perhaps too many ALU operations or
// too many texel fetch instructions or too many interpolators or dynamic loops.
GL_CHECK(glGetProgramiv(mShaderProgram, GL_LINK_STATUS, (int *)&IsLinked));
if(IsLinked == false)
{
// Noticed that glGetProgramiv is used to get the length for a shader program, not glGetShaderiv.
glGetProgramiv(mShaderProgram, GL_INFO_LOG_LENGTH, &maxLength);
// The maxLength includes the NULL character
shaderProgramInfoLog = (char *)malloc(maxLength);
// Notice that glGetProgramInfoLog, not glGetShaderInfoLog.
glGetProgramInfoLog(mShaderProgram, maxLength, &maxLength, shaderProgramInfoLog);
DEBUG_PRINT_ALWAYS((_L("Failed to link shader program:\n%s\n"), shaderProgramInfoLog));
ASSERT(false, _L("glLinkProgram failed"));
// Handle the error in an appropriate way such as displaying a message or writing to a log file.
// In this simple program, we'll just leave
//DEBUG_PRINT_ALWAYS(("Failed to link shader program:\n%s\n", shaderProgramInfoLog));
free(shaderProgramInfoLog);
}
// Shader must be successfully linked before we can query uniform locations
ReadShaderSamplersAndTextures( mShaderProgram, &mVertexShaderParameters );
glUseProgram(0);
// For each of the shader stages, bind shaders and buffers
// for( CPUTShaderParameters **pCur = mpShaderParametersList; *pCur; pCur++ ) // Bind textures and buffersfor each shader stage
{
BindTextures( mVertexShaderParameters, pModel, meshIndex );
//BindTextures( **pCur, pModel, meshIndex );
//BindBuffers( **pCur, pModel, meshIndex );
BindUAVs( mVertexShaderParameters, pModel, meshIndex );
BindConstantBuffers( mVertexShaderParameters, pModel, meshIndex );
}
return result;
}
void Shader::Use() const
{
BindTextures();
}
void SObjModel::Render(RenderContext &r) {
glBindVertexArray(d_emptyVAO);
/*activate shader and load model matrix*/
if (r.shader->IsReady) {
r.shader->Bind();//Commit changes
SProg *s = r.shader->getDirect();
s->Bind();
/*request shader locations*/
int locPositions = s->LookupAttribLocation("position");
int locNormals = s->LookupAttribLocation("normal");
int locUV = s->LookupAttribLocation("UV");
/*ARB_vertex_attrib_binding*/
/* if (locPositions != EFAIL) {
glVertexAttribFormat ( locPositions, 3 ,GL_FLOAT, GL_FALSE, offsetof(CObjVertexN,p) );
glVertexAttribBinding(0, 0);
}
if (locNormals != EFAIL) {
glVertexAttribFormat ( locNormals, 3 ,GL_FLOAT, GL_FALSE, offsetof(CObjVertexN,n) );
glVertexAttribBinding(1, 0);
}
if (locUV != EFAIL) {
glVertexAttribFormat ( locUV, 2 ,GL_FLOAT, GL_FALSE, offsetof(CObjVertexN,tc) );
glVertexAttribBinding(2, 0);
}
*/
s->SetUniform(r.d_modelMatrixLoc,model);
s->SetUniform(r.d_viewMatrixLoc,r.d_V);
s->SetUniform(r.d_projMatrixLoc,r.d_P);
/*optimize*/
s->SetUniform(r.d_uniformMVP,r.d_P*r.d_V*model);
s->SetUniform(r.d_uniformMV,r.d_V*model);//small todo
std::size_t last_hash = -1;
for (auto it = d_sm.begin(); it != d_sm.end();++it) {
auto &submesh = (*it);
SMaterial m = d_materials[submesh->m_name];
//glBindVertexArray ( submesh_idx[submesh->id].vao );
if (last_hash != m.name_hash){
last_hash = m.name_hash;
BindTextures(m);
for (int i = 0 ; i < r.MAX_RBO_TEXTURES;i++)
{
if (r.d_RBOTexture[i]) {
r.d_RBOTexture[i]->Bind(5+i);
}
}
/*shader*/
/*shadow mapping*/
}
auto& idx = submesh_idx[submesh->id];
glBindBuffer(GL_ARRAY_BUFFER, idx.vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, idx.ibo);
/*direct approach*/
if (locPositions != EFAIL) {
glVertexAttribPointer ( locPositions, 3 ,GL_FLOAT, GL_FALSE, sizeof(UVNVertex), (const GLvoid*) offsetof(UVNVertex,p) );
glEnableVertexAttribArray ( locPositions );
}
if (locNormals != EFAIL) {
glVertexAttribPointer ( locNormals, 3 ,GL_FLOAT, GL_FALSE, sizeof(UVNVertex), (const GLvoid*) offsetof(UVNVertex,n) );
glEnableVertexAttribArray ( locNormals );
}
if (locUV != EFAIL) {
glVertexAttribPointer ( locUV, 2 ,GL_FLOAT, GL_FALSE, sizeof(UVNVertex), (const GLvoid*) offsetof(UVNVertex,tc) );
glEnableVertexAttribArray ( locUV );
}
//glBindVertexBuffer(0,idx.vbo,0, sizeof(CObjVertexN));
int idx_c = submesh->indexes.size();
glDrawElements(GL_TRIANGLES, idx_c, GL_UNSIGNED_INT, (GLvoid *)0);
//glBindVertexArray ( 0 );
}
}
glBindVertexArray(0);
}
//---------------------------------------------------------------------------
void Material::ActivateMaterial()
{
BindTextures();
UseProgram();
SetUniforms();
}