Exemple #1
0
_Bool gl_init(void)
{
    GLuint vertshader, fragshader;
    GLint status;
    const GLchar *data;

    vertshader = glCreateShader(GL_VERTEX_SHADER);
    if(!vertshader) {
        debug("glCreateShader() failed (vert)\n");
        return 0;
    }

    data = &vertex_shader[0];
    glShaderSource(vertshader, 1, &data, NULL);
    glCompileShader(vertshader);
    glGetShaderiv(vertshader, GL_COMPILE_STATUS, &status);
    if(!status) {
        #ifdef DEBUG
        debug("glCompileShader() failed (vert):\n%s\n", data);
        GLint infologsize = 0;
        glGetShaderiv(vertshader, GL_INFO_LOG_LENGTH, &infologsize);
        if(infologsize)
        {
            char* infolog = malloc(infologsize);
            glGetShaderInfoLog(vertshader, infologsize, NULL, (GLbyte*)infolog);
            debug("Infolog: %s\n", infolog);
            free(infolog);
        }
        #endif
        return 0;
    }

    fragshader = glCreateShader(GL_FRAGMENT_SHADER);
    if(!fragshader)
    {
        return 0;
    }

    data = &fragment_shader[0];
    glShaderSource(fragshader, 1, &data, NULL);
    glCompileShader(fragshader);
    glGetShaderiv(fragshader, GL_COMPILE_STATUS, &status);
    if(!status)
    {
        #ifdef DEBUG
        debug("glCompileShader failed (frag):\n%s\n", data);
        GLint infologsize = 0;
        glGetShaderiv(fragshader, GL_INFO_LOG_LENGTH, &infologsize);
        if(infologsize)
        {
            char* infolog = malloc(infologsize);
            glGetShaderInfoLog(fragshader, infologsize, NULL, (GLbyte*)infolog);
            debug("Infolog: %s\n", infolog);
            free(infolog);
        }
        #endif
        return 0;
    }

    prog = glCreateProgram();
    glAttachShader(prog, vertshader);
    glAttachShader(prog, fragshader);
    glBindAttribLocation(prog, 0, "pos");
    glBindAttribLocation(prog, 1, "tex");

    glLinkProgram(prog);
    glGetProgramiv(prog, GL_LINK_STATUS, &status);
    if(!status)
    {
        #ifdef DEBUG
        debug("glLinkProgram failed\n");
        GLint infologsize = 0;
        glGetShaderiv(prog, GL_INFO_LOG_LENGTH, &infologsize);
        if(infologsize)
        {
            char* infolog = malloc(infologsize);
            glGetShaderInfoLog(prog, infologsize, NULL, (GLbyte*)infolog);
            debug("Infolog: %s\n", infolog);
            free(infolog);
        }
        #endif
        return 0;
    }

    glUseProgram(prog);

    matrix = glGetUniformLocation(prog, "matrix");
    k = glGetUniformLocation(prog, "k");
    k2 = glGetUniformLocation(prog, "k2");
    samp = glGetUniformLocation(prog, "samp");

    debug("uniforms: %i %i %i\n", matrix, k, samp);

    GLint zero = 0;
    float one[] = {1.0, 1.0, 1.0};
    glUniform1iv(samp, 1, &zero);
    glUniform3fv(k2, 1, one);

    uint8_t wh = {255};
    glGenTextures(1, &white);
    glBindTexture(GL_TEXTURE_2D, white);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 1, 1, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &wh);

    //
    glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE, sizeof(VERTEX2D), &quads[0]);
    glVertexAttribPointer(1, 2, GL_UNSIGNED_SHORT, GL_FALSE, sizeof(VERTEX2D), &quads[0].vertex[0].tx);
    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);

    //Alpha blending
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);

    //
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    #ifndef NO_OPENGL_ES
    uint8_t i = 0;
    uint16_t ii = 0;
    do {
        quad_indices[ii] = i + 0;
        quad_indices[ii + 1] = i + 1;
        quad_indices[ii + 2] = i + 3;
        quad_indices[ii + 3] = i + 3;
        quad_indices[ii + 4] = i + 1;
        quad_indices[ii + 5] = i + 2;
        i += 4;
        ii += 6;
    } while(i);
    #endif

    glGenTextures(countof(bitmap), bitmap);

    svg_draw(0);
    loadfonts();

    float vec[4];
    vec[0] = -(float)utox_window_width / 2.0;
    vec[1] = -(float)utox_window_height / 2.0;
    vec[2] = 2.0 / (float)utox_window_width;
    vec[3] = -2.0 / (float)utox_window_height;
    glUniform4fv(matrix, 1, vec);

    ui_size(utox_window_width, utox_window_height);

    glViewport(0, 0, utox_window_width, utox_window_height);

    redraw();

    return 1;
}
      "    varying highp vec4   lightPosition_PASS;                                                          \n"                           
      "    varying highp vec2   varTexcoord;                                                                 \n"                           


      "    void main()                                                                                         \n"                           
      "    {                                                                                                   \n"                           
      "        lightPosition_PASS = normalize(lightMatrix * light_POSITION_01);                                \n"                           

      "        varTexcoord        = texture;                                                                   \n"                           

      "        gl_Position        = mvpMatrix * position;                                                      \n"                           

      "    }\n";                                                                                                                             
      //---------------------------------------------------------------------                                                                   
      sphere_SHADER_VERTEX = glCreateShader(GL_VERTEX_SHADER);                                                                                   
      glShaderSource(sphere_SHADER_VERTEX, 1, &vertexSource_sphere, NULL);                                                                        
      glCompileShader(sphere_SHADER_VERTEX);                                                                                                     
      //---------------------------------------------------------------------                                                                   
      const GLchar *fragmentSource_sphere =                                                                                                            

      " #ifdef GL_ES                                                                                                     \n"                       
      " #else                                                                                                     \n"                       
      " #define highp                                                                                                  \n"                       
      " #endif                                                                                                           \n"                       

      "    uniform sampler2D       Texture1;                                                                             \n"                       
      "    uniform sampler2D       NormalMap;                                                                            \n"                       
      "    uniform highp float   shininess;                                                                            \n"                       
      "    uniform highp float   attenuation;                                                                          \n"                       
