Ejemplo n.º 1
0
panel panel_create(int width, int height, image font) {
    panel result = {width, height, font.width, font.height, NULL, NULL, 0, 0, 0, 0, 0};

    result.font = texture_create(font);
    result.foreground = malloc(4*width*height);
    result.background = malloc(4*width*height);

    // program and shader handles
    GLhandleARB vertex_shader, fragment_shader;

    int length;
    GLint shader_ok;

    // create and compiler vertex shader
    vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    length = strlen(vertex_source);
    glShaderSourceARB(vertex_shader, 1, &vertex_source, &length);
    glCompileShaderARB(vertex_shader);
    glGetObjectParameterivARB(vertex_shader, GL_COMPILE_STATUS, &shader_ok);
    assert(shader_ok);

    // create and compiler fragment shader
    fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
    length = strlen(fragment_source);
    glShaderSourceARB(fragment_shader, 1, &fragment_source, &length);
    glCompileShaderARB(fragment_shader);
    glGetObjectParameterivARB(fragment_shader, GL_COMPILE_STATUS, &shader_ok);
    assert(shader_ok);

    // create program
    result.shader_program = glCreateProgramObjectARB();

    // attach shaders
    glAttachObjectARB(result.shader_program, vertex_shader);
    glAttachObjectARB(result.shader_program, fragment_shader);

    // link the program and check for errors
    glLinkProgramARB(result.shader_program);
    glGetObjectParameterivARB(result.shader_program, GL_LINK_STATUS, &shader_ok);
    assert(shader_ok);

    // we don't need these anymore
    glDeleteObjectARB(vertex_shader);
    glDeleteObjectARB(fragment_shader);

    // generate and bind the buffer object
    glGenBuffersARB(1, &result.vbo);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, result.vbo);

    // fill with data
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(GLfloat)*6*5, quad_data, GL_STATIC_DRAW_ARB);

    glActiveTexture(GL_TEXTURE1);
    glGenTextures(1, &result.fg_tex);
    glBindTexture(GL_TEXTURE_2D, result.fg_tex);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, result.width, result.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, result.foreground);

    glActiveTexture(GL_TEXTURE2);
    glGenTextures(1, &result.bg_tex);
    glBindTexture(GL_TEXTURE_2D, result.bg_tex);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, result.width, result.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, result.background);

    glUseProgramObjectARB(result.shader_program);

    glUniform1iARB(glGetUniformLocationARB(result.shader_program, "font"), 0);
    glUniform1iARB(glGetUniformLocationARB(result.shader_program, "foreground"), 1);
    glUniform1iARB(glGetUniformLocationARB(result.shader_program, "background"), 2);
    glUniform2fARB(glGetUniformLocationARB(result.shader_program, "panel_size"), width, height);

    return result;
}
Ejemplo n.º 2
0
	implementation(const std::string& vertex_source_str, const std::string& fragment_source_str) : program_(0)
	{
		GLint success;
	
		const char* vertex_source = vertex_source_str.c_str();
						
		auto vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
					
		GL(glShaderSourceARB(vertex_shader, 1, &vertex_source, NULL));
		GL(glCompileShaderARB(vertex_shader));

		GL(glGetObjectParameterivARB(vertex_shader, GL_OBJECT_COMPILE_STATUS_ARB, &success));
		if (success == GL_FALSE)
		{
			char info[2048];
			GL(glGetInfoLogARB(vertex_shader, sizeof(info), 0, info));
			GL(glDeleteObjectARB(vertex_shader));
			std::stringstream str;
			str << "Failed to compile vertex shader:" << std::endl << info << std::endl;
			BOOST_THROW_EXCEPTION(caspar_exception() << msg_info(str.str()));
		}
			
		const char* fragment_source = fragment_source_str.c_str();
						
		auto fragmemt_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
					
		GL(glShaderSourceARB(fragmemt_shader, 1, &fragment_source, NULL));
		GL(glCompileShaderARB(fragmemt_shader));

		GL(glGetObjectParameterivARB(fragmemt_shader, GL_OBJECT_COMPILE_STATUS_ARB, &success));
		if (success == GL_FALSE)
		{
			char info[2048];
			GL(glGetInfoLogARB(fragmemt_shader, sizeof(info), 0, info));
			GL(glDeleteObjectARB(fragmemt_shader));
			std::stringstream str;
			str << "Failed to compile fragment shader:" << std::endl << info << std::endl;
			BOOST_THROW_EXCEPTION(caspar_exception() << msg_info(str.str()));
		}
			
		program_ = glCreateProgramObjectARB();
			
		GL(glAttachObjectARB(program_, vertex_shader));
		GL(glAttachObjectARB(program_, fragmemt_shader));

		GL(glLinkProgramARB(program_));
			
		GL(glDeleteObjectARB(vertex_shader));
		GL(glDeleteObjectARB(fragmemt_shader));

		GL(glGetObjectParameterivARB(program_, GL_OBJECT_LINK_STATUS_ARB, &success));
		if (success == GL_FALSE)
		{
			char info[2048];
			GL(glGetInfoLogARB(program_, sizeof(info), 0, info));
			GL(glDeleteObjectARB(program_));
			std::stringstream str;
			str << "Failed to link shader program:" << std::endl << info << std::endl;
			BOOST_THROW_EXCEPTION(caspar_exception() << msg_info(str.str()));
		}
		GL(glUseProgramObjectARB(program_));
	}
