Example #1
0
bool C4Shader::Init(const char *szWhat, const char **szUniforms)
{
#ifndef USE_CONSOLE
	// No support?
	if(!GLEW_ARB_fragment_program)
	{
		Log("  gl: no shader support!");
		return false;
	}

	// Clear old shader first
	if (hProg) Clear();
#endif

	StdStrBuf VertexShader = Build(VertexSlices, true),
		FragmentShader = Build(FragmentSlices, true);

	// Dump
	if (C4Shader::IsLogging())
	{
		ShaderLogF("******** Vertex shader for %s:", szWhat);
		ShaderLog(VertexShader.getData());
		ShaderLogF("******** Fragment shader for %s:", szWhat);
		ShaderLog(FragmentShader.getData());
	}

#ifndef USE_CONSOLE
	// Attempt to create shaders
	hVert = Create(GL_VERTEX_SHADER_ARB,
				   FormatString("%s vertex shader", szWhat).getData(),
				   VertexShader.getData());
	hFrag = Create(GL_FRAGMENT_SHADER_ARB,
				   FormatString("%s fragment shader", szWhat).getData(),
				   FragmentShader.getData());
	if(!hFrag || !hVert)
		return false;

	// Link program
	hProg = glCreateProgramObjectARB();
#ifdef GL_KHR_debug
	if (glObjectLabel)
		glObjectLabel(GL_PROGRAM, hProg, -1, szWhat);
#endif
	glAttachObjectARB(hProg, hVert);
	glAttachObjectARB(hProg, hFrag);
	// Bind all input variables
	for (int i = 0; i <= VAI_BoneWeightsMax - VAI_BoneWeights; ++i)
	{
		glBindAttribLocation(hProg, VAI_BoneWeights + i, FormatString("oc_BoneWeights%d", i).getData());
		glBindAttribLocation(hProg, VAI_BoneIndices + i, FormatString("oc_BoneIndices%d", i).getData());
	}
	glLinkProgramARB(hProg);

	// Link successful?
	DumpInfoLog(FormatString("%s shader program", szWhat).getData(), hProg);
	if(GetObjectStatus(hProg, GL_OBJECT_LINK_STATUS_ARB) != 1) {
		Clear();
		ShaderLogF("  gl: Failed to link %s shader!", szWhat);
		return false;
	}
	ShaderLogF("  gl: %s shader linked successfully", szWhat);

	// Okay, allocate uniform array
	iUniformCount = 0;
	while (szUniforms[iUniformCount])
		iUniformCount++;
	pUniforms = new GLint[iUniformCount];

	// Get uniform locations. Note this is expected to fail for a few of them
	// because the respective uniforms got optimized out!
	for (int i = 0; i < iUniformCount; i++)
		pUniforms[i] = glGetUniformLocationARB(hProg, szUniforms[i]);
#endif

	return true;
}
Example #2
0
void moShaderGLSL::CreateVertShader(moText vert_source)
{
    m_ProgramObject = glCreateProgramObjectARB();
    compileVertShader(vert_source);
    linkProgram();
}
ShaderProgram::ShaderProgram()
{
   mID = glCreateProgramObjectARB();
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglCreateProgramObjectARB(JNIEnv *env, jclass clazz, jlong function_pointer) {
	glCreateProgramObjectARBPROC glCreateProgramObjectARB = (glCreateProgramObjectARBPROC)((intptr_t)function_pointer);
	GLhandleARB __result = glCreateProgramObjectARB();
	return __result;
}
Example #5
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_));
	}
Example #6
0
/**
 * Loads vertex and fragment shader from disk/memory.
 * Loads any combination of vertex and fragment shader from disk or from a memory position.
 * Generates error/information messages to stdout during loading.
 * If nor successful the handle of the shader will be set to 0.
 * \param VSFile - name of the file containing the vertex shader
 * \param FSFile - name of the file containing the fragment shader
 * \param src - selects the source of vertex and fragment shader. Can be either GLSLPROGRAM_DISK or GLSLPROGRAM_STRING
 * \return void
 * \warning Uses glGetError()
 * \author <a href="mailto:[email protected]">Jens Schneider</a>
 * \date Aug.2004
 * \see GLSLPROGRAM_SOURCE
 */