Exemple #3
0
bool initialize(){
     // Initialize basic geometry and shaders for this example

     //this defines a cube, this is why a model loader is nice
     //you can also do this with a draw elements and indices, try to get that working
     Vertex geometry[] = { {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}},
                           {{-1.0, -1.0, 1.0}, {0.0, 0.0, 1.0}},
                           {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}},

                           {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}},
                           {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}},
                           {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}},
                          
                           {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}},
                           {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}},
                           {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}},
                          
                           {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}},
                           {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}},
                           {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}},

                           {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}},
                           {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}},
                           {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}},

                           {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}},
                           {{-1.0, -1.0, 1.0}, {0.0, 0.0, 1.0}},
                           {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}},

                           {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}},
                           {{-1.0, -1.0, 1.0}, {0.0, 0.0, 1.0}},
                           {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}},
                          
                           {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}},
                           {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}},
                           {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}},

                           {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}},
                           {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}},
                           {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}},

                           {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}},
                           {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}},
                           {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}},

                           {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}},
                           {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}},
                           {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}},

                           {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}},
                           {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}},
                           {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}}
                        };
	// Create a Vertex Buffer object to store this vertex info on the GPU
    	glGenBuffers(1, &vbo_geometry);
    	glBindBuffer(GL_ARRAY_BUFFER, vbo_geometry);
    	glBufferData(GL_ARRAY_BUFFER, sizeof(geometry), geometry, GL_STATIC_DRAW);

    	//--Geometry done

    	GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    	GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);

    	//Shader Sources
    	// Put these into files and write a loader in the future
    	// Note the added uniform!
    	const char *vs;
    	vs = shaderLoader("vertexShader");
    	const char *fs;
     fs = shaderLoader("fragmentShader");


	
    	//compile the shaders
    	GLint shader_status;

    	// Vertex shader first
    	glShaderSource(vertex_shader, 1, &vs, NULL);
    	glCompileShader(vertex_shader);
    	//check the compile status
    	glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &shader_status);
    	if(!shader_status){
     	std::cerr << "[F] FAILED TO COMPILE VERTEX SHADER!" << std::endl;
    		return false;
    	}

    	// Now the Fragment shader
    	glShaderSource(fragment_shader, 1, &fs, NULL);
    	glCompileShader(fragment_shader);
    	//check the compile status
    	glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &shader_status);
    	if(!shader_status){
        	std::cerr << "[F] FAILED TO COMPILE FRAGMENT SHADER!" << std::endl;
        	return false;
     }

    	//Now we link the 2 shader objects into a program
    	//This program is what is run on the GPU
    	program = glCreateProgram();
    	glAttachShader(program, vertex_shader);
    	glAttachShader(program, fragment_shader);
    	glLinkProgram(program);
    	//check if everything linked ok
    	glGetProgramiv(program, GL_LINK_STATUS, &shader_status);
    	if(!shader_status){
     	std::cerr << "[F] THE SHADER PROGRAM FAILED TO LINK" << std::endl;
       	return false;
    	}

    	//Now we set the locations of the attributes and uniforms
    	//this allows us to access them easily while rendering
    	loc_position = glGetAttribLocation(program,
                    const_cast<const char*>("v_position"));
    	if(loc_position == -1){
     	std::cerr << "[F] POSITION NOT FOUND" << std::endl;
    		return false;
    	}

    	loc_color = glGetAttribLocation(program,
                    const_cast<const char*>("v_color"));
    	if(loc_color == -1){
     	std::cerr << "[F] V_COLOR NOT FOUND" << std::endl;
     	return false;
	}

    	loc_mvpmat = glGetUniformLocation(program,
                    const_cast<const char*>("mvpMatrix"));
    	if(loc_mvpmat == -1){
     	std::cerr << "[F] MVPMATRIX NOT FOUND" << std::endl;
     	return false;
     }
    
    	//--Init the view and projection matrices
    	//  if you will be having a moving camera the view matrix will need to more dynamic
    	//  ...Like you should update it before you render more dynamic 
    	//  for this project having them static will be fine
    	view = glm::lookAt( glm::vec3(0.0, 8.0, -16.0), //Eye Position
    	                    glm::vec3(0.0, 0.0, 0.0), //Focus point
                         glm::vec3(0.0, 1.0, 0.0)); //Positive Y is up
	
  	projection = glm::perspective( 45.0f, //the FoV typically 90 degrees is good which is what this is set to
                                   float(w)/float(h), //Aspect Ratio, so Circles stay Circular
                                   0.01f, //Distance to the near plane, normally a small value like this
                                   100.0f); //Distance to the far plane, 

    	//enable depth testing
    	glEnable(GL_DEPTH_TEST);
    	glDepthFunc(GL_LESS);

    	//and its done
    	return true;
}
{
	// create shaders
	const char* vsSource = "#version 150\n \
					 in vec4 Position; \
					 in vec4 Colour; \
					 out vec4 vColour; \
					 uniform mat4 ProjectionView; \
					 void main() { vColour = Colour; gl_Position = ProjectionView * Position; }";

	const char* fsSource = "#version 150\n \
					 in vec4 vColour; \
                     out vec4 FragColor; \
					 void main()	{ FragColor = vColour; }";
    
    
	unsigned int vs = glCreateShader(GL_VERTEX_SHADER);
	unsigned int fs = glCreateShader(GL_FRAGMENT_SHADER);

	glShaderSource(vs, 1, (const char**)&vsSource, 0);
	glCompileShader(vs);

	glShaderSource(fs, 1, (const char**)&fsSource, 0);
	glCompileShader(fs);

	m_shader = glCreateProgram();
	glAttachShader(m_shader, vs);
	glAttachShader(m_shader, fs);
	glBindAttribLocation(m_shader, 0, "Position");
	glBindAttribLocation(m_shader, 1, "Colour");
	glLinkProgram(m_shader);
    
Exemple #5
0
////////////////////////////////////////////////////////////////////////////////
//! 
////////////////////////////////////////////////////////////////////////////////
GLuint compileGLSLprogram(const char *vertex_shader_src, const char *fragment_shader_src)
{
  GLuint v, f, p = 0;

  p = glCreateProgram();
    
  if (vertex_shader_src) {
      v = glCreateShader(GL_VERTEX_SHADER);
      glShaderSource(v, 1, &vertex_shader_src, NULL);
      glCompileShader(v);

      // check if shader compiled
      GLint compiled = 0;
      glGetShaderiv(v, GL_COMPILE_STATUS, &compiled);
      
      if (!compiled)
      {
          //#ifdef NV_REPORT_COMPILE_ERRORS
          char temp[256] = "";
          glGetShaderInfoLog( v, 256, NULL, temp);
          //shrLog("Vtx Compile failed:\n%s\n", temp);
          //#endif
          glDeleteShader( v);
          return 0;
      }
      else
      glAttachShader(p,v);
  }
  
  if (fragment_shader_src)  {
      f = glCreateShader(GL_FRAGMENT_SHADER);
      glShaderSource(f, 1, &fragment_shader_src, NULL);
      glCompileShader(f);

      // check if shader compiled
      GLint compiled = 0;
      glGetShaderiv(f, GL_COMPILE_STATUS, &compiled);
      
      if (!compiled)
      {
          //#ifdef NV_REPORT_COMPILE_ERRORS
          char temp[256] = "";
          glGetShaderInfoLog(f, 256, NULL, temp);
          //shrLog("frag Compile failed:\n%s\n", temp);
          //#endif
          glDeleteShader(f);
          return 0;
      }
      else
      glAttachShader(p,f);
  }
  
  glLinkProgram(p);

  int infologLength = 0;
  int charsWritten  = 0;
  
  glGetProgramiv(p, GL_INFO_LOG_LENGTH, (GLint *)&infologLength);
  
  if (infologLength > 0) {
      char *infoLog = (char *)malloc(infologLength);
      glGetProgramInfoLog(p, infologLength, (GLsizei *)&charsWritten, infoLog);
      //shrLog("Shader compilation error: %s\n", infoLog);
      free(infoLog);
  }

  return p;
}
Exemple #6
0
void Shader::loadFrag(const std::string &filename)
{
	// création du shader
	shaderFrag = glCreateShader(GL_FRAGMENT_SHADER);
	compile(shaderFrag, filename);
}
Exemple #7
0
void Shader::loadVert(const std::string &filename)
{
	// création du shader
	shaderVert = glCreateShader(GL_VERTEX_SHADER);
	compile(shaderVert, filename);
}
Exemple #8
0
static GLuint LoadProgram(const char* vsKey, const char* tcsKey, const char* tesKey, const char* gsKey, const char* fsKey)
{
    GLchar spew[256];
    GLint compileSuccess;
    GLuint programHandle = glCreateProgram();

    const char* vsSource = pezGetShader(vsKey);
    pezCheck(vsSource != 0, "Can't find vshader: %s\n", vsKey);
    GLuint vsHandle = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vsHandle, 1, &vsSource, 0);
    glCompileShader(vsHandle);
    glGetShaderiv(vsHandle, GL_COMPILE_STATUS, &compileSuccess);
    glGetShaderInfoLog(vsHandle, sizeof(spew), 0, spew);
    pezCheck(compileSuccess, "Can't compile vshader:\n%s", spew);
    glAttachShader(programHandle, vsHandle);

    if (tcsKey) {
        const char* tcsSource = pezGetShader(tcsKey);
        pezCheck(tcsSource != 0, "Can't find tcshader: %s\n", tcsKey);
        GLuint tcsHandle = glCreateShader(GL_TESS_CONTROL_SHADER);
        glShaderSource(tcsHandle, 1, &tcsSource, 0);
        glCompileShader(tcsHandle);
        glGetShaderiv(tcsHandle, GL_COMPILE_STATUS, &compileSuccess);
        glGetShaderInfoLog(tcsHandle, sizeof(spew), 0, spew);
        pezCheck(compileSuccess, "Can't compile tcshader:\n%s", spew);
        glAttachShader(programHandle, tcsHandle);
    }

    if (tesKey) {
        const char* tesSource = pezGetShader(tesKey);
        pezCheck(tesSource != 0, "Can't find teshader: %s\n", tesKey);
        GLuint tesHandle = glCreateShader(GL_TESS_EVALUATION_SHADER);
        glShaderSource(tesHandle, 1, &tesSource, 0);
        glCompileShader(tesHandle);
        glGetShaderiv(tesHandle, GL_COMPILE_STATUS, &compileSuccess);
        glGetShaderInfoLog(tesHandle, sizeof(spew), 0, spew);
        pezCheck(compileSuccess, "Can't compile teshader:\n%s", spew);
        glAttachShader(programHandle, tesHandle);
    }

    if (gsKey) {
        const char* gsSource = pezGetShader(gsKey);
        pezCheck(gsSource != 0, "Can't find gshader: %s\n", gsKey);
        GLuint gsHandle = glCreateShader(GL_GEOMETRY_SHADER);
        glShaderSource(gsHandle, 1, &gsSource, 0);
        glCompileShader(gsHandle);
        glGetShaderiv(gsHandle, GL_COMPILE_STATUS, &compileSuccess);
        glGetShaderInfoLog(gsHandle, sizeof(spew), 0, spew);
        pezCheck(compileSuccess, "Can't compile gshader:\n%s", spew);
        glAttachShader(programHandle, gsHandle);
    }

    if (fsKey) {
        const char* fsSource = pezGetShader(fsKey);
        pezCheck(fsSource != 0, "Can't find fshader: %s\n", fsKey);
        GLuint fsHandle = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fsHandle, 1, &fsSource, 0);
        glCompileShader(fsHandle);
        glGetShaderiv(fsHandle, GL_COMPILE_STATUS, &compileSuccess);
        glGetShaderInfoLog(fsHandle, sizeof(spew), 0, spew);
        pezCheck(compileSuccess, "Can't compile fshader:\n%s", spew);
        glAttachShader(programHandle, fsHandle);
    }

    glBindAttribLocation(programHandle, PositionSlot, "Position");
    glBindAttribLocation(programHandle, NormalSlot, "Normal");
    glBindAttribLocation(programHandle, OcclusionSlot, "Occlusion");

    glLinkProgram(programHandle);
    GLint linkSuccess;
    glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
    glGetProgramInfoLog(programHandle, sizeof(spew), 0, spew);
    pezCheck(linkSuccess, "Can't link shaders:\n%s", spew);
    glUseProgram(programHandle);
    return programHandle;
}
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
	GLFWwindow* window = glfwCreateWindow(800, 600, "triangle", nullptr, nullptr);
	glfwMakeContextCurrent(window);
	glfwSetKeyCallback(window, key_callback);
	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
	glfwSetCursorPosCallback(window, mouse_callback);
	glfwSetScrollCallback(window, scroll);
	glewExperimental = GL_TRUE;
	glewInit();
	glViewport(0, 0, 800, 600);
	glEnable(GL_DEPTH_TEST);
	GLint vertex = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertex, 1, &vertexshader, NULL);
	GLint fragment = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragment, 1, &fragmentshader, NULL);
	glCompileShader(vertex);
	glCompileShader(fragment);
	GLint program = glCreateProgram();
	glAttachShader(program, vertex);
	glAttachShader(program, fragment);
	glLinkProgram(program);
	GLint fragment1 = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragment1, 1, &fragmentshader1, NULL);
	glCompileShader(fragment1);
	GLint program1 = glCreateProgram();
	glAttachShader(program1, vertex);
	glAttachShader(program1, fragment1);
	glLinkProgram(program1);
	GLfloat vertices[] = {
		-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
		0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
		0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
		0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
		-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
		-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,

		-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
		0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
		0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
		0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
		-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
		-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,

		-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
		-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
		-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
		-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
		-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
		-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,

		0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
		0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
		0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
		0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
		0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
		0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,

		-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
		0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
		0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
		0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
		-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
		-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,

		-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
		0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
		0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
		0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
		-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
		-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f
	};
	glm::vec3 cubePositions[] = {
		glm::vec3(0.0f, 0.0f, 0.0f),
		glm::vec3(0.0f, 0.0f, -4.0f),
		glm::vec3(0.0f, 0.0f, -10.f),
		glm::vec3(0.0f, 0.0f, -22.0f),
		glm::vec3(0.0f, 0.0f, -35.0f),
		glm::vec3(0.0f, 0.0f, -55.0f),
		glm::vec3(0.0f, 0.0f, -80.0f),
	};
	GLfloat angle[7] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
	GLfloat size[7] = { 0.3f, 1.0f, 1.2f, 0.7, 5.0f, 4.0f, 3.0f };
	GLuint vbo, vaoc, vaol;
	glGenBuffers(1, &vbo);
	glGenVertexArrays(1, &vaoc);
	glGenVertexArrays(1, &vaol);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
	glBindVertexArray(vaoc);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
	glEnableVertexAttribArray(1);
	glBindVertexArray(0);
	glBindVertexArray(vaol);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
	glEnableVertexAttribArray(0);
	glBindVertexArray(0);
	while (!glfwWindowShouldClose(window))
	{
		glfwPollEvents();
		movement();
		glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glUseProgram(program);
		glm::mat4 model;
		glm::mat4 view;
		glm::mat4 projection;
		view = glm::lookAt(camerapos, camerapos - cameramove, cameraup);
		projection = glm::perspective(aspect, (GLfloat)800 / (GLfloat)600, 0.1f, 200.0f);
		GLint modelLoc = glGetUniformLocation(program, "model");
		GLint viewLoc = glGetUniformLocation(program, "view");
		GLint projLoc = glGetUniformLocation(program, "projection");
		GLint objectcolorLoc = glGetUniformLocation(program, "objectcolor");
		GLint lightcolorLoc = glGetUniformLocation(program, "lightcolor");
		GLint lightPosLoc = glGetUniformLocation(program, "lightPos");
		GLint viewPosLoc = glGetUniformLocation(program, "viewPos");
		glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
		glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
		glUniform3f(lightcolorLoc, 1.0f, 1.0f, 1.0f);

		glUniform3f(lightPosLoc, lightPos.x, lightPos.y, lightPos.z);
		glUniform3f(viewPosLoc, camerapos.x, camerapos.y, camerapos.z);
		glBindVertexArray(vaoc);
		for (GLint i = 0; i < 7; i++)
		{
			model = glm::mat4();
			model = glm::translate(model, cubePositions[i]);
			angle[i] = angle[i] + ((7 - i)* 0.00002);
			GLfloat radius = (20.0f + -1 * cubePositions[i].z);
			GLfloat x = sin(angle[i]) * radius;
			GLfloat z = (1 - cos(angle[i])) * radius;
			model = glm::translate(model, glm::vec3(x, 0.0f, z));
			model = glm::rotate(model, (GLfloat)glfwGetTime() / (i + 1) * 2, glm::vec3(0.0f, 1.0f, 0.0f));
			model = glm::scale(model, glm::vec3(size[i]));
			glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
			glUniform3f(objectcolorLoc, 1.0f - (GLfloat)0.14f * i, 0.0f + (GLfloat)0.1f * i, 0.0f + (GLfloat)0.1f * i);
			glDrawArrays(GL_TRIANGLES, 0, 36);
		}
		glBindVertexArray(0);
		glUseProgram(program1);
		modelLoc = glGetUniformLocation(program1, "model");
		viewLoc = glGetUniformLocation(program1, "view");
		projLoc = glGetUniformLocation(program1, "projection");
		glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
		glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
		model = glm::mat4();
		model = glm::translate(model, lightPos);
		model = glm::scale(model, glm::vec3(10.0f));
		model = glm::rotate(model, (GLfloat)glfwGetTime() *0.2f, glm::vec3(0.0f, 1.0f, 0.0f));
		glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
		glBindVertexArray(vaol);
		glDrawArrays(GL_TRIANGLES, 0, 36);
		glBindVertexArray(0);
		glfwSwapBuffers(window);
	}
	glfwTerminate();
	return 0;
}
Exemple #10
0
void Shader::create(const std::string _vertexFileName, const std::string& _fragmentFileName)
{
	clear();
	assert(!_vertexFileName.empty() && !_fragmentFileName.empty());
	// Vertex Shader Loading
	unsigned int vertexShader;
	std::ifstream fileVs;
	fileVs.open(_vertexFileName.c_str(), std::ios::binary);
	assert(fileVs.is_open());
	if(fileVs.is_open())
	{  
		fileVs.seekg(0, std::ios::end);    
		unsigned int fileSize = (unsigned int)(fileVs.tellg());
		assert(fileSize != 0);
		fileVs.seekg(std::ios::beg);       
		char *bufferVs = new char[fileSize+1];
		fileVs.read(bufferVs, fileSize);
		fileVs.close();
		bufferVs[fileSize] = '\0';
		///////////////////////////////////////////////////////////////////
		vertexShader = glCreateShader(GL_VERTEX_SHADER);
		assert(vertexShader != 0);
		glShaderSource(vertexShader, 1, (const char **)(&bufferVs), NULL);
		glCompileShader(vertexShader);
		delete [] bufferVs;
		//Get Compilation Information
		int compiled;
		glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &compiled);
		if(compiled == 0) 
		{
			int length;
			glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &length);
			char *str = new char[length];
			glGetShaderInfoLog(vertexShader, length, NULL, str);
			std::cerr << "Vertex shader error " << str << std::endl;
			delete [] str;
			assert(false);
			return;
		}
	}
	else
	{
		std::cerr << "Didn't succeed to open the vertex shader file!" << std::endl;
		assert(false);
		return;
	}

	// Fragment Shader Loading
	unsigned int fragmentShader;
	std::ifstream fileFs;
	fileFs.open(_fragmentFileName.c_str(), std::ios::binary);
	assert(fileFs.is_open());
	if(fileFs.is_open())
	{  
		fileFs.seekg(0, std::ios::end);    
		unsigned int fileSize = (unsigned int)(fileFs.tellg());
		assert(fileSize != 0);
		fileFs.seekg(std::ios::beg);       
		char *bufferFs = new char[fileSize+1];
		fileFs.read(bufferFs, fileSize);
		fileFs.close();
		bufferFs[fileSize] = '\0';
		///////////////////////////////////////////////////////////////////
		fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
		assert(fragmentShader != 0);
		glShaderSource(fragmentShader, 1, (const char **)(&bufferFs), NULL);
		glCompileShader(fragmentShader);
		delete [] bufferFs;
		//Get Compilation Information
		int compiled;
		glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &compiled);
		if(compiled == 0) 
		{
			int length;
			glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &length);
			char *str = new char[length];
			glGetShaderInfoLog(fragmentShader, length, NULL, str);
			std::cerr << "Fragment shader Error " << str << std::endl;
			delete [] str;
			assert(false);
			return;
		}
	}
	else
	{
		std::cerr << "Didn't succeed to open the fragment shader file!" << std::endl;
		assert(false);
		return;
	}

	//Bind Vertex and Fragment
	programObj_ = glCreateProgram();
	assert(programObj_ != 0);
	glAttachShader(programObj_, vertexShader);
	glAttachShader(programObj_, fragmentShader);
	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);

	glLinkProgram(programObj_);
	//Get Linker Information
	int linked;
	glGetProgramiv(programObj_, GL_LINK_STATUS, &linked);
	if(linked == 0)
	{
		int length;
		glGetProgramiv(programObj_, GL_INFO_LOG_LENGTH, &length);
		char *str = new char[length];
		glGetProgramInfoLog(programObj_, length, NULL, str);
		std::cerr << "Linker error " << str << std::endl;
		delete [] str;
		clear();
		assert(false);
	}
}
Exemple #11
0
GLuint LoadShaders(const char * vertex_file_path, const char * fragment_file_path){

	// Create the shaders
	GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
	GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

	// Read the Vertex Shader code from the file
	std::string VertexShaderCode;
	std::ifstream VertexShaderStream(vertex_file_path, std::ios::in);
	if (VertexShaderStream.is_open()){
		std::string Line = "";
		while (getline(VertexShaderStream, Line))
			VertexShaderCode += "\n" + Line;
		VertexShaderStream.close();
	}
	else{
		printf("Impossible to open %s. Are you in the right directory ? Don't forget to read the FAQ !\n", vertex_file_path);
		getchar();
		return 0;
	}

	// Read the Fragment Shader code from the file
	std::string FragmentShaderCode;
	std::ifstream FragmentShaderStream(fragment_file_path, std::ios::in);
	if (FragmentShaderStream.is_open()){
		std::string Line = "";
		while (getline(FragmentShaderStream, Line))
			FragmentShaderCode += "\n" + Line;
		FragmentShaderStream.close();
	}



	GLint Result = GL_FALSE;
	int InfoLogLength;



	// Compile Vertex Shader
	printf("Compiling shader : %s\n", vertex_file_path);
	char const * VertexSourcePointer = VertexShaderCode.c_str();
	glShaderSource(VertexShaderID, 1, &VertexSourcePointer, NULL);
	glCompileShader(VertexShaderID);

	// Check Vertex Shader
	glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
	glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
	if (InfoLogLength > 0){
		std::vector<char> VertexShaderErrorMessage(InfoLogLength + 1);
		glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
		printf("%s\n", &VertexShaderErrorMessage[0]);
	}



	// Compile Fragment Shader
	printf("Compiling shader : %s\n", fragment_file_path);
	char const * FragmentSourcePointer = FragmentShaderCode.c_str();
	glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer, NULL);
	glCompileShader(FragmentShaderID);

	// Check Fragment Shader
	glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
	glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
	if (InfoLogLength > 0){
		std::vector<char> FragmentShaderErrorMessage(InfoLogLength + 1);
		glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
		printf("%s\n", &FragmentShaderErrorMessage[0]);
	}



	// Link the program
	printf("Linking program\n");
	GLuint ProgramID = glCreateProgram();
	glAttachShader(ProgramID, VertexShaderID);
	glAttachShader(ProgramID, FragmentShaderID);
	glLinkProgram(ProgramID);

	// Check the program
	glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
	glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
	if (InfoLogLength > 0){
		std::vector<char> ProgramErrorMessage(InfoLogLength + 1);
		glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
		printf("%s\n", &ProgramErrorMessage[0]);
	}

	glDeleteShader(VertexShaderID);
	glDeleteShader(FragmentShaderID);

	return ProgramID;
}
Exemple #12
0
/////////////////////////////////////////////////////////////////
// Load a pair of shaders, compile, and link together. Specify the complete
// file path for each shader. Note, there is no support for
// just loading say a vertex program... you have to do both.
GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg, bool loadFromFile)
{
	// Temporary Shader objects
	GLuint hVertexShader;
	GLuint hFragmentShader; 
	GLuint hReturn = 0;   
	GLint testVal;

	// Create shader objects
	hVertexShader = glCreateShader(GL_VERTEX_SHADER);
	hFragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

	if (loadFromFile)
	{

		if(gltLoadShaderFile(szVertexProg, hVertexShader) == false)
		{
			glDeleteShader(hVertexShader);
			glDeleteShader(hFragmentShader);
			return (GLuint)NULL;
		}

		if(gltLoadShaderFile(szFragmentProg, hFragmentShader) == false)
		{
			glDeleteShader(hVertexShader);
			glDeleteShader(hFragmentShader);
			return (GLuint)NULL;
		}
	} else
	{
		gltLoadShaderSrc(vertexShader, hVertexShader);
		gltLoadShaderSrc(fragmentShader, hFragmentShader);
	}
	// Compile them
	glCompileShader(hVertexShader);
	glCompileShader(hFragmentShader);

	// Check for errors
	glGetShaderiv(hVertexShader, GL_COMPILE_STATUS, &testVal);
	if(testVal == GL_FALSE)
	{
			 char temp[256] = "";
			glGetShaderInfoLog( hVertexShader, 256, NULL, temp);
			fprintf( stderr, "Compile failed:\n%s\n", temp);
			assert(0);
			exit(0);
		glDeleteShader(hVertexShader);
		glDeleteShader(hFragmentShader);
		return (GLuint)NULL;
	}

	glGetShaderiv(hFragmentShader, GL_COMPILE_STATUS, &testVal);
	if(testVal == GL_FALSE)
	{
		 char temp[256] = "";
			glGetShaderInfoLog( hFragmentShader, 256, NULL, temp);
			fprintf( stderr, "Compile failed:\n%s\n", temp);
			assert(0);
			exit(0);
		glDeleteShader(hVertexShader);
		glDeleteShader(hFragmentShader);
		return (GLuint)NULL;
	}

	// Link them - assuming it works...
	hReturn = glCreateProgram();
	glAttachShader(hReturn, hVertexShader);
	glAttachShader(hReturn, hFragmentShader);

	glLinkProgram(hReturn);

	// These are no longer needed
	glDeleteShader(hVertexShader);
	glDeleteShader(hFragmentShader);  

	// Make sure link worked too
	glGetProgramiv(hReturn, GL_LINK_STATUS, &testVal);
	if(testVal == GL_FALSE)
	{
		glDeleteProgram(hReturn);
		return (GLuint)NULL;
	}

	return hReturn;  
}   
// load shaders
GLuint loadShader(const char *vertex_path, const char *fragment_path)
{
    // create shaders
    GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);
    GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);

    // read shaders
    std::string vertShaderStr = readFile(vertex_path);
    std::string fragShaderStr = readFile(fragment_path);
    const char *vertShaderSrc = vertShaderStr.c_str();
    const char *fragShaderSrc = fragShaderStr.c_str();

    // hold results
    GLint result = GL_FALSE;
    int logLength;

    // compile vertex shader
    glShaderSource(vertShader, 1, &vertShaderSrc, NULL);
    glCompileShader(vertShader);

    // check vertex shader
    glGetShaderiv(vertShader, GL_COMPILE_STATUS, &result);

        // failed compile
        if(!result)
        {
            glGetShaderiv(vertShader, GL_INFO_LOG_LENGTH, &logLength);
            std::vector<char> vertShaderError((logLength > 1) ? logLength : 1);
            glGetShaderInfoLog(vertShader, logLength, NULL, &vertShaderError[0]);
            std::cerr << "[F] FAILED TO COMPILE VERTEX SHADER!" << &vertShaderError[0] << std::endl;
            return false;
        }

    // compile fragment shader
    glShaderSource(fragShader, 1, &fragShaderSrc, NULL);
    glCompileShader(fragShader);

    // check fragment shader
    glGetShaderiv(fragShader, GL_COMPILE_STATUS, &result);

        // failed compile
        if(!result)
        {
            glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &logLength);
            std::vector<char> fragShaderError((logLength > 1) ? logLength : 1);
            glGetShaderInfoLog(fragShader, logLength, NULL, &fragShaderError[0]);
            std::cerr << "[F] FAILED TO COMPILE FRAGMENT SHADER!" << &fragShaderError[0] << std::endl;
            return false;
        }

    // create program and link with shaders
    GLuint program = glCreateProgram();
    glAttachShader(program, vertShader);
    glAttachShader(program, fragShader);
    glLinkProgram(program);

    // check program status
    glGetProgramiv(program, GL_LINK_STATUS, &result);

        // failed program
        if(!result)
        {
            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
            std::vector<char> programError( (logLength > 1) ? logLength : 1 );
            glGetProgramInfoLog(program, logLength, NULL, &programError[0]);
            std::cerr << "[F] THE SHADER PROGRAM FAILED TO LINK" << &programError[0] << std::endl;
            return false;
        }

    // delete shaders after attachment
    glDeleteShader(vertShader);
    glDeleteShader(fragShader);

    // return program with shaders
    return program;
}
int main()
{
    int width = 640;
    int height = 480;
    
    if(glfwInit() == GL_FALSE)
    {
        std::cerr << "failed to init GLFW" << std::endl;
        return 1;
    }

    // sadly glew doesn't play nice with core profiles... 
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
 
    // create a window
    if(glfwOpenWindow(width, height, 0, 0, 0, 8, 24, 8, GLFW_WINDOW) == GL_FALSE)
    {
        std::cerr << "failed to open window" << std::endl;
        glfwTerminate();
        return 1;
    }
    
    // setup windows close callback
    glfwSetWindowCloseCallback(closedWindow);
    
    // this time we disable the mouse cursor since we want differential
    // mouse input
    glfwDisable(GLFW_MOUSE_CURSOR);
    
    
    
    if (gl3wInit())
    {
        std::cerr << "failed to init GL3W" << std::endl;
        glfwCloseWindow();
        glfwTerminate();
        return 1;
    }

    // draw shader
    std::string vertex_source =
        "#version 330\n"
        "uniform mat4 ViewProjection;\n"
        "layout(location = 0) in vec4 vposition;\n"
        "layout(location = 1) in vec3 normal;\n"
        "out vec4 fcolor;\n"
        "void main() {\n"
        "   float brightness = dot(normal,normalize(vec3(1,2,3)));\n"
        "   brightness = 0.3+((brightness>0)?0.7*brightness:0.3*brightness);\n"
        "   fcolor = vec4(brightness,brightness,brightness,1);\n"
        "   gl_Position = ViewProjection*vposition;\n"
        "}\n";
        
    std::string fragment_source =
        "#version 330\n"
        "in vec4 fcolor;\n"
        "layout(location = 0) out vec4 FragColor;\n"
        "void main() {\n"
        "   FragColor = abs(fcolor);\n"
        "}\n";
    
    // program and shader handles
    GLuint shader_program, vertex_shader, fragment_shader;
    
    // we need these to properly pass the strings
    const char *source;
    int length;

    // create and compiler vertex shader
    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    source = vertex_source.c_str();
    length = vertex_source.size();
    glShaderSource(vertex_shader, 1, &source, &length); 
    glCompileShader(vertex_shader);
    if(!check_shader_compile_status(vertex_shader))
    {
        return 1;
    }
 
    // create and compiler fragment shader
    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    source = fragment_source.c_str();
    length = fragment_source.size();
    glShaderSource(fragment_shader, 1, &source, &length);   
    glCompileShader(fragment_shader);
    if(!check_shader_compile_status(fragment_shader))
    {
        return 1;
    }
    
    // create program
    shader_program = glCreateProgram();
    
    // attach shaders
    glAttachShader(shader_program, vertex_shader);
    glAttachShader(shader_program, fragment_shader);
    
    // link the program and check for errors
    glLinkProgram(shader_program);
    check_program_link_status(shader_program);
    
    // obtain location of projection uniform
    GLint DrawViewProjection_location = glGetUniformLocation(shader_program, "ViewProjection");
 

    // trivial shader for occlusion queries
    std::string query_vertex_source =
        "#version 330\n"
        "uniform mat4 ViewProjection;\n"
        "layout(location = 0) in vec4 vposition;\n"
        "void main() {\n"
        "   gl_Position = ViewProjection*vposition;\n"
        "}\n";
        
    std::string query_fragment_source =
        "#version 330\n"
        "void main() {\n"
        "}\n";
    
    // program and shader handles
    GLuint query_shader_program, query_vertex_shader, query_fragment_shader;

    // create and compiler vertex shader
    query_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    source = query_vertex_source.c_str();
    length = query_vertex_source.size();
    glShaderSource(query_vertex_shader, 1, &source, &length); 
    glCompileShader(query_vertex_shader);
    if(!check_shader_compile_status(query_vertex_shader))
    {
        return 1;
    }
 
    // create and compiler fragment shader
    query_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    source = query_fragment_source.c_str();
    length = query_fragment_source.size();
    glShaderSource(query_fragment_shader, 1, &source, &length);   
    glCompileShader(query_fragment_shader);
    if(!check_shader_compile_status(query_fragment_shader))
    {
        return 1;
    }
    
    // create program
    query_shader_program = glCreateProgram();
    
    // attach shaders
    glAttachShader(query_shader_program, query_vertex_shader);
    glAttachShader(query_shader_program, query_fragment_shader);
    
    // link the program and check for errors
    glLinkProgram(query_shader_program);
    check_program_link_status(query_shader_program);
    
    // obtain location of projection uniform
    GLint QueryViewProjection_location = glGetUniformLocation(query_shader_program, "ViewProjection");


    // chunk container and chunk parameters
    std::vector<Chunk> chunks;
    int chunkrange = 4;
    int chunksize = 32;
    
    // chunk extraction
    std::cout << "generating chunks, this may take a while." << std::endl;
    
    // iterate over all chunks we want to extract        
    for(int i = -chunkrange;i<chunkrange;++i)
        for(int j = -chunkrange;j<chunkrange;++j)
            for(int k = -chunkrange;k<chunkrange;++k)
    {
        
        Chunk chunk;
        
        // chunk data
        
        // generate and bind the vao
        glGenVertexArrays(1, &chunk.vao);
        glBindVertexArray(chunk.vao);
        
        // generate and bind the vertex buffer object
        glGenBuffers(1, &chunk.vbo);
        glBindBuffer(GL_ARRAY_BUFFER, chunk.vbo);
        
        std::vector<glm::vec3> vertexData;
        glm::vec3 offset = static_cast<float>(chunksize) * glm::vec3(i,j,k);
        float threshold = 0.0f;
        // iterate over all blocks within the chunk
        for(int x = 0;x<chunksize;++x)
            for(int y = 0;y<chunksize;++y)
                for(int z = 0;z<chunksize;++z)
                {
                    glm::vec3 pos = glm::vec3(x,y,z) + offset;
                    // insert quads if current block is solid and neighbors are not
                    if(world_function(pos)<threshold)
                    {
                        if(world_function(pos+glm::vec3(1,0,0))>=threshold)
                        {
                            vertexData.push_back(pos+0.5f*glm::vec3( 1, 1, 1));
                            vertexData.push_back(glm::vec3( 1, 0, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3( 1,-1, 1));
                            vertexData.push_back(glm::vec3( 1, 0, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3( 1, 1,-1));
                            vertexData.push_back(glm::vec3( 1, 0, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3( 1,-1,-1));
                            vertexData.push_back(glm::vec3( 1, 0, 0));
                        }
                        if(world_function(pos+glm::vec3(0,1,0))>=threshold)
                        {
                            vertexData.push_back(pos+0.5f*glm::vec3( 1, 1, 1));
                            vertexData.push_back(glm::vec3( 0, 1, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3( 1, 1,-1));
                            vertexData.push_back(glm::vec3( 0, 1, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1, 1, 1));
                            vertexData.push_back(glm::vec3( 0, 1, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1, 1,-1));
                            vertexData.push_back(glm::vec3( 0, 1, 0));
                        }
                        if(world_function(pos+glm::vec3(0,0,1))>=threshold)
                        {
                            vertexData.push_back(pos+0.5f*glm::vec3( 1, 1, 1));
                            vertexData.push_back(glm::vec3( 0, 0, 1));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1, 1, 1));
                            vertexData.push_back(glm::vec3( 0, 0, 1));
                            vertexData.push_back(pos+0.5f*glm::vec3( 1,-1, 1));
                            vertexData.push_back(glm::vec3( 0, 0, 1));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1,-1, 1));
                            vertexData.push_back(glm::vec3( 0, 0, 1));
                        }
                        if(world_function(pos-glm::vec3(1,0,0))>=threshold)
                        {
                            vertexData.push_back(pos+0.5f*glm::vec3(-1, 1, 1));
                            vertexData.push_back(glm::vec3(-1, 0, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1, 1,-1));
                            vertexData.push_back(glm::vec3(-1, 0, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1,-1, 1));
                            vertexData.push_back(glm::vec3(-1, 0, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1,-1,-1));
                            vertexData.push_back(glm::vec3(-1, 0, 0));
                        }
                        if(world_function(pos-glm::vec3(0,1,0))>=threshold)
                        {
                            vertexData.push_back(pos+0.5f*glm::vec3( 1,-1, 1));
                            vertexData.push_back(glm::vec3( 0,-1, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1,-1, 1));
                            vertexData.push_back(glm::vec3( 0,-1, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3( 1,-1,-1));
                            vertexData.push_back(glm::vec3( 0,-1, 0));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1,-1,-1));
                            vertexData.push_back(glm::vec3( 0,-1, 0));
                        }
                        if(world_function(pos-glm::vec3(0,0,1))>=threshold)
                        {
                            vertexData.push_back(pos+0.5f*glm::vec3( 1, 1,-1));
                            vertexData.push_back(glm::vec3( 0, 0,-1));
                            vertexData.push_back(pos+0.5f*glm::vec3( 1,-1,-1));
                            vertexData.push_back(glm::vec3( 0, 0,-1));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1, 1,-1));
                            vertexData.push_back(glm::vec3( 0, 0,-1));
                            vertexData.push_back(pos+0.5f*glm::vec3(-1,-1,-1));
                            vertexData.push_back(glm::vec3( 0, 0,-1));
                        }
                    }
                }
        // upload
        glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3)*vertexData.size(), &vertexData[0], GL_STATIC_DRAW);
                        
               
        // set up generic attrib pointers
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), (char*)0 + 0*sizeof(GLfloat));
     
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), (char*)0 + 3*sizeof(GLfloat));
        
        
        // generate and bind the index buffer object
        glGenBuffers(1, &chunk.ibo);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, chunk.ibo);
        
        chunk.quadcount = vertexData.size()/8;
        std::vector<GLuint> indexData(6*chunk.quadcount);
        for(int i = 0;i<chunk.quadcount;++i)
        {
            indexData[6*i + 0] = 4*i + 0;
            indexData[6*i + 1] = 4*i + 1;
            indexData[6*i + 2] = 4*i + 2;
            indexData[6*i + 3] = 4*i + 2;
            indexData[6*i + 4] = 4*i + 1;
            indexData[6*i + 5] = 4*i + 3;
        }
        
        // upload
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*indexData.size(), &indexData[0], GL_STATIC_DRAW);


        // chunk bounding box

        // generate and bind the vao
        glGenVertexArrays(1, &chunk.bounding_vao);
        glBindVertexArray(chunk.bounding_vao);
        
        // generate and bind the vertex buffer object
        glGenBuffers(1, &chunk.bounding_vbo);
        glBindBuffer(GL_ARRAY_BUFFER, chunk.bounding_vbo);
                
        // data for the bounding cube
        GLfloat boundingVertexData[] = {
        //  X                           Y                           Z 
        // face 0:
            offset.x+chunksize-0.5f,    offset.y+chunksize-0.5f,    offset.z+chunksize-0.5f,
            offset.x-0.5f,              offset.y+chunksize-0.5f,    offset.z+chunksize-0.5f,
            offset.x+chunksize-0.5f,    offset.y-0.5f,              offset.z+chunksize-0.5f,
            offset.x-0.5f,              offset.y-0.5f,              offset.z+chunksize-0.5f,

        // face 1:
            offset.x+chunksize-0.5f,    offset.y+chunksize-0.5f,    offset.z+chunksize-0.5f,
            offset.x+chunksize-0.5f,    offset.y-0.5f,              offset.z+chunksize-0.5f,
            offset.x+chunksize-0.5f,    offset.y+chunksize-0.5f,    offset.z-0.5f,
            offset.x+chunksize-0.5f,    offset.y-0.5f,              offset.z-0.5f,

        // face 2:
            offset.x+chunksize-0.5f,    offset.y+chunksize-0.5f,    offset.z+chunksize-0.5f,
            offset.x+chunksize-0.5f,    offset.y+chunksize-0.5f,    offset.z-0.5f,
            offset.x-0.5f,              offset.y+chunksize-0.5f,    offset.z+chunksize-0.5f,
            offset.x-0.5f,              offset.y+chunksize-0.5f,    offset.z-0.5f,
          
        // face 3:
            offset.x+chunksize-0.5f,    offset.y+chunksize-0.5f,    offset.z-0.5f,
            offset.x+chunksize-0.5f,    offset.y-0.5f,              offset.z-0.5f,
            offset.x-0.5f,              offset.y+chunksize-0.5f,    offset.z-0.5f,
            offset.x-0.5f,              offset.y-0.5f,              offset.z-0.5f,

        // face 4:
            offset.x-0.5f,              offset.y+chunksize-0.5f,    offset.z+chunksize-0.5f,
            offset.x-0.5f,              offset.y+chunksize-0.5f,    offset.z-0.5f,
            offset.x-0.5f,              offset.y-0.5f,              offset.z+chunksize-0.5f,
            offset.x-0.5f,              offset.y-0.5f,              offset.z-0.5f,

        // face 5:
            offset.x+chunksize-0.5f,    offset.y-0.5f,              offset.z+chunksize-0.5f,
            offset.x-0.5f,              offset.y-0.5f,              offset.z+chunksize-0.5f,
            offset.x+chunksize-0.5f,    offset.y-0.5f,              offset.z-0.5f,
            offset.x-0.5f,              offset.y-0.5f,              offset.z-0.5f,
        }; // 6 faces with 4 vertices with 6 components (floats)

        // fill with data
        glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*6*4*3, boundingVertexData, GL_STATIC_DRAW);
                        
               
        // set up generic attrib pointers
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), (char*)0 + 0*sizeof(GLfloat));
        
        // generate and bind the index buffer object
        glGenBuffers(1, &chunk.bounding_ibo);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, chunk.bounding_ibo);
                
        GLuint boundingIndexData[] = {
             0, 1, 2, 2, 1, 3, 4, 5, 6, 6, 5, 7, 8, 9,10,10, 9,11,
            12,13,14,14,13,15,16,17,18,18,17,19,20,21,22,22,21,23,
        };

        // fill with data
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*6*2*3, boundingIndexData, GL_STATIC_DRAW);
        
        // generate the query object for the occlusion query
        glGenQueries(1, &chunk.query);
        
        // set the center location of the chunk
        chunk.center = offset + 0.5f*chunksize;
        
        // add to container
        chunks.push_back(chunk);
    }
    
    // "unbind" vao
    glBindVertexArray(0);

    // timer query setup
    // use multiple queries to avoid stalling on getting the results
    const int querycount = 5;
    GLuint queries[querycount];
    int current_query = 0;
    glGenQueries(querycount, queries);
    
    // we are drawing 3d objects so we want depth testing
    glEnable(GL_DEPTH_TEST);

    // camera position and orientation
    glm::vec3 position;
    glm::mat4 rotation = glm::mat4(1.0f);
    
    running = true;
    float t = glfwGetTime();
    bool occlusion_cull = true;
    bool space_down = false;
    
    // mouse position
    int mousex, mousey;
    glfwGetMousePos(&mousex, &mousey);
    while(running)
    {   
        // calculate timestep
        float new_t = glfwGetTime();
        float dt = new_t - t;
        t = new_t;

        // update mouse differential
        int tmpx, tmpy;
        glfwGetMousePos(&tmpx, &tmpy);
        glm::vec2 mousediff(tmpx-mousex, tmpy-mousey);
        mousex = tmpx;
        mousey = tmpy;
        
        // find up, forward and right vector
        glm::mat3 rotation3(rotation);
        glm::vec3 up = glm::transpose(rotation3)*glm::vec3(0.0f, 1.0f, 0.0f);
        glm::vec3 right = glm::transpose(rotation3)*glm::vec3(1.0f, 0.0f, 0.0f);
        glm::vec3 forward = glm::transpose(rotation3)*glm::vec3(0.0f, 0.0f,-1.0f);
        
        // apply mouse rotation
        rotation = glm::rotate(rotation,  0.2f*mousediff.x, up);
        rotation = glm::rotate(rotation,  0.2f*mousediff.y, right);
        
        // roll
        if(glfwGetKey('Q'))
        {
            rotation = glm::rotate(rotation, 180.0f*dt, forward); 
        }  
        if(glfwGetKey('E'))
        {
            rotation = glm::rotate(rotation,-180.0f*dt, forward); 
        }
        
        // movement
        if(glfwGetKey('W'))
        {
            position += 10.0f*dt*forward; 
        }  
        if(glfwGetKey('S'))
        {
            position -= 10.0f*dt*forward;
        }
        if(glfwGetKey('D'))
        {
            position += 10.0f*dt*right; 
        }  
        if(glfwGetKey('A'))
        {
            position -= 10.0f*dt*right;
        }
        
        // toggle occlusion culling
        if(glfwGetKey(GLFW_KEY_SPACE) && !space_down)
        {
            occlusion_cull = !occlusion_cull;
        }
        space_down = glfwGetKey(GLFW_KEY_SPACE);
        
        // terminate on escape 
        if(glfwGetKey(GLFW_KEY_ESC))
        {
            running = false;
        }
        
        
        // calculate ViewProjection matrix
        glm::mat4 Projection = glm::perspective(90.0f, 4.0f / 3.0f, 0.1f, 200.f);
        glm::mat4 View = rotation*glm::translate(glm::mat4(1.0f), -position);
        glm::mat4 ViewProjection = Projection*View;


        // set matrices for both shaders
        glUseProgram(query_shader_program);
        glUniformMatrix4fv(QueryViewProjection_location, 1, GL_FALSE, glm::value_ptr(ViewProjection)); 
        glUseProgram(shader_program);
        glUniformMatrix4fv(DrawViewProjection_location, 1, GL_FALSE, glm::value_ptr(ViewProjection));
        
        // set clear color to sky blue
        glClearColor(0.5f,0.8f,1.0f,1.0f);
        
        // clear
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // sort chunks by distance
        std::sort(chunks.begin(), chunks.end(), DistancePred(position));
        
        size_t i = 0;
        float maxdist = chunksize;

        // start timer query
        glBeginQuery(GL_TIME_ELAPSED, queries[current_query]);
        
        // peel chunks
        while(i!=chunks.size())
        {
            size_t j = i;
            if(occlusion_cull)
            {
                // start occlusion queries and render for the current slice
                glDisable(GL_CULL_FACE);
                
                // we don't want the queries to actually render something
                glDepthMask(GL_FALSE);
                glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
                glUseProgram(query_shader_program);
                for(;j<chunks.size() && glm::distance(chunks[j].center, position)<maxdist;++j)
                {
                    // frustum culling
                    glm::vec4 projected = ViewProjection*glm::vec4(chunks[j].center,1);
                    if( (glm::distance(chunks[j].center,position) > chunksize) &&
                        (std::max(std::abs(projected.x), std::abs(projected.y)) > projected.w+chunksize))
                        continue;
                    
                    // begin occlusion query
                    glBeginQuery(GL_ANY_SAMPLES_PASSED, chunks[j].query);
                    
                    // draw bounding box
                    glBindVertexArray(chunks[j].bounding_vao);
                    glDrawElements(GL_TRIANGLES, 6*6, GL_UNSIGNED_INT, 0);
                    
                    // end occlusion query
                    glEndQuery(GL_ANY_SAMPLES_PASSED);
                }
                j = i;
            }

            // render the current slice
            glEnable(GL_CULL_FACE);
            
            // turn rendering back on
            glDepthMask(GL_TRUE);
            glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
            glUseProgram(shader_program);
            for(;j<chunks.size() && glm::distance(chunks[j].center, position)<maxdist;++j)
            {
                // frustum culling
                glm::vec4 projected = ViewProjection*glm::vec4(chunks[j].center,1);
                if( (glm::distance(chunks[j].center,position) > chunksize) &&
                    (std::max(std::abs(projected.x), std::abs(projected.y)) > projected.w+chunksize))
                    continue;
                
                // begin conditional render
                if(occlusion_cull)
                    glBeginConditionalRender(chunks[j].query, GL_QUERY_BY_REGION_WAIT);
                
                // draw chunk
                glBindVertexArray(chunks[j].vao);
                glDrawElements(GL_TRIANGLES, 6*chunks[j].quadcount, GL_UNSIGNED_INT, 0);
                
                // end conditional render
                if(occlusion_cull)
                    glEndConditionalRender();
            }
            i = j;
            maxdist += 2*chunksize;
        }
        
        // end timer query
        glEndQuery(GL_TIME_ELAPSED);
        
        // display timer query results from querycount frames before
        if(GL_TRUE == glIsQuery(queries[(current_query+1)%querycount]))
        {
            GLuint64 result;
            glGetQueryObjectui64v(queries[(current_query+1)%querycount], GL_QUERY_RESULT, &result);
            std::cout << result*1.e-6 << " ms/frame" << std::endl;
        }
        // advance query counter
        current_query = (current_query + 1)%querycount;
        
        // check for errors
        GLenum error = glGetError();
        if(error != GL_NO_ERROR)
        {
            std::cerr << gluErrorString(error);
            running = false;       
        }
        
        // finally swap buffers
        glfwSwapBuffers();       
    }
    
    // delete the created objects
    
    for(size_t i = 0;i<chunks.size();++i)
    {    
        glDeleteVertexArrays(1, &chunks[i].vao);
        glDeleteBuffers(1, &chunks[i].vbo);
        glDeleteBuffers(1, &chunks[i].ibo);
        glDeleteVertexArrays(1, &chunks[i].bounding_vao);
        glDeleteBuffers(1, &chunks[i].bounding_vbo);
        glDeleteBuffers(1, &chunks[i].bounding_ibo);
        glDeleteQueries(1, &chunks[i].query);
    }
    
    glDeleteQueries(querycount, queries);
    
    glDetachShader(shader_program, vertex_shader);	
    glDetachShader(shader_program, fragment_shader);
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);
    glDeleteProgram(shader_program);

    glDetachShader(query_shader_program, query_vertex_shader);	
    glDetachShader(query_shader_program, query_fragment_shader);
    glDeleteShader(query_vertex_shader);
    glDeleteShader(query_fragment_shader);
    glDeleteProgram(query_shader_program);
    
    glfwCloseWindow();
    glfwTerminate();
    return 0;
}
Exemple #15
0
 Shader(const std::string &fileName, GLenum type) :
         mObjectName(0), mType(type) {
     mObjectName = glCreateShader(mType);
     setFromFile(fileName);
 }
