Beispiel #1
0
int compile(std::string fragmentSource){
	const std::string vertexSource="";

	GLuint fragmentShaderIndex = glCreateShader(GL_FRAGMENT_SHADER);
	const char* fragmentSourceStr = fragmentSource.c_str();
	int fragmentSourceLen = fragmentSource.length();
	glShaderSourceARB(fragmentShaderIndex, 1, &(fragmentSourceStr), &(fragmentSourceLen));
	glCompileShader(fragmentShaderIndex);

	printShaderInfoLog(fragmentShaderIndex);

	GLuint programIndex = glCreateProgram();
	glAttachShader(programIndex, fragmentShaderIndex);
	glLinkProgram(programIndex);

	printProgramInfoLog(programIndex);

	return programIndex;

}
Beispiel #2
0
    //-----------------------------------------------------------------------
    void GLSLProgram::loadFromSource(void)
    {
        // only create a shader object if glsl is supported
        if (isSupported())
        {
            checkForGLSLError( "GLSLProgram::GLSLProgram", "GL Errors before creating shader object", 0 );
            // create shader object
            mGLHandle = glCreateShaderObjectARB(
                (mType == GPT_VERTEX_PROGRAM) ? GL_VERTEX_SHADER_ARB : GL_FRAGMENT_SHADER_ARB );

            checkForGLSLError( "GLSLProgram::GLSLProgram", "Error creating GLSL shader Object", 0 );
        }

        const char* SLSource = mSource.c_str();
		glShaderSourceARB(mGLHandle, 1, &SLSource, NULL);
		// check for load errors
		checkForGLSLError( "GLSLProgram::loadFromSource", "Cannot load GLSL high-level shader source : " + mName, 0 );

		compile();
    }
