bool GLSLESProgram::compile(const bool checkErrors)
{
if (mCompiled == 1)
{
return true;
}
// Only create a shader object if glsl es is supported
if (isSupported())
{
GL_CHECK_ERROR
// Create shader object
GLenum shaderType = 0x0000;
if (mType == GPT_VERTEX_PROGRAM)
{
shaderType = GL_VERTEX_SHADER;
}
else if (mType == GPT_FRAGMENT_PROGRAM)
{
shaderType = GL_FRAGMENT_SHADER;
}
mGLHandle = glCreateShader(shaderType);
GL_CHECK_ERROR
}
// Add preprocessor extras and main source
if (!mSource.empty())
{
const char *source = mSource.c_str();
glShaderSource(mGLHandle, 1, &source, NULL);
// Check for load errors
GL_CHECK_ERROR
}
if (checkErrors)
logObjectInfo("GLSL ES compiling: " + mName, mGLHandle);
glCompileShader(mGLHandle);
GL_CHECK_ERROR
// Check for compile errors
glGetShaderiv(mGLHandle, GL_COMPILE_STATUS, &mCompiled);
if(!mCompiled && checkErrors)
{
String message = logObjectInfo("GLSL ES compile log: " + mName, mGLHandle);
checkAndFixInvalidDefaultPrecisionError(message);
}
// Log a message that the shader compiled successfully.
if (mCompiled && checkErrors)
logObjectInfo("GLSL ES compiled: " + mName, mGLHandle);
return (mCompiled == 1);
}
bool GLSLESProgram::compile(const bool checkErrors)
{
if (mCompiled == 1)
{
return true;
}
// Only create a shader object if glsl es is supported
if (isSupported())
{
GL_CHECK_ERROR
// Create shader object
GLenum shaderType = 0x0000;
if (mType == GPT_VERTEX_PROGRAM)
{
shaderType = GL_VERTEX_SHADER;
}
else if (mType == GPT_FRAGMENT_PROGRAM)
{
shaderType = GL_FRAGMENT_SHADER;
}
mGLShaderHandle = glCreateShader(shaderType);
GL_CHECK_ERROR
#if GL_EXT_debug_label && OGRE_PLATFORM != OGRE_PLATFORM_NACL
glLabelObjectEXT(GL_SHADER_OBJECT_EXT, mGLShaderHandle, 0, mName.c_str());
#endif
if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS))
{
mGLProgramHandle = glCreateProgram();
GL_CHECK_ERROR
#if GL_EXT_debug_label && OGRE_PLATFORM != OGRE_PLATFORM_NACL
glLabelObjectEXT(GL_PROGRAM_OBJECT_EXT, mGLProgramHandle, 0, mName.c_str());
#endif
}
}
// Add preprocessor extras and main source
if (!mSource.empty())
{
const char *source = mSource.c_str();
glShaderSource(mGLShaderHandle, 1, &source, NULL);
// Check for load errors
GL_CHECK_ERROR
}
if (checkErrors)
logObjectInfo("GLSL ES compiling: " + mName, mGLShaderHandle);
glCompileShader(mGLShaderHandle);
GL_CHECK_ERROR
// Check for compile errors
glGetShaderiv(mGLShaderHandle, GL_COMPILE_STATUS, &mCompiled);
if(!mCompiled && checkErrors)
{
String message = logObjectInfo("GLSL ES compile log: " + mName, mGLShaderHandle);
checkAndFixInvalidDefaultPrecisionError(message);
}
// Log a message that the shader compiled successfully.
if (mCompiled && checkErrors)
logObjectInfo("GLSL ES compiled: " + mName, mGLShaderHandle);
if(!mCompiled)
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
((mType == GPT_VERTEX_PROGRAM) ? "Vertex Program " : "Fragment Program ") + mName +
" failed to compile. See compile log above for details.",
"GLSLESProgram::compile");
return (mCompiled == 1);
}
bool GLSLESProgram::compile(const bool checkErrors)
{
if (mCompiled == 1)
{
return true;
}
// Only create a shader object if glsl es is supported
if (isSupported())
{
// Create shader object
GLenum shaderType = 0x0000;
if (mType == GPT_VERTEX_PROGRAM)
{
shaderType = GL_VERTEX_SHADER;
}
else if (mType == GPT_FRAGMENT_PROGRAM)
{
shaderType = GL_FRAGMENT_SHADER;
}
OGRE_CHECK_GL_ERROR(mGLShaderHandle = glCreateShader(shaderType));
#if OGRE_PLATFORM != OGRE_PLATFORM_NACL
if(getGLES2SupportRef()->checkExtension("GL_EXT_debug_label"))
{
OGRE_IF_IOS_VERSION_IS_GREATER_THAN(5.0)
glLabelObjectEXT(GL_SHADER_OBJECT_EXT, mGLShaderHandle, 0, mName.c_str());
}
#endif
if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS))
{
OGRE_CHECK_GL_ERROR(mGLProgramHandle = glCreateProgram());
#if OGRE_PLATFORM != OGRE_PLATFORM_NACL
if(getGLES2SupportRef()->checkExtension("GL_EXT_debug_label"))
{
OGRE_IF_IOS_VERSION_IS_GREATER_THAN(5.0)
glLabelObjectEXT(GL_PROGRAM_OBJECT_EXT, mGLProgramHandle, 0, mName.c_str());
}
#endif
}
}
// Add preprocessor extras and main source
if (!mSource.empty())
{
// Fix up the source in case someone forgot to redeclare gl_Position
if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS) &&
mType == GPT_VERTEX_PROGRAM)
{
size_t versionPos = mSource.find("#version");
int shaderVersion = StringConverter::parseInt(mSource.substr(versionPos+9, 3));
// Check that it's missing and that this shader has a main function, ie. not a child shader.
if(mSource.find("out highp vec4 gl_Position") == String::npos)
{
if(shaderVersion >= 300)
mSource.insert(versionPos+16, "out highp vec4 gl_Position;\nout highp float gl_PointSize;\n");
}
if(mSource.find("#extension GL_EXT_separate_shader_objects : require") == String::npos)
{
if(shaderVersion >= 300)
mSource.insert(versionPos+16, "#extension GL_EXT_separate_shader_objects : require\n");
}
}
#if !OGRE_NO_GLES2_GLSL_OPTIMISER
const char *source = (getOptimiserEnabled() && getIsOptimised()) ? mOptimisedSource.c_str() : mSource.c_str();
#else
const char *source = mSource.c_str();
#endif
OGRE_CHECK_GL_ERROR(glShaderSource(mGLShaderHandle, 1, &source, NULL));
}
if (checkErrors)
logObjectInfo("GLSL ES compiling: " + mName, mGLShaderHandle);
OGRE_CHECK_GL_ERROR(glCompileShader(mGLShaderHandle));
// Check for compile errors
OGRE_CHECK_GL_ERROR(glGetShaderiv(mGLShaderHandle, GL_COMPILE_STATUS, &mCompiled));
if(!mCompiled && checkErrors)
{
String message = logObjectInfo("GLSL ES compile log: " + mName, mGLShaderHandle);
checkAndFixInvalidDefaultPrecisionError(message);
}
// Log a message that the shader compiled successfully.
if (mCompiled && checkErrors)
logObjectInfo("GLSL ES compiled: " + mName, mGLShaderHandle);
if(!mCompiled)
{
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
((mType == GPT_VERTEX_PROGRAM) ? "Vertex Program " : "Fragment Program ") + mName +
" failed to compile. See compile log above for details.",
"GLSLESProgram::compile");
}
return (mCompiled == 1);
}
//---------------------------------------------------------------------------
bool GLSLProgram::compile(const bool checkErrors)
{
if (mCompiled == 1)
{
return true;
}
// only create a shader object if glsl is supported
if (isSupported())
{
// create shader object
GLenum shaderType = 0x0000;
switch (mType)
{
case GPT_VERTEX_PROGRAM:
shaderType = GL_VERTEX_SHADER;
break;
case GPT_FRAGMENT_PROGRAM:
shaderType = GL_FRAGMENT_SHADER;
break;
case GPT_GEOMETRY_PROGRAM:
shaderType = GL_GEOMETRY_SHADER;
break;
case GPT_DOMAIN_PROGRAM:
shaderType = GL_TESS_EVALUATION_SHADER;
break;
case GPT_HULL_PROGRAM:
shaderType = GL_TESS_CONTROL_SHADER;
break;
case GPT_COMPUTE_PROGRAM:
shaderType = GL_COMPUTE_SHADER;
break;
}
OGRE_CHECK_GL_ERROR(mGLShaderHandle = glCreateShader(shaderType));
// if(getGLSupport()->checkExtension("GL_KHR_debug") || gl3wIsSupported(4, 3))
// glObjectLabel(GL_SHADER, mGLShaderHandle, 0, mName.c_str());
if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS))
{
OGRE_CHECK_GL_ERROR(mGLProgramHandle = glCreateProgram());
// if(getGLSupport()->checkExtension("GL_KHR_debug") || gl3wIsSupported(4, 3))
// glObjectLabel(GL_PROGRAM, mGLProgramHandle, 0, mName.c_str());
}
}
// Add preprocessor extras and main source
if (!mSource.empty())
{
// Fix up the source in case someone forgot to redeclare gl_Position
if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS) &&
mType == GPT_VERTEX_PROGRAM)
{
// Check that it's missing and that this shader has a main function, ie. not a child shader.
if(mSource.find("vec4 gl_Position") == String::npos)
{
size_t mainPos = mSource.find("void main");
if(mainPos != String::npos)
{
size_t versionPos = mSource.find("#version");
int shaderVersion = StringConverter::parseInt(mSource.substr(versionPos+9, 3));
if(shaderVersion >= 150)
mSource.insert(mainPos, "out gl_PerVertex\n{\nvec4 gl_Position;\nfloat gl_PointSize;\nfloat gl_ClipDistance[];\n};\n");
}
}
}
const char *source = mSource.c_str();
OGRE_CHECK_GL_ERROR(glShaderSource(mGLShaderHandle, 1, &source, NULL));
}
OGRE_CHECK_GL_ERROR(glCompileShader(mGLShaderHandle));
// Check for compile errors
OGRE_CHECK_GL_ERROR(glGetShaderiv(mGLShaderHandle, GL_COMPILE_STATUS, &mCompiled));
if(!mCompiled && checkErrors)
{
String message = logObjectInfo("GLSL compile log: " + mName, mGLShaderHandle);
checkAndFixInvalidDefaultPrecisionError(message);
}
// Log a message that the shader compiled successfully.
if (mCompiled && checkErrors)
logObjectInfo("GLSL compiled: " + mName, mGLShaderHandle);
if(!mCompiled)
{
String progType = "Fragment";
if (mType == GPT_VERTEX_PROGRAM)
{
progType = "Vertex";
}
else if (mType == GPT_GEOMETRY_PROGRAM)
{
progType = "Geometry";
}
else if (mType == GPT_DOMAIN_PROGRAM)
{
progType = "Tesselation Evaluation";
}
else if (mType == GPT_HULL_PROGRAM)
{
progType = "Tesselation Control";
}
else if (mType == GPT_COMPUTE_PROGRAM)
{
progType = "Compute";
}
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
progType + " Program " + mName +
" failed to compile. See compile log above for details.",
"GLSLProgram::compile");
}
return (mCompiled == 1);
}