void GLSLProgram::Load(const char *VSFile, const char *FSFile, GLSLPROGRAM_SOURCE src) {
  CheckGLError();

  // load
  GLuint hVS=0;
  GLuint hFS=0;
  bool bVSSuccess=true;  // fixed function pipeline is always working
  if (VSFile!=NULL) {
    hVS=LoadShader(VSFile,GL_VERTEX_SHADER,src);
    if(hVS != 0) {
      m_sVS = std::string(VSFile); // record program source
    } else {
      bVSSuccess=false;
      if (src==GLSLPROGRAM_DISK) {
        T_ERROR("ERROR IN: %s", VSFile);
      }
      else {
        T_ERROR("---------- ERROR -----------");
        int iPos=0;
        int iLine=1;
        char chLine[32];
        char *chVerbose=new char[strlen(VSFile)+1];
        memcpy(chVerbose,VSFile,strlen(VSFile)+1);
        for (unsigned int i=0; i<strlen(VSFile); i++) {
          if (chVerbose[i]=='\n') {
            chVerbose[i]='\0';
            sprintf(chLine,"(%.4i) ",iLine++);
            T_ERROR("Load %s %s", chLine, &chVerbose[iPos]);
            iPos=i+1;
          }
        }
        delete[] chVerbose;
      }
    }
  }
  bool bFSSuccess=true;  // fixed function pipeline is always working
  if (FSFile!=NULL) {
    hFS=LoadShader(FSFile,GL_FRAGMENT_SHADER,src);
    if(hVS != 0) {
      m_sFS = std::string(FSFile); // record program source
    } else {
      bFSSuccess=false;
      if (src==GLSLPROGRAM_DISK) {
        T_ERROR( "Error in fragment shader: %s", FSFile);
      }
      else {
        T_ERROR("---------- ERROR -----------");
        int iPos=0;
        int iLine=1;
        char chLine[32];
        char *chVerbose=new char[strlen(FSFile)+1];
        memcpy(chVerbose,FSFile,strlen(FSFile)+1);
        for (unsigned int i=0; i<strlen(FSFile); i++) {
          if (chVerbose[i]=='\n') {
            chVerbose[i]='\0';
            sprintf(chLine,"(%.4i) ",iLine++);
            T_ERROR( "Load %s %s",chLine, &chVerbose[iPos]);
            iPos=i+1;
          }
        }
        delete[] chVerbose;
      }
    }
  }

  if (m_bGLUseARB) {
    // attach to shader program
    m_hProgram=glCreateProgramObjectARB();
    if (hVS) glAttachObjectARB(m_hProgram,hVS);
    if (hFS) glAttachObjectARB(m_hProgram,hFS);

    // link the program together
    if (bVSSuccess && bFSSuccess) {
      glLinkProgramARB(m_hProgram);

      // check for errors
      GLint iLinked;
      glGetObjectParameterivARB(m_hProgram,GL_OBJECT_LINK_STATUS_ARB,&iLinked);
      WriteError(m_hProgram);

      // delete temporary objects
      if (hVS) glDeleteObjectARB(hVS);
      if (hFS) glDeleteObjectARB(hFS);

      if (CheckGLError("Load()") || !iLinked) {
        glDeleteObjectARB(m_hProgram);
        m_bInitialized=false;
        return;
      } else {
        m_bInitialized=true;
      }
    } else {
      if (hVS) glDeleteObjectARB(hVS);
      if (hFS) glDeleteObjectARB(hFS);
      glDeleteObjectARB(m_hProgram);
      m_hProgram=0;
      m_bInitialized=false;
      if (!bVSSuccess && !bFSSuccess) T_ERROR("Error in vertex and fragment shaders");
      else if (!bVSSuccess) T_ERROR("Error in vertex shader");
      else if (!bFSSuccess) T_ERROR("Error in fragment shader");
    }
  } else {
    // attach to program object
    m_hProgram=glCreateProgram();
    if (hVS) glAttachShader(m_hProgram,hVS);
    if (hFS) glAttachShader(m_hProgram,hFS);

    // link the program together
    if (bVSSuccess && bFSSuccess) {
      glLinkProgram(m_hProgram);

      // check for errors
      GLint iLinked;
      glGetProgramiv(m_hProgram,GL_LINK_STATUS,&iLinked);

      std::string fileDesc = std::string("VS: ") + std::string(VSFile) +
                             std::string(", FS:") + std::string(FSFile);
      WriteInfoLog(fileDesc.c_str(), m_hProgram, true);

      // flag shaders such that they can be deleted when they get detached
      if (hVS) glDeleteShader(hVS);
      if (hFS) glDeleteShader(hFS);
      if (CheckGLError("Load()") || iLinked!=GLint(GL_TRUE)) {
        glDeleteProgram(m_hProgram);
        m_hProgram=0;
        m_bInitialized=false;
        return;
      }
      else {
        m_bInitialized=true;
      }
    }
    else {
      if (hVS) glDeleteShader(hVS);
      if (hFS) glDeleteShader(hFS);
      glDeleteProgram(m_hProgram);
      m_hProgram=0;
      m_bInitialized=false;
      if (!bVSSuccess && !bFSSuccess) T_ERROR("Error in vertex and fragment shaders");
      else if (!bVSSuccess) T_ERROR("Error in vertex shader");
      else if (!bFSSuccess) T_ERROR("Error in fragment shader");
    }
  }
}
Example #7
0
bool Shader::compile(const char *vertexShaderCode, const char *fragmentShaderCode) {
	ensureGLContext();

	if (!isAvailable()) {
		std::cerr << "Failed to create a shader. Your system doesn't support shaders. "
				  << "You should use Shader::isAvailable() befor trying to use shaders.\n";

		return false;
	}

	if (mShaderProgram) {
		glCheck(glDeleteObjectARB(mShaderProgram));
	}

	mCurrentTexture = -1;
	mTextures.clear();
	mParams.clear();

	mShaderProgram = glCheck(glCreateProgramObjectARB());

	if (vertexShaderCode) {
		GLhandleARB vertexShader = glCheck(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
		glCheck(glShaderSourceARB(vertexShader, 1, &vertexShaderCode, null));
		glCheck(glCompileShaderARB(vertexShader));

		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));
			std::cerr << "Failed to compile vertex shader. " << log << "\n";
			glCheck(glDeleteObjectARB(mShaderProgram));
			glCheck(glDeleteObjectARB(vertexShader));

			mShaderProgram = 0;

			return false;
		}

		glCheck(glAttachObjectARB(mShaderProgram, vertexShader));
		glCheck(glDeleteObjectARB(vertexShader));
	}

	if (fragmentShaderCode) {
		GLhandleARB fragmentShader = glCheck(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
		glCheck(glShaderSourceARB(fragmentShader, 1, &fragmentShaderCode, null));
		glCheck(glCompileShaderARB(fragmentShader));

		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));
			std::cerr << "Failed to compile vertex shader. " << log << "\n";
			glCheck(glDeleteObjectARB(mShaderProgram));
			glCheck(glDeleteObjectARB(fragmentShader));

			mShaderProgram = 0;

			return false;
		}

		glCheck(glAttachObjectARB(mShaderProgram, fragmentShader));
		glCheck(glDeleteObjectARB(fragmentShader));
	}

	glCheck(glLinkProgramARB(mShaderProgram));

	GLint success;
	glCheck(glGetObjectParameterivARB(mShaderProgram, GL_OBJECT_LINK_STATUS_ARB, &success));
	if (success == GL_FALSE) {
		char log[1024];
		glCheck(glGetInfoLogARB(mShaderProgram, sizeof(log), 0, log));
		std::cerr << "Failed to link shader. " << log << "\n";
		glCheck(glDeleteObjectARB(mShaderProgram));
		mShaderProgram = 0;

		return false;
	}

	glCheck(glFlush());

	return true;
}
Example #8
0
 ShaderProgram::ShaderProgram()
 {
     _linked = false;
     _id = glCreateProgramObjectARB();
 }