Beispiel #3
0
void CompileProgram(GLcharARB* sourcecode, GLhandleARB *shader) {
  GLint	logLength;
  GLint	compiled;
  glShaderSourceARB(*shader,1,(const GLcharARB **)&sourcecode,0);
  HandleGLError("Failed glShaderSourceARB");
  glCompileShaderARB(*shader);
  HandleGLError("Failed glCompileShaderARB");
  glGetObjectParameterivARB(*shader,GL_OBJECT_COMPILE_STATUS_ARB,&compiled);
  glGetObjectParameterivARB(*shader,GL_OBJECT_INFO_LOG_LENGTH_ARB,&logLength);
  if (logLength) {
    GLcharARB *log = (GLcharARB *)malloc(logLength+128);
    glGetInfoLogARB(*shader, logLength, &logLength, log);
    printf("Compile log: \n");
    free (log);
  }
  if (!compiled) {
    std::cout << "shader could not compile" << std::endl;
    exit(0);
  }
}
Beispiel #4
0
bool    GlslProgram :: loadShader ( GLhandleARB shader, Data * data )
{
    const char * body = (const char *) data -> getPtr ( 0 );
    GLint		 len  = data -> getLength ();
    GLint        compileStatus;

    glShaderSourceARB ( shader, 1, &body,  &len );

                                        // compile the particle vertex shader, and print out
    glCompileShaderARB ( shader );

    if ( !checkGlError() )              // check for OpenGL errors
        return false;

    glGetObjectParameterivARB ( shader, GL_OBJECT_COMPILE_STATUS_ARB, &compileStatus );

    loadLog ( shader );

    return compileStatus != 0;

}
Beispiel #5
0
GLhandleARB GLSL_CompileShader(const char* shaderfilename,unsigned int ShaderObject)
{
	GLhandleARB GLSLShaderObject=0;
	GLSLShaderObject=glCreateShaderObjectARB(ShaderObject);
	unsigned char *ShaderAssembly = readShaderFile( shaderfilename );
	const char *ShaderStrings[1];
	ShaderStrings[0] = (char*)ShaderAssembly;
	glShaderSourceARB( GLSLShaderObject, 1, ShaderStrings, NULL );
	glCompileShaderARB( GLSLShaderObject);
	//delete [] ShaderAssembly;
	GLint bCompiled=0;
	glGetObjectParameterivARB( GLSLShaderObject, GL_OBJECT_COMPILE_STATUS_ARB, &bCompiled );
	if( bCompiled == false )
	{
		char str[4096];
		glGetInfoLogARB(GLSLShaderObject, sizeof(str), NULL, str);
		MessageBox( NULL, str, "Shader Compile Error", MB_OK|MB_ICONEXCLAMATION );
		//MessageBox( NULL, "请尝试降低阴影设置,否则程序无法正常运行", "注意", MB_OK|MB_ICONEXCLAMATION );
	}
	return GLSLShaderObject;
}
Beispiel #6
0
//-----------------------------------------------------------------------------
bool LoadShader(char *file, GLenum type, GLhandleARB context)
{
   // GLSL shader.
   GLhandleARB shader;

   // Load shader's source text.
   char *code = LoadText(file);

   if(code == NULL)
      return false;

   // Create the shader from a text file.
   shader = glCreateShaderObjectARB(type);
   glShaderSourceARB(shader, 1, (const char**)&code, NULL);
   glCompileShaderARB(shader);

   GLint result;
   char error[1024];

   // Returns the results of the shader compilation.
   glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB,
                             &result);
   delete[] code;

   // Display shader errors if any.
   if(!result)
      {
         // Get the error message and display it.
         glGetInfoLogARB(shader, sizeof(error), NULL, error);
         printf("Error in %s...\n%s\n", file, error);
         return false;
      }

   // Attach to the effect's context.
   glAttachObjectARB(context, shader);

   glDeleteObjectARB(shader);

   return true;
}
Beispiel #7
0
	//--------------------------------------------------------------------------------------
	// Método para cargar un shader en la memoria de la tarjeta.
	//--------------------------------------------------------------------------------------
	bool CShaderObject::Load (const char * path, GLenum type)
	{
		appResetLastError();
		FILE * file = fopen(path, "r");
		if(file == NULL) return appSetLastError(SHAERR_SHAOBJ_FOPENFILE);


		string source = "";
		char aux;

		fread(&aux, sizeof(char), 1, file);
		while(!feof(file))
		{
			source += aux;
			fread(&aux, sizeof(char), 1, file);
		}

		fclose(file);

		if(!source.length()) return appSetLastError(SHAERR_SHAOBJ_EMPTYFILE);


		this->shader = glCreateShaderObjectARB(type);
		if(!this->shader) return appSetLastError(SHAERR_SHAOBJ_CREATESHADEROBJECT);


		const char * srcstr = source.c_str();
		int len = source.length();

		glShaderSourceARB(this->shader, 1, &srcstr, &len);
		glCompileShaderARB(this->shader);

		int cmperr;
		glGetObjectParameterivARB(this->shader, GL_OBJECT_COMPILE_STATUS_ARB, &cmperr);

		if(cmperr == 0) return appSetLastError(SHAERR_SHAOBJ_COMPILESHADER);


		return true;
	}
