GLint ComputeWaterSimulation::createShaderPipelineProgram(GLuint target, const char* src, GLuint &pipeline, GLuint &program)
{
GLint status;
glGenProgramPipelines(1, &pipeline);
program = glCreateShaderProgramv(target, 1, (const GLchar **)&src);
glBindProgramPipeline(pipeline);
glUseProgramStages(pipeline, GL_COMPUTE_SHADER_BIT, program);
glValidateProgramPipeline(pipeline);
glGetProgramPipelineiv(pipeline, GL_VALIDATE_STATUS, &status);
if (status != GL_TRUE)
{
GLint logLength;
glGetProgramPipelineiv(pipeline, GL_INFO_LOG_LENGTH, &logLength);
char *log = new char [logLength];
glGetProgramPipelineInfoLog(pipeline, logLength, 0, log);
LOGI("Shader pipeline not valid:\n%s\n", log);
delete [] log;
}
glBindProgramPipeline(0);
return status;
}
GLuint ShaderPipeline::createShaderPipelineProgram(GLuint target, const char* src, const char* m_shaderPrefix, GLuint m_programPipeline)
{
GLuint object;
GLint status;
const GLchar* fullSrc[2] = { m_shaderPrefix, src };
object = glCreateShaderProgramv(target, 2, fullSrc);
{
GLint logLength;
glGetProgramiv(object, GL_INFO_LOG_LENGTH, &logLength);
if (logLength > 0)
{
// This log contains shader compile errors.
char *log = new char[logLength];
glGetProgramInfoLog(object, logLength, 0, log);
LOGI("Shader pipeline program not valid:\n%s\n", log);
delete[] log;
}
}
glBindProgramPipeline(m_programPipeline);
glUseProgramStages(m_programPipeline, GL_COMPUTE_SHADER_BIT, object);
glValidateProgramPipeline(m_programPipeline);
glGetProgramPipelineiv(m_programPipeline, GL_VALIDATE_STATUS, &status);
if (status != GL_TRUE) {
GLint logLength;
glGetProgramPipelineiv(m_programPipeline, GL_INFO_LOG_LENGTH, &logLength);
if (logLength > 0)
{
char *log = new char[logLength];
glGetProgramPipelineInfoLog(m_programPipeline, logLength, 0, log);
LOGI("Shader pipeline not valid:\n%s\n", log);
delete[] log;
}
}
glBindProgramPipeline(0);
CHECK_GL_ERROR();
return object;
}
string Pipeline :: getLog () const
{
int len;
string log;
glGetProgramPipelineiv ( id, GL_INFO_LOG_LENGTH, &len );
if ( len < 1 )
return "";
char * buf = (char *) malloc ( len + 1 );
glGetProgramPipelineInfoLog ( id, len+1, NULL, buf );
log = buf;
free ( buf );
return log;
}
GeneralGL::GLError::GLError(GLErrorType type, GLuint handle, std::string message)
{
this->type = type;
this->handle = handle;
this->msg = message;
char log[512];
switch (type)
{
case SHADER:
glGetShaderInfoLog(handle, 512, 0, log);
break;
case PROGRAM:
glGetProgramInfoLog(handle, 512, 0, log);
break;
case PROGRAM_PIPELINE:
glGetProgramPipelineInfoLog(handle, 512, 0, log);
}
std::string infoLog = std::string(log);
this->log = infoLog;
}
bool GSShaderOGL::ValidatePipeline(GLuint p)
{
if (!m_debug_shader) return true;
// FIXME: might be mandatory to validate the pipeline
glValidateProgramPipeline(p);
GLint status = 0;
glGetProgramPipelineiv(p, GL_VALIDATE_STATUS, &status);
if (status) return true;
GLint log_length = 0;
glGetProgramPipelineiv(p, GL_INFO_LOG_LENGTH, &log_length);
if (log_length > 0) {
char* log = new char[log_length];
glGetProgramPipelineInfoLog(p, log_length, NULL, log);
fprintf(stderr, "%s", log);
delete[] log;
}
fprintf(stderr, "\n");
return false;
}
std::string GlslShaderSource::get_pipeline_info_log(GLuint op)
{
#if defined(DNLOAD_GLESV2)
(void)op;
return std::string();
#else
std::string ret;
GLint len;
glGetProgramPipelineiv(op, GL_INFO_LOG_LENGTH, &len);
if(len)
{
GLchar *log = new GLchar[len];
GLsizei acquired;
glGetProgramPipelineInfoLog(op, len, &acquired, log);
ret.assign(log);
delete[] log;
}
return ret;
#endif
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL41_nglGetProgramPipelineInfoLog(JNIEnv *env, jclass clazz, jint pipeline, jint bufSize, jlong length, jlong infoLog, jlong function_pointer) {
GLsizei *length_address = (GLsizei *)(intptr_t)length;
GLchar *infoLog_address = (GLchar *)(intptr_t)infoLog;
glGetProgramPipelineInfoLogPROC glGetProgramPipelineInfoLog = (glGetProgramPipelineInfoLogPROC)((intptr_t)function_pointer);
glGetProgramPipelineInfoLog(pipeline, bufSize, length_address, infoLog_address);
}
bool validate(GLuint const & ProgramName)
{
bool Error = false;
// Pipeline object validation
{
GLint Status(0);
GLint LengthMax(0);
glValidateProgramPipeline(PipelineName);
glGetProgramPipelineiv(PipelineName, GL_VALIDATE_STATUS, &Status);
glGetProgramPipelineiv(PipelineName, GL_INFO_LOG_LENGTH, &LengthMax);
GLsizei LengthQuery(0);
std::vector<GLchar> InfoLog(LengthMax + 1, '\0');
glGetProgramPipelineInfoLog(PipelineName, GLsizei(InfoLog.size()), &LengthQuery, &InfoLog[0]);
glDebugMessageInsertARB(
GL_DEBUG_SOURCE_APPLICATION_ARB,
GL_DEBUG_TYPE_OTHER_ARB, 76,
GL_DEBUG_SEVERITY_LOW_ARB,
LengthQuery,
&InfoLog[0]);
}
GLint ActiveAttributeMaxLength(0);
GLint ActiveAttribute(0);
glGetProgramiv(ProgramName, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &ActiveAttributeMaxLength);
glGetProgramiv(ProgramName, GL_ACTIVE_ATTRIBUTES, &ActiveAttribute);
GLsizei AttribLength(0);
GLint AttribSize(0);
GLenum AttribType(0);
std::vector<GLchar> AttribName(ActiveAttributeMaxLength, '\0');
for(GLint i = 0; i < ActiveAttribute; ++i)
{
glGetActiveAttrib(ProgramName,
GLuint(i),
GLsizei(ActiveAttributeMaxLength),
&AttribLength,
&AttribSize,
&AttribType,
&AttribName[0]);
std::string NameString;
NameString.insert(NameString.begin(), AttribName.begin(), AttribName.end());
std::vector<GLchar> NameSwap(ActiveAttributeMaxLength, '\0');
std::swap(AttribName, NameSwap);
GLint AttribLocation = glGetAttribLocation(ProgramName, NameString.c_str());
vertexattrib VertexAttrib;
glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &VertexAttrib.Enabled);
//glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &VertexAttrib.Binding);
glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_SIZE, &VertexAttrib.Size);
glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &VertexAttrib.Stride);
glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_TYPE, &VertexAttrib.Type);
glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &VertexAttrib.Normalized);
glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_INTEGER, &VertexAttrib.Integer);
glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, &VertexAttrib.Divisor);
glGetVertexAttribPointerv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_POINTER, &VertexAttrib.Pointer);
if(GL_VERTEX_ATTRIB_ARRAY_INTEGER == GL_TRUE)
{
if(!(
VertexAttrib.Type == GL_INT ||
VertexAttrib.Type == GL_INT_VEC2 ||
VertexAttrib.Type == GL_INT_VEC3 ||
VertexAttrib.Type == GL_INT_VEC4 ||
VertexAttrib.Type == GL_UNSIGNED_INT ||
VertexAttrib.Type == GL_UNSIGNED_INT_VEC2 ||
VertexAttrib.Type == GL_UNSIGNED_INT_VEC3 ||
VertexAttrib.Type == GL_UNSIGNED_INT_VEC4))
return true;
if(!(
VertexAttrib.Type == GL_BYTE ||
VertexAttrib.Type == GL_UNSIGNED_BYTE ||
VertexAttrib.Type == GL_SHORT ||
VertexAttrib.Type == GL_UNSIGNED_SHORT ||
VertexAttrib.Type == GL_INT ||
VertexAttrib.Type == GL_UNSIGNED_INT))
return true;
//if(AttribSize > 1)
//GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE
}
else if(VertexAttrib.Long == GL_TRUE) // OpenGL Spec bug
{
if( VertexAttrib.Type == GL_DOUBLE ||
VertexAttrib.Type == GL_DOUBLE_VEC2 ||
VertexAttrib.Type == GL_DOUBLE_VEC3 ||
VertexAttrib.Type == GL_DOUBLE_VEC4 ||
VertexAttrib.Type == GL_DOUBLE_MAT2 ||
VertexAttrib.Type == GL_DOUBLE_MAT3 ||
VertexAttrib.Type == GL_DOUBLE_MAT4 ||
VertexAttrib.Type == GL_DOUBLE_MAT2x3 ||
VertexAttrib.Type == GL_DOUBLE_MAT2x4 ||
VertexAttrib.Type == GL_DOUBLE_MAT3x2 ||
VertexAttrib.Type == GL_DOUBLE_MAT3x4 ||
VertexAttrib.Type == GL_DOUBLE_MAT4x2 ||
VertexAttrib.Type == GL_DOUBLE_MAT4x3)
{
if(VertexAttrib.Type != GL_DOUBLE)
return true;
}
else// if((VertexAttrib.Normalized == GL_TRUE) || (GL_VERTEX_ATTRIB_ARRAY_FLOAT == GL_TRUE))
{
if(!(
VertexAttrib.Type == GL_FLOAT ||
VertexAttrib.Type == GL_FLOAT_VEC2 ||
VertexAttrib.Type == GL_FLOAT_VEC3 ||
VertexAttrib.Type == GL_FLOAT_VEC4 ||
VertexAttrib.Type == GL_FLOAT_MAT2 ||
VertexAttrib.Type == GL_FLOAT_MAT3 ||
VertexAttrib.Type == GL_FLOAT_MAT4 ||
VertexAttrib.Type == GL_FLOAT_MAT2x3 ||
VertexAttrib.Type == GL_FLOAT_MAT2x4 ||
VertexAttrib.Type == GL_FLOAT_MAT3x2 ||
VertexAttrib.Type == GL_FLOAT_MAT3x4 ||
VertexAttrib.Type == GL_FLOAT_MAT4x2 ||
VertexAttrib.Type == GL_FLOAT_MAT4x3))
return true;
// It could be any vertex array attribute type
}
}
printf("glGetActiveAttrib(\n\t%d, \n\t%d, \n\t%d, \n\t%d, \n\t%d, \n\t%s)\n",
i, AttribLocation, AttribLength, AttribSize, AttribType, NameString.c_str());
}
return Error;
}
int main(int argc, char* argv[])
{
MyGame* game = nullptr; // pointer to allow game termination when exceptions are caught
try
{
load(WINDOW_WIDTH, WINDOW_HEIGHT);
SDL_Window* window = SDL_GL_GetCurrentWindow();
SDL_GLContext glContext = SDL_GL_GetCurrentContext();
MyGame myGame(window, glContext, WINDOW_WIDTH, WINDOW_HEIGHT); // should MyGame become owner of window and glcontext when passed them? would change ~MyGame()
// also, should MyGame::Terminate and Initialize even exist? Initialize could be constructor, terminate destructor
game = &myGame;
myGame.Initialize();
myGame.Draw();
unsigned int lastUpdate = SDL_GetTicks();
while (myGame.isRunning())
{
if (lastUpdate + 66 < SDL_GetTicks())
{
myGame.Update();
myGame.Draw();
lastUpdate = SDL_GetTicks();
}
}
myGame.Terminate();
unload();
}
catch (SDLInitError err)
{
printf("%s, err: %s", err.getMessage().c_str(), SDL_GetError());
std::cin.get();
}
catch (InitError err)
{
printf("Initialization failed, err: %s", err.getMessage().c_str());
std::cin.get();
}
catch (GLError err)
{
char* type = "";
GLchar log[512];
switch (err.getType())
{
case GLErrorType::PROGRAM:
type = "Program";
glGetProgramInfoLog(err.getHandle(), 512, NULL, log);
break;
case GLErrorType::PROGRAM_PIPELINE:
type = "Program Pipeline";
glGetProgramPipelineInfoLog(err.getHandle(), 512, NULL, log);
break;
case GLErrorType::SHADER:
type = "Shaders";
glGetShaderInfoLog(err.getHandle(), 512, NULL, log);
break;
}
printf("Error with GL %s. \nError Message: %s.\n", type, err.getMessage().c_str());
std::cout << "GL Log: " << log << std::endl;
std::cin.get();
}
if (game)
{
game->Terminate();
}
unload();
return 0;
}
String logObjectInfo(const String& msg, const GLuint obj)
{
String logMessage = msg;
// Invalid object.
if (obj <= 0)
{
return logMessage;
}
GLint infologLength = 0;
GLboolean isShader = glIsShader(obj);
GLboolean isProgramPipeline = glIsProgramPipeline(obj);
GLboolean isProgram = glIsProgram(obj);
if (isShader)
{
OGRE_CHECK_GL_ERROR(glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &infologLength));
}
else if (isProgramPipeline &&
Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS))
{
//FIXME Crashes on NVIDIA? See GL3+ GSoC forum
// posts around 2013-11-25.
OGRE_CHECK_GL_ERROR(glGetProgramPipelineiv(obj, GL_INFO_LOG_LENGTH, &infologLength));
}
else if (isProgram)
{
OGRE_CHECK_GL_ERROR(glGetProgramiv(obj, GL_INFO_LOG_LENGTH, &infologLength));
}
// No info log available.
// if (infologLength <= 1)
if (infologLength < 1)
{
return logMessage;
}
GLint charsWritten = 0;
char * infoLog = new char [infologLength];
infoLog[0] = 0;
if (isShader)
{
OGRE_CHECK_GL_ERROR(glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog));
}
else if (isProgramPipeline &&
Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS))
{
OGRE_CHECK_GL_ERROR(glGetProgramPipelineInfoLog(obj, infologLength, &charsWritten, infoLog));
}
else if (isProgram)
{
OGRE_CHECK_GL_ERROR(glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog));
}
if (strlen(infoLog) > 0)
{
logMessage += "\n" + String(infoLog);
}
delete [] infoLog;
if (logMessage.size() > 0)
{
// Remove empty lines from the end of the log.
while (logMessage[logMessage.size() - 1] == '\n')
{
logMessage.erase(logMessage.size() - 1, 1);
}
LogManager::getSingleton().logMessage(logMessage);
}
return logMessage;
}