// Create a GLSL program object from vertex and fragment shader files
GLuint
InitShader(const char* vShaderFile, const char* fShaderFile)
{
    struct Shader {
	const char*  filename;
	GLenum       type;
	GLchar*      source;
    }  shaders[2] = {
	{ vShaderFile, GL_VERTEX_SHADER, NULL },
	{ fShaderFile, GL_FRAGMENT_SHADER, NULL }
    };

    GLuint program = glCreateProgram();
    
    for ( int i = 0; i < 2; ++i ) {
	Shader& s = shaders[i];
	s.source = readShaderSource( s.filename );
	if ( shaders[i].source == NULL ) {
	    std::cerr << "Failed to read " << s.filename << std::endl;
	    exit( EXIT_FAILURE );
	}

	GLuint shader = glCreateShader( s.type );
	glShaderSource( shader, 1, (const GLchar**) &s.source, NULL );
	glCompileShader( shader );

	GLint  compiled;
	glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );
	if ( !compiled ) {
	    std::cerr << s.filename << " failed to compile:" << std::endl;
	    GLint  logSize;
	    glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &logSize );
	    char* logMsg = new char[logSize];
	    glGetShaderInfoLog( shader, logSize, NULL, logMsg );
	    std::cerr << logMsg << std::endl;
	    delete [] logMsg;

	    exit( EXIT_FAILURE );
	}

	delete [] s.source;

	glAttachShader( program, shader );
    }

    /* link  and error check */
    glLinkProgram(program);

    GLint  linked;
    glGetProgramiv( program, GL_LINK_STATUS, &linked );
    if ( !linked ) {
	std::cerr << "Shader program failed to link" << std::endl;
	GLint  logSize;
	glGetProgramiv( program, GL_INFO_LOG_LENGTH, &logSize);
	char* logMsg = new char[logSize];
	glGetProgramInfoLog( program, logSize, NULL, logMsg );
	std::cerr << logMsg << std::endl;
	delete [] logMsg;

	exit( EXIT_FAILURE );
    }

    /* use program object */
    glUseProgram(program);

    return program;
}
Exemple #17
0
	GLShader::GLShader(EGLShaderType type, const string &filename)
		:m_ID(GL_NONE), m_type(type)
	{
		// Check if file exists
		if(!fileExists(filename))
		{
			cerr << "Shader source file '" << filename << "' does not exist." << endl;
		}

		// File exists
		else
		{
			// Create shader
			m_ID = glCreateShader(getShaderTypeConstant(type));

			if(m_ID == GL_NONE)
			{
				cerr << "Could not create OpenGL shader." << endl;
			}

			// Successfully created shader
			else
			{
				cout << "Created OpenGL shader: " << m_ID << endl;

				// Load shader source
				string line, source;
				ifstream sourceStream(filename);
				while(sourceStream.good() && !sourceStream.eof())
				{
					getline(sourceStream, line);
					source.append(line + "\n");
				}

				// Compile shader
				const char *sourceCString = source.c_str();
				glShaderSource(m_ID, 1, &sourceCString, nullptr);
				glCompileShader(m_ID);

				// Check compilation
				GLint compileResult;
				glGetShaderiv(m_ID, GL_COMPILE_STATUS, &compileResult);
				if(compileResult != GL_TRUE)
				{
					cerr << "Shader compilation of file '" << filename << "' failed." << endl;

					GLsizei logLength;
					GLchar  log[1024];
					glGetShaderInfoLog(	m_ID, sizeof(log), &logLength, log);

					cerr << "Shader info log: " << endl << log << endl;
				}

				// Compilation worked
				else
				{
					cout << "Successfully compiled shader '" << filename << "'" << endl;
				}
			}
		}
	}