Beispiel #8
0
GLhandleARB LoadGLSLShader(GLenum ShadeType, const char *SourceFile, char *ErrorLog, int *ErrorLength)
{
	GLhandleARB Handle = 0;

	FILE *InFile = fopen(SourceFile, "rt");
	if (InFile == NULL)
	{
		printf("could not find file %s\n", SourceFile);
		return false;
	}

	GLint Length = (GLint)fsize(InFile);
	GLcharARB *Shader = new char[Length + 1];

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

	Length = (GLint)fread(Shader, sizeof(GLcharARB), Length, InFile);
	Shader[Length] = '\0';
	fclose(InFile);

	Handle = glCreateShaderObjectARB(ShadeType);
	glShaderSourceARB(Handle, 1, (const GLcharARB**)&Shader, &Length);
	glCompileShaderARB(Handle);
	delete [] Shader;

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

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

		*ErrorLength = TotalLength - 1;
	}

	return Handle;
}
Beispiel #9
0
static void load_test_file (const char *filename)
{
   FILE *f;
   GLint size;
   char *code;
   GLint i;

   f = fopen (filename, "r");
   if (f == NULL)
      return;

   fseek (f, 0, SEEK_END);
   size = ftell (f);

   if (size == -1) {
      fclose (f);
      return;
   }

   fseek (f, 0, SEEK_SET);

   code = (char *) (malloc (size));
   if (code == NULL) {
      fclose (f);
      return;
   }
   size = fread (code, 1, size, f);
   fclose (f);

   glShaderSourceARB (vert, 1, (const GLcharARB **) (&code), &size);
   glCompileShaderARB (vert);
   if (!CheckObjectStatus (vert))
      exit (0);

   for (i = 0; i < sizeof (attribs) / sizeof (*attribs); i++)
      if (attribs[i].dispatch == A && attribs[i].bind != -1)
         glBindAttribLocationARB (prog, attribs[i].bind, attribs[i].name);
}
Beispiel #10
0
GLShader::GLShader(const QString& fileName, GLenum shaderType)
    : m_compileError(false), m_failed(false)
{
    GLSHADERS_ASSERT_OPENGL("GLShader::GLShader",
        glCreateShaderObjectARB && glShaderSourceARB && glCompileShaderARB && glGetObjectParameterivARB, return)

    m_shader = glCreateShaderObjectARB(shaderType);

    QFile file(fileName);
    if (file.open(QIODevice::ReadOnly)) {
        QByteArray bytes = file.readAll();
        GLint size = file.size();
        const char *p = bytes.data();
        file.close();
        glShaderSourceARB(m_shader, 1,  reinterpret_cast<const GLcharARB**>(&p), &size);
        glCompileShaderARB(m_shader);
        int status;
        glGetObjectParameterivARB(m_shader, GL_OBJECT_COMPILE_STATUS_ARB, &status);
        m_compileError = (status != 1);
    } else {
        m_compileError = true;
    }
}
Beispiel #11
0
void Shader::load(const std::string& fname)
{
	std::ifstream file;
	std::string code;

	printf("loading shader %s\n", fname.c_str());

	file.open(fname.c_str(), std::ios::in);
	if (!file) {
		throw Exception("failed to open " + fname);
	}

	file.seekg(0, std::ios::end);
	code.resize(file.tellg());
	file.seekg(0, std::ios::beg);

	file.read(&code[0], code.size());
	file.close();

	const char* str = code.c_str();
	glShaderSourceARB(handle, 1, &str, NULL);
	compile();
}
GLuint Painter::compileShader(const char* shader, GLenum type) {
    GLuint shaderId = glCreateShader(type);
    glShaderSourceARB(shaderId, 1, &shader, NULL);
    glCompileShader(shaderId);

    GLint success = 0;
    glGetShaderiv(shaderId, GL_COMPILE_STATUS, &success);
    if (success == GL_FALSE) {
        fprintf(stderr, "Failed to compile shader!\n%s\n", shader);

        GLint maxLength = 0;
        glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &maxLength);

        std::vector<GLchar> errorLog(maxLength);
        glGetShaderInfoLog(shaderId, maxLength, &maxLength, &errorLog[0]);

        fprintf(stderr, "%s\n", &errorLog[0]);

        glDeleteShader(shaderId);
    }

    return shaderId;
}
Beispiel #13
0
bool glsl_vertex :: openMessARB(void)
{
  if(m_shaderARB) {
    glDeleteObjectARB( m_shaderARB );
    gem::utils::glsl::delshader(m_shaderARB);
  }
  m_shaderARB = glCreateShaderObjectARB(m_shaderTarget);

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

  return true;
}
Beispiel #14
0
GLhandleARB C4Shader::Create(GLenum iShaderType, const char *szWhat, const char *szShader)
{
	// Create shader
	GLhandleARB hShader = glCreateShaderObjectARB(iShaderType);
#ifdef GL_KHR_debug
	if (glObjectLabel)
		glObjectLabel(GL_SHADER, hShader, -1, szWhat);
#endif

	// Compile
	glShaderSourceARB(hShader, 1, &szShader, 0);
	glCompileShaderARB(hShader);

	// Dump any information to log
	DumpInfoLog(szWhat, hShader);

	// Success?
	if(GetObjectStatus(hShader, GL_OBJECT_COMPILE_STATUS_ARB) == 1)
		return hShader;

	// Did not work :/
	glDeleteObjectARB(hShader);
	return 0;
}
Beispiel #15
0
void GLShader::loadShader(GLhandleARB shaderObject,const char* shaderSourceFileName)
	{
	/* Open the source file: */
	Misc::File shaderSourceFile(shaderSourceFileName,"rt");
	
	/* Determine the length of the source file: */
	shaderSourceFile.seekEnd(0);
	GLint shaderSourceLength=GLint(shaderSourceFile.tell());
	shaderSourceFile.seekSet(0);
	
	/* Read the shader source: */
	GLcharARB* shaderSource=new GLcharARB[shaderSourceLength];
	shaderSourceFile.read<GLcharARB>(shaderSource,shaderSourceLength);
	
	/* Upload the shader source into the shader object: */
	const GLcharARB* ss=shaderSource;
	glShaderSourceARB(shaderObject,1,&ss,&shaderSourceLength);
	delete[] shaderSource;
	
	/* Compile the shader source: */
	glCompileShaderARB(shaderObject);
	
	/* Check if the shader compiled successfully: */
	GLint compileStatus;
	glGetObjectParameterivARB(shaderObject,GL_OBJECT_COMPILE_STATUS_ARB,&compileStatus);
	if(!compileStatus)
		{
		/* Get some more detailed information: */
		GLcharARB compileLogBuffer[2048];
		GLsizei compileLogSize;
		glGetInfoLogARB(shaderObject,sizeof(compileLogBuffer),&compileLogSize,compileLogBuffer);
		
		/* Signal an error: */
		Misc::throwStdErr("%s",compileLogBuffer);
		}
	}