Example #9
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;
}
Example #10
0
GLhandleARB Shader::loadShader(const std::string& filestr)
{

//  std::string filestr(filename);

  bool vertexshader = false;
  bool fragmentshader = false;
  bool geometryshader = false;

  if(filestr.find(".vert") != std::string::npos){
    vertexshader=true;
  }else{
    if(filestr.find(".frag") != std::string::npos){
      fragmentshader=true;
    }
#ifdef USE_GEOMETRY_SHADER
    else{
      if(filestr.find(".geo") != std::string::npos){
	geometryshader=true;
      }
#endif
  }

	if(!vertexshader && !fragmentshader && !geometryshader )
		return 0;

  std::ifstream file(filestr.c_str()); 
  if(!file)
    return 0;
  
  std::stringstream buffer;
  buffer << file.rdbuf();
  file.close();

  std::string s = buffer.str();

  GLcharARB * source = new GLcharARB[4*(buffer.str().size()/4+1)];
  if(source == 0)
    return 0;

  unsigned int i;
  for(i =0; i < buffer.str().size(); ++i){
   source[i] = s[i];
  }
  source[i] = '\0';

  GLhandleARB so = 0; 
  if(vertexshader)
    so = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
  if(fragmentshader)
    so = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
#ifdef USE_GEOMETRY_SHADER
  if(geometryshader)
    so = glCreateShaderObjectARB(GL_GEOMETRY_SHADER_ARB);  
#endif
  glShaderSourceARB(so, 1,(const GLcharARB**) &source, 0);

  return so;

}

bool Shader::compileShader(GLhandleARB object)
{

  if(object==0)
    return false;

  glCompileShaderARB(object);
  
  int status;
  glGetObjectParameterivARB(object, GL_OBJECT_COMPILE_STATUS_ARB, &status);
  if(status==0){
    int length = 0;
    glGetObjectParameterivARB(object, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
    if(length>0){
      GLsizei minlength = min(MAX_LOG_STRING,length);
      glGetInfoLogARB(object, minlength, 0, logstring);
      std::cerr << logstring << std::endl;
    }
    return false;
  }
  return true;
}


GLhandleARB Shader::linkShaders(GLhandleARB* object, const unsigned int& nb)
{
  if(object==0)
    return 0;

  GLhandleARB po = 0;
  po = glCreateProgramObjectARB();

  for(unsigned int i = 0; i < nb; ++i){
    if(object[i]>0)
      glAttachObjectARB(po,object[i]);
  }
  
  glLinkProgramARB(po);

  int status;
  glGetObjectParameterivARB(po, GL_OBJECT_LINK_STATUS_ARB, &status);
  if(status==0){
    int length = 0;
    glGetObjectParameterivARB(po, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
    if(length>0){
      GLsizei minlength = min(MAX_LOG_STRING,length);
      glGetInfoLogARB(po, minlength, 0, logstring);
      std::cerr << logstring << std::endl;
    }
    return 0;
  }
  return po;
}
/*
void Shader::PrintSupportedExtensions()
{
	std::stringstream extensions = std::stringstream((char*)(glGetString(GL_EXTENSIONS)));
	std::cout << "Supported extensions :" << std::endl;
	while(!extensions.eof()) {
		std::string str("end");
		extensions >> str;
		std::cout << "- " << str << std::endl;
	}

}

bool Shader::isExtensionSupported(const std::string& ext)
{  
	std::string extensions = std::string((char*)(glGetString(GL_EXTENSIONS)));
	if(extensions.find(ext) != std::string::npos)
		return true;
	std::cerr << "WARNING : Extension \"" << ext << "\" is not supported" << std::endl;
	return false;
}
*/

bool Shader::Init()
{
	s_bInitialized = true;
	s_pCurrent = NULL;

	if(! glInfo::GetSingleton().isExtensionSupported("GL_ARB_shading_language_100") )
		s_bInitialized = false;

	return s_bInitialized;
}
	ShaderObject::ShaderObject()
	{
		Handle = glCreateProgramObjectARB();

		Compiled = false;
	}
Example #12
0
char GLSLBase::initializeShaders(std::string& log)
{
    log = "";
	GLint vertex_compiled, fragment_compiled;
	GLint linked;
		
// Delete any existing program object 
	if (program_object) {
		glDeleteObjectARB(program_object);
		program_object = NULL;
	}
		
	vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	const char* a = vertexProgramSource();
	glShaderSourceARB(vertex_shader, 1, &a, NULL);
	glCompileShaderARB(vertex_shader);
	glGetObjectParameterivARB(vertex_shader, GL_OBJECT_COMPILE_STATUS_ARB, &vertex_compiled);
	
	fragment_shader   = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
	const char* b = fragmentProgramSource();
	glShaderSourceARB(fragment_shader, 1, &b, NULL);
	glCompileShaderARB(fragment_shader);
	glGetObjectParameterivARB(fragment_shader, GL_OBJECT_COMPILE_STATUS_ARB, &fragment_compiled);
	
	if (!vertex_compiled || !fragment_compiled) {
		if (vertex_shader) {
			glDeleteObjectARB(vertex_shader);
			vertex_shader   = NULL;
			log += "\n Glsl error vertex shader not compiled \n";
		}
		if (fragment_shader) {
			glDeleteObjectARB(fragment_shader);
			fragment_shader = NULL;
			log += "\n Glsl error fragment shader not compiled \n";
		}
		return 0;
	}
	
	program_object = glCreateProgramObjectARB();
	if (vertex_shader != NULL)
	{
		glAttachObjectARB(program_object, vertex_shader);
		glDeleteObjectARB(vertex_shader);
	}
	if (fragment_shader != NULL)
	{
		glAttachObjectARB(program_object, fragment_shader);
		glDeleteObjectARB(fragment_shader);
	}
	glLinkProgramARB(program_object);
	glGetObjectParameterivARB(program_object, GL_OBJECT_LINK_STATUS_ARB, &linked);
		
	if (!linked) {
		glDeleteObjectARB(program_object);
		program_object = NULL;
		log += "\n Glsl error shaders not linked";
		return 0;
	}

	defaultShaderParameters();
	log += "\n Glsl shaders compiled";
	m_hasShaders = 1;
	return 1;
}
Example #13
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 (m_shaderProgram) {
                glCheck(glDeleteObjectARB(m_shaderProgram));
            }

            // Reset the internal state
            m_currentTexture = -1;
            m_textures.clear();
            m_params.clear();

            // Create the program
            m_shaderProgram = 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(m_shaderProgram));
                    m_shaderProgram = 0;
                    return false;
                }
                glCheck(glAttachObjectARB(m_shaderProgram, 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(m_shaderProgram));
                    m_shaderProgram = 0;
                    return false;
                }
                glCheck(glAttachObjectARB(m_shaderProgram, fragmentShader));
                glCheck(glDeleteObjectARB(fragmentShader));
            }
            // Link the program
            glCheck(glLinkProgramARB(m_shaderProgram));

            // Check the link log
            GLint success;
            glCheck(glGetObjectParameterivARB(m_shaderProgram, GL_OBJECT_LINK_STATUS_ARB, &success));
            if (success == GL_FALSE)
            {
                char log[1024];
                glCheck(glGetInfoLogARB(m_shaderProgram, sizeof(log), 0, log));
                err() << "Failed to link shader:" << std::endl
                      << log << std::endl;
                glCheck(glDeleteObjectARB(m_shaderProgram));
                m_shaderProgram = 0;
                return false;
            }
            // Force an OpenGL flush, so that the shader will appear updated
            // in all contexts immediately (solves problems in multi-threaded apps)
            glCheck(glFlush());

            return true;
        }