Ejemplo n.º 3
0
	  /*! \brief Builds the shader and allocates the associated
              OpenGL objects.
	   *
	   * This function will throw an exception if compilation
	   * fails.
	   */
	  inline void build()
	  {
	    if (_vertexShaderCode.empty()) 
	      _vertexShaderCode = magnet::string::format_code(initVertexShaderSource());
	    if (_fragmentShaderCode.empty()) 
	      _fragmentShaderCode = magnet::string::format_code(initFragmentShaderSource());
	    if (_geometryShaderCode.empty()) 
	      _geometryShaderCode = magnet::string::format_code(initGeometryShaderSource());

	    //Check for the ability to use fragment and vertex shaders
	    if (!GLEW_ARB_fragment_program || !GLEW_ARB_vertex_program
		|| !GLEW_ARB_fragment_shader || !GLEW_ARB_vertex_shader)
	      M_throw() << "This OpenGL context/driver does not support GLSL (programmable shaders)";
	  
	    GLint result;

	    //Vertex shader
	    if (!_vertexShaderCode.empty())
	      {
		if (!GLEW_ARB_vertex_shader)
		  M_throw() << "Vertex shaders are not supported by your OpenGL driver.";

		if (!(_vertexShaderHandle = glCreateShaderObjectARB(GL_VERTEX_SHADER)))
		  M_throw() << "Failed to create vertex shader handle";
		const GLcharARB* src = _vertexShaderCode.c_str();
		glShaderSourceARB(_vertexShaderHandle, 1, &src, NULL);	 
		glCompileShaderARB(_vertexShaderHandle);	  
		glGetObjectParameterivARB(_vertexShaderHandle, GL_OBJECT_COMPILE_STATUS_ARB, &result);
		if (!result)
		  M_throw() << "Vertex shader compilation failed, build log follows\n"
			    << getShaderBuildlog(_vertexShaderHandle);
	      }

	    //Fragment shader
	    if (!_fragmentShaderCode.empty())
	      {
		if (!GLEW_ARB_fragment_shader)
		  M_throw() << "Fragment shaders are not supported by your OpenGL driver.";

		if (!(_fragmentShaderHandle = glCreateShaderObjectARB(GL_FRAGMENT_SHADER)))
		  M_throw() << "Failed to create fragment shader handle";
		const GLcharARB* src = _fragmentShaderCode.c_str();
		glShaderSourceARB(_fragmentShaderHandle, 1, &src, NULL);
		glCompileShaderARB(_fragmentShaderHandle);	  
		glGetObjectParameterivARB(_fragmentShaderHandle, GL_OBJECT_COMPILE_STATUS_ARB, &result);
		if (!result)
		  M_throw() << "Fragment shader compilation failed, build log follows\n"
			    << getShaderBuildlog(_fragmentShaderHandle);
	      }

	    //Geometry shader
	    if (!(_geometryShaderCode.empty()))
	      {
		if (!GL_EXT_geometry_shader4)
		  M_throw() << "Geometry shaders are not supported by your OpenGL driver.";

		if (!(_geometryShaderHandle = glCreateShaderObjectARB(GL_GEOMETRY_SHADER_EXT)))
		  M_throw() << "Failed to create geometry shader handle";
		const GLcharARB* src = _fragmentShaderCode.c_str();
		glShaderSourceARB(_geometryShaderHandle, 1, &src, NULL);
		glCompileShaderARB(_geometryShaderHandle);
		glGetObjectParameterivARB(_fragmentShaderHandle, GL_OBJECT_COMPILE_STATUS_ARB, &result);
		if (!result)
		  M_throw() << "Geometry shader compilation failed, build log follows\n"
			    << getShaderBuildlog(_fragmentShaderHandle);
	      }

	    //Now we've build both shaders, combine them into a program
	    _shaderID = glCreateProgramObjectARB();

	    if (!(_vertexShaderCode.empty()))
	      glAttachObjectARB(_shaderID,_vertexShaderHandle);

	    if (!(_fragmentShaderCode.empty()))
	      glAttachObjectARB(_shaderID,_fragmentShaderHandle);

	    if (!(_geometryShaderCode.empty()))
	      glAttachObjectARB(_shaderID,_geometryShaderHandle);

	    glLinkProgramARB(_shaderID);

	    //Done, now the inheriting shader should grab the locations of its uniforms
	    _built = true;
	  }