Beispiel #16
0
///	This function compiles a shader and check the log
bool GLSLShader::CompileShader(GLint target, const std::string& fileName, const std::string& header)
{
    std::string source = LoadTextFile(fileName);

    std::string shaderStage = GetShaderStageName(target);

    source = CombineHeaders(header, shaderStage + std::string("Shader"), source);

    GLhandleARB shader = glCreateShaderObjectARB(target);

    const char* src = source.c_str();

    glShaderSourceARB(shader, 1, &src, NULL);

    glCompileShaderARB(shader);

    GLint compiled = 0, length = 0, laux = 0;
    glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);
    if (!compiled) std::cerr << "ERROR: Compilation of "<<shaderStage<<" shader failed:"<<std::endl;
    //     else std::cout << "Compilation of "<<shaderStage<<" shader OK" << std::endl;
    glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
    if (length > 1)
    {
        std::cerr << "File: " << fileName << std::endl;
        if (!header.empty()) std::cerr << "Header:\n" << header << std::endl;
        GLcharARB *logString = (GLcharARB *)malloc((length+1) * sizeof(GLcharARB));
        glGetInfoLogARB(shader, length, &laux, logString);
        std::cerr << logString << std::endl;
        free(logString);
    }
    if (compiled)
        m_hShaders[target] = shader;
    else
        glDeleteObjectARB(shader);
    return (compiled!=0);
}
int main(int argc, char **argv)
{
   float r = 0.5, g = 0.5, b = 1, ratio = 0;
   int dir = 1;
   ALLEGRO_DISPLAY *display;
   ALLEGRO_BITMAP *mysha;
   ALLEGRO_BITMAP *buffer;

   const char *tinter_shader_src[] = {
      "uniform sampler2D backBuffer;",
      "uniform float r;",
      "uniform float g;",
      "uniform float b;",
      "uniform float ratio;",
      "void main() {",
      "	vec4 color;",
      "	float avg, dr, dg, db;",
      "	color = texture2D(backBuffer, gl_TexCoord[0].st);",
      "	avg = (color.r + color.g + color.b) / 3.0;",
      "	dr = avg * r;",
      "	dg = avg * g;",
      "	db = avg * b;",
      "	color.r = color.r - (ratio * (color.r - dr));",
      "	color.g = color.g - (ratio * (color.g - dg));",
      "	color.b = color.b - (ratio * (color.b - db));",
      "	gl_FragColor = color;",
      "}"
   };
   const int TINTER_LEN = 18;
   double start;
   GLint loc;

   (void)argc;
   (void)argv;

   if (!al_init()) {
      abort_example("Could not init Allegro\n");
   }

   al_install_keyboard();
   al_init_image_addon();

   al_set_new_display_flags(ALLEGRO_OPENGL);
   display = al_create_display(320, 200);
   if (!display) {
      abort_example("Error creating display\n");
   }

   mysha = al_load_bitmap("data/mysha.pcx");
   if (!mysha) {
      abort_example("Could not load image.\n");
   }

   buffer = al_create_bitmap(320, 200);

   if (!al_have_opengl_extension("GL_EXT_framebuffer_object")
      && !al_have_opengl_extension("GL_ARB_fragment_shader")) {
      abort_example("Fragment shaders not supported.\n");
   }

   tinter_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

   glShaderSourceARB(tinter_shader, TINTER_LEN, tinter_shader_src, NULL);
   glCompileShaderARB(tinter_shader);
   tinter = glCreateProgramObjectARB();
   glAttachObjectARB(tinter, tinter_shader);
   glLinkProgramARB(tinter);
   loc = glGetUniformLocationARB(tinter, "backBuffer");
   glUniform1iARB(loc, al_get_opengl_texture(buffer));

   start = al_get_time();

   while (1) {
      double now, diff;
      ALLEGRO_KEYBOARD_STATE state;
      al_get_keyboard_state(&state);
      if (al_key_down(&state, ALLEGRO_KEY_ESCAPE)) {
         break;
      }
      now = al_get_time();
      diff = now - start;
      start = now;
      ratio += diff * 0.5 * dir;
      if (dir < 0 && ratio < 0) {
         ratio = 0;
         dir = -dir;
      }
      else if (dir > 0 && ratio > 1) {
         ratio = 1;
         dir = -dir;
      }

      al_set_target_bitmap(buffer);

      glUseProgramObjectARB(tinter);
      loc = glGetUniformLocationARB(tinter, "ratio");
      glUniform1fARB(loc, ratio);
      loc = glGetUniformLocationARB(tinter, "r");
      glUniform1fARB(loc, r);
      loc = glGetUniformLocationARB(tinter, "g");
      glUniform1fARB(loc, g);
      loc = glGetUniformLocationARB(tinter, "b");
      glUniform1fARB(loc, b);
      al_draw_bitmap(mysha, 0, 0, 0);
      glUseProgramObjectARB(0);

      al_set_target_backbuffer(display);
      al_draw_bitmap(buffer, 0, 0, 0);
      al_flip_display();
      al_rest(0.001);
   }

   glDetachObjectARB(tinter, tinter_shader);
   glDeleteObjectARB(tinter_shader);

   al_uninstall_system();

   return 0;
}
Beispiel #18
0
int XGLShader::compileShaders( const char *shdrVertex, const char *shdrFragment )
{

    GLhandleARB shdrVS, shdrFS;//, shdrProg;   // handles to objects
    GLint       vertCompiled, fragCompiled;    // status values
    GLint       linked;

    // Create a vertex shader object and a fragment shader object

    shdrVS = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    shdrFS = glCreateShaderObjectARB(GL_FRAGMENT_SHADER);
    // Load source code strings into shaders



    glShaderSourceARB(shdrVS, 1, &shdrVertex, NULL);
    glShaderSourceARB(shdrFS, 1, &shdrFragment, NULL);



    // Compile the shdr vertex shader and print out
    // the compiler log file.

    glCompileShaderARB(shdrVS);
    printOpenGLError();  // Check for OpenGL errors
    glGetObjectParameterivARB(shdrVS,
                              GL_OBJECT_COMPILE_STATUS_ARB, &vertCompiled);
    this->printInfoLog(shdrVS);

    // Compile the shdr vertex shader and print out
    // the compiler log file.

    glCompileShaderARB(shdrFS);
    printOpenGLError();  // Check for OpenGL errors
    glGetObjectParameterivARB(shdrFS,
                              GL_OBJECT_COMPILE_STATUS_ARB, &fragCompiled);
    this->printInfoLog(shdrFS);

    if (!vertCompiled || !fragCompiled)
        return 0;
    // Create a program object and attach the two compiled shaders

    this->sp = glCreateProgramObjectARB();
    glAttachObjectARB(this->sp, shdrVS);
    glAttachObjectARB(this->sp, shdrFS);

    // Link the program object and print out the info log

    glLinkProgramARB(this->sp);
    printOpenGLError();  // Check for OpenGL errors
    glGetObjectParameterivARB(this->sp,
                              GL_OBJECT_LINK_STATUS_ARB, &linked);
    this->printInfoLog(this->sp);

    if (!linked)
        return 0;

    // Install program object as part of current state

    //glUseProgramObjectARB(shdrProg);

    // Set up initial uniform values

    //glUniform3fARB( getUniLoc(shdrProg, "BrickColor"), 1.0, 0.3, 0.2);
    //glUniform3fARB( getUniLoc(shdrProg, "MortarColor"), 0.85, 0.86, 0.84);
    //glUniform2fARB( getUniLoc(shdrProg, "BrickSize"), 0.30, 0.15);
    //glUniform2fARB( getUniLoc(shdrProg, "BrickPct"), 0.90, 0.85);
    //glUniform3fARB( getUniLoc(shdrProg, "LightPosition"), 0.0, 0.0, 4.0);

    this->validShader = 1;

    return 1;
}
Beispiel #19
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);
}
GLhandleARB loadShaderFromFile(char* filename, unsigned int type)
{
    FILE *pfile;
    GLhandleARB handle;
    const GLcharARB* files[1];
    
    // shader Compilation variable
    GLint result;				// Compilation code result
    GLint errorLoglength;
    char* errorLogText;
    GLsizei actualErrorLogLength;
    
    char buffer[400000];
    memset(buffer, 0, 400000);
    
    // This will raise a warning on MS compiler
    pfile = fopen(filename, "rb");
    if (!pfile)
    {
        printf("Sorry, can't open file: '%s'.\n", filename);
        exit(0);
    }
    
    fread(buffer, sizeof(char), 400000, pfile);
    //printf("%s\n",buffer);
    
    
    fclose(pfile);
    
    handle = glCreateShaderObjectARB(type);
    if (!handle)
    {
        //We have failed creating the vertex shader object.
        printf("Failed creating vertex shader object from file: %s.", filename);
        exit(0);
    }
    
    files[0] = (const GLcharARB*)buffer;
    glShaderSourceARB(
                      handle, //The handle to our shader
                      1, //The number of files.
                      files, //An array of const char * data, which represents the source code of theshaders
                      NULL);
    
    glCompileShaderARB(handle);
    
    //Compilation checking.
    glGetObjectParameterivARB(handle, GL_OBJECT_COMPILE_STATUS_ARB, &result);
    
    // If an error was detected.
    if (!result)
    {
        //We failed to compile.
        printf("Shader '%s' failed compilation.\n", filename);
        
        //Attempt to get the length of our error log.
        glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &errorLoglength);
        
        //Create a buffer to read compilation error message
        errorLogText = (char*)malloc(sizeof(char)* errorLoglength);
        
        //Used to get the final length of the log.
        glGetInfoLogARB(handle, errorLoglength, &actualErrorLogLength, errorLogText);
        
        // Display errors.
        printf("%s\n", errorLogText);
        
        // Free the buffer malloced earlier
        free(errorLogText);
    }
    printf("Shader loaded done\n");
    return handle;
}
Beispiel #21
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_));
	}