Example #14
0
shade::GLSLARBWrapper::Handle shade::GLSLARBWrapper::CreateProgram(void)
{
  return glCreateProgramObjectARB();
}
Example #15
0
void InitScene (void)
{
   GLint params[1];
   const char *tab[2];

   /*
    * GL should silently ignore calls that delete object 0.
    */
   begintest (TT_GETERROR_NOERROR, "glDeleteObject(0)");
   glDeleteObjectARB (0);
   endtest ();

   /*
    * GL generates an error on invalid object handle.
    */
   begintest (TT_GETERROR_INVALIDVALUE, "Pass invalid non-zero object handle");
   glDeleteObjectARB (find_invalid_handle ());
   endtest ();
   glUseProgramObjectARB (find_invalid_handle ());
   endtest ();

   /*
    * Create object. GL should return unique non-zero values.
    */
   begintest (TT_PARAM1_NONZERO, "Create object");
   vert = glCreateShaderObjectARB (GL_VERTEX_SHADER_ARB);
   endtest1 (vert);
   frag = glCreateShaderObjectARB (GL_FRAGMENT_SHADER_ARB);
   endtest1 (frag);
   prog = glCreateProgramObjectARB ();
   endtest1 (prog);
   endtest1 (vert != frag && frag != prog && prog != vert);

   /*
    * Link empty program.
    */
   begintest (TT_PARAM1_NONZERO, "Link empty program");
   glLinkProgramARB (prog);
   endtest1 (CheckObjectStatus (prog));

   /*
    * Use empty program object. Empty program objects are valid.
    */
   begintest (TT_GETERROR_NOERROR, "Use empty program object");
   glUseProgramObjectARB (prog);
   endtest ();

   /*
    * Attach invalid object handles. Program object 0 should not be accepted.
    */
   begintest (TT_GETERROR_INVALIDVALUE, "Attach invalid object handle");
   glAttachObjectARB (0, find_invalid_handle ());
   endtest ();
   glAttachObjectARB (0, frag);
   endtest ();
   glAttachObjectARB (find_invalid_handle (), find_invalid_handle ());
   endtest ();
   glAttachObjectARB (find_invalid_handle (), frag);
   endtest ();
   glAttachObjectARB (prog, find_invalid_handle ());
   endtest ();

   /*
    * Attach valid object handles with wrong semantics.
    */
   begintest (TT_GETERROR_INVALIDOPERATION, "Attach object badly");
   glAttachObjectARB (vert, frag);
   endtest ();
   glAttachObjectARB (vert, prog);
   endtest ();
   glAttachObjectARB (prog, prog);
   endtest ();

   /*
    * Detach non-attached object.
    */
   begintest (TT_GETERROR_INVALIDOPERATION, "Detach non-attached object");
   glDetachObjectARB (prog, vert);
   endtest ();
   glDetachObjectARB (prog, frag);
   endtest ();

   /*
    * Attach shader.
    */
   begintest (TT_GETERROR_NOERROR, "Attach shader to program object");
   glAttachObjectARB (prog, vert);
   endtest ();
   glAttachObjectARB (prog, frag);
   endtest ();

   /*
    * Attach object twice.
    */
   begintest (TT_GETERROR_INVALIDOPERATION, "Attach object twice");
   glAttachObjectARB (prog, vert);
   endtest ();
   glAttachObjectARB (prog, frag);
   endtest ();

   /*
    * Detach attached object.
    */
   begintest (TT_GETERROR_NOERROR, "Detach attached object");
   glDetachObjectARB (prog, vert);
   endtest ();
   glDetachObjectARB (prog, frag);
   endtest ();

   /*
    * Attach shader again.
    */
   begintest (TT_GETERROR_NOERROR, "Attach shader again");
   glAttachObjectARB (prog, vert);
   endtest ();
   glAttachObjectARB (prog, frag);
   endtest ();

   /*
    * Delete attached object.
    */
   begintest (TT_GETERROR_NOERROR, "Delete attached object");
   glDeleteObjectARB (vert);
   endtest ();
   glDeleteObjectARB (frag);
   endtest ();

   /*
    * Query delete status. It should return TRUE. Object handles are still valid
    * as they are referenced by program object container.
    */
   begintest (TT_PARAM1_NONZERO, "Query delete status");
   glGetObjectParameterivARB (vert, GL_OBJECT_DELETE_STATUS_ARB, params);
   endtest1 (params[0]);
   glGetObjectParameterivARB (frag, GL_OBJECT_DELETE_STATUS_ARB, params);
   endtest1 (params[0]);

   /*
    * Delete already deleted attached object. The behaviour is undefined, but we
    * check for no errors. The object still exists, so the handle value is okay.
    * In other words, these calls should be silently ignored by GL.
    */
   begintest (TT_GETERROR_NOERROR, "Delete already deleted attached object");
   glDeleteObjectARB (vert);
   endtest ();
   glDeleteObjectARB (frag);
   endtest ();

   /*
    * Compile shader source with syntax error.
    */
   begintest (TT_PARAM1_ZERO, "Compile shader source with syntax error");
   glShaderSourceARB (vert, 1, &invsynvertsrc, NULL);
   glCompileShaderARB (vert);
   endtest1 (CheckObjectStatus (vert));
   glShaderSourceARB (frag, 1, &invsynfragsrc, NULL);
   glCompileShaderARB (frag);
   endtest1 (CheckObjectStatus (frag));

   /*
    * Compile shader source with semantic error.
    */
   begintest (TT_PARAM1_ZERO, "Compile shader source with semantic error");
   glShaderSourceARB (vert, 1, &invsemvertsrc, NULL);
   glCompileShaderARB (vert);
   endtest1 (CheckObjectStatus (vert));
   glShaderSourceARB (frag, 1, &invsemfragsrc, NULL);
   glCompileShaderARB (frag);
   endtest1 (CheckObjectStatus (frag));

   /*
    * Link ill-formed vertex-fragment program.
    */
   begintest (TT_PARAM1_ZERO, "Link ill-formed vertex-fragment program");
   glLinkProgramARB (prog);
   endtest1 (CheckObjectStatus (prog));

   /*
    * Use badly linked program object.
    */
   begintest (TT_GETERROR_INVALIDOPERATION, "Use badly linked program object");
   glUseProgramObjectARB (prog);
   endtest ();

   /*
    * Compile well-formed shader source. Check if multi-string sources can be handled.
    */
   begintest (TT_PARAM1_NONZERO, "Compile well-formed shader source");
   tab[0] = uniforms;
   tab[1] = validvertsrc;
   glShaderSourceARB (vert, 2, tab, NULL);
   glCompileShaderARB (vert);
   endtest1 (CheckObjectStatus (vert));
   tab[0] = uniforms;
   tab[1] = validfragsrc;
   glShaderSourceARB (frag, 2, tab, NULL);
   glCompileShaderARB (frag);
   endtest1 (CheckObjectStatus (frag));

   /*
    * Link vertex-fragment program.
    */
   begintest (TT_PARAM1_NONZERO, "Link vertex-fragment program");
   glLinkProgramARB (prog);
   endtest1 (CheckObjectStatus (prog));

   /*
    * Use valid linked program object.
    */
   begintest (TT_GETERROR_NOERROR, "Use linked program object");
   glUseProgramObjectARB (prog);
   endtest ();

   /*
    * Get current program.
    */
   begintest (TT_PARAM1_NONZERO, "Get current program");
   endtest1 (glGetHandleARB (GL_PROGRAM_OBJECT_ARB) == prog);

   /*
    * Use 0 program object.
    */
   begintest (TT_GETERROR_NOERROR, "Use 0 program object");
   glUseProgramObjectARB (0);
   endtest ();

   /*
    * Query uniform location. Uniforms with gl_ prefix cannot be queried.
    */
   begintest (TT_PARAM1_NONZERO, "Query uniform location");
   endtest1 (glGetUniformLocationARB (prog, "gl_ModelViewMatrix") == -1);
   endtest1 (glGetUniformLocationARB (prog, "UniformThatDoesNotExist") == -1);
   endtest1 (glGetUniformLocationARB (prog, "") == -1);
   endtest1 (glGetUniformLocationARB (prog, "CommonUniform") != -1);
   endtest1 (glGetUniformLocationARB (prog, "VertexUniform") != -1);
   endtest1 (glGetUniformLocationARB (prog, "FragmentUniform") != -1);

   /*
    * Query attrib location. Attribs with gl_ prefix cannot be queried.
    * When gl_Vertex is used, none of the generic attribs can have index 0.
    */
   begintest (TT_PARAM1_NONZERO, "Query attrib location");
   endtest1 (glGetAttribLocationARB (prog, "gl_Vertex") == -1);
   endtest1 (glGetAttribLocationARB (prog, "AttribThatDoesNotExist") == -1);
   endtest1 (glGetAttribLocationARB (prog, "") == -1);
   endtest1 (glGetAttribLocationARB (prog, "FirstAttrib") > 0);
   endtest1 (glGetAttribLocationARB (prog, "SecondAttrib") > 0);

   /*
    * Bind attrib locations, link and check if locations are correct.
    */
   begintest (TT_PARAM1_NONZERO, "Bind attrib location #1");
   glBindAttribLocationARB (prog, 1, "FirstAttrib");
   glBindAttribLocationARB (prog, 2, "SecondAttrib");
   glLinkProgramARB (prog);
   endtest1 (CheckObjectStatus (prog));
   endtest1 (glGetAttribLocationARB (prog, "FirstAttrib") == 1);
   endtest1 (glGetAttribLocationARB (prog, "SecondAttrib") == 2);

   /*
    * Bind attrib locations in different order. Link and check if locations are correct.
    */
   begintest (TT_PARAM1_NONZERO, "Bind attrib location #2");
   glBindAttribLocationARB (prog, 1, "SecondAttrib");
   glBindAttribLocationARB (prog, 2, "FirstAttrib");
   glLinkProgramARB (prog);
   endtest1 (CheckObjectStatus (prog));
   endtest1 (glGetAttribLocationARB (prog, "SecondAttrib") == 1);
   endtest1 (glGetAttribLocationARB (prog, "FirstAttrib") == 2);

   /*
    * Detach deleted object.
    */
   begintest (TT_GETERROR_NOERROR, "Detach deleted object");
   glDetachObjectARB (prog, vert);
   endtest ();
   glDetachObjectARB (prog, frag);
   endtest ();

   /*
    * Delete deleted detached object.
    */
   begintest (TT_GETERROR_INVALIDVALUE, "Delete deleted detached object");
   glDeleteObjectARB (vert);
   endtest ();
   glDeleteObjectARB (frag);
   endtest ();

   exit (0);
}
Example #16
0
 GLuint CreateProgram() {
   if(arb) { return glCreateProgramObjectARB(); }
   else    { return glCreateProgram(); }
 }