/**
*  @brief
*    Constructor
*/
TessellationControlShaderGLSL::TessellationControlShaderGLSL(PLRenderer::Renderer &cRenderer) : PLRenderer::TessellationControlShader(cRenderer),
	m_nOpenGLTessellationControlShader(glCreateShaderObjectARB(GL_TESS_CONTROL_SHADER))
{
}
Ejemplo n.º 5
0
//
// Load vertex and fragment shader, compile, link etc.
//
qbool SHD_Load(shader_t *s, const char *vertex_fileName, const char *fragment_fileName)
{
	shader_t	s_tmp;
	GLint		linked = 0;
	int			i;

	if (!SHD_Initialized())
	{
		Com_Printf("SHD_Load: shader system not initialized\n");
		return false;
	}

	memset(&s_tmp, 0, sizeof(s_tmp));

	// just some assertion checks
	SHD_AlredyLoaded(s);

	if (shd.count >= MAX_SHADERS)
	{
		Com_Printf("SHD_Load: full shader list\n");
		goto cleanup;
	}

	if (!s)
	{
		Com_Printf("SHD_Load: zero shader\n");
		goto cleanup;
	}

	// we must have here nulified struct
	for (i = 0; i < sizeof(*s); i++)
	{
		if (((byte*)s)[i])
		{
			Com_Printf("SHD_Load: shader struct not ready\n");
			goto cleanup;
		}
	}

	// create a program object
	s_tmp.program			= glCreateProgramObjectARB();
	if (!s_tmp.program)
	{
		Com_Printf("SHD_Load: failed to create program\n");
		goto cleanup;
	}

	// create shaders
    s_tmp.vertexShader		= glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    s_tmp.fragmentShader	= glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

	// load source code strings into shaders
	if (!SHD_LoadAndCompile(s_tmp.vertexShader, vertex_fileName))
		goto cleanup;

    if (!SHD_LoadAndCompile(s_tmp.fragmentShader, fragment_fileName))
		goto cleanup;

	// attach the two compiled shaders
	// TODO: check success
    glAttachObjectARB(s_tmp.program, s_tmp.vertexShader);
    glAttachObjectARB(s_tmp.program, s_tmp.fragmentShader);

	// link the program object and print out the info log
    glLinkProgramARB(s_tmp.program);
	// check for OpenGL errors
    if (!SHD_CheckOpenGLError())
	{
		Com_Printf("SHD_Load: OpenGL errors encountered\n");
		goto cleanup;
	}

    glGetObjectParameterivARB(s_tmp.program, GL_OBJECT_LINK_STATUS_ARB, &linked);
    if (!linked)
	{
		Com_Printf("SHD_Load: program not linked\n");
		goto cleanup;
	}

	// copy struct
	*s = s_tmp;

	// link to shd list
	shd.shaders[shd.count] = s;
	shd.count++;

	return true;

cleanup: // GOTO MARK
	SHD_Free(&s_tmp);

	return false;
}
    const char *marcLeftUpperArm_SHADER_VertexStrings[1];
    const char *marcLeftUpperArm_SHADER_FragmentStrings[1];

    marcLeftUpperArm_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );

	 unsigned char *marcLeftUpperArm_SHADER_VertexAssembly   = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.vert" );
    marcLeftUpperArm_SHADER_VertexStrings[0] = (char*)marcLeftUpperArm_SHADER_VertexAssembly;
    glShaderSourceARB( marcLeftUpperArm_SHADER_Vertex, 1, marcLeftUpperArm_SHADER_VertexStrings, NULL );
    glCompileShaderARB( marcLeftUpperArm_SHADER_Vertex);
    delete marcLeftUpperArm_SHADER_VertexAssembly;

    marcLeftUpperArm_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );

    unsigned char *marcLeftUpperArm_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.frag" );
    marcLeftUpperArm_SHADER_FragmentStrings[0] = (char*)marcLeftUpperArm_SHADER_FragmentAssembly;
    glShaderSourceARB( marcLeftUpperArm_SHADER_Fragment, 1, marcLeftUpperArm_SHADER_FragmentStrings, NULL );
    glCompileShaderARB( marcLeftUpperArm_SHADER_Fragment );

    delete marcLeftUpperArm_SHADER_FragmentAssembly;

	 marcLeftUpperArm_SHADER = glCreateProgramObjectARB();

    glAttachObjectARB( marcLeftUpperArm_SHADER, marcLeftUpperArm_SHADER_Vertex );
    glAttachObjectARB( marcLeftUpperArm_SHADER, marcLeftUpperArm_SHADER_Fragment );

    glLinkProgramARB(marcLeftUpperArm_SHADER); 

    UNIFORM_counter_marcLeftUpperArm = glGetUniformLocationARB( marcLeftUpperArm_SHADER, "counter" );