Exemple #18
0
void Poh::gLib::Shader::glibShader::Build(Poh::gLib::Application::itfApplication * _application, const char * VertexShaderSource, const char * FragmentShaderSource)
{
	if (_application->MakeContextCurrent() != 0) {
		throw glibException(GLIB_ERROR_TYPE_SHADER | OPENGL_CONTEXT_ERROR);
	}
	if (_shader != 0) { }
	if (glewInit() != GLEW_OK) { throw glibException(GLIB_ERROR_TYPE_SHADER | OPENGL_CONTEXT_ERROR); }

	_shader = glCreateProgram();

	if (_shader == 0) {
		throw glibException(GLIB_ERROR_TYPE_SHADER | OPENGL_SHADER_OVERRIDE_ERROR);
	}

	GLint success = 0;

	success = 0;
	GLuint _vShr = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(_vShr, 1, &VertexShaderSource, 0);
	glCompileShader(_vShr);
	glGetShaderiv(_vShr, GL_COMPILE_STATUS, &success);
	if (success != GL_TRUE)
	{
		GLint len = 0;
		glGetShaderiv(_vShr, GL_INFO_LOG_LENGTH, &success);
		GLchar * log = new GLchar[len]{};
		glGetShaderInfoLog(_vShr, len, 0, log);
		delete[] log;
	}

	success = 0;
	GLuint _fShr = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(_fShr, 1, &FragmentShaderSource, 0);
	glCompileShader(_fShr);
	glGetShaderiv(_fShr, GL_COMPILE_STATUS, &success);
	if (success != GL_TRUE)
	{
		GLint len = 0;
		glGetShaderiv(_fShr, GL_INFO_LOG_LENGTH, &success);
		GLchar * log = new GLchar[len]{};
		glGetShaderInfoLog(_fShr, len, 0, log);
		delete[] log;
	}

	glAttachShader(_shader, _vShr);
	glAttachShader(_shader, _fShr);

	glLinkProgram(_shader);
	success = 0;
	glGetProgramiv(_shader, GL_LINK_STATUS, &success);
	if (success != GL_TRUE)
	{
		GLint len = 0;
		glGetProgramiv(_shader, GL_INFO_LOG_LENGTH, &success);
		GLchar * log = new GLchar[len]{};
		glGetProgramInfoLog(_shader, len, 0, log);
		delete[] log;
	}

	glDeleteShader(_vShr);
	glDeleteShader(_fShr);

	glGenBuffers(1, &_vbo);
	glGenVertexArrays(1, &_vao);
}
GLuint CreateProgram(const char* VertexShader, const char* FragmentShader)
{
	Text sourceVert, sourceFrag;
	//Load Vertex Shader
	sourceVert.readTexFile(VertexShader);
	const char* vpString = sourceVert.getContent();
	//Load Fragment Shader
	sourceFrag.readTexFile(FragmentShader);
	const char* fpString = sourceFrag.getContent();

	GLuint programHandle = glCreateProgram();
	GLint compileSuccess;
	GLchar compilerSpew[256];

	//Attach Vertex Shader 
	GLuint vsHandle = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vsHandle, 1, &vpString, 0);
    glCompileShader(vsHandle);
	glGetShaderiv(vsHandle, GL_COMPILE_STATUS, &compileSuccess);
    glGetShaderInfoLog(vsHandle, sizeof(compilerSpew), 0, compilerSpew);
	if (!compileSuccess) {
		 std::cout<<"Failed to compile/attach";
	 }
	 else
	 {	
		 std::cout<<"Succeded to compile/attach";
	}



    glAttachShader(programHandle, vsHandle);

	//Attach Fragment Shader
	GLuint fsHandle = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fsHandle, 1, &fpString, 0);
    glCompileShader(fsHandle);
	glAttachShader(programHandle, fsHandle);
	glGetShaderiv(fsHandle, GL_COMPILE_STATUS, &compileSuccess);
    glGetShaderInfoLog(fsHandle, sizeof(compilerSpew), 0, compilerSpew);
	if (!compileSuccess) {
		 std::cout<<"Failed to compile/attach";
	 }
	 else
	 {	
		 std::cout<<"Succeded to compile/attach";
	}


	glLinkProgram(programHandle);

	GLint linkSuccess;
	
    glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
    glGetProgramInfoLog(programHandle, sizeof(compilerSpew), 0, compilerSpew);

	 if (!linkSuccess) {
		 std::cout<<"Failed to compile/attach";
	 }
	 else
	 {	
		 std::cout<<"Succeded to compile/attach";
	}


	return programHandle;

}
GLuint
LoadShaders( ShaderInfo* shaders )
{
    if ( shaders == NULL ) { return 0; }

    GLuint program = glCreateProgram();
    ShaderInfo* entry = shaders;
    while ( entry->type != GL_NONE ) {
        GLuint shader = glCreateShader( entry->type );

        entry->shader = shader;

        const GLchar* source = ReadShader( entry->filename );
        if ( source == NULL ) {

            for ( entry = shaders; entry->type != GL_NONE; ++entry ) {
                glDeleteShader( entry->shader );
                entry->shader = 0;
            }

            return 0;
        }

        glShaderSource( shader, 1, &source, NULL );
        delete [] source;

        glCompileShader( shader );

        GLint compiled;
        glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );
        if ( !compiled ) {
#ifdef _DEBUG
            GLsizei len;
            glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &len );

            GLchar* log = new GLchar[len+1];
            glGetShaderInfoLog( shader, len, &len, log );
            std::cerr << "Shader compilation failed: " << log << std::endl;
            delete [] log;
#endif /* DEBUG */

            return 0;
        }

        glAttachShader( program, shader );
        
        ++entry;
    }

    
    glLinkProgram( program );

    GLint linked;
    glGetProgramiv( program, GL_LINK_STATUS, &linked );
    if ( !linked ) {
#ifdef _DEBUG
        GLsizei len;
        glGetProgramiv( program, GL_INFO_LOG_LENGTH, &len );

        GLchar* log = new GLchar[len+1];
        glGetProgramInfoLog( program, len, &len, log );
        std::cerr << "Shader linking failed: " << log << std::endl;
        delete [] log;
#endif /* DEBUG */

        for ( entry = shaders; entry->type != GL_NONE; ++entry ) {
            glDeleteShader( entry->shader );
            entry->shader = 0;
        }
        
        return 0;
    }

    return program;
}
Exemple #21
0
bool GLSLShader_vinit(GLSLShader * self, const char * vshaderSource, size_t vshaderLength, const char * fshaderSource, size_t fshaderLength, va_list args) {
	GLint shaderLength;
	GLuint vertexShader, fragmentShader;
	const char * attribName;
	GLuint attribLocation;
#ifdef DEBUG
	GLint logLength;
#endif
	
	call_super(init, self);
	self->dispose = GLSLShader_dispose;
	self->getUniformLocation = GLSLShader_getUniformLocation;
	self->activate = GLSLShader_activate;
	self->deactivate = GLSLShader_deactivate;
	self->validate = GLSLShader_validate;
	
	self->program = glCreateProgram();
	vertexShader = glCreateShader(GL_VERTEX_SHADER);
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	
	shaderLength = vshaderLength;
	glShaderSource(vertexShader, 1, (const GLchar **) &vshaderSource, &shaderLength);
	glCompileShader(vertexShader);
#ifdef DEBUG
	glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logLength);
	if (logLength > 0) {
		GLchar * log = malloc(logLength);
		glGetShaderInfoLog(vertexShader, logLength, &logLength, log);
		if (logLength > 0) { // Surprisingly enough, this is not always true! In the glgraphics test harness, Windows gives me 1 the first time, and 0 the second...
			fprintf(stderr, "Vertex shader compile log:\n%s\n", log);
		}
		free(log);
	}