Example #17
0
//---------------------------------------------------------------
void ofxShader::loadShader(string fragmentName, string vertexName){
	
	fragmentName = ofToDataPath(fragmentName);
	vertexName = ofToDataPath(vertexName);

	
	bLoaded = false;	
	
	if (GLEE_ARB_shader_objects){
		
		// ---------------------------------- (a) load in the shaders
		char *vs = NULL,*fs = NULL;
		vs = LoadShaderText(vertexName.c_str());
		fs = LoadShaderText(fragmentName.c_str());
		
		vertexShader = (GLhandleARB)glCreateShader(GL_VERTEX_SHADER);
		fragmentShader = (GLhandleARB)glCreateShader(GL_FRAGMENT_SHADER);
		
		if( vs == NULL || fs == NULL ){
			assert(NULL);
			printf("unable to load %s \n", vertexName.c_str());
			return;
		}
		
		GLint length = strlen(vs);
		glShaderSourceARB(vertexShader, 1, (const char**)&vs, &length);
		length = strlen(fs);
		glShaderSourceARB(fragmentShader, 1, (const char**)&fs, &length);
		
		char infobuffer[1000];
		GLsizei infobufferlen = 0;
		
		// ----------------------------------- (b) compile the shaders
		// try to compile "vertex shader"
		glCompileShaderARB(vertexShader);
		
		
		//please add compile status check in:
		GLint compileStatus = 0;
		glGetObjectParameterivARB( vertexShader, GL_COMPILE_STATUS, &compileStatus );
		printf("vertexShader status = %i \n", compileStatus);
		
		
		glGetInfoLogARB(vertexShader, 999, &infobufferlen, infobuffer);
		if (infobufferlen != 0){
			infobuffer[infobufferlen] = 0;
			printf("vertexShader reports: %s \n", infobuffer);
			return;
		}
		
		// ------------------------------------
		// try to compile "fragment shader"
		glCompileShaderARB(fragmentShader);
		

		glGetObjectParameterivARB( fragmentShader, GL_COMPILE_STATUS, &compileStatus );
		printf("fragmentShader status %i \n", compileStatus);
		
		
		glGetInfoLogARB(fragmentShader, 999, &infobufferlen, infobuffer);
		if (infobufferlen != 0){
			infobuffer[infobufferlen] = 0;
			printf("fragmentShader reports: %s \n", infobuffer);
			return;
		}
		
		// ----------------------------------- (c) link the shaders
		shader = glCreateProgramObjectARB();
		glAttachObjectARB(shader,vertexShader);
		glAttachObjectARB(shader,fragmentShader);
		glLinkProgramARB(shader);
		
		
		bLoaded = true;
			
	} else {
	
		printf("sorry, it looks like you can't run 'ARB_shader_objects' \n please check the capabilites of your graphics card (http://www.ozone3d.net/gpu_caps_viewer/) \n");
	
	}


}
int initShaderWithFile(std::string vertname, std::string fragname) {
    
    GLhandleARB my_program, my_vertex_shader,my_fragment_shader;
    int Vcompiled,Fcompiled,FShaderLength,VShaderLength;
    std::string fname,vname,my_fragment_shader_source, my_vertex_shader_source,lErrors;
    // Create Shader And Program Objects
    int result = 0;
    Vcompiled = 0;
    Fcompiled = 0;
    fname = fragname;
    vname = vertname;
    if (!fileexists(fname)){
        fname = extractfilepath(fname);
        vname = vertname;
    }
    if (!fileexists(vname)){
        vname = extractfilepath(vname);
    }
    if ((!(fileexists(fname))) || (!(fileexists(vname)))) {
        std::cout << "Unable to find GLSL shaders " << fname << " " << vname << std::endl;
    }
    
    //    char** tmpArray = new char*[1];
    //    tmpArray[0] = (char*)my_fragment_shader_source.c_str();
    //    char** tmpArray2 = new char*[1];
    //    tmpArray2[0] = (char*)my_vertex_shader_source.c_str();
    //    
    //    loadshader((char*)fname.c_str(), (GLchar**)tmpArray);
    //    loadshader((char*)vname.c_str(), (GLchar**)tmpArray2);
    
    //loadshader((char*)fname.c_str(), (GLchar**)my_fragment_shader_source.c_str());
    //loadshader((char*)vname.c_str(), (GLchar**)my_vertex_shader_source.c_str());
    my_fragment_shader_source = LoadStr( fname);
    my_vertex_shader_source = LoadStr( vname);
    my_program = glCreateProgramObjectARB();
    my_vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    my_fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
    // Load Shader Sources
    FShaderLength = (int)my_fragment_shader_source.length();
    VShaderLength = (int)my_vertex_shader_source.length();
    const char * tmp1 = (const char *)my_vertex_shader_source.c_str();
    const char * tmp2 = (const char *)my_fragment_shader_source.c_str();
    
    glShaderSourceARB(my_vertex_shader, 1, &tmp1, NULL);
    glShaderSourceARB(my_fragment_shader, 1, &tmp2, NULL);
    // Compile The Shaders
    glCompileShaderARB(my_vertex_shader);
    glGetObjectParameterivARB(my_vertex_shader,GL_OBJECT_COMPILE_STATUS_ARB, &Vcompiled);
    glCompileShaderARB(my_fragment_shader);
    glGetObjectParameterivARB(my_fragment_shader,GL_OBJECT_COMPILE_STATUS_ARB, &Fcompiled);
    // Attach The Shader Objects To The Program Object
    glAttachObjectARB(my_program, my_vertex_shader);
    glAttachObjectARB(my_program, my_fragment_shader);
    // Link The Program Object
    glLinkProgramARB(my_program);
    if ((Vcompiled!=1) || (Fcompiled!=1)){
        //        lErrors := CheckForErrors(my_program);
        //        if lErrors <> '' then
        //            showDebug('GLSL shader error '+lErrors);
        //        end;
        //        result := my_program ;
        std::cout << "shader has errors!" << std::endl;
    }
    
    //result = my_program
    int i = 0;
    memcpy(&i, &my_program, sizeof(my_program));
    result = i;
    
    if (result == 0){
        std::cout << "Unable to load or compile shader" << std::endl;
    }
    
    return result;
}
/***************************************************************************
 setShader
 ****************************************************************************/