Ejemplo n.º 7
0
bool
ShaderFactory::loadShader(GLhandleARB &progObj,
			  QString shaderString)
{
  GLhandleARB fragObj = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);  
  glAttachObjectARB(progObj, fragObj);

  GLhandleARB vertObj = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);  
  glAttachObjectARB(progObj, vertObj);

  {  // vertObj
    QString qstr;
    qstr = "varying vec3 pointpos;\n";
    qstr += "void main(void)\n";
    qstr += "{\n";
    qstr += "  // Transform vertex position into homogenous clip-space.\n";
    qstr += "  gl_FrontColor = gl_Color;\n";
    qstr += "  gl_BackColor = gl_Color;\n";
    qstr += "  gl_Position = ftransform();\n";
    qstr += "  gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;\n";
    qstr += "  gl_TexCoord[1] = gl_TextureMatrix[1] * gl_MultiTexCoord1;\n";
    qstr += "  gl_TexCoord[2] = gl_TextureMatrix[2] * gl_MultiTexCoord2;\n";
    qstr += "  gl_ClipVertex = gl_ModelViewMatrix * gl_Vertex;\n";
    qstr += "  pointpos = gl_Vertex.xyz;\n";
    qstr += "}\n";
    
    int len = qstr.length();
    char *tbuffer = new char[len+1];
    sprintf(tbuffer, qstr.toLatin1().data());
    const char *sstr = tbuffer;
    glShaderSourceARB(vertObj, 1, &sstr, NULL);
    delete [] tbuffer;

    GLint compiled = -1;
    glCompileShaderARB(vertObj);
    glGetObjectParameterivARB(vertObj,
			      GL_OBJECT_COMPILE_STATUS_ARB,
			      &compiled);
    if (!compiled)
      {
	GLcharARB str[1000];
	GLsizei len;
	glGetInfoLogARB(vertObj,
			(GLsizei) 1000,
			&len,
			str);
	
	QMessageBox::information(0,
				 "Error : Vertex Shader",
				 str);
	return false;
    }
  }
    
    
  { // fragObj
    int len = shaderString.length();
    char *tbuffer = new char[len+1];
    sprintf(tbuffer, shaderString.toLatin1().data());
    const char *sstr = tbuffer;
    glShaderSourceARB(fragObj, 1, &sstr, NULL);
    delete [] tbuffer;
  
    GLint compiled = -1;
    glCompileShaderARB(fragObj);
    glGetObjectParameterivARB(fragObj,
			    GL_OBJECT_COMPILE_STATUS_ARB,
			      &compiled);
    if (!compiled)
      {
	GLcharARB str[1000];
	GLsizei len;
	glGetInfoLogARB(fragObj,
			(GLsizei) 1000,
			&len,
			str);
	
	//-----------------------------------
	// display error
	
	//qApp->beep();
	
	QString estr;
	QStringList slist = shaderString.split("\n");
	for(int i=0; i<slist.count(); i++)
	  estr += QString("%1 : %2\n").arg(i+1).arg(slist[i]);
	
	QTextEdit *tedit = new QTextEdit();
	tedit->insertPlainText("-------------Error----------------\n\n");
	tedit->insertPlainText(str);
	tedit->insertPlainText("\n-----------Shader---------------\n\n");
	tedit->insertPlainText(estr);
	
	QVBoxLayout *layout = new QVBoxLayout();
	layout->addWidget(tedit);
	
	QDialog *showError = new QDialog();
	showError->setWindowTitle("Error in Fragment Shader");
	showError->setSizeGripEnabled(true);
	showError->setModal(true);
	showError->setLayout(layout);
	showError->exec();
	//-----------------------------------
	
	return false;
      }
  }

  
  //----------- link program shader ----------------------
  GLint linked = -1;
  glLinkProgramARB(progObj);
  glGetObjectParameterivARB(progObj, GL_OBJECT_LINK_STATUS_ARB, &linked);
  if (!linked)
    {
      GLcharARB str[1000];
      GLsizei len;
      QMessageBox::information(0,
			       "ProgObj",
			       "error linking texProgObj");
      glGetInfoLogARB(progObj,
		      (GLsizei) 1000,
		      &len,
		      str);
      QMessageBox::information(0,
			       "Error",
			       QString("%1\n%2").arg(len).arg(str));
      return false;
    }

  glDeleteObjectARB(fragObj);
  glDeleteObjectARB(vertObj);

  return true;
}
    const char *marcRightLowerLeg_SHADER_VertexStrings[1];
    const char *marcRightLowerLeg_SHADER_FragmentStrings[1];

    marcRightLowerLeg_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );

	 unsigned char *marcRightLowerLeg_SHADER_VertexAssembly   = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.vert" );
    marcRightLowerLeg_SHADER_VertexStrings[0] = (char*)marcRightLowerLeg_SHADER_VertexAssembly;
    glShaderSourceARB( marcRightLowerLeg_SHADER_Vertex, 1, marcRightLowerLeg_SHADER_VertexStrings, NULL );
    glCompileShaderARB( marcRightLowerLeg_SHADER_Vertex);
    delete marcRightLowerLeg_SHADER_VertexAssembly;

    marcRightLowerLeg_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );

    unsigned char *marcRightLowerLeg_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.frag" );
    marcRightLowerLeg_SHADER_FragmentStrings[0] = (char*)marcRightLowerLeg_SHADER_FragmentAssembly;
    glShaderSourceARB( marcRightLowerLeg_SHADER_Fragment, 1, marcRightLowerLeg_SHADER_FragmentStrings, NULL );
    glCompileShaderARB( marcRightLowerLeg_SHADER_Fragment );

    delete marcRightLowerLeg_SHADER_FragmentAssembly;

	 marcRightLowerLeg_SHADER = glCreateProgramObjectARB();

    glAttachObjectARB( marcRightLowerLeg_SHADER, marcRightLowerLeg_SHADER_Vertex );
    glAttachObjectARB( marcRightLowerLeg_SHADER, marcRightLowerLeg_SHADER_Fragment );

    glLinkProgramARB(marcRightLowerLeg_SHADER); 

    UNIFORM_counter_marcRightLowerLeg = glGetUniformLocationARB( marcRightLowerLeg_SHADER, "counter" );

Ejemplo n.º 9
0
void pip::Shader::loadShader(const string &vertexName, const string &fragmentName)
{
	//printLog(this->prog);

	// Loading vertex shader.
	if(this->vertexShadersMap.count(vertexName) == 0) // TODO Error checking?
	{
		this->vertexShadersMap[vertexName] = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
		//printLog(this->vertexShadersMap[vertexName]);

		string program;
		if(loadFile(vertexName, program))
		{
			const char * vv = STR_CCHR(program);
			std::cout << "Program: " << vv << std::endl;
			glShaderSourceARB(this->vertexShadersMap[vertexName], 1, &vv, NULL);

			/*GLenum glErr;

			    glErr = glGetError();
			    while (glErr != GL_NO_ERROR)
			    {
			        printf("%s\n", gluErrorString(glErr));
			        glErr = glGetError();
			    }*/
			//delete vv;
			glCompileShaderARB(this->vertexShadersMap[vertexName]);

			//printLog(this->vertexShadersMap[vertexName]);
			GLint result = GL_FALSE;
			glGetObjectParameterivARB(this->vertexShadersMap[vertexName],GL_COMPILE_STATUS,&result);
			if(result == GL_FALSE)
			{
				//printLog(this->vertexShadersMap[vertexName]);
				throw EngineException("Error occurred when compiling '" + vertexName + "' vertex shader.");
			}
		}else
			throw EngineException("Can't load '" + vertexName + "' shader!");
	}

	// Loading fragment shader.
	if(this->fragmentShadersMap.count(fragmentName) == 0)
	{
		this->fragmentShadersMap[fragmentName] = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
		string program;
		if(loadFile(fragmentName, program))
		{
			const char * ff = STR_CCHR(program);
			glShaderSourceARB(this->fragmentShadersMap[fragmentName], 1, &ff,NULL);
			//delete ff;
			glCompileShaderARB(this->fragmentShadersMap[fragmentName]);
			GLint result = GL_FALSE;
			glGetObjectParameterivARB(this->fragmentShadersMap[fragmentName],GL_COMPILE_STATUS,&result);
			if(result == GL_FALSE)
				throw EngineException("Error occurred when compiling '" + fragmentName + "' fragment shader.");

		}else
			throw EngineException("Can't load '" + fragmentName + "' shader!");
	}

	this->prog = glCreateProgramObjectARB();

	// Attaching vertex shader to program object.
	glAttachObjectARB(this->prog, this->vertexShadersMap[vertexName]);

	// Attaching fragment shader to program object.
	glAttachObjectARB(this->prog, this->fragmentShadersMap[fragmentName]);

	glLinkProgramARB(this->prog);

	GLint result = GL_FALSE;
	glGetObjectParameterivARB(this->prog,GL_OBJECT_LINK_STATUS_ARB,&result);
	if(result == GL_FALSE)
		throw EngineException("Error occurred when linking shaders.");
}
const char *spikes_00_SHADER_VertexStrings[1];
const char *spikes_00_SHADER_FragmentStrings[1];