#endif
	
	shaderLength = fshaderLength;
	glShaderSource(fragmentShader, 1, (const GLchar **) &fshaderSource, &shaderLength);
	glCompileShader(fragmentShader);
#ifdef DEBUG
	glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &logLength);
	if (logLength > 0) {
		GLchar * log = malloc(logLength);
		glGetShaderInfoLog(fragmentShader, logLength, &logLength, log);
		if (logLength > 0) {
			fprintf(stderr, "Fragment shader compile log:\n%s\n", log);
		}
		free(log);
	}
#endif
	
	glAttachShader(self->program, vertexShader);
	glAttachShader(self->program, fragmentShader);
	
	for (attribName = va_arg(args, const char *); attribName != NULL; attribName = va_arg(args, const char *)) {
		attribLocation = va_arg(args, GLuint);
		glBindAttribLocation(self->program, attribLocation, attribName);
	}
	
	glLinkProgram(self->program);
#ifdef DEBUG
	glGetProgramiv(self->program, GL_INFO_LOG_LENGTH, &logLength);
	if (logLength > 0) {
		GLchar * log = malloc(logLength);
		glGetProgramInfoLog(self->program, logLength, &logLength, log);
		if (logLength > 0) {
			fprintf(stderr, "Program link log:\n%s\n", log);
		}
		free(log);
	}