void setShader(){
    GLhandleARB my_program;
    GLhandleARB my_vertex_shader;
    GLhandleARB my_fragment_shader;
    GLsizei* elength = E_MALLOC(sizeof(GLint));
    GLchar* infolog = E_MALLOC(5000*sizeof(GLchar));
    
    // Create Shader And Program Objects
    my_program = glCreateProgramObjectARB();
    my_vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    my_fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
    
    // Load Shader Sources
    GLcharARB* vertsrc;
    GLcharARB* fragsrc;
    switch(shademode){
        case GOOCH_SHADER:
            vertsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/gooch.vert");
            fragsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/gooch.frag");
            break;
        case PHONG_SHADER:
            vertsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/phong-use-diffuse.vert");
            fragsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/phong-use-diffuse.frag");
            break;
        case LATTICE_SHADER:
            vertsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/CH11-lattice.vert.txt");
            fragsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/CH11-lattice.frag.txt");
            break;
        case PPL2_SHADER:
            vertsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/per-pixel-lighting.vert");
            fragsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/per-pixel-lighting.frag");
            break;
        case TEST_SHADER:
            vertsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/CH14-chromaticAb.vert.txt");
            fragsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/CH14-chromaticAb.frag.txt");
            break;
    }
    
    glShaderSourceARB(my_vertex_shader, 1, &vertsrc, NULL);
    glShaderSourceARB(my_fragment_shader, 1, &fragsrc, NULL);
    
    
    // Compile The Shaders
    glCompileShaderARB(my_vertex_shader);
    
    GLint blen = 0;	
    GLint slen = 0;
    GLchar* compiler_log;
    
    glGetObjectParameterivARB(my_vertex_shader, GL_OBJECT_INFO_LOG_LENGTH_ARB , &blen);
    if (blen > 1)
    {
        if ((compiler_log = (GLcharARB*)E_MALLOC(blen)) == NULL) 
        {
            printf("OOM\n");
        }
        glGetInfoLogARB(my_vertex_shader, blen, &slen, compiler_log);
        if (compiler_log!=0) {
            printf("compiler_log: %s\n", compiler_log); 
            free(compiler_log);
        }
    }
    
    
    glCompileShaderARB(my_fragment_shader);
    
    glGetObjectParameterivARB(my_fragment_shader, GL_OBJECT_INFO_LOG_LENGTH_ARB , &blen);
    if (blen > 1)
    {
        if ((compiler_log = (GLcharARB*)E_MALLOC(blen)) == NULL) 
        {
            printf("OOM\n");
        }
        glGetInfoLogARB(my_fragment_shader, blen, &slen, compiler_log);
        if (compiler_log!=0) {
            printf("compiler_log: %s\n", compiler_log); 
            free(compiler_log);
        }
    }
    
    
    // Attach The Shader Objects To The Program Object
    glAttachObjectARB(my_program, my_vertex_shader);
    glAttachObjectARB(my_program, my_fragment_shader);
    
    glGetObjectParameterivARB(my_program, GL_OBJECT_INFO_LOG_LENGTH_ARB , elength);
    if (elength > 0){
        glGetInfoLogARB(my_program, 500, elength, infolog);
        printf("%s\n", infolog);
    }
    
    
    // Link The Program Object
    glLinkProgramARB(my_program);
	
    glGetObjectParameterivARB(my_program, GL_OBJECT_INFO_LOG_LENGTH_ARB , elength);
    if (elength > 0){
        glGetInfoLogARB(my_program, 500, elength, infolog);
        printf("%s\n", infolog);
    }
    
    
    glValidateProgramARB(my_program);
    if(GL_VALIDATE_STATUS){
        // Use The Program Object Instead Of Fixed Function OpenGL
        glUseProgramObjectARB(my_program);
        
        if(shademode == GOOCH_SHADER){
			// set gooch shader parameters
            GLint loc;
            GLfloat vs[]={0.75, 0.75, 0.75};
            loc = glGetUniformLocationARB(my_program, "SurfaceColor");
            glUniform3fv(loc, 1, vs);
            GLfloat vw[]={0.6, 0.6, 0.0};
            loc = glGetUniformLocationARB(my_program, "WarmColor");
            glUniform3fv(loc, 1, vw);
            GLfloat vc[]={0.0, 0.0, 0.6};
            loc = glGetUniformLocationARB(my_program, "CoolColor");
            glUniform3fv(loc, 1, vc);
            loc = glGetUniformLocationARB(my_program, "DiffuseWarm");
            glUniform1f(loc, 0.45);
            loc = glGetUniformLocationARB(my_program, "DiffuseCool");
            glUniform1f(loc, 0.40);
        }
        if(shademode == LATTICE_SHADER){
            // set gooch shader parameters
            GLint loc;
            GLfloat vs[]={10.00, 100.0, 0.0};
            loc = glGetUniformLocationARB(my_program, "LightPosition");
            glUniform3fv(loc, 1, vs);
            GLfloat vw[]={0.6, 0.6, 0.0};
            loc = glGetUniformLocationARB(my_program, "LightColor");
            glUniform3fv(loc, 1, vw);
            GLfloat vc[]={0.0, 0.0, 100.0};
            loc = glGetUniformLocationARB(my_program, "EyePosition");
            glUniform3fv(loc, 1, vc);
            GLfloat vd[]={0.5, 0.5, 0.5};
            loc = glGetUniformLocationARB(my_program, "Specular");
            glUniform3fv(loc, 1, vd);
            GLfloat ve[]={1.0, 1.0, 1.0};
            loc = glGetUniformLocationARB(my_program, "Ambient");
            glUniform3fv(loc, 1, ve);
            loc = glGetUniformLocationARB(my_program, "Kd");
            glUniform1f(loc, 0.40);
            GLfloat vf[]={20.0, 20.0};
            loc = glGetUniformLocationARB(my_program, "Scale");
            glUniform2fv(loc, 1, vf);
            GLfloat vg[]={0.3, 0.3};
            loc = glGetUniformLocationARB(my_program, "Threshold");
            glUniform2fv(loc, 1, vg);
            GLfloat vh[]={0.5, 0.5, 0.5};
            loc = glGetUniformLocationARB(my_program, "SurfaceColor");
            glUniform3fv(loc, 1, vh);
        }
        
    }
    
    glGetObjectParameterivARB(my_program, GL_OBJECT_INFO_LOG_LENGTH_ARB , elength);
    if (elength > 0){
        glGetInfoLogARB(my_program, 500, elength, infolog);
        printf("%s\n", infolog);
    }
}
Example #20
0
bool Shader::CompileProgram()
{
    // 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;
    }

    // Make sure that GLEW is initialized (extra safety -- it is already done in IsAvailable())
    priv::EnsureGlewInit();

    // 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;
}
bool BL_Shader::LinkProgram()
{
	int vertlen = 0, fraglen=0, proglen=0;
	int vertstatus=0, fragstatus=0, progstatus=0;
	unsigned int tmpVert=0, tmpFrag=0, tmpProg=0;
	int char_len=0;
	char *logInf =0;

	if (mError)
		goto programError;

	if (!vertProg || !fragProg) {
		spit("Invalid GLSL sources");
		return false;
	}
	if ( !GLEW_ARB_fragment_shader) {
		spit("Fragment shaders not supported");
		return false;
	}
	if ( !GLEW_ARB_vertex_shader) {
		spit("Vertex shaders not supported");
		return false;
	}
	
	// -- vertex shader ------------------
	tmpVert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	glShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
	glCompileShaderARB(tmpVert);
	glGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB,(GLint*) &vertlen);
	
	// print info if any
	if ( vertlen > 0 && vertlen < MAX_LOG_LEN) {
		logInf = (char*)MEM_mallocN(vertlen, "vert-log");
		glGetInfoLogARB(tmpVert, vertlen, (GLsizei*)&char_len, logInf);
		if (char_len >0) {
			spit("---- Vertex Shader Error ----");
			spit(logInf);
		}
		MEM_freeN(logInf);
		logInf=0;
	}
	// check for compile errors
	glGetObjectParameterivARB(tmpVert, GL_OBJECT_COMPILE_STATUS_ARB,(GLint*)&vertstatus);
	if (!vertstatus) {
		spit("---- Vertex shader failed to compile ----");
		goto programError;
	}

	// -- fragment shader ----------------
	tmpFrag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
	glShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
	glCompileShaderARB(tmpFrag);
	glGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &fraglen);
	if (fraglen >0 && fraglen < MAX_LOG_LEN) {
		logInf = (char*)MEM_mallocN(fraglen, "frag-log");
		glGetInfoLogARB(tmpFrag, fraglen,(GLsizei*) &char_len, logInf);
		if (char_len >0) {
			spit("---- Fragment Shader Error ----");
			spit(logInf);
		}
		MEM_freeN(logInf);
		logInf=0;
	}

	glGetObjectParameterivARB(tmpFrag, GL_OBJECT_COMPILE_STATUS_ARB, (GLint*) &fragstatus);
	if (!fragstatus) {
		spit("---- Fragment shader failed to compile ----");
		goto programError;
	}

	
	// -- program ------------------------
	//  set compiled vert/frag shader & link
	tmpProg = glCreateProgramObjectARB();
	glAttachObjectARB(tmpProg, tmpVert);
	glAttachObjectARB(tmpProg, tmpFrag);
	glLinkProgramARB(tmpProg);
	glGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &proglen);
	glGetObjectParameterivARB(tmpProg, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &progstatus);
	

	if (proglen > 0 && proglen < MAX_LOG_LEN) {
		logInf = (char*)MEM_mallocN(proglen, "prog-log");
		glGetInfoLogARB(tmpProg, proglen, (GLsizei*)&char_len, logInf);
		if (char_len >0) {
			spit("---- GLSL Program ----");
			spit(logInf);
		}
		MEM_freeN(logInf);
		logInf=0;
	}

	if (!progstatus) {
		spit("---- GLSL program failed to link ----");
		goto programError;
	}

	// set
	mShader = tmpProg;
	glDeleteObjectARB(tmpVert);
	glDeleteObjectARB(tmpFrag);
	mOk		= 1;
	mError = 0;
	return true;