spikes_00_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );

unsigned char *spikes_00_SHADER_VertexAssembly   = readShaderFile( "_MODEL_FOLDERS_/spikes_00/spikes_00.vert" );
spikes_00_SHADER_VertexStrings[0] = (char*)spikes_00_SHADER_VertexAssembly;
glShaderSourceARB( spikes_00_SHADER_Vertex, 1, spikes_00_SHADER_VertexStrings, NULL );
glCompileShaderARB( spikes_00_SHADER_Vertex);
delete spikes_00_SHADER_VertexAssembly;

spikes_00_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );

unsigned char *spikes_00_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/spikes_00/spikes_00.frag" );
spikes_00_SHADER_FragmentStrings[0] = (char*)spikes_00_SHADER_FragmentAssembly;
glShaderSourceARB( spikes_00_SHADER_Fragment, 1, spikes_00_SHADER_FragmentStrings, NULL );
glCompileShaderARB( spikes_00_SHADER_Fragment );

delete spikes_00_SHADER_FragmentAssembly;

spikes_00_SHADER = glCreateProgramObjectARB();

glAttachObjectARB( spikes_00_SHADER, spikes_00_SHADER_Vertex );
glAttachObjectARB( spikes_00_SHADER, spikes_00_SHADER_Fragment );

glLinkProgramARB(spikes_00_SHADER);

UNIFORM_counter_spikes_00 = glGetUniformLocationARB( spikes_00_SHADER, "counter" );

Ejemplo n.º 11
0
bool Shader::Compile(const char* vertexShaderCode, const char* fragmentShaderCode)
{
    EnsureGlContext();

    // First make sure that we can use shaders
    if (!IsAvailable())
    {
        Err() << "Failed to create a shader: your system doesn't support shaders "
              << "(you should test Shader::IsAvailable() before trying to use the Shader class)" << std::endl;
        return false;
    }

    // Destroy the shader if it was already created
    if (myShaderProgram)
        GLCheck(glDeleteObjectARB(myShaderProgram));

    // Create the program
    myShaderProgram = glCreateProgramObjectARB();

    // Create the vertex shader if needed
    if (vertexShaderCode)
    {
        // Create and compile the shader
        GLhandleARB vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
        GLCheck(glShaderSourceARB(vertexShader, 1, &vertexShaderCode, NULL));
        GLCheck(glCompileShaderARB(vertexShader));

        // Check the compile log
        GLint success;
        GLCheck(glGetObjectParameterivARB(vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &success));
        if (success == GL_FALSE)
        {
            char log[1024];
            GLCheck(glGetInfoLogARB(vertexShader, sizeof(log), 0, log));
            Err() << "Failed to compile vertex shader:" << std::endl
                  << log << std::endl;
            GLCheck(glDeleteObjectARB(vertexShader));
            GLCheck(glDeleteObjectARB(myShaderProgram));
            myShaderProgram = 0;
            return false;
        }

        // Attach the shader to the program, and delete it (not needed anymore)
        GLCheck(glAttachObjectARB(myShaderProgram, vertexShader));
        GLCheck(glDeleteObjectARB(vertexShader));
    }

    // Create the fragment shader if needed
    if (fragmentShaderCode)
    {
        // Create and compile the shader
        GLhandleARB fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
        GLCheck(glShaderSourceARB(fragmentShader, 1, &fragmentShaderCode, NULL));
        GLCheck(glCompileShaderARB(fragmentShader));

        // Check the compile log
        GLint success;
        GLCheck(glGetObjectParameterivARB(fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &success));
        if (success == GL_FALSE)
        {
            char log[1024];
            GLCheck(glGetInfoLogARB(fragmentShader, sizeof(log), 0, log));
            Err() << "Failed to compile fragment shader:" << std::endl
                  << log << std::endl;
            GLCheck(glDeleteObjectARB(fragmentShader));
            GLCheck(glDeleteObjectARB(myShaderProgram));
            myShaderProgram = 0;
            return false;
        }

        // Attach the shader to the program, and delete it (not needed anymore)
        GLCheck(glAttachObjectARB(myShaderProgram, fragmentShader));
        GLCheck(glDeleteObjectARB(fragmentShader));
    }

    // Link the program
    GLCheck(glLinkProgramARB(myShaderProgram));

    // Check the link log
    GLint success;
    GLCheck(glGetObjectParameterivARB(myShaderProgram, GL_OBJECT_LINK_STATUS_ARB, &success));
    if (success == GL_FALSE)
    {
        char log[1024];
        GLCheck(glGetInfoLogARB(myShaderProgram, sizeof(log), 0, log));
        Err() << "Failed to link shader:" << std::endl
              << log << std::endl;
        GLCheck(glDeleteObjectARB(myShaderProgram));
        myShaderProgram = 0;
        return false;
    }

    return true;
}
Ejemplo n.º 12
0
GPUShader *GPU_shader_create(const char *vertexcode, const char *fragcode, const char *libcode, const char *defines)
{
	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");

	if (vertexcode)
		shader->vertex = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	if (fragcode)
		shader->fragment = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
	shader->object = glCreateProgramObjectARB();

	if (!shader->object ||
	    (vertexcode && !shader->vertex) ||
	    (fragcode && !shader->fragment))
	{
		fprintf(stderr, "GPUShader, object creation failed.\n");
		GPU_shader_free(shader);
		return NULL;
	}

	if (vertexcode) {
		const char *source[4];
		int num_source = 0;

		source[num_source++] = gpu_shader_standard_extensions();
		source[num_source++] = gpu_shader_standard_defines();

		if (defines) source[num_source++] = defines;
		if (vertexcode) source[num_source++] = vertexcode;

		glAttachObjectARB(shader->object, shader->vertex);
		glShaderSourceARB(shader->vertex, num_source, source, NULL);

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

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

			GPU_shader_free(shader);
			return NULL;
		}
	}

	if (fragcode) {
		const char *source[5];
		int num_source = 0;

		source[num_source++] = gpu_shader_standard_extensions();
		source[num_source++] = gpu_shader_standard_defines();

		if (defines) source[num_source++] = defines;
		if (libcode) source[num_source++] = libcode;
		if (fragcode) source[num_source++] = fragcode;

		glAttachObjectARB(shader->object, shader->fragment);
		glShaderSourceARB(shader->fragment, num_source, source, NULL);

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

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

			GPU_shader_free(shader);
			return NULL;
		}
	}