#endif
	
	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);
	return true;
}
GLuint ShaderLoader::loadShader()
{
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

    //Read Shader
    std::string strVertexShader = loadFile(pathVertexShader);
    std::string strFragmentShader = loadFile(pathFragmentShader);
    const char* cStrVertexShader = strVertexShader.c_str();
    const char* cStrFragmentShader = strFragmentShader.c_str();

    GLint result = GL_FALSE;
    int logLength;

    //Compile Vertex Shader
    glShaderSource(vertexShader, 1, &cStrVertexShader, NULL);
    glCompileShader(vertexShader);

    //Check Vertex Shader
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &result);
    glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logLength);
    std::vector<char> vertexShaderError((logLength > 1) ? logLength : 1);
    if(logLength > 1)
    {
        glGetShaderInfoLog(vertexShader, logLength, NULL, 
            &vertexShaderError[0]);
        std::cerr << &vertexShaderError[0] << std::endl;
    }

    //Compile Fragment Shader
    glShaderSource(fragmentShader, 1, &cStrFragmentShader, NULL);
    glCompileShader(fragmentShader);

    //Check Fragment Shader
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &result);
    glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &logLength);
    std::vector<char> fragmentShaderError((logLength > 1) ? logLength : 1);
    if(logLength > 1)
    {
        glGetShaderInfoLog(fragmentShader, logLength, NULL, 
            &fragmentShaderError[0]);
        std::cerr << &fragmentShaderError[0] << std::endl;
    }

    //Link Program
    GLuint program = glCreateProgram();
    glAttachShader(program, vertexShader);
    glAttachShader(program, fragmentShader);
    glLinkProgram(program);

    glGetProgramiv(program, GL_LINK_STATUS, &result);
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
    std::vector<char> programError( (logLength > 1) ? logLength : 1);
    if(logLength > 1)
    {
        glGetProgramInfoLog(program, logLength, NULL, &programError[0]);
        std::cerr << &programError[0] << std::endl;
    }

    //Return Program
    return program;
}
void OpenGlImplement::InitShaders()
{
	/////CHECK VERSION OF OPENGL/////
	//char message [200];
	//strcpy (message, (char *)glGetString(GL_VERSION));
	//strcat (message, "\n\nEs necesario tener la versinn 3.2 para que funcione adecuadamente.\nSi no es tu caso, actualiza tus Driver de video.\nPrecione ENTER para continuar. ");
	//SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION,"OpenGL Version: ",	(const char *)message,NULL);
	
	//Success flag
	bool success = true;

	//Generate program
	shaderProgram = glCreateProgram();

	GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
	GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

	// Read shaders
	std::string vertShaderStr = readFile("vertex.glsl");
	std::string fragShaderStr = readFile("fragment.glsl");
	const GLchar *vertexShaderSource = vertShaderStr.c_str();
	const GLchar *fragmentShaderSource = fragShaderStr.c_str();
		
	glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
	glCompileShader(vertexShader);
	GLint vShaderCompiled = GL_FALSE;
	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &vShaderCompiled);
	if (vShaderCompiled != GL_TRUE)
		printf("Unable to compile vertex shader %d!\n", vertexShader);
	glAttachShader(shaderProgram, vertexShader);


	glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
	glCompileShader(fragmentShader);
	GLint fShaderCompiled = GL_FALSE;
	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &fShaderCompiled);
	if (fShaderCompiled != GL_TRUE)
		printf("Unable to compile fragment shader %d!\n", fragmentShader);
	glAttachShader(shaderProgram, fragmentShader);


	glLinkProgram(shaderProgram);
	GLint programSuccess = GL_TRUE;
	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &programSuccess);
		
	if (programSuccess != GL_TRUE)
		printf("Error linking program %d!\n", shaderProgram);
		
	//Get vertex attribute location
	vertexPositionAttribute = glGetAttribLocation(shaderProgram, "aVertexPosition");
	vertexTextureCoordAttribute = glGetAttribLocation(shaderProgram, "aTextureCoord");
	samplerUniform = glGetUniformLocation(shaderProgram, "uSampler");
	
	//Initialize clear color
	glClearColor(0.6f, 0.6f, 0.6f, 1.f);
	glViewport(0, 0, WIDTH_SCREEN, HEIGHT_SCREEN);

	//glClearDepth(1.0f);                   // Set background depth to farthest
	glEnable(GL_DEPTH_TEST);   // Enable depth testing for z-culling
	glDepthFunc(GL_ALWAYS);    // Set the type of depth-test
	glShadeModel(GL_SMOOTH);   // Enable smooth shading
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  // Nice perspective corrections
}
void load_shader(Shader *s, char *vert_filename, char *frag_filename)
{
    assert(s != NULL);
    assert(vert_filename != NULL);
    assert(frag_filename != NULL);

    strncpy(s->vert_filename, (vert_filename), MAX_FILENAME_LEN);
    strncpy(s->frag_filename, (frag_filename), MAX_FILENAME_LEN);

    s->vert_program_id = glCreateShader(GL_VERTEX_SHADER);
    if (s->vert_program_id == 0) {
        set_error_msg(&s->status, "Could not create vert shader.");
        return;
    }

    s->frag_program_id = glCreateShader(GL_FRAGMENT_SHADER);
    if (s->frag_program_id == 0) {
        set_error_msg(&s->status, "Could not create frag shader.");
        return;
    }

    char *vs = NULL;
    int vs_size;
    vs = text_file_read(s->vert_filename, &vs_size);
    if (vs == NULL) {
        set_error_msg(&s->status, "Could not read vert shader '%s'.",
            s->vert_filename);
        return;
    }

    char *fs = NULL;
    int fs_size;
    fs = text_file_read(s->frag_filename, &fs_size);
    if (fs == NULL) {
        set_error_msg(&s->status, "Could not read frag shader '%s'.",
            s->frag_filename);
        return;
    }

    GLenum glerror;
    GLint result;
    const char * vv = vs;
    const char * ff = fs;

    glShaderSource(s->vert_program_id, 1, &vv, NULL);
    if ((glerror = glGetError()) != GL_NO_ERROR) {
        set_error_msg(&s->status, "Could set vert shader source. (%d)",
            glerror);
        return;
    }

    glShaderSource(s->frag_program_id, 1, &ff, NULL);
    if ((glerror = glGetError()) != GL_NO_ERROR) {
        set_error_msg(&s->status, "Could set frag shader source. (%d)",
            glerror);
        return;
    }

    glCompileShader(s->vert_program_id);
    glGetShaderiv(s->vert_program_id, GL_COMPILE_STATUS, &result);
    if (result != GL_TRUE) {
        set_error_msg(&s->status, "Could not compile vert shader.");
        return;
    }

    glCompileShader(s->frag_program_id);
    glGetShaderiv(s->frag_program_id, GL_COMPILE_STATUS, &result);
    if (result != GL_TRUE) {
        set_error_msg(&s->status, "Could not compile frag shader.");
        return;
    }

    free(vs); free(fs);

    print_shader_log(s->vert_program_id);
    print_shader_log(s->frag_program_id);

    s->program_id = glCreateProgram();
    if (s->program_id == 0) {
        set_error_msg(&s->status, "Could not create program.");
        return;
    }

    glAttachShader(s->program_id, s->vert_program_id);
    if ((glerror = glGetError()) != GL_NO_ERROR) {
        set_error_msg(&s->status, "Could not attach vert shader. (%d)",
            glerror);
        return;
    }

    glAttachShader(s->program_id, s->frag_program_id);
    if ((glerror = glGetError()) != GL_NO_ERROR) {
        set_error_msg(&s->status, "Could not attach frag shader. (%d)",
            glerror);
        return;
    }

    glBindFragDataLocation(s->program_id, 0, "FracColor");
    if ((glerror = glGetError()) != GL_NO_ERROR) {
        set_error_msg(&s->status, "Could not bind frag data location. (%d)",
            glerror);
        return;
    }

    glLinkProgram(s->program_id);
    glGetProgramiv(s->program_id, GL_LINK_STATUS, &result);
    if ((glerror = glGetError()) != GL_NO_ERROR || result == GL_FALSE) {
        set_error_msg(&s->status, "Could not bind frag data location. (%d,%d)",
            glerror, result);
        return;
    }

    print_program_log(s->program_id);

    s->vertex_loc = glGetAttribLocation(s->program_id, "MCvertex");
    s->normal_loc = glGetAttribLocation(s->program_id, "MCnormal");
    s->tangent_loc = glGetAttribLocation(s->program_id, "MCtangent");
    s->tex_coords_loc = glGetAttribLocation(s->program_id, "TexCoord0");

    s->proj_matrix_loc = glGetUniformLocation(s->program_id, "MVPMatrix");
    s->view_matrix_loc = glGetUniformLocation(s->program_id, "MVMatrix");
    s->rot_matrix_loc = glGetUniformLocation(s->program_id, "RotMatrix");
}
  
      //-----------------------------------------------------------------------------------------------------------------

      "        normal_PASS    =  normalize(mvMatrix * vec4(normal, 1.0)).xyz;                                                             \n"                           
      //-----------------------------------------------------------------------------------------------------------------



      "        varTexcoord           =  texture;                                                                                                \n"                           

      "        gl_Position           =  mvpMatrix * position;                                                                                   \n"                           

      "    }\n";                                                                                                                             
      //---------------------------------------------------------------------                                                                   
      cube_relief_SHADER_VERTEX = glCreateShader(GL_VERTEX_SHADER);                                                                                   
      glShaderSource(cube_relief_SHADER_VERTEX, 1, &vertexSource_cube_relief, NULL);                                                                        
      glCompileShader(cube_relief_SHADER_VERTEX);                                                                                                     
      //---------------------------------------------------------------------                                                                   
      const GLchar *fragmentSource_cube_relief =                                                                                                            

      " #ifdef GL_ES                                                                                                                               \n"                       
      " #else                                                                                                                                      \n"                       
      " #define highp                                                                                                                              \n"                       
      " #endif                                                                                                                                     \n"                       

      "    uniform sampler2D     Texture1;                                                                                                         \n"                       
      "    uniform sampler2D     NormalMap;                                                                                                        \n"                       
      "    uniform sampler2D     HeightMap;                                                                                                        \n"        
      "    uniform highp float   shininess;                                                                                                        \n"                       
      "    uniform highp float   attenuation;                                                                                                      \n"                       