programError:
	if (tmpVert) {
		glDeleteObjectARB(tmpVert);
		tmpVert=0;
	}
	if (tmpFrag) {
		glDeleteObjectARB(tmpFrag);
		tmpFrag=0;
	}

	if (tmpProg) {
		glDeleteObjectARB(tmpProg);
		tmpProg=0;
	}

	mOk		= 0;
	mUse	= 0;
	mError	= 1;
	return false;
}
Example #22
0
void GlslProgram::test(){
	GLhandleARB program1        = 0;         // program handles
	program1 = glCreateProgramObjectARB();
	checkGlError();
}
Example #23
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;
}
WShaderProgram::WShaderProgram()
{
	progId = glCreateProgramObjectARB();
}
Example #25
0
static void R_BuildGammaProgram(void)
{
	GLint compiled;

	gammaProgram.vertexShader   = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	gammaProgram.fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

	glShaderSourceARB(gammaProgram.vertexShader, 1, (const GLcharARB **)&simpleGammaVert, NULL);
	glShaderSourceARB(gammaProgram.fragmentShader, 1, (const GLcharARB **)&simpleGammaFrag, NULL);

	glCompileShaderARB(gammaProgram.vertexShader);
	glCompileShaderARB(gammaProgram.fragmentShader);

	glGetObjectParameterivARB(gammaProgram.vertexShader, GL_COMPILE_STATUS, &compiled);
	if (!compiled)
	{
		GLint   blen = 0;
		GLsizei slen = 0;

		glGetShaderiv(gammaProgram.vertexShader, GL_INFO_LOG_LENGTH, &blen);
		if (blen > 1)
		{
			GLchar *compiler_log;

			compiler_log = (GLchar *) malloc(blen);

			glGetInfoLogARB(gammaProgram.vertexShader, blen, &slen, compiler_log);
			Ren_Fatal("Failed to compile the gamma vertex shader reason: %s\n", compiler_log);
		}
		else
		{
			Ren_Fatal("Failed to compile the gamma vertex shader\n");
		}
	}

	glGetObjectParameterivARB(gammaProgram.fragmentShader, GL_COMPILE_STATUS, &compiled);
	if (!compiled)
	{
		Ren_Fatal("Failed to compile the gamma fragment shader\n");
	}

	gammaProgram.program = glCreateProgramObjectARB();
	if (!gammaProgram.program)
	{
		Ren_Fatal("Failed to create program\n");
	}

	glAttachObjectARB(gammaProgram.program, gammaProgram.vertexShader);
	glAttachObjectARB(gammaProgram.program, gammaProgram.fragmentShader);

	glLinkProgramARB(gammaProgram.program);

	glGetProgramivARB(gammaProgram.program, GL_LINK_STATUS, &compiled); // this throws glGetError() = 0x500
	if (!compiled)
	{
		Ren_Fatal("Failed to link gamma shaders\n");
	}

	glUseProgramObjectARB(gammaProgram.program);

	gammaProgram.currentMapUniform = glGetUniformLocation(gammaProgram.program, "u_CurrentMap");
	gammaProgram.gammaUniform      = glGetUniformLocation(gammaProgram.program, "u_gamma");

	glUseProgramObjectARB(0);
}
Example #26
0
///	This function loads a vertex and fragment shader file
void GLSLShader::InitShaders()
{
    // Make sure the user passed in at least a vertex and fragment shader file
    if(!GetVertexShaderFileName().length() || !GetFragmentShaderFileName().length())
    {
        std::cerr << "GLSLShader requires setting a VertexShader and a FragmentShader" << std::endl;
        return;
    }

    // If any of our shader pointers are set, let's free them first.
    if(!m_hShaders.empty() || m_hProgramObject)
        Release();

    bool ready = true;

    // Now we load and compile the shaders from their respective files
    for (std::map<GLint,std::string>::const_iterator it = m_hFileNames.begin(), itend = m_hFileNames.end(); it != itend; ++it)
    {
        ready &= CompileShader( it->first, it->second, header );
    }

    if (!ready)
    {
        std::cerr << "SHADER compilation failed.\n";
        return;
    }

    // Next we create a program object to represent our shaders
    m_hProgramObject = glCreateProgramObjectARB();

    // We attach each shader we just loaded to our program object
    for (std::map<GLint,GLhandleARB>::const_iterator it = m_hShaders.begin(), itend = m_hShaders.end(); it != itend; ++it)
    {
        glAttachObjectARB(m_hProgramObject, it->second);
    }

#if defined(GL_EXT_geometry_shader4) && defined(SOFA_HAVE_GLEW)
    if (GetGeometryShaderID())
    {
        if (geometry_input_type != -1) glProgramParameteriEXT(m_hProgramObject, GL_GEOMETRY_INPUT_TYPE_EXT, geometry_input_type );
        if (geometry_output_type != -1) glProgramParameteriEXT(m_hProgramObject, GL_GEOMETRY_OUTPUT_TYPE_EXT, geometry_output_type );
        if (geometry_vertices_out != -1) glProgramParameteriEXT(m_hProgramObject, GL_GEOMETRY_VERTICES_OUT_EXT, geometry_vertices_out );
    }
#endif

    // Our last init function is to link our program object with OpenGL
    glLinkProgramARB(m_hProgramObject);

    GLint linked = 0, length = 0, laux = 0;
    glGetObjectParameterivARB(m_hProgramObject, GL_OBJECT_LINK_STATUS_ARB, &linked);
    if (!linked) std::cerr << "ERROR: Link of program shader failed:\n"<<std::endl;
//     else std::cout << "Link of program shader OK" << std::endl;
    glGetObjectParameterivARB(m_hProgramObject, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
    if (length > 1)
    {
        GLcharARB *logString = (GLcharARB *)malloc((length+1) * sizeof(GLcharARB));
        glGetInfoLogARB(m_hProgramObject, length, &laux, logString);
        std::cerr << logString << std::endl;
        free(logString);
        for (std::map<GLint,std::string>::const_iterator it = m_hFileNames.begin(), itend = m_hFileNames.end(); it != itend; ++it)
            std::cerr << GetShaderStageName(it->first) << " shader file: " << it->second << std::endl;
    }

    // Now, let's turn off the shader initially.
    glUseProgramObjectARB(0);
}
Example #27
0
void moShaderGLSL::CreateFragShader(moText frag_source)
{
    m_ProgramObject = glCreateProgramObjectARB();
    compileFragShader(frag_source);
    linkProgram();
}
Example #28
0
		/*
		*vertexShaderSrc   contains the memory representation of the vertex shader
		*fragmentShaderSrc contains the memory representation of the fragment shader
		*/
		void CShader::loadShadersVF()
		{

			GLint compiled;
			GLint blen = 0;
			GLsizei slen = 0;
			
			
			vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
			glShaderSourceARB(vertexShader,1,(const char **)(&vertexSrcProgram),NULL);
			
			//COMPILATION OF SHADERS
			glCompileShaderARB(vertexShader);
			glGetShaderiv(vertexShader,GL_COMPILE_STATUS,&compiled);
			if(compiled == GL_FALSE)
			{
				std::cout<<"Vertex shader compiled Unsuccesfully"<<std::endl;
				glGetShaderiv(vertexShader,GL_INFO_LOG_LENGTH,&blen);
				if(blen > 1)
				{
					GLchar* compiler_log = new GLchar[blen];
					glGetInfoLogARB(vertexShader,blen,&slen,compiler_log);
					std::cout<<"Compiler log: "<<compiler_log<<std::endl;
					delete compiler_log;
				}
				glDeleteShader(vertexShader);
				glDeleteShader(fragmentShader);
				return;
			}
			
			std::cout<<"Vertex shader compiled succesfully"<<std::endl;
			fragmentShader  = glCreateShaderObjectARB(GL_FRAGMENT_SHADER);
			glShaderSourceARB(fragmentShader,1 ,(const char **)(&fragmentSrcProgram),NULL);
			glCompileShaderARB(fragmentShader);
			glGetShaderiv(fragmentShader,GL_COMPILE_STATUS,&compiled);
			if(compiled == GL_FALSE)
			{
				std::cout<<"Fragment shader compiled Unsuccesfully"<<std::endl;
				glGetShaderiv(fragmentShader,GL_INFO_LOG_LENGTH,&blen);
				if(blen > 1)
				{
					GLchar* compiler_log = new GLchar[blen];
					glGetInfoLogARB(fragmentShader,blen,&slen,compiler_log);
					std::cout<<"Compiler log: "<<compiler_log<<std::endl;
					delete compiler_log;
				}
				glDeleteShader(vertexShader);
				glDeleteShader(fragmentShader);
				return;
			}
			std::cout<<"FragmentShader Conpiled Successfully"<<std::endl;
			
			//if everything compiled well, link the program
			shaderProgram = glCreateProgramObjectARB();
			glAttachShader(shaderProgram, vertexShader);
			glAttachShader(shaderProgram,fragmentShader);

			//binding of attributes should be done here
			glLinkProgram(shaderProgram);
			//we do not need these any more
			glDeleteShader(vertexShader);
			glDeleteShader(fragmentShader);
			
			
			
		}
Example #29
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 (m_shaderProgram)
        glCheck(glDeleteObjectARB(m_shaderProgram));

    // Create the program
    m_shaderProgram = 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(m_shaderProgram));
            m_shaderProgram = 0;
            return false;
        }

        // Attach the shader to the program, and delete it (not needed anymore)
        glCheck(glAttachObjectARB(m_shaderProgram, 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(m_shaderProgram));
            m_shaderProgram = 0;
            return false;
        }

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

    // Link the program
    glCheck(glLinkProgramARB(m_shaderProgram));

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

    return true;
}
bool
ShaderModeData::BeginSphereTexturing()
{
    if(!ModeAvailable())
        return false;

    if(!GLSL_shaders_setup)
    {
        GLsizei loglen = 0;
#define MAX_LOG_SIZE 2000
        char *log = new char[MAX_LOG_SIZE];
        memset(log, 0, MAX_LOG_SIZE);

        GLint maxvarying = 0;
        glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &maxvarying);
        debug1 << "Maximum # of varying floats:" << maxvarying << endl;

        // Create the shader program handle.
        p = glCreateProgramObjectARB();

        // Create the vertex program and link it to the program.
        v = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
        if(GLSL_set_depth)
            glShaderSourceARB(v, 1, &GLSL_spheredepth_vertex_program_source, NULL);
        else
            glShaderSourceARB(v, 1, &GLSL_sphere_vertex_program_source, NULL);
        glCompileShaderARB(v);
        GLint vc = 0;
        glGetObjectParameterivARB(v, GL_OBJECT_COMPILE_STATUS_ARB, &vc);
        debug1 << "Vertex program "
               << ((vc==1)?" compiled":" did not compile")
               << endl;
        glAttachObjectARB(p, v);
        memset(log, 0, MAX_LOG_SIZE);
        glGetInfoLogARB(v, MAX_LOG_SIZE, &loglen, log);
        debug1 << "Vertex log:\n" << log << endl;
    
        // Create the fragment program and link it to the program.
        f = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
        if(GLSL_set_depth)
            glShaderSourceARB(f, 1, &GLSL_spheredepth_fragment_program_source, NULL);
        else
            glShaderSourceARB(f, 1, &GLSL_sphere_fragment_program_source, NULL);
        glCompileShaderARB(f);
        GLint fc = 0;
        glGetObjectParameterivARB(f, GL_OBJECT_COMPILE_STATUS_ARB, &fc);
        debug1 << "Fragment program "
               << ((fc==1)?" compiled":" did not compile")
               << endl;
        glAttachObjectARB(p, f);
        memset(log, 0, MAX_LOG_SIZE);
        glGetInfoLogARB(f, MAX_LOG_SIZE, &loglen, log);
        debug1 << "Fragment log:\n" << log << endl;

        glLinkProgramARB(p);
 
        GLint pls = 0;
        glGetObjectParameterivARB(p, GL_OBJECT_LINK_STATUS_ARB, &pls);
        debug1 << "Program "
               << ((pls==1)?" linked":" did not link")
               << endl;

        memset(log, 0, MAX_LOG_SIZE);
        glGetInfoLogARB(p, MAX_LOG_SIZE, &loglen, log);
        debug1 << "Program log:\n" << log << endl;
        delete [] log;

        GLSL_shaders_setup = true;

        if(vc == 0 || fc == 0 || pls == 0)
        {
            debug1 << "One or more of the required shader programs is "
                      "not supported." << endl;
            return false;
        }
    }

    // Start using the shader.
    glUseProgramObjectARB(p);

    return true;
}