#if 0
	if (lib && lib->lib)
		glAttachObjectARB(shader->object, lib->lib);
#endif

	glLinkProgramARB(shader->object);
	glGetObjectParameterivARB(shader->object, GL_OBJECT_LINK_STATUS_ARB, &status);
	if (!status) {
		glGetInfoLogARB(shader->object, sizeof(log), &length, log);
		if (fragcode) shader_print_errors("linking", log, fragcode);
		else if (vertexcode) shader_print_errors("linking", log, vertexcode);
		else if (libcode) shader_print_errors("linking", log, libcode);

		GPU_shader_free(shader);
		return NULL;
	}

	return shader;
}
Ejemplo n.º 13
0
static inline bool r_create_program(const char *id, const char *vss,
	const char *fss, uint *vs, uint *fs, uint *prog) {
	OPENGL_EVENT_BEGIN(0, __PRETTY_FUNCTION__);

	*vs = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	*fs = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
	// shut up compiler...
	glShaderSourceARB(*vs, 1, (const char **)&vss, NULL);
	glShaderSourceARB(*fs, 1, (const char **)&fss, NULL);

	// compile vertex shader
	glCompileShaderARB(*vs);
	if (!r_shader_check(*vs, GL_OBJECT_COMPILE_STATUS_ARB, id,
		"vertex shader compilation")) {
		OPENGL_EVENT_END();

		return false;
	}

	// compile fragment shader
	glCompileShaderARB(*fs);
	if (!r_shader_check(*fs, GL_OBJECT_COMPILE_STATUS_ARB, id,
		"fragment shader compilation")) {
		OPENGL_EVENT_END();

		return false;
	}

	// link the program together
	*prog = glCreateProgramObjectARB();
	glAttachObjectARB(*prog, *vs);
	glAttachObjectARB(*prog, *fs);
	glLinkProgramARB(*prog);
	if (!r_shader_check(*prog, GL_OBJECT_LINK_STATUS_ARB, id,
		"GPU program linking")) {
		OPENGL_EVENT_END();

		return false;
	}

	// validate the program
	glValidateProgramARB(*prog);
	if (!r_shader_check(*prog, GL_OBJECT_VALIDATE_STATUS_ARB, id,
		"GPU program validation")) {
		OPENGL_EVENT_END();

		return false;
	}

#if OPENGL_DEBUG
	if (GLEW_KHR_debug) {
		glObjectLabel(GL_SHADER, *vs, -1, id);
		glObjectLabel(GL_SHADER, *fs, -1, id);
		glObjectLabel(GL_PROGRAM, *prog, -1, id);
	}
#endif

	OPENGL_EVENT_END();

	return true;
}
Ejemplo n.º 14
0
void
initShader(void)
{
    ///////////////////////////////////////////////////////////////////////////
    //
    // Create earth shader
    //
    GLhandleARB terrain_vertex_shader;
    GLhandleARB terrain_fragment_shader;

    //
    // Create and load resources
    //
    g_terrainProgram          = glCreateProgramObjectARB();
    terrain_vertex_shader     = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    terrain_fragment_shader   = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

    loadShaderFromFile(terrain_vertex_shader, "shader/terrain.vert");
    loadShaderFromFile(terrain_fragment_shader, "shader/terrain.frag");

    //
    // Compile
    //
    glCompileShaderARB(terrain_vertex_shader);
    GET_GLERROR(0);
    printInfoLog(terrain_vertex_shader);

    glCompileShaderARB(terrain_fragment_shader);
    GET_GLERROR(0);
    printInfoLog(terrain_fragment_shader);

    //
    // Link
    //
    glAttachObjectARB(g_terrainProgram, terrain_vertex_shader);
    glAttachObjectARB(g_terrainProgram, terrain_fragment_shader);
    glLinkProgramARB(g_terrainProgram);
    GET_GLERROR(0);
    printInfoLog(g_terrainProgram);

    ///////////////////////////////////////////////////////////////////////////
    //
    // Setup terrain shader
    //

    //
    // Sampler
    //
    glUseProgramObjectARB(g_terrainProgram);
	GET_GLERROR(0);

	float test;
    //
    // Aufgabe 1.b - Begin
    //
	
	int samplerTerrain = glGetUniformLocationARB(g_terrainProgram, "samplerTerrain");
	GET_GLERROR(0);
	int samplerGradient = glGetUniformLocationARB(g_terrainProgram, "samplerGradient");
	GET_GLERROR(0);

	glUniform1i(samplerTerrain, 0);
	GET_GLERROR(0);
	glUniform1i(samplerGradient, 1);
	GET_GLERROR(0);
    //
    // Aufgabe 1.b - End
    //

	//
	// Bounding Box
	//
	int LLFLocation = glGetUniformLocationARB(g_terrainProgram, "v3LLF");
	GET_GLERROR(0);
	int URBLocation = glGetUniformLocationARB(g_terrainProgram, "v3URB");
	GET_GLERROR(0);

	vec3 LLF = vec3(g_sceneAABB.xMin, g_sceneAABB.yMin, g_sceneAABB.zMin);
	vec3 URB = vec3(g_sceneAABB.xMax, g_sceneAABB.yMax, g_sceneAABB.zMax);

    glUniform3fARB(LLFLocation, g_sceneAABB.xMin, g_sceneAABB.yMin, g_sceneAABB.zMin);
	GET_GLERROR(0);
	glUniform3fARB(URBLocation, g_sceneAABB.xMax, g_sceneAABB.yMax, g_sceneAABB.zMax);
	GET_GLERROR(0);
    return;
}
Ejemplo n.º 15
0
bool GPU::Shader::PgObject::Allocate()
{
    m_Id = glCreateShaderObjectARB( m_PgType );
    return m_Id != 0;
}
    const char *marcRightHand_SHADER_VertexStrings[1];
    const char *marcRightHand_SHADER_FragmentStrings[1];

    marcRightHand_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );

	 unsigned char *marcRightHand_SHADER_VertexAssembly   = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.vert" );
    marcRightHand_SHADER_VertexStrings[0] = (char*)marcRightHand_SHADER_VertexAssembly;
    glShaderSourceARB( marcRightHand_SHADER_Vertex, 1, marcRightHand_SHADER_VertexStrings, NULL );
    glCompileShaderARB( marcRightHand_SHADER_Vertex);
    delete marcRightHand_SHADER_VertexAssembly;

    marcRightHand_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );

    unsigned char *marcRightHand_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.frag" );
    marcRightHand_SHADER_FragmentStrings[0] = (char*)marcRightHand_SHADER_FragmentAssembly;
    glShaderSourceARB( marcRightHand_SHADER_Fragment, 1, marcRightHand_SHADER_FragmentStrings, NULL );
    glCompileShaderARB( marcRightHand_SHADER_Fragment );

    delete marcRightHand_SHADER_FragmentAssembly;

	 marcRightHand_SHADER = glCreateProgramObjectARB();

    glAttachObjectARB( marcRightHand_SHADER, marcRightHand_SHADER_Vertex );
    glAttachObjectARB( marcRightHand_SHADER, marcRightHand_SHADER_Fragment );

    glLinkProgramARB(marcRightHand_SHADER); 