Exemple #26
0
// pass in pointers so we can free the memory in the gpu later
void setup_polygons(GLuint *vertex_attribute_obj, GLuint *element_buffer, GLuint *vertex_buffer, GLuint *v_shader, GLuint *f_shader, GLuint *shader_program, int height) 
{
    glewInit();
    // calculate OpenGL point for 50px away from the top
    float top = ((height / 2.0f - 50) / (height / 2.0f));
    // create vertices simple triangle
    float vertices[] = {
        //position     //texture coordinates
        -1.0f,  top ,  0.0f, 0.0f, // top left 
         1.0f,  top ,  1.0f, 0.0f, // top right
         1.0f, -1.0f,  1.0f, 1.0f, // bottom-right
        -1.0f, -1.0f,  0.0f, 1.0f  // bottom-left
    };
    glDeleteBuffers(1, vertex_attribute_obj);
    glDeleteBuffers(1, vertex_buffer);
    // create vertex array object for storing shader and attribute data
    glGenVertexArrays(1, vertex_attribute_obj);
    glBindVertexArray(*vertex_attribute_obj);


    // create vertex buffer
    glGenBuffers(1, vertex_buffer); // generate one buffer
    // make this buffer the "active" buffer
    glBindBuffer(GL_ARRAY_BUFFER, *vertex_buffer);
    // put vertices into the buffer
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // create element buffer
    GLuint elements[] = {
        0, 1, 2,
        2, 3, 0
    };
    glGenBuffers(1, element_buffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, *element_buffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW);
    // create vertex shader
    *v_shader = glCreateShader(GL_VERTEX_SHADER);
    // load shader source into GPU
    glShaderSource(*v_shader, 1, &vertex_shader, NULL);
    // compile the shader
    glCompileShader(*v_shader);
    // check if shader compiled correctly
    GLint status;
    glGetShaderiv(*v_shader, GL_COMPILE_STATUS, &status);
    if(status != GL_TRUE)
    {
        puts("Error compiling vertex shader");
        // get error log from shader
        char buffer[512];
        glGetShaderInfoLog(*v_shader, 512, NULL, buffer);
        printf("%s\n", buffer); 
    }
    // same thing for fragment shader
    *f_shader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(*f_shader, 1, &fragment_shader, NULL);
    glCompileShader(*f_shader);
    glGetShaderiv(*f_shader, GL_COMPILE_STATUS, &status);

    if(status != GL_TRUE)
    {
        puts("Error compiling fragment shader");
        // get error log from shader
        char buffer[512];
        glGetShaderInfoLog(*f_shader, 512, NULL, buffer);
        printf("%s\n", buffer); 
    }
    // combine shaders into a program
    *shader_program = glCreateProgram();
    glAttachShader(*shader_program, *v_shader);
    glAttachShader(*shader_program, *f_shader);
    /*glBindFragDataLocation(*shader_program, 0, "outColor");*/
    // link the program
    glLinkProgram(*shader_program);
    // tell opengl to use this program
    glUseProgram(*shader_program);

    // get position of the input position in vertex_shader
    GLint posAttribute = glGetAttribLocation(*shader_program, "position"); // always 0 since it's the first and only arg
    // (arg_position, number of values for that arg, type for each component, 
    // should they be normalized?, distance (in bytes) between each position attribute,
    // offset from start of array for first attribute value)
    glVertexAttribPointer(posAttribute, 2, GL_FLOAT, GL_FALSE, 4*sizeof(float), 0);
    // enable attribute array
    glEnableVertexAttribArray(posAttribute);
    GLint texAttrib = glGetAttribLocation(*shader_program, "texCoord");
    glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 4*sizeof(float), (void*)(2*sizeof(float)));
    glEnableVertexAttribArray(texAttrib);
}
int CShaderObject::GenProgram(const char* vertexShader, const char* fragmentShader, const char** Attribs, int AttribsArraySize, const char** Uniforms, int UniformsArraySize, const char** Textures, int TextureArraySize)
{
	if (Initialized) return -1;

	int i;

    pid = glCreateProgram();

	GLuint vs = glCreateShader(GL_VERTEX_SHADER);
    GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);

    glShaderSource(vs, 1, &vertexShader, 0);
    glShaderSource(fs, 1, &fragmentShader, 0);

    glCompileShader(vs);

    GLint compiled = 0;
    glGetShaderiv(vs, GL_COMPILE_STATUS, &compiled);
    if (!compiled) {
        GLint infoLen = 0;
        glGetShaderiv(vs, GL_INFO_LOG_LENGTH, &infoLen);
        if (infoLen) {
            char* buf = new char[infoLen];
            if (buf) {
                glGetShaderInfoLog(vs, infoLen, NULL, buf);
                //LOGI("Shader log:\n%s\n", buf);
                delete[] buf;
            }
        }
        return 0;
	}
	glAttachShader(pid, vs);
	glDeleteShader(vs);

    glCompileShader(fs);
	glGetShaderiv(fs, GL_COMPILE_STATUS, &compiled);
	if (!compiled) {
        GLint infoLen = 0;
        glGetShaderiv(fs, GL_INFO_LOG_LENGTH, &infoLen);
        if (infoLen) {
            char* buf = new char[infoLen];
            if (buf) {
                glGetShaderInfoLog(fs, infoLen, NULL, buf);
                //LOGI("Shader log:\n%s\n", buf);
                delete[] buf;
            }
        }
		return 0;
	}
    glAttachShader(pid, fs);
	glDeleteShader(fs);


    glLinkProgram(pid);

    // check if program linked
    GLint success = 0;
    glGetProgramiv(pid, GL_LINK_STATUS, &success);

    if (!success)
    {
        GLint bufLength = 0;
        glGetProgramiv(pid, GL_INFO_LOG_LENGTH, &bufLength);
        if (bufLength) {
            char* buf = new char[bufLength];
            if (buf) {
                glGetProgramInfoLog(pid, bufLength, NULL, buf);
                delete [] buf;
            }
        }
        glDeleteProgram(pid);
        pid = 0;
    }

	if (!pid) return -1;

	glUseProgram(pid);


	//bind the vertex attribute from string Attribs[i] to location i
	for (i = 0; i < AttribsArraySize; ++i) {
		glBindAttribLocation(pid, i, Attribs[i]);
	}

	//get location of uniform from string Uniforms[i]
	for (i=0; i<UniformsArraySize; i++) {
		auiLocation[i] = glGetUniformLocation(pid, Uniforms[i]);
	}

	int sid;
	//set the sampler2D named by string Textures[i] to texture i
	for (i=0; i<TextureArraySize; i++) {
		sid = glGetUniformLocation(pid, Textures[i]);
		glUniform1i(sid, i);
	}
	Initialized = 1;
	return 0;
}
int CShaderObject::GenCSProgram(const char* computeShader, const char** Uniforms, int UniformsArraySize, const char** Textures, int TextureArraySize)
{
	int i;
    GLuint program = glCreateProgram();

    GLuint cs = glCreateShader(GL_COMPUTE_SHADER);
    glShaderSource(cs, 1, &(computeShader), 0);
    glCompileShader(cs);
    GLint compiled = 0;
    glGetShaderiv(cs, GL_COMPILE_STATUS, &compiled);
    if (!compiled) {
        GLint infoLen = 0;
        glGetShaderiv(cs, GL_INFO_LOG_LENGTH, &infoLen);
        if (infoLen) {
            char* buf = new char[infoLen];
            if (buf) {
                glGetShaderInfoLog(cs, infoLen, NULL, buf);
                //LOGI("Shader log:\n%s\n", buf);
                delete[] buf;
            }
        }
        return 0;
	}

    glAttachShader(program, cs);

    // can be deleted since the program will keep a reference
    glDeleteShader(cs);

    glLinkProgram(program);

    // check if program linked
    GLint success = 0;
    glGetProgramiv(program, GL_LINK_STATUS, &success);

    if (!success)
    {
        GLint bufLength = 0;
        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
        if (bufLength) {
            char* buf = new char[bufLength];
            if (buf) {
                glGetProgramInfoLog(program, bufLength, NULL, buf);
                //LOGI("Could not link program:\n%s\n", buf);
                delete [] buf;
            }
        }
        glDeleteProgram(program);
        program = 0;
    }
	//get location of uniform from string Uniforms[i]
	for (i=0; i<UniformsArraySize; i++) {
		auiLocation[i] = glGetUniformLocation(program, Uniforms[i]);
	}
	err = glGetError();
	int sid;
	//set the sampler2D named by string Textures[i] to texture i
	for (i=0; i<TextureArraySize; i++) {
		sid = glGetUniformLocation(program, Textures[i]);
		glUniform1i(sid, i);
	}

	pid = program;
    return pid;
}
Exemple #29
0
 Shader():
     handle(glCreateShader(detail::ShaderType<T>::value))
 {}
	OpenGLProgram::OpenGLProgram(string vertex_shader_file_name, string fragment_shader_file_name) {
		/* Cool preprocessing */
		m_program_ok = true;
		ifstream input_vertex_shader_file(vertex_shader_file_name, ios::in | ios::binary);
		if (input_vertex_shader_file) {
			input_vertex_shader_file.seekg(0, ios::end);
			m_vertex_shader_source.resize(static_cast<unsigned int>(input_vertex_shader_file.tellg()));
			input_vertex_shader_file.seekg(0, ios::beg);
			input_vertex_shader_file.read(&m_vertex_shader_source[0], m_vertex_shader_source.size());
			input_vertex_shader_file.close();
		} else {
			cerr << "Could not open vertex shader file at: " << vertex_shader_file_name << endl;
			m_program_ok = false;
		}

		ifstream input_fragment_shader_file(fragment_shader_file_name, ios::in | ios::binary);
		if (input_fragment_shader_file) {
			input_fragment_shader_file.seekg(0, ios::end);
			m_fragment_shader_source.resize(static_cast<unsigned int>(input_fragment_shader_file.tellg()));
			input_fragment_shader_file.seekg(0, ios::beg);
			input_fragment_shader_file.read(&m_fragment_shader_source[0], m_fragment_shader_source.size());
			input_fragment_shader_file.close();
		} else {
			cerr << "Could not open fragment shader file at: " << fragment_shader_file_name << endl;
			m_program_ok = false;
		}

		/* or not */
		m_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
		const char* start = &m_vertex_shader_source[0];
		glShaderSource(m_vertex_shader, 1, &start, NULL);

		m_fragment_shader= glCreateShader(GL_FRAGMENT_SHADER);
		start = &m_fragment_shader_source[0];
		glShaderSource(m_fragment_shader, 1, &start, NULL);

		try {
			int status;
			glCompileShader(m_vertex_shader);
			glGetShaderiv(m_vertex_shader, GL_COMPILE_STATUS, &status); 

			if(status == GL_FALSE) {
				throw m_vertex_shader;
			}

			glCompileShader(m_fragment_shader);
			glGetShaderiv(m_fragment_shader, GL_COMPILE_STATUS, &status); 
	
			if(status == GL_FALSE) {
				throw m_fragment_shader;
			}
		} catch(GLuint bad_shader) {
			printShaderInfoLog(bad_shader);
			m_program_ok = false;
		}

		m_program = glCreateProgram();
		try {
			int status;
			glAttachShader(m_program, m_vertex_shader);
			glAttachShader(m_program, m_fragment_shader);
			glLinkProgram(m_program);

			glGetProgramiv(m_program, GL_LINK_STATUS, &status);

			if(status == GL_FALSE) {
				throw m_program;	
			}

		} catch(GLuint bad_program) {
			printProgramInfoLog(bad_program);
			m_program_ok = false;
		}

	}