Example #1
0
void
Shader::setup(const char *vs, const char *fs)
{
	//fprintf(stdout, "vs, fs = %p, %p\n", vs, fs);
	
	//GLuint vid = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	//GLuint fid = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
	GLhandleARB vid = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	GLhandleARB fid = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
	
	glShaderSourceARB(vid, 1, &vs, 0);
	glShaderSourceARB(fid, 1, &fs, 0);
	
	glCompileShaderARB(vid);
	glCompileShaderARB(fid);
	char glslLog[1024];
	GLsizei glslLogSize;
	glGetInfoLogARB(vid, 1024, &glslLogSize, glslLog);
	if (glslLogSize)
		printf("vertex program log: %s\n", glslLog);
	glGetInfoLogARB(fid, 1024, &glslLogSize, glslLog);
	if (glslLogSize)
		printf("fragment program log: %s\n", glslLog);

	pid = glCreateProgramObjectARB();

	glAttachObjectARB(pid, vid);
	glAttachObjectARB(pid, fid);

	// delete shader objects as soon as they have been attached to a program
	glDeleteObjectARB(vid);
	glDeleteObjectARB(fid);
	
	glLinkProgramARB(pid);
}
Example #2
0
void ofxShader::setup(string fragmentName, string vertexName) {
	bLoaded = false;
	if (GLEE_ARB_shader_objects) {
		vertexShader = (GLhandleARB) glCreateShader(GL_VERTEX_SHADER);
		fragmentShader = (GLhandleARB) glCreateShader(GL_FRAGMENT_SHADER);

		string vs = loadShaderText(vertexName);
		string fs = loadShaderText(fragmentName);
		const char* vsptr = vs.c_str();
		const char* fsptr = fs.c_str();
		int vssize = vs.size();
		int fssize = fs.size();

		glShaderSourceARB(vertexShader, 1, &vsptr, &vssize);
		glShaderSourceARB(fragmentShader, 1, &fsptr, &fssize);

		glCompileShaderARB(vertexShader);

		//please add compile status check in:
		//GLint compileStatus = 0;
		//glGetObjectParameterivARB( vertexShader, GL_COMPILE_STATUS, &compileStatus );
		//printf("%i \n", compileStatus);

		char infobuffer[1000];
		GLsizei infobufferlen = 0;

		glGetInfoLogARB(vertexShader, 999, &infobufferlen, infobuffer);
		if (infobufferlen != 0) {
			infobuffer[infobufferlen] = 0;
			printf("vertexShader reports: %s \n", infobuffer);
			return;
		}

		glCompileShaderARB(fragmentShader);

		//glGetObjectParameterivARB( fragmentShader, GL_COMPILE_STATUS, &compileStatus );
		//printf("%i \n", compileStatus);

		glGetInfoLogARB(fragmentShader, 999, &infobufferlen, infobuffer);
		if (infobufferlen != 0) {
			infobuffer[infobufferlen] = 0;
			printf("fragmentShader reports: %s \n", infobuffer);
			return;
		}

		shader = glCreateProgramObjectARB();
		glAttachObjectARB(shader, vertexShader);
		glAttachObjectARB(shader, fragmentShader);
		glLinkProgramARB(shader);

		bLoaded = true;
	} else {
		cout << "Sorry, it looks like you can't run 'ARB_shader_objects'." << endl;
		cout << "Please check the capabilites of your graphics card." << endl;
		cout << "http://www.ozone3d.net/gpu_caps_viewer/)" << endl;
	}
}
Example #3
0
int
main()
{
	GLenum shader_prog, shader_vert, shader_frag;
	int i;
	char buf[1024];
	const GLcharARB *vertex_shader_code, *fragment_shader_code;
	GLint loc;

	assert((vertex_shader_code = loadShader("shader.vert")));
	assert((fragment_shader_code = loadShader("shader.frag")));
	assert(!SDL_Init(SDL_INIT_EVERYTHING));
	atexit(SDL_Quit);
	SDL_GL_SET_ATTR(RED_SIZE, 8);
	SDL_GL_SET_ATTR(GREEN_SIZE, 8);
	SDL_GL_SET_ATTR(BLUE_SIZE, 8);
	SDL_GL_SET_ATTR(DEPTH_SIZE, 16);
	SDL_GL_SET_ATTR(DOUBLEBUFFER, 1);
	assert(SDL_SetVideoMode(SCRW, SCRH, SCRBPP, SDL_OPENGL /*| SDL_FULLSCREEN*/));
/*	puts((const char *)glGetString(GL_EXTENSIONS));*/
	DO_GL_PROCS(DEFINE_GL_PROC)
	assert((shader_prog = glCreateProgramObjectARB()));
	assert((shader_vert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB)));
	assert((shader_frag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB)));
	i = strlen(vertex_shader_code);
	printf("vert len: %d\n", i);
	glShaderSourceARB(shader_vert, 1, &vertex_shader_code, &i);
	i = strlen(fragment_shader_code);
	printf("frag len: %d\n", i);
	glShaderSourceARB(shader_frag, 1, &fragment_shader_code, &i);
	glCompileShaderARB(shader_vert);
	glCompileShaderARB(shader_frag);
	glAttachObjectARB(shader_prog, shader_vert);
	glAttachObjectARB(shader_prog, shader_frag);
	glLinkProgramARB(shader_prog);
	i = 0; glGetInfoLogARB(shader_vert, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("vert error: \"%s\"\n", buf);
	i = 0; glGetInfoLogARB(shader_frag, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("frag error: \"%s\"\n", buf);
	i = 0; glGetInfoLogARB(shader_prog, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("prog error: \"%s\"\n", buf);
	glUseProgramObjectARB(shader_prog);
	loc = glGetUniformLocationARB(shader_prog, "time");
	while (!SDL_GetKeyState(0)[SDLK_ESCAPE]) {
		float time = (float)SDL_GetTicks() / 2000.0f;
		SDL_PumpEvents();
		glUniform1fARB(loc, time);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glBegin(GL_QUADS);
		glVertex3f(-1.0f, 1.0f, 0.0f);
		glVertex3f(1.0f, 1.0f, 0.0f);
		glVertex3f(1.0f, -1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f, 0.0f);
		glEnd();
		SDL_GL_SwapBuffers();
	}
	return 0;
}
Example #4
0
GPUShader *GPU_shader_create_lib(const char *code)
{
	GLint status;
	GLcharARB log[5000];
	GLsizei length = 0;
	GPUShader *shader;

	if (!GLEW_ARB_vertex_shader || !GLEW_ARB_fragment_shader)
		return NULL;

	shader = MEM_callocN(sizeof(GPUShader), "GPUShader");

	shader->lib = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

	if (!shader->lib) {
		fprintf(stderr, "GPUShader, object creation failed.\n");
		GPU_shader_free(shader);
		return NULL;
	}

	glShaderSourceARB(shader->lib, 1, (const char**)&code, NULL);

	glCompileShaderARB(shader->lib);
	glGetObjectParameterivARB(shader->lib, GL_OBJECT_COMPILE_STATUS_ARB, &status);

	if (!status) {
		glGetInfoLogARB(shader->lib, sizeof(log), &length, log);
		shader_print_errors("compile", log, code);

		GPU_shader_free(shader);
		return NULL;
	}

	return shader;
}
Example #5
0
static void
link_shader_arb (GLuint *program, GLuint vert, GLuint frag)
{
    GLint gl_status;

    *program = glCreateProgramObjectARB ();
    glAttachObjectARB (*program, vert);
    glAttachObjectARB (*program, frag);
    glLinkProgramARB (*program);
    glGetObjectParameterivARB (*program, GL_OBJECT_LINK_STATUS_ARB, &gl_status);
    if (gl_status == GL_FALSE) {
        GLint log_size;
        glGetObjectParameterivARB (*program, GL_OBJECT_INFO_LOG_LENGTH_ARB, &log_size);
        if (0 < log_size) {
            char *log = _cairo_malloc (log_size);
            GLint chars;

            log[log_size - 1] = '\0';
            glGetInfoLogARB (*program, log_size, &chars, log);
            printf ("OpenGL shader link failed:\n%s\n", log);

            free (log);
        } else {
            printf ("OpenGL shader link failed.\n");
        }

	ASSERT_NOT_REACHED;
    }
}
Example #6
0
void	neb::glsl::program::compile() {
	//GRU_GLSL_PROGRAM_FUNC
	
	glLinkProgram(o_);
	checkerror("glLinkProgram");
	
	GLint blen = 0;	
	GLsizei slen = 0;
	
	glGetProgramiv(o_, GL_INFO_LOG_LENGTH , &blen);
	
	checkerror("glGetProgramiv");

	if (blen > 1)
	{
		GLchar* compiler_log = (GLchar*)malloc(blen);

		glGetInfoLogARB(o_, blen, &slen, compiler_log);
		printf("compiler_log:%s\n", compiler_log);
		free (compiler_log);
	}

	printf("program=%i\n",o_);

}
    //-----------------------------------------------------------------------------
	String logObjectInfo(const String& msg, const GLhandleARB obj)
	{
		String logMessage = msg;

		if (obj > 0)
		{
			GLint infologLength = 0;

			glGetObjectParameterivARB(obj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infologLength);

			if (infologLength > 0)
			{
				GLint charsWritten  = 0;

				GLcharARB * infoLog = new GLcharARB[infologLength];

				glGetInfoLogARB(obj, infologLength, &charsWritten, infoLog);
				logMessage += String(infoLog);
				LogManager::getSingleton().logMessage(logMessage);

				delete [] infoLog;
			}
		}

		return logMessage;

	}
Example #8
0
bool glsl_geometry :: openMessARB(void)
{
  if(m_shaderARB) {
    glDeleteObjectARB( m_shaderARB );
    gem::utils::glsl::delshader(m_shaderARB);
  }
  m_shaderARB = glCreateShaderObjectARB(m_shaderTarget);

  if (!m_shaderARB)
    {
      error("could not create ARB shader object");
      return false;
    }
  const char * vs = m_shaderString;
  glShaderSourceARB( m_shaderARB, 1, &vs, NULL );
  glCompileShaderARB( m_shaderARB );
  glGetObjectParameterivARB( m_shaderARB, GL_OBJECT_COMPILE_STATUS_ARB, &m_compiled );
  if (!m_compiled) {
    GLint	length;
    GLcharARB* log;
    glGetObjectParameterivARB( m_shaderARB, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length );
    log = (GLcharARB*)malloc( length * sizeof(GLcharARB) );
    glGetInfoLogARB( m_shaderARB, length, NULL, log );
    post("compile Info_log:");
    post("%s", log );
    error("shader not loaded");
    free(log);
    return false;
  }

  return true;
}
Example #9
0
//#include <object.h>
//#include <sb6ktx.h>
//#include <shader.h>
GLint	create_program(GLuint* s, int c, bool b)
{
        printf("%s\n",__PRETTY_FUNCTION__);

        GLint o = glCreateProgram();
	
        for(int i = 0; i < c; ++i )
        {
                printf("shader %i attached to program %i\n",s[i],o);

                glAttachShader(o, s[i]);
        }

        glLinkProgram(o);
        
        GLint blen = 0; 
        GLsizei slen = 0;
        
        glGetProgramiv(o, GL_INFO_LOG_LENGTH , &blen);
        
        if (blen > 1)
        {
                GLchar* compiler_log = (GLchar*)malloc(blen);

                glGetInfoLogARB(o, blen, &slen, compiler_log);
                printf("compiler_log:%s\n", compiler_log);
                free (compiler_log);
        }

        printf("program=%i\n",o);

}
Example #10
0
File: Shader.cpp Project: BSkin/MTG
GLhandleARB Shader::makeShader(const char * fileName, GLenum type)
{
	ifstream file(fileName);
	stringstream ss;
	ss << file.rdbuf();
	string source = ss.str();
	char * mem = (char *)alloca(source.length()+1);
	strcpy(mem, source.c_str());
	//mem[source.length] = '\0';

	GLhandleARB shaderHandle = glCreateShaderObjectARB (type);
	glShaderSourceARB (shaderHandle, 1, (const GLcharARB **)&mem, 0);
	glCompileShaderARB (shaderHandle);
	int status; glGetObjectParameterivARB (shaderHandle, GL_OBJECT_COMPILE_STATUS_ARB, &status);
	if (status != 0) 
		return shaderHandle; //Everything OK...

	//It didn't, so log error information...
	//::log ("\nFailed to compile %s shader \"%s\"...", type == GL_VERTEX_SHADER_ARB ? "VERTEX" : "PIXEL", name.c_str ());
	int length = 0; glGetObjectParameterivARB (shaderHandle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
	const long MAXIMUM_LOG_STRING = 1024; char logString [MAXIMUM_LOG_STRING];
	GLsizei messageLength = min (length, MAXIMUM_LOG_STRING);
	if (messageLength > 0) {
		glGetInfoLogARB (shaderHandle, messageLength, 0, logString);
		MessageBox(NULL, logString, "Shader Error", MB_OK);
	}

	glDeleteObjectARB (shaderHandle); 

	return NULL;
}
Example #11
0
GLhandleARB glLinkShader(GLhandleARB vertexShaderObject,GLhandleARB fragmentShaderObject)
	{
	/* Create the program object: */
	GLhandleARB programObject=glCreateProgramObjectARB();
	
	/* Attach all shader objects to the shader program: */
	glAttachObjectARB(programObject,vertexShaderObject);
	glAttachObjectARB(programObject,fragmentShaderObject);
	
	/* Link the program: */
	glLinkProgramARB(programObject);
	
	/* Check if the program linked successfully: */
	GLint linkStatus;
	glGetObjectParameterivARB(programObject,GL_OBJECT_LINK_STATUS_ARB,&linkStatus);
	if(!linkStatus)
		{
		/* Get some more detailed information: */
		GLcharARB linkLogBuffer[2048];
		GLsizei linkLogSize;
		glGetInfoLogARB(programObject,sizeof(linkLogBuffer),&linkLogSize,linkLogBuffer);
		
		/* Delete the program object: */
		glDeleteObjectARB(programObject);
		
		/* Signal an error: */
		Misc::throwStdErr("glLinkShader: Error \"%s\" while linking shader program",linkLogBuffer);
		}
	
	return programObject;
	}
Example #12
0
GLhandleARB glLinkShader(const std::vector<GLhandleARB>& shaderObjects)
	{
	/* Create the program object: */
	GLhandleARB programObject=glCreateProgramObjectARB();
	
	/* Attach all shader objects to the shader program: */
	for(std::vector<GLhandleARB>::const_iterator soIt=shaderObjects.begin();soIt!=shaderObjects.end();++soIt)
		glAttachObjectARB(programObject,*soIt);
	
	/* Link the program: */
	glLinkProgramARB(programObject);
	
	/* Check if the program linked successfully: */
	GLint linkStatus;
	glGetObjectParameterivARB(programObject,GL_OBJECT_LINK_STATUS_ARB,&linkStatus);
	if(!linkStatus)
		{
		/* Get some more detailed information: */
		GLcharARB linkLogBuffer[2048];
		GLsizei linkLogSize;
		glGetInfoLogARB(programObject,sizeof(linkLogBuffer),&linkLogSize,linkLogBuffer);
		
		/* Delete the program object: */
		glDeleteObjectARB(programObject);
		
		/* Signal an error: */
		Misc::throwStdErr("glLinkShader: Error \"%s\" while linking shader program",linkLogBuffer);
		}
	
	return programObject;
	}
Example #13
0
void glCompileShaderFromStrings(GLhandleARB shaderObject,size_t numShaderSources,va_list ap)
	{
	/* Get pointers to all shader source strings: */
	const GLcharARB** strings=new const GLcharARB*[numShaderSources];
	for(size_t i=0;i<numShaderSources;++i)
		strings[i]=va_arg(ap,const char*);
	
	/* Upload all shader source strings into the shader object: */
	glShaderSourceARB(shaderObject,numShaderSources,strings,0);
	delete[] strings;
	
	/* Compile the shader source: */
	glCompileShaderARB(shaderObject);
	
	/* Check if the shader compiled successfully: */
	GLint compileStatus;
	glGetObjectParameterivARB(shaderObject,GL_OBJECT_COMPILE_STATUS_ARB,&compileStatus);
	if(!compileStatus)
		{
		/* Get some more detailed information: */
		GLcharARB compileLogBuffer[2048];
		GLsizei compileLogSize;
		glGetInfoLogARB(shaderObject,sizeof(compileLogBuffer),&compileLogSize,compileLogBuffer);
		
		/* Signal an error: */
		Misc::throwStdErr("glCompileShaderFromStrings: Error \"%s\" while compiling shader",compileLogBuffer);
		}
	}
Example #14
0
void glCompileShaderFromString(GLhandleARB shaderObject,const char* shaderSource)
	{
	/* Determine the length of the source string: */
	GLint shaderSourceLength=GLint(strlen(shaderSource));
	
	/* Upload the shader source into the shader object: */
	const GLcharARB* ss=reinterpret_cast<const GLcharARB*>(shaderSource);
	glShaderSourceARB(shaderObject,1,&ss,&shaderSourceLength);
	
	/* Compile the shader source: */
	glCompileShaderARB(shaderObject);
	
	/* Check if the shader compiled successfully: */
	GLint compileStatus;
	glGetObjectParameterivARB(shaderObject,GL_OBJECT_COMPILE_STATUS_ARB,&compileStatus);
	if(!compileStatus)
		{
		/* Get some more detailed information: */
		GLcharARB compileLogBuffer[2048];
		GLsizei compileLogSize;
		glGetInfoLogARB(shaderObject,sizeof(compileLogBuffer),&compileLogSize,compileLogBuffer);
		
		/* Signal an error: */
		Misc::throwStdErr("glCompileShaderFromString: Error \"%s\" while compiling shader",compileLogBuffer);
		}
	}
Example #15
0
void GLShader::linkShader(void)
	{
	if(programObject!=0)
		Misc::throwStdErr("GLShader::linkShader: Attempt to link shader program multiple times");
	
	/* Create the program object: */
	programObject=glCreateProgramObjectARB();
	
	/* Attach all previously compiled shaders to the program object: */
	for(HandleList::iterator vsoIt=vertexShaderObjects.begin();vsoIt!=vertexShaderObjects.end();++vsoIt)
		glAttachObjectARB(programObject,*vsoIt);
	for(HandleList::iterator fsoIt=fragmentShaderObjects.begin();fsoIt!=fragmentShaderObjects.end();++fsoIt)
		glAttachObjectARB(programObject,*fsoIt);
	
	/* Link the program: */
	glLinkProgramARB(programObject);
	
	/* Check if the program linked successfully: */
	GLint linkStatus;
	glGetObjectParameterivARB(programObject,GL_OBJECT_LINK_STATUS_ARB,&linkStatus);
	if(!linkStatus)
		{
		/* Get some more detailed information: */
		GLcharARB linkLogBuffer[2048];
		GLsizei linkLogSize;
		glGetInfoLogARB(programObject,sizeof(linkLogBuffer),&linkLogSize,linkLogBuffer);
		
		/* Signal an error: */
		Misc::throwStdErr("GLShader::linkShader: Error \"%s\" while linking shader program",linkLogBuffer);
		}
	}
Example #16
0
void GlProgram::
compile(GLhandleARB shader, const std::string& sourceString) const
{
	//determine the length of the source code
	GLint length = static_cast<GLint>(sourceString.size());
	
	//upload the shader source into the shader object
	const GLcharARB* code =
        reinterpret_cast<const GLcharARB*>(sourceString.c_str());
	glShaderSourceARB(shader, 1, &code, &length);
	
	//compile the shader source
	glCompileShaderARB(shader);
	
	//check if the shader compiled successfully
	GLint compileStatus;
	glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB,
                              &compileStatus);
	if(!compileStatus)
    {
		//get some more detailed information
		GLcharARB compileLogBuffer[2048];
		GLsizei compileLogSize;
		glGetInfoLogARB(shader, sizeof(compileLogBuffer), &compileLogSize,
                        compileLogBuffer);
		
		//signal an error
		Misc::throwStdErr("%s", compileLogBuffer);
    }
}
Example #17
0
void GlProgram::
link()
{
	//attach all previously compiled shaders to the program object
	for(ShaderHandle it=shaders.begin(); it!=shaders.end(); ++it)
		glAttachObjectARB(program, *it);
	
	//link the program
	glLinkProgramARB(program);
	
	//check if the program linked successfully
	GLint linkStatus;
	glGetObjectParameterivARB(program, GL_OBJECT_LINK_STATUS_ARB, &linkStatus);
	if (!linkStatus)
    {
		//get some more detailed information
		GLcharARB linkLogBuffer[2048];
		GLsizei linkLogSize;
		glGetInfoLogARB(program, sizeof(linkLogBuffer), &linkLogSize,
                        linkLogBuffer);
		
		//signal an error
		Misc::throwStdErr("GLProgram::link: Error \"%s\" while linking shader "
                          "program", linkLogBuffer);
    }
}
Example #18
0
static void glsl_print_error( char *msg, GLhandleARB obj )
{
    char buf[MAX_ERROR_BUF];
    GLsizei length;
    glGetInfoLogARB( obj, sizeof(buf), &length, buf );
    ERROR( "%s: %s", msg, buf );
}
void LLPostProcess::checkShaderError(GLhandleARB shader)
{
    GLint infologLength = 0;
    GLint charsWritten  = 0;
    GLchar *infoLog;

    checkError();  // Check for OpenGL errors

    glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infologLength);

    checkError();  // Check for OpenGL errors

    if (infologLength > 0)
    {
        infoLog = (GLchar *)malloc(infologLength);
        if (infoLog == NULL)
        {
            /// Could not allocate infolog buffer
            return;
        }
        glGetInfoLogARB(shader, infologLength, &charsWritten, infoLog);
		// shaderErrorLog << (char *) infoLog << std::endl;
		mShaderErrorString = (char *) infoLog;
        free(infoLog);
    }
    checkError();  // Check for OpenGL errors
}
Example #20
0
bool ShaderGl::compile(string &messages){
	
	assertGl();

	messages= "Compiling shader: " + source.getPathInfo() + "\n";

	//load source
	GLint length= source.getCode().size();
	const GLcharARB *csource= source.getCode().c_str();
	glShaderSourceARB(handle, 1, &csource, &length);

	//compile
	glCompileShaderARB(handle);
	
	//log
	GLint logLength= 0;
	glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &logLength);
	char *buffer= new char[logLength+1];
	glGetInfoLogARB(handle, logLength+1, NULL, buffer);
	messages+= buffer;
	delete [] buffer;

	//status
	GLint status= false;
	glGetObjectParameterivARB(handle, GL_OBJECT_COMPILE_STATUS_ARB, &status);
	assertGl();

	return status!=0;
}
Example #21
0
void XGLShader::printInfoLog(GLhandleARB obj)
{
    int infologLength = 0;
    int charsWritten  = 0;
    GLcharARB *infoLog;

    printOpenGLError();  // Check for OpenGL errors

    glGetObjectParameterivARB(obj, GL_OBJECT_INFO_LOG_LENGTH_ARB,
                              (GLint*)&infologLength);
    printOpenGLError();  // Check for OpenGL errors

    if (infologLength > 0)
    {
        infoLog = (GLcharARB*)malloc(infologLength);
        if (infoLog == NULL)
        {
            printf("ERROR: Could not allocate InfoLog buffer\n");
            exit(1);
        }
        glGetInfoLogARB(obj, infologLength, (GLint*)&charsWritten, infoLog);
        printf("InfoLog:\n%s\n\n", infoLog);
        free(infoLog);
    }
    printOpenGLError();  // Check for OpenGL errors
}
Example #22
0
GLuint	Shader::GenerateShader(string from, GLenum type)	{
	cout << "Compiling Shader..." << endl;

	string load;
	if(!LoadShaderFile(from,load)) {
		cout << "Compiling failed!" << endl;
		loadFailed = true;
		return 0;
	}

	GLuint shader = glCreateShader(type);

	const char *chars = load.c_str();
	glShaderSource(shader, 1, &chars, NULL);
	glCompileShader(shader);

	GLint status;
	glGetShaderiv(shader, GL_COMPILE_STATUS, &status);

	if (status == GL_FALSE)	{
		cout << "Compiling failed!" << endl;
		char error[512];
		glGetInfoLogARB(shader, sizeof(error), NULL, error);
		cout << error;
		loadFailed = true;
		return 0;
	}
	cout << "Compiling success!" << endl << endl;
	loadFailed = false;
	return shader;
}
Example #23
0
GLuint GLUtil::CreateShader(GLenum eShaderType, const char *source) {
    GLuint shader = glCreateShaderObjectARB(eShaderType);
    glShaderSourceARB(shader, 1, (const char**)&source, NULL);
    
    glCompileShaderARB(shader);
    
    // debugging
    if (true)
    {
        GLchar *strInfoLog = new GLchar[1000];
        GLsizei nChars;
        glGetInfoLogARB(shader, 999, &nChars, strInfoLog);
        strInfoLog[999] = '\0';
        
        if (nChars != 0) {
            const char *strShaderType = NULL;
            switch(eShaderType)
            {
                case GL_VERTEX_SHADER: strShaderType = "Vertex"; break;
                case GL_GEOMETRY_SHADER: strShaderType = "Geometry"; break;
                case GL_FRAGMENT_SHADER: strShaderType = "Fragment"; break;
            }
            
            Console::getInstance()->message(CONSOLE_MSG_SYS, "%s Shader: %s", strShaderType, strInfoLog);
        }
        delete [] strInfoLog;
    }
    
	return shader;
}
Example #24
0
////////////////////////////////////////////////////////////////////////////////////////////////////
//! Print info log for glsl program object. The log is empty if no errors / warning occur.
//! @param program_obj handle to the program / shader object
////////////////////////////////////////////////////////////////////////////////////////////////////
/*static*/ void
ErrorDevel::checkInfologGLSL( const unsigned int& program_obj) {

  // errror or only warnings
  bool error = false;

  int infolog_length;
  glGetObjectParameterivARB( program_obj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infolog_length);

  // bigger then 1 important while length('\n') == 1
  if (infolog_length > 1) {

    char* infolog = new GLcharARB[infolog_length];

    int readback_length;
    glGetInfoLogARB( program_obj, infolog_length, &readback_length, infolog);

    //std::cerr << "GLSL infolog reports:\n" << infolog << '\n' << std::endl;
    std::cerr << infolog << '\n' << std::endl;

    // check if errors occured or only warnings
    std::string str_infolog( infolog);
    error = ( std::string::npos != str_infolog.find( "error")) ? true : false;

    delete[] infolog;
  }

  if (error) {

    // call exit handler

    // exit
    exit( EXIT_SUCCESS);
  }
}
Example #25
0
void Shader::CompileShader() {
  char const * source = m_shaderSource.c_str();

  glShaderSource(m_shader, 1, (const GLchar**)&source, 0);

  glCompileShader(m_shader);

  GLint isCompiled;

  glGetShaderiv(m_shader, GL_COMPILE_STATUS, &isCompiled);
  if(0 == isCompiled) {
    printf("Failed to compile shader!\n");
    GLint blen = 0;	
    GLsizei slen = 0;

    glGetShaderiv(m_shader, GL_INFO_LOG_LENGTH , &blen);       
    if (blen > 1)
    {
     GLchar* compiler_log = (GLchar*)malloc(blen);
     glGetInfoLogARB(m_shader, blen, &slen, compiler_log);
     std::cerr << "compiler_log:\n" << compiler_log;
     free (compiler_log);
    }
  }
}
Example #26
0
GLuint GLUtil::CreateShaderProgram(GLuint *shaderList, int nShaders) {
	if (nShaders > 0) {
		GLuint program = glCreateProgramObjectARB();
		
		// attach list of compiled shaders to the shader program
		for(size_t iLoop = 0; iLoop < nShaders; iLoop++)
			glAttachObjectARB(program, shaderList[iLoop]);
		
		//glBindAttribLocationARB(*program, 0, "position");
		
		glLinkProgramARB(program);
		
		// debugging
		if (true)
		{
		    GLchar *strInfoLog = new GLchar[1000];
		    GLsizei nChars;
		    glGetInfoLogARB(program, 999, &nChars, strInfoLog);
		    strInfoLog[999] = '\0';
		    
		    if (nChars != 0) {
		        Console::getInstance()->message(CONSOLE_MSG_SYS, "GLSL Linker: %s", strInfoLog);
		    }
		    delete[] strInfoLog;
		}
		
		// the shaders are no longer needed by the program once compiled
		for(size_t iLoop = 0; iLoop < nShaders; iLoop++)
		    glDetachObjectARB(program, shaderList[iLoop]);
		
		return program;
	}
	return 0;
    
}
Example #27
0
GLhandleARB LoadGLSLShaderSource(GLenum ShadeType, GLcharARB *Source, char *ErrorLog, int *ErrorLength)
{
	GLhandleARB Handle = 0;

	GLint Length = sizeof(Source)/sizeof(GLcharARB);

	if (Length == 0 || Source == NULL)
		return NULL;

	Handle = glCreateShaderObjectARB(ShadeType);
	glShaderSourceARB(Handle, 1, (const GLcharARB**)&Source, &Length);
	glCompileShaderARB(Handle);

	if (ErrorLog && ErrorLength)
	{
		GLint TotalLength = 0, nCharsWritten = 0;

		glGetObjectParameterivARB(Handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &TotalLength);
		if(TotalLength > 1)
			glGetInfoLogARB(Handle, *ErrorLength, &nCharsWritten, ErrorLog);

		*ErrorLength = TotalLength - 1;
	}

	return Handle;
}
Example #28
0
void ShaderProgram::initialize()
{
	GLint status;

	handle = glCreateProgramObjectARB();
	if (handle == 0)
		throw Exception("failed to create program");
	// Add all shaders
	Shader::Iter i = shaders.begin();
	for (; i != shaders.end(); ++i) {
		glAttachObjectARB(handle, (*i)->getHandle());
	}
	// Link
	glLinkProgramARB(handle);
	glGetObjectParameterivARB(handle, GL_OBJECT_LINK_STATUS_ARB, &status);
	if (status != GL_TRUE) {
		std::string errors;
		GLint len;
		// Get size of info log
		glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &len);
		if (len > 1) {
			errors.resize(len);
			glGetInfoLogARB(handle, len, NULL, &errors[0]);
		}
		throw Exception("shader program link failed\n" + errors);
	}
}
Example #29
0
GLenum GLShader::CompileProgram(GLenum target, GLcharARB* sourcecode, GLhandleARB *shader)
{
	GLint	logLength;
	GLint	compiled;

	if (sourcecode != 0)
	{
		*shader = glCreateShaderObjectARB(target);
		FailGLError("Failed to create fragment shader");
		glShaderSourceARB(*shader,1,(const GLcharARB **)&sourcecode,0);
		FailGLError("Failed glShaderSourceARB");
		glCompileShaderARB(*shader);
		FailGLError("Failed glCompileShaderARB");

		glGetObjectParameterivARB(*shader,GL_OBJECT_COMPILE_STATUS_ARB,&compiled);
		glGetObjectParameterivARB(*shader,GL_OBJECT_INFO_LOG_LENGTH_ARB,&logLength);
		if (logLength)
		{
			GLcharARB *log = (GLcharARB *)malloc(logLength+128);
			glGetInfoLogARB(*shader, logLength, &logLength, log);
			//printf("Compile log: \n");
			free (log);
		}
		//if (!compiled)
		//	FailWithMessage("shader could not compile");
		
	}
	return GL_NO_ERROR;
}
Example #30
0
/* ARB_shader_objects / ARB_vertex_shader / ARB_fragment_shader extensions
   API. */
static void
compile_shader_arb (GLuint *shader, GLenum type, const char *text)
{
    const char* strings[1] = { text };
    GLint gl_status;

    *shader = glCreateShaderObjectARB (type);
    glShaderSourceARB (*shader, 1, strings, 0);
    glCompileShaderARB (*shader);
    glGetObjectParameterivARB (*shader, GL_OBJECT_COMPILE_STATUS_ARB, &gl_status);
    if (gl_status == GL_FALSE) {
        GLint log_size;
        glGetObjectParameterivARB (*shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &log_size);
        if (0 < log_size) {
            char *log = _cairo_malloc (log_size);
            GLint chars;

            log[log_size - 1] = '\0';
            glGetInfoLogARB (*shader, log_size, &chars, log);
            printf ("OpenGL shader compilation failed.  Shader:\n"
                    "%s\n"
                    "OpenGL compilation log:\n"
                    "%s\n",
                    text, log);

            free (log);
        } else {
            printf ("OpenGL shader compilation failed.\n");
        }

	ASSERT_NOT_REACHED;
    }
}