Ejemplo n.º 17
0
GPUShader *GPU_shader_create(const char *vertexcode, const char *fragcode, /*GPUShader *lib,*/ const char *libcode)
{
	GLint status;
	GLcharARB log[5000];
	const char *fragsource[2];
	GLsizei length = 0;
	GLint count;
	GPUShader *shader;

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

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

	if(vertexcode)
		shader->vertex = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	if(fragcode)
		shader->fragment = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
	shader->object = glCreateProgramObjectARB();

	if (!shader->object ||
		(vertexcode && !shader->vertex) ||
		(fragcode && !shader->fragment)) {
		fprintf(stderr, "GPUShader, object creation failed.\n");
		GPU_shader_free(shader);
		return NULL;
	}

	if(vertexcode) {
		glAttachObjectARB(shader->object, shader->vertex);
		glShaderSourceARB(shader->vertex, 1, (const char**)&vertexcode, NULL);

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

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

			GPU_shader_free(shader);
			return NULL;
		}
	}

	if(fragcode) {
		count = 0;
		if(libcode) fragsource[count++] = libcode;
		if(fragcode) fragsource[count++] = fragcode;

		glAttachObjectARB(shader->object, shader->fragment);
		glShaderSourceARB(shader->fragment, count, fragsource, NULL);

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

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

			GPU_shader_free(shader);
			return NULL;
		}
	}

	/*if(lib && lib->lib)
		glAttachObjectARB(shader->object, lib->lib);*/

	glLinkProgramARB(shader->object);
	glGetObjectParameterivARB(shader->object, GL_OBJECT_LINK_STATUS_ARB, &status);
	if (!status) {
		glGetInfoLogARB(shader->object, sizeof(log), &length, log);
		if (fragcode) shader_print_errors("linking", log, fragcode);
		else if (vertexcode) shader_print_errors("linking", log, vertexcode);
		else if (libcode) shader_print_errors("linking", log, libcode);

		GPU_shader_free(shader);
		return NULL;
	}

	return shader;
}
    const char *particle_50mm_SHADER_VertexStrings[1];
    const char *particle_50mm_SHADER_FragmentStrings[1];

    particle_50mm_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );

	 unsigned char *particle_50mm_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/particle_50mm/particle_50mm.vert" );
    particle_50mm_SHADER_VertexStrings[0] = (char*)particle_50mm_SHADER_VertexAssembly;
    glShaderSourceARB( particle_50mm_SHADER_Vertex, 1, particle_50mm_SHADER_VertexStrings, NULL );
    glCompileShaderARB( particle_50mm_SHADER_Vertex);
    delete particle_50mm_SHADER_VertexAssembly;

    particle_50mm_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );

    unsigned char *particle_50mm_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/particle_50mm/particle_50mm.frag" );
    particle_50mm_SHADER_FragmentStrings[0] = (char*)particle_50mm_SHADER_FragmentAssembly;
    glShaderSourceARB( particle_50mm_SHADER_Fragment, 1, particle_50mm_SHADER_FragmentStrings, NULL );
    glCompileShaderARB(particle_50mm_SHADER_Fragment );

    delete particle_50mm_SHADER_FragmentAssembly;

	 particle_50mm_SHADER = glCreateProgramObjectARB();

    glAttachObjectARB( particle_50mm_SHADER, particle_50mm_SHADER_Vertex );
    glAttachObjectARB( particle_50mm_SHADER, particle_50mm_SHADER_Fragment );

    glLinkProgramARB(particle_50mm_SHADER); 

    UNIFORM_counter1_particle_50mm = glGetUniformLocationARB( particle_50mm_SHADER, "counter1" );

    UNIFORM_counter2_particle_50mm = glGetUniformLocationARB( particle_50mm_SHADER, "counter2" );