Beispiel #22
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;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglShaderSourceARB(JNIEnv *env, jclass clazz, jint shader, jint count, jobject string, jint string_position, jint length, jlong function_pointer) {
	const GLcharARB *string_address = ((const GLcharARB *)(*env)->GetDirectBufferAddress(env, string)) + string_position;
	glShaderSourceARBPROC glShaderSourceARB = (glShaderSourceARBPROC)((intptr_t)function_pointer);
	glShaderSourceARB(shader, count, (const GLcharARB **)&string_address, (const GLint*)&length);
}
Beispiel #24
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;
}
Beispiel #25
0
bool Shader::compile(){

	const char * ff = mFragText.c_str();
	const char * vv = mVertText.c_str();
	
	//printf("Fragment: %s\n", ff);
	//printf("Vertex: %s\n", vv);
		
	char infobuffer[16385];
	GLsizei infobufferlen = 0;

	if(mVertText != ""){
		glShaderSourceARB(mVert, 1, &vv,NULL);
		glCompileShaderARB(mVert);
	}
	
	if(mFragText != ""){
		glShaderSourceARB(mFrag, 1, &ff,NULL);
		glCompileShaderARB(mFrag);
	}	

	mProgram = glCreateProgramObjectARB();
	
	if(mFragText != "") glAttachObjectARB(mProgram, mFrag);
	if(mVertText != "") glAttachObjectARB(mProgram, mVert);

	GLint compiled, linked;
	glGetObjectParameterivARB(mVert, GL_COMPILE_STATUS, &compiled);

	if (!compiled && mVertText != "") {
	
		glGetInfoLogARB(mVert, 16384, &infobufferlen, infobuffer);
		infobuffer[infobufferlen] = 0;	
		ERR("Couldn't compile vertex shader: \n%s\n", infobuffer);
		return false;
	}
	
	glGetObjectParameterivARB(mFrag, GL_COMPILE_STATUS, &compiled);
	if (!compiled && mFragText != "") {
		glGetInfoLogARB(mFrag, 16384, &infobufferlen, infobuffer);
		infobuffer[infobufferlen] = 0;	
		ERR("Couldn't compile fragment shader: \n%s\n", infobuffer);
		return false;
	}
	
	glLinkProgramARB(mProgram);
	
	//glGetProgramiv(mProgram, GL_LINK_STATUS, &linked);
	glGetObjectParameterivARB(mProgram, GL_OBJECT_LINK_STATUS_ARB, &linked);

	if (!linked) {
		glGetInfoLogARB(mProgram, 16384, &infobufferlen, infobuffer);
		infobuffer[infobufferlen] = 0;	
		ERR("Couldn't link shader: \n%s\n", infobuffer);
		return false;
	}
	
	//Log::debug("Compiled shader!\n");
	bIsCompiled = true;
	
	return true;		
}
/***************************************************************************
 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);
    }
}
Beispiel #27
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 ){
			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);
		
		 if(compileStatus == 0)
		 {
			 printf("vertexShader erroorrr");
			 exit (0);
		 }
		/*
		glGetInfoLogARB(vertexShader, 999, &infobufferlen, infobuffer);
		if (infobufferlen != 0){
			infobuffer[infobufferlen] = 0;
			printf("vertexShader reports0: %s \n", infobuffer);
			return;
		}
		*/
		
		
		// ------------------------------------
		// try to compile "fragment shader"
		glCompileShaderARB(fragmentShader);
		
		

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

		if(compileStatus == 0)
		 {
			 printf("fragmentShader erroorrr");
			//exit (0);
		 }

		/* // per a que funcioni el shader te que estar comentat
		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");
	
	}


}
Beispiel #28
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;
}
Beispiel #29
0
bool
GeoShaderFactory::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 pointPosition;\n";
    qstr += "varying vec3 normal;\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 += "  pointPosition = gl_Vertex.xyz;\n";
    qstr += "  normal = gl_NormalMatrix * gl_Normal;\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 += "}\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;
    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;
    glCompileShaderARB(fragObj);
    glGetObjectParameterivARB(fragObj,
			      GL_OBJECT_COMPILE_STATUS_ARB,
			      &compiled);
    if (!compiled)
      {
	GLcharARB str[1000];
	GLsizei len;
	glGetInfoLogARB(fragObj,
			(GLsizei) 1000,
			&len,
			str);
	
	QMessageBox::information(0,
				 "Error : Fragment Shader",
				 str);
	return false;
      }
  }

  
  //----------- link program shader ----------------------
  GLint linked;
  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;
}
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;
}