Ejemplo n.º 19
0
bool Shader::CompileProgram()
{
    EnsureGlContext();

    // First make sure that we can use shaders
    if (!IsAvailable())
    {
        Err() << "Failed to create a shader: your system doesn't support shaders "
              << "(you should test Shader::IsAvailable() before trying to use the Shader class)" << std::endl;
        return false;
    }

    // Destroy the shader if it was already created
    if (myShaderProgram)
        GLCheck(glDeleteObjectARB(myShaderProgram));

    // Define the vertex shader source (we provide it directly as it doesn't have to change)
    static const char* vertexSrc =
        "void main()"
        "{"
        "    gl_TexCoord[0] = gl_MultiTexCoord0;"
        "    gl_FrontColor = gl_Color;"
        "    gl_Position = ftransform();"
        "}";

    // Create the program
    myShaderProgram = glCreateProgramObjectARB();

    // Create the shaders
    GLhandleARB vertexShader   = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    GLhandleARB fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

    // Compile them
    const char* fragmentSrc = myFragmentShader.c_str();
    GLCheck(glShaderSourceARB(vertexShader,   1, &vertexSrc,   NULL));
    GLCheck(glShaderSourceARB(fragmentShader, 1, &fragmentSrc, NULL));
    GLCheck(glCompileShaderARB(vertexShader));
    GLCheck(glCompileShaderARB(fragmentShader));

    // Check the compile logs
    GLint success;
    GLCheck(glGetObjectParameterivARB(vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &success));
    if (success == GL_FALSE)
    {
        char log[1024];
        GLCheck(glGetInfoLogARB(vertexShader, sizeof(log), 0, log));
        Err() << "Failed to compile shader:" << std::endl
              << log << std::endl;
        GLCheck(glDeleteObjectARB(vertexShader));
        GLCheck(glDeleteObjectARB(fragmentShader));
        GLCheck(glDeleteObjectARB(myShaderProgram));
        myShaderProgram = 0;
        return false;
    }
    GLCheck(glGetObjectParameterivARB(fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &success));
    if (success == GL_FALSE)
    {
        char log[1024];
        GLCheck(glGetInfoLogARB(fragmentShader, sizeof(log), 0, log));
        Err() << "Failed to compile shader:" << std::endl
              << log << std::endl;
        GLCheck(glDeleteObjectARB(vertexShader));
        GLCheck(glDeleteObjectARB(fragmentShader));
        GLCheck(glDeleteObjectARB(myShaderProgram));
        myShaderProgram = 0;
        return false;
    }

    // Attach the shaders to the program
    GLCheck(glAttachObjectARB(myShaderProgram, vertexShader));
    GLCheck(glAttachObjectARB(myShaderProgram, fragmentShader));

    // We can now delete the shaders
    GLCheck(glDeleteObjectARB(vertexShader));
    GLCheck(glDeleteObjectARB(fragmentShader));

    // Link the program
    GLCheck(glLinkProgramARB(myShaderProgram));

    // Get link log
    GLCheck(glGetObjectParameterivARB(myShaderProgram, GL_OBJECT_LINK_STATUS_ARB, &success));
    if (success == GL_FALSE)
    {
        // Oops... link errors
        char log[1024];
        GLCheck(glGetInfoLogARB(myShaderProgram, sizeof(log), 0, log));
        Err() << "Failed to link shader:" << std::endl
              << log << std::endl;
        GLCheck(glDeleteObjectARB(myShaderProgram));
        myShaderProgram = 0;
        return false;
    }

    return true;
}