コード例 #1
0
ファイル: shader.c プロジェクト: svenssonjoel/Graphics
Shader *shader_basic(Mat4x4f *mv,Mat4x4f *p ) {
 
  
  Shader *s = NULL;
 

  GLuint shader_program;
  GLuint shader_frag;
  GLuint shader_vert; 

  GLuint shader_vindex;
  GLuint shader_cindex;

  GLuint shader_proj;
  GLuint shader_mod;


  char vertexshader[] = 
    "#version 140\n" 
    "uniform mat4 proj;\n"
    "uniform mat4 mod;\n"
    "in vec4 Vertex;\n"
    "in vec4 Color;\n"
    "out vec4 ColorInterp;\n"
    "void main() {\n"
    "gl_Position = proj * (mod * Vertex);\n"
    "ColorInterp = Color;\n}";

  char fragmentshader[] = 
    "#version 140\n"
    "in vec4 ColorInterp;\n"
    "out vec4 out_FragColor;\n"
    "void main() {\n"
    "out_FragColor = ColorInterp;\n}";
  

  const char * f = fragmentshader;
  const char * v = vertexshader;
  //printf("%s\n",vertexshader);
  //printf("\n\n%s\n",fragmentshader);
  


  
  s = (Shader*)malloc(sizeof(Shader));
  
  if (s == NULL) 
    return s;
  

  shader_vert = glCreateShader(GL_VERTEX_SHADER);
  shader_frag = glCreateShader(GL_FRAGMENT_SHADER);
  
  //shader_vert = shader_load("/home/ian/Graphics/Graphics/Gfx2/Shaders/const_mv.vert",GL_VERTEX_SHADER);
  //shader_frag = shader_load("/home/ian/Graphics/Graphics/Gfx2/Shaders/const_mv.frag",GL_FRAGMENT_SHADER);
  
  printGLError("shader A:");
  
  if (!shader_vert) printf("error creating shader\n");
  if (!shader_frag) printf("error creating shader\n");

  
  glShaderSource(shader_vert,1,&v,NULL);
  glShaderSource(shader_frag,1,&f,NULL);
  
  printGLError("shader B:");
  
  glCompileShader(shader_vert);
  shader_printCompileLog(shader_vert);
  glCompileShader(shader_frag);
  shader_printCompileLog(shader_frag);
 
  printGLError("shader C:");   

  shader_program = glCreateProgram();
  		
  glAttachShader(shader_program,shader_vert);
  glAttachShader(shader_program,shader_frag);
  
  printGLError("shader D:");
  
  glLinkProgram(shader_program);
  
  printGLError("shader E:");

  shader_proj = glGetUniformLocation(shader_program, "proj");
   printGLError("shader F1:");
  shader_mod  = glGetUniformLocation(shader_program, "mod");
   printGLError("shader F2:");
 
  
  shader_vindex = glGetAttribLocation(shader_program, "Vertex");
  shader_cindex = glGetAttribLocation(shader_program, "Color");
  printGLError("shader G:");
  
  //  shader_uniform_m4x4f(&unis[0],shader_proj,p);
  //shader_uniform_m4x4f(&unis[1],shader_mod,mv);

  s->uniforms = (Uniform*)malloc(2*sizeof(Uniform));
  if (s->uniforms == NULL) printf("ERROR\n");
  s->num_uniforms = 2; 
  
  shader_uniform_m4x4f(&s->uniforms[0],shader_proj,p);
  shader_uniform_m4x4f(&s->uniforms[1],shader_mod,mv);

  
  s->shader   = shader_program;
  s->attributes[VERTEX_INDEX].vattrib = shader_vindex;
  s->attributes[VERTEX_INDEX].active = true;
  
  s->attributes[COLOR_INDEX].vattrib = shader_cindex;
  s->attributes[COLOR_INDEX].active = true;
  
  return s;
  
}
コード例 #2
0
int main()
{
    int width = 640;
    int height = 480;
    
    if(glfwInit() == GL_FALSE)
    {
        std::cerr << "failed to init GLFW" << std::endl;
        return 1;
    }

    // select opengl version 
    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;
}
コード例 #3
0
// 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;
}
コード例 #4
0
bool LightPassHandles::installShaders(const std::string &vShaderName, const std::string &fShaderName) {
  GLint rc;

  // Create shader handles
  GLuint VS = glCreateShader(GL_VERTEX_SHADER);
  GLuint FS = glCreateShader(GL_FRAGMENT_SHADER);

  // Read shader sources
  const char *vshader = GLSL::textFileRead(vShaderName.c_str());
  const char *fshader = GLSL::textFileRead(fShaderName.c_str());
  glShaderSource(VS, 1, &vshader, NULL);
  glShaderSource(FS, 1, &fshader, NULL);

  // Compile vertex shader
  glCompileShader(VS);
  GLSL::printError();
  glGetShaderiv(VS, GL_COMPILE_STATUS, &rc);
  GLSL::printShaderInfoLog(VS);
  if(!rc) {
    printf("Error compiling vertex shader %s\n", vShaderName.c_str());
    return false;
  }

  // Compile fragment shader
  glCompileShader(FS);
  GLSL::printError();
  glGetShaderiv(FS, GL_COMPILE_STATUS, &rc);
  GLSL::printShaderInfoLog(FS);
  if(!rc) {
    printf("Error compiling fragment shader %s\n", fShaderName.c_str());
    return false;
  }

  // Create the program and link
  this->prog = glCreateProgram();
  assert(this->prog > 0);
  glAttachShader(this->prog, VS);
  glAttachShader(this->prog, FS);
  glLinkProgram(this->prog);

  GLSL::printError();
  glGetProgramiv(this->prog, GL_LINK_STATUS, &rc);
  GLSL::printProgramInfoLog(this->prog);
  if(!rc) {
    printf("Error linking shaders %s and %s\n", vShaderName.c_str(), fShaderName.c_str());
    return false;
  }

  aPosition = GLSL::getAttribLocation(this->prog, "aPosition");
  uScreenSize = GLSL::getUniformLocation(this->prog, "uScreenSize");
  uNormMap = GLSL::getUniformLocation(this->prog, "uNormMap");
  uPosMap = GLSL::getUniformLocation(this->prog, "uPosMap");
  uColMap = GLSL::getUniformLocation(this->prog, "uColMap");
  uDepthMap = GLSL::getUniformLocation(this->prog, "uDepthMap");
  uLightCol = GLSL::getUniformLocation(this->prog, "uLightCol");
  uLightAtten = GLSL::getUniformLocation(this->prog, "uLightAtten");
  uLightDirection = GLSL::getUniformLocation(this->prog, "uLightDirection");
  uLightAngleCos = GLSL::getUniformLocation(this->prog, "uLightAngleCos");
  uDetectionLevel = GLSL::getUniformLocation(this->prog, "uDetectionLevel");
  uAmbient = GLSL::getUniformLocation(this->prog, "uAmbient");
  uNumLights = GLSL::getUniformLocation(this->prog, "uNumLights");
  pt1 = GLSL::getUniformLocation(this->prog, "pt1");
  pt2 = GLSL::getUniformLocation(this->prog, "pt2");
  pt3 = GLSL::getUniformLocation(this->prog, "pt3");
  detecDir = GLSL::getUniformLocation(this->prog, "detecDir");
  uDepthMVP = GLSL::getUniformLocation(this->prog, "uDepthMVP");

  // stuff to init quad buffers (i didn't know where to put this)
  /*glGenVertexArrays(1, &quad_VertexArrayID);
  assert(quad_VertexArrayID > 0);
  glBindVertexArray(quad_VertexArrayID);*/

  glGenBuffers(1, &quad_vertexbuffer);
  assert(quad_vertexbuffer > 0);
  glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
  glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data) * sizeof(GLfloat), &g_quad_vertex_buffer_data[0], GL_STATIC_DRAW);

  return true;
}
コード例 #5
0
ファイル: triangle2.cpp プロジェクト: Ebiroll/pi3d
static void init_shaders(CUBE_STATE_T *state)
{
   static const GLfloat vertex_data[] = {
        -1.0,-1.0,1.0,
        1.0,-1.0,1.0,
        1.0,1.0,1.0,
        -1.0,1.0,1.0,
   };
   const GLchar *vshader_source =
              "attribute vec4 vertex;"
              "varying vec2 tcoord;"
              "void main(void) {"
              " vec4 pos = vertex;"
              " gl_Position = pos;"
              " tcoord = vertex.xy*0.5+0.5;"
              "}";
#if 0      
   //Mandelbrot
   const GLchar *mandelbrot_fshader_source =
"uniform vec4 color;"
"uniform vec2 scale;"
"uniform vec2 centre;"
"varying vec2 tcoord;"
"void main(void) {"
"  float intensity;"
"  vec4 color2;"
"  float cr=(gl_FragCoord.x-centre.x)*scale.x;"
"  float ci=(gl_FragCoord.y-centre.y)*scale.y;"
"  float ar=cr;"
"  float ai=ci;"
"  float tr,ti;"
"  float col=0.0;"
"  float p=0.0;"
"  int i=0;"
"  for(int i2=1;i2<16;i2++)"
"  {"
"    tr=ar*ar-ai*ai+cr;"
"    ti=2.0*ar*ai+ci;"
"    p=tr*tr+ti*ti;"
"    ar=tr;"
"    ai=ti;"
"    if (p>16.0)"
"    {"
"      i=i2;"
"      break;"
"    }"
"  }"
"  color2 = vec4(float(i)*0.0625,0,0,1);"
"  gl_FragColor = color2;"
"}";

   // Julia
   const GLchar *julia_fshader_source =
"uniform vec4 color;"
"uniform vec2 scale;"
"uniform vec2 centre;"
"uniform vec2 offset;"
"varying vec2 tcoord;"
"uniform sampler2D tex;"
"void main(void) {"
"  float intensity;"
"  vec4 color2;"
"  float ar=(gl_FragCoord.x-centre.x)*scale.x;"
"  float ai=(gl_FragCoord.y-centre.y)*scale.y;"
"  float cr=(offset.x-centre.x)*scale.x;"
"  float ci=(offset.y-centre.y)*scale.y;"
"  float tr,ti;"
"  float col=0.0;"
"  float p=0.0;"
"  int i=0;"
"  vec2 t2;"
"  t2.x=tcoord.x+(offset.x-centre.x)*(0.5/centre.y);"
"  t2.y=tcoord.y+(offset.y-centre.y)*(0.5/centre.x);"
"  for(int i2=1;i2<16;i2++)"
"  {"
"    tr=ar*ar-ai*ai+cr;"
"    ti=2.0*ar*ai+ci;"
"    p=tr*tr+ti*ti;"
"    ar=tr;"
"    ai=ti;"
"    if (p>16.0)"
"    {"
"      i=i2;"
"      break;"
"    }"
"  }"
"  color2 = vec4(0,float(i)*0.0625,0,1);"
"  color2 = color2+texture2D(tex,t2);"
"  gl_FragColor = color2;"
"}";

        state->vshader = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(state->vshader, 1, &vshader_source, 0);
        glCompileShader(state->vshader);
        check();

        if (state->verbose)
            showlog(state->vshader);
            
        state->fshader = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(state->fshader, 1, &julia_fshader_source, 0);
        glCompileShader(state->fshader);
        check();

        if (state->verbose)
            showlog(state->fshader);

        state->mshader = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(state->mshader, 1, &mandelbrot_fshader_source, 0);
        glCompileShader(state->mshader);
        check();

        if (state->verbose)
            showlog(state->mshader);

        // julia 
        state->program = glCreateProgram();
        glAttachShader(state->program, state->vshader);
        glAttachShader(state->program, state->fshader);
        glLinkProgram(state->program);
        check();

        if (state->verbose)
            showprogramlog(state->program);
            
        state->attr_vertex = glGetAttribLocation(state->program, "vertex");
        state->unif_color  = glGetUniformLocation(state->program, "color");
        state->unif_scale  = glGetUniformLocation(state->program, "scale");
        state->unif_offset = glGetUniformLocation(state->program, "offset");
        state->unif_tex    = glGetUniformLocation(state->program, "tex");       
        state->unif_centre = glGetUniformLocation(state->program, "centre");

        // mandelbrot
        state->program2 = glCreateProgram();
        glAttachShader(state->program2, state->vshader);
        glAttachShader(state->program2, state->mshader);
        glLinkProgram(state->program2);
        check();

        if (state->verbose)
            showprogramlog(state->program2);
            
        state->attr_vertex2 = glGetAttribLocation(state->program2, "vertex");
        state->unif_scale2  = glGetUniformLocation(state->program2, "scale");
        state->unif_offset2 = glGetUniformLocation(state->program2, "offset");
        state->unif_centre2 = glGetUniformLocation(state->program2, "centre");
        check();
#endif

	
        glClearColor ( 0.0, 1.0, 1.0, 1.0 );
        
        glGenBuffers(1, &state->buf);

        check();

        // Prepare a texture image
        glGenTextures(1, &state->tex);
        check();
        glBindTexture(GL_TEXTURE_2D,state->tex);
        check();
        // glActiveTexture(0)
        glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,state->screen_width,state->screen_height,0,GL_RGB,GL_UNSIGNED_SHORT_5_6_5,0);
        check();
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        check();
        // Prepare a framebuffer for rendering
        glGenFramebuffers(1,&state->tex_fb);
        check();
        glBindFramebuffer(GL_FRAMEBUFFER,state->tex_fb);
        check();
        glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D,state->tex,0);
        check();
        glBindFramebuffer(GL_FRAMEBUFFER,0);
        check();
        // Prepare viewport
        glViewport ( 0, 0, state->screen_width, state->screen_height );
        check();
        
        // Upload vertex data to a buffer
        glBindBuffer(GL_ARRAY_BUFFER, state->buf);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data),
                             vertex_data, GL_STATIC_DRAW);
        glVertexAttribPointer(state->attr_vertex, 3, GL_FLOAT, 0, 12, 0);
        glEnableVertexAttribArray(state->attr_vertex);
        check();
}
コード例 #6
0
GLuint DepalShaderCache::GetDepalettizeShader(GEBufferFormat pixelFormat) {
	u32 id = GenerateShaderID(pixelFormat);

	auto shader = cache_.find(id);
	if (shader != cache_.end()) {
		return shader->second->program;
	}

	char *buffer = new char[2048];

	if (useGL3_) {
		GenerateDepalShader300(buffer, pixelFormat);
	} else {
		GenerateDepalShader100(buffer, pixelFormat);
	}

	GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);

	const char *buf = buffer;
	glShaderSource(fragShader, 1, &buf, 0);
	glCompileShader(fragShader);

	CheckShaderCompileSuccess(fragShader, buffer);

	GLuint program = glCreateProgram();
	glAttachShader(program, vertexShader_);
	glAttachShader(program, fragShader);
	
	glBindAttribLocation(program, 0, "a_position");
	glBindAttribLocation(program, 1, "a_texcoord0");

	if (useGL3_) {
		// This call is not really necessary, I think.
#ifndef MOBILE_DEVICE
		glBindFragDataLocation(program, 0, "fragColor0");
#endif
	}

	glLinkProgram(program);
	glUseProgram(program);

	GLint u_tex = glGetUniformLocation(program, "tex");
	GLint u_pal = glGetUniformLocation(program, "pal");

	glUniform1i(u_tex, 0);
	glUniform1i(u_pal, 1);

	GLint linkStatus = GL_FALSE;
	glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
	if (linkStatus != GL_TRUE) {
		GLint bufLength = 0;
		glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
		if (bufLength) {
			char* errorbuf = new char[bufLength];
			glGetProgramInfoLog(program, bufLength, NULL, errorbuf);
#ifdef SHADERLOG
			OutputDebugStringUTF8(buffer);
			OutputDebugStringUTF8(errorbuf);
#endif
			ERROR_LOG(G3D, "Could not link program:\n %s  \n\n %s", errorbuf, buf);
			delete[] errorbuf;	// we're dead!
		}

		delete[] buffer;
		return 0;
	}

	DepalShader *depal = new DepalShader();
	depal->program = program;
	depal->fragShader = fragShader;

	cache_[id] = depal;

	delete[] buffer;

	return depal->program;
}
コード例 #7
0
int main () {
	GLFWwindow* window = NULL;
	const GLubyte* renderer;
	const GLubyte* version;
	GLuint vao;
	GLuint vbo;
	/* geometry to use. these are 3 xyz points (9 floats total) to make a triangle
	*/
	GLfloat points[] = {
		 0.0f,	0.5f,	0.0f,
		 0.5f, -0.5f,	0.0f,
		-0.5f, -0.5f,	0.0f
	};
	/* these are the strings of code for the shaders
	the vertex shader positions each vertex point */
	const char* vertex_shader =
	"#version 400\n"
	"in vec3 vp;"
	"void main () {"
	"	gl_Position = vec4 (vp, 1.0);"
	"}";
	/* the fragment shader colours each fragment (pixel-sized area of the
	triangle) */
	const char* fragment_shader =
	"#version 400\n"
	"out vec4 frag_colour;"
	"void main () {"
	"	frag_colour = vec4 (0.5, 0.0, 0.5, 1.0);"
	"}";
	/* GL shader objects for vertex and fragment shader [components] */
	GLuint vs, fs;
	/* GL shader programme object [combined, to link] */
	GLuint shader_programme;

	/* start GL context and O/S window using the GLFW helper library */
	if (!glfwInit ()) {
		fprintf (stderr, "ERROR: could not start GLFW3\n");
		return 1;
	} 

	/* change to 3.2 if on Apple OS X */
	glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 4);
	glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 0);
	glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
	glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	window = glfwCreateWindow (
		640, 480, "Hello Triangle", NULL, NULL
	);
	if (!window) {
		fprintf (stderr, "ERROR: could not open window with GLFW3\n");
		glfwTerminate();
		return 1;
	}
	glfwMakeContextCurrent (window);
	/* start GLEW extension handler */
	glewExperimental = GL_TRUE;
	glewInit ();

	/* get version info */
	renderer = glGetString (GL_RENDERER); /* get renderer string */
	version = glGetString (GL_VERSION); /* version as a string */
	printf ("Renderer: %s\n", renderer);
	printf ("OpenGL version supported %s\n", version);

	/* tell GL to only draw onto a pixel if the shape is closer to the viewer */
	glEnable (GL_DEPTH_TEST); /* enable depth-testing */
	glDepthFunc (GL_LESS);/*depth-testing interprets a smaller value as "closer"*/

	/* a vertex buffer object (VBO) is created here. this stores an array of data
	on the graphics adapter's memory. in our case - the vertex points */
	glGenBuffers (1, &vbo);
	glBindBuffer (GL_ARRAY_BUFFER, vbo);
	glBufferData (GL_ARRAY_BUFFER, 9 * sizeof (GLfloat), points, GL_STATIC_DRAW);
	
	/* the vertex array object (VAO) is a little descriptor that defines which
	data from vertex buffer objects should be used as input variables to vertex
	shaders. in our case - use our only VBO, and say 'every three floats is a 
	variable' */
	glGenVertexArrays (1, &vao);
	glBindVertexArray (vao);
	glEnableVertexAttribArray (0);
	glBindBuffer (GL_ARRAY_BUFFER, vbo);
	glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
	
	/* here we copy the shader strings into GL shaders, and compile them. we then
	create an executable shader 'program' and attach both of the compiled shaders.
	we link this, which matches the outputs of the vertex shader to the inputs of
	the fragment shader, etc. and it is then ready to use */
	vs = glCreateShader (GL_VERTEX_SHADER);
	glShaderSource (vs, 1, &vertex_shader, NULL);
	glCompileShader (vs);
	fs = glCreateShader (GL_FRAGMENT_SHADER);
	glShaderSource (fs, 1, &fragment_shader, NULL);
	glCompileShader (fs);
	shader_programme = glCreateProgram ();
	glAttachShader (shader_programme, fs);
	glAttachShader (shader_programme, vs);
	glLinkProgram (shader_programme);
	
	/* this loop clears the drawing surface, then draws the geometry described by
	the VAO onto the drawing surface. we 'poll events' to see if the window was
	closed, etc. finally, we 'swap the buffers' which displays our drawing surface
	onto the view area. we use a double-buffering system which means that we have
	a 'currently displayed' surface, and 'currently being drawn' surface. hence
	the 'swap' idea. in a single-buffering system we would see stuff being drawn
	one-after-the-other */
	while (!glfwWindowShouldClose (window)) {
		/* wipe the drawing surface clear */
		glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glUseProgram (shader_programme);
		glBindVertexArray (vao);
		/* draw points 0-3 from the currently bound VAO with current in-use shader*/
		glDrawArrays (GL_TRIANGLES, 0, 3);
		/* update other events like input handling */
		glfwPollEvents ();
		/* put the stuff we've been drawing onto the display */
		glfwSwapBuffers (window);
	}
	
	/* close GL context and any other GLFW resources */
	glfwTerminate();
	return 0;
}
コード例 #8
0
ファイル: blackhole_dispatch.c プロジェクト: dumbbell/piglit
void
piglit_init(int argc, char **argv)
{
	enum piglit_result result = PIGLIT_PASS;
	GLuint data_bo = 0;
	GLfloat *data_buf;
	GLint ok = 1;
	GLint prog = 0;
	GLuint shader;
	const float one = 1.0f;

	piglit_require_extension("GL_ARB_compute_shader");
	piglit_require_extension("GL_INTEL_blackhole_render");

	data_buf = calloc(SIZE_X, sizeof(*data_buf));
	glGenBuffers(1, &data_bo);
	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, data_bo);
	glBufferData(GL_SHADER_STORAGE_BUFFER,
		     sizeof(float) * SIZE_X,
		     data_buf, GL_STATIC_DRAW);
	free(data_buf);

	shader = glCreateShader(GL_COMPUTE_SHADER);

	glShaderSource(shader, 1,
		       (const GLchar **) &compute_shader,
		       NULL);

	glCompileShader(shader);

	glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
	assert(ok);

	prog = glCreateProgram();

	glAttachShader(prog, shader);

	glLinkProgram(prog);

	glGetProgramiv(prog, GL_LINK_STATUS, &ok);
	assert(ok);

	glUseProgram(prog);

	assert(!glIsEnabled(GL_BLACKHOLE_RENDER_INTEL));

	glMemoryBarrier(GL_ALL_BARRIER_BITS);
	glUniform1f(glGetUniformLocation(prog, "value"), 1.0f);
	glDispatchCompute(SIZE_X, 1, 1);
	glMemoryBarrier(GL_ALL_BARRIER_BITS);

	if (!piglit_probe_buffer(data_bo, GL_SHADER_STORAGE_BUFFER, "output_values",
				 SIZE_X, 1, &one))
		result = PIGLIT_FAIL;

	glEnable(GL_BLACKHOLE_RENDER_INTEL);
	assert(glIsEnabled(GL_BLACKHOLE_RENDER_INTEL));

	glMemoryBarrier(GL_ALL_BARRIER_BITS);
	glUniform1f(glGetUniformLocation(prog, "value"), 2.0f);
	glDispatchCompute(SIZE_X, 1, 1);
	glMemoryBarrier(GL_ALL_BARRIER_BITS);

	if (!piglit_probe_buffer(data_bo, GL_SHADER_STORAGE_BUFFER, "output_values",
				 SIZE_X, 1, &one))
		result = PIGLIT_FAIL;

	piglit_report_result(result);
}
コード例 #9
0
ファイル: shader.cpp プロジェクト: roman1pr/roman
    // Constructor generates the shader on the fly
    Shader::Shader(const GLchar* vertexPath, const GLchar* fragmentPath)
    {
        // 1. Retrieve the vertex/fragment source code from filePath
        std::string vertexCode;
        std::string fragmentCode;
        std::ifstream vShaderFile;
        std::ifstream fShaderFile;
        // ensures ifstream objects can throw exceptions:
        vShaderFile.exceptions (std::ifstream::badbit);
        fShaderFile.exceptions (std::ifstream::badbit);
        try
        {
            // Open files
            vShaderFile.open(vertexPath);
            fShaderFile.open(fragmentPath);
            std::stringstream vShaderStream, fShaderStream;
            // Read file's buffer contents into streams
            vShaderStream << vShaderFile.rdbuf();
            fShaderStream << fShaderFile.rdbuf();
            // close file handlers
            vShaderFile.close();
            fShaderFile.close();
            // Convert stream into string
            vertexCode = vShaderStream.str();
            fragmentCode = fShaderStream.str();
        }
        catch (std::ifstream::failure e)
        {
            std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
        }
        const GLchar* vShaderCode = vertexCode.c_str();
        const GLchar * fShaderCode = fragmentCode.c_str();
        // 2. Compile shaders
        GLuint vertex, fragment;
        GLint success;
        GLchar infoLog[512];
        // Vertex Shader
        vertex = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertex, 1, &vShaderCode, NULL);
        glCompileShader(vertex);
        // Print compile errors if any
        glGetShaderiv(vertex, GL_COMPILE_STATUS, &success);
        if (!success)
        {
            glGetShaderInfoLog(vertex, 512, NULL, infoLog);
            std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
        }
        // Fragment Shader
        fragment = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragment, 1, &fShaderCode, NULL);
        glCompileShader(fragment);
        // Print compile errors if any
        glGetShaderiv(fragment, GL_COMPILE_STATUS, &success);
        if (!success)
        {
            glGetShaderInfoLog(fragment, 512, NULL, infoLog);
            std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
        }
        // Shader Program
        this->Program = glCreateProgram();
        glAttachShader(this->Program, vertex);
        glAttachShader(this->Program, fragment);
        glLinkProgram(this->Program);
        // Print linking errors if any
        glGetProgramiv(this->Program, GL_LINK_STATUS, &success);
        if (!success)
        {
            glGetProgramInfoLog(this->Program, 512, NULL, infoLog);
            std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
        }
        // Delete the shaders as they're linked into our program now and no longer necessery
        glDeleteShader(vertex);
        glDeleteShader(fragment);

    }
コード例 #10
0
ファイル: main.cpp プロジェクト: csorkin09/CS-480
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., -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!

    std::string vs_string = shaderLoader("../bin/vs.txt");
    std::string fs_string = shaderLoader("../bin/fs.txt");

    const char* vs = vs_string.c_str();
    const char* fs = fs_string.c_str();

    //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;
}
コード例 #11
0
ファイル: shader.cpp プロジェクト: jinghuage/pcaster
void shader_object::setShader(const char *vs, const char *fs, const char *gs,
                              GLuint itype, GLuint otype, GLint osize) 
{
    //fprintf(stderr, "**** %s:%s() ****\n", __FILE__, __func__);

    v = glCreateShader(GL_VERTEX_SHADER);
    f = glCreateShader(GL_FRAGMENT_SHADER);	
	
    if(gs) g = glCreateShader(GL_GEOMETRY_SHADER_EXT);

    glShaderSource(v, 1, &vs, NULL);
    glShaderSource(f, 1, &fs, NULL);
	
    if(g)
    {
        glShaderSource(g, 1, &gs, NULL);
    }


    //printf("compile vertex shader\n");
    glCompileShader(v);
    GLint params;
    glGetShaderiv(v, GL_COMPILE_STATUS, &params);
    if(params == GL_FALSE)
    {
	fprintf(stderr, "compile vertex shader error:\n");
	printShaderInfoLog(v);
        exit(10);
    }

    //printf("compile fragment shader\n");
    glCompileShader(f);
    glGetShaderiv(f, GL_COMPILE_STATUS, &params);
    if(params == GL_FALSE)
    {
	fprintf(stderr, "compile fragment shader error:\n");
	printShaderInfoLog(f);
        exit(10);
    }
	
    if(g)
    {
        //printf("compile geometry shader\n");
        glCompileShader(g);
        glGetShaderiv(g, GL_COMPILE_STATUS, &params);
        if(params == GL_FALSE)
        {
            fprintf(stderr, "compile geometry shader error:\n");
            printShaderInfoLog(g);
            exit(10);
        }
    }

    //printf("create program\n");
    p = glCreateProgram();
	
    //printf("attach shaders to program\n");
    glAttachShader(p, v);
    glAttachShader(p, f);
    if(g) 
    {
        glAttachShader(p, g);
        setup_geometry_shader(itype, otype, osize);
    }


    //printf("link program\n");
    glLinkProgram(p);
    glGetProgramiv(p, GL_LINK_STATUS, &params);
    if(params == GL_FALSE)
    {
	fprintf(stderr, "link program error:\n");
	printProgramInfoLog(p);
        exit(10);
    }

    if( printOpenGLError() )    exit(1);	
    //glUseProgram(p);
}
コード例 #12
0
ファイル: Shader.cpp プロジェクト: La-Stravaganza/LearnOpenGL
Shader::Shader(const GLchar *vsPath, const GLchar *fsPath) {
    // Read shaders from files
    std::ifstream vsStream(vsPath);
    std::stringstream vsBuffer;
    vsBuffer << vsStream.rdbuf();
    std::string vsStr = vsBuffer.str();
    const char* vertexShaderSource = vsStr.c_str();

    std::ifstream fgStream(fsPath);
    std::stringstream fgBuffer;
    fgBuffer << fgStream.rdbuf();
    std::string fgStr = fgBuffer.str();
    const char* fragmentShaderSource = fgStr.c_str();

    // Create a vertex shader and compile it
    GLuint vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);

    // Check if the vertex shader is compiled correctly
    GLint success;
    GLchar infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);

    if (success == false) {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::VERTEX:COMPILATION_FAILED\n" << infoLog << std::endl;
    }

    // Create a fragment shader and compile it
    GLuint fragmentShader;
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);

    // Check if the fragment shader is compiled correctly
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);

    if (success == false) {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
    }

    // Link two shaders with the shader program.
    this->program = glCreateProgram();
    glAttachShader(this->program, vertexShader);
    glAttachShader(this->program, fragmentShader);
    glLinkProgram(this->program);

    // check if the linking is successful.
    glGetShaderiv(this->program, GL_LINK_STATUS, &success);

    if (success == false) {
        glGetShaderInfoLog(this->program, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::PROGRAM_LINKING_FAILED\n" << infoLog << std::endl;
    }

    // After linking, we don't need shader objects anymore
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
}
コード例 #13
0
static
VdpStatus
compile_shaders(VdpDeviceData *deviceData)
{
    VdpStatus retval = VDP_STATUS_ERROR;

    for (int k = 0; k < SHADER_COUNT; k ++) {
        struct shader_s *s = &glsl_shaders[k];
        GLint errmsg_len;
        GLuint f_shader, program;
        int ok;


        f_shader = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(f_shader, 1, &s->body, &s->len);
        glCompileShader(f_shader);
        glGetShaderiv(f_shader, GL_COMPILE_STATUS, &ok);
        if (!ok) {
            glGetShaderiv(f_shader, GL_INFO_LOG_LENGTH, &errmsg_len);
            char *errmsg = malloc(errmsg_len);
            glGetShaderInfoLog(f_shader, errmsg_len, NULL, errmsg);
            traceError("error (%s): compilation of shader #%d failed with '%s'\n", __func__, k,
                       errmsg);
            free(errmsg);
            glDeleteShader(f_shader);
            goto err;
        }

        program = glCreateProgram();
        glAttachShader(program, f_shader);
        glLinkProgram(program);
        glGetProgramiv(program, GL_LINK_STATUS, &ok);
        if (!ok) {
            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &errmsg_len);
            char *errmsg = malloc(errmsg_len);
            glGetProgramInfoLog(program, errmsg_len, NULL, errmsg);
            traceError("error (%s): linking of shader #%d failed with '%s'\n", __func__, k,
                       errmsg);
            free(errmsg);
            glDeleteProgram(program);
            glDeleteShader(f_shader);
            goto err;
        }

        deviceData->shaders[k].f_shader = f_shader;
        deviceData->shaders[k].program = program;

        switch (k) {
        case glsl_YV12_RGBA:
        case glsl_NV12_RGBA:
            deviceData->shaders[k].uniform.tex_0 = glGetUniformLocation(program, "tex[0]");
            deviceData->shaders[k].uniform.tex_1 = glGetUniformLocation(program, "tex[1]");
            break;
        case glsl_red_to_alpha_swizzle:
            deviceData->shaders[k].uniform.tex_0 = glGetUniformLocation(program, "tex_0");
            break;
        }
    }

    retval = VDP_STATUS_OK;
err:
    return retval;
}
コード例 #14
0
ファイル: glus_shaderprogram.c プロジェクト: tufei/GLUS
GLUSboolean GLUSAPIENTRY glusCreateProgramFromSource(GLUSshaderprogram* shaderProgram, const GLUSchar** vertexSource, const GLUSchar** controlSource, const GLUSchar** evaluationSource, const GLUSchar** geometrySource, const GLUSchar** fragmentSource)
{
    GLUSint compiled;

    GLUSint logLength, charsWritten;

    char* log;

    if (!shaderProgram || !vertexSource || !fragmentSource)
    {
        return GLUS_FALSE;
    }

    shaderProgram->program = 0;
    shaderProgram->compute = 0;
    shaderProgram->vertex = 0;
    shaderProgram->control = 0;
    shaderProgram->evaluation = 0;
    shaderProgram->geometry = 0;
    shaderProgram->fragment = 0;

    shaderProgram->vertex = glCreateShader(GLUS_VERTEX_SHADER);

    glShaderSource(shaderProgram->vertex, 1, (const char**) vertexSource, 0);

    glCompileShader(shaderProgram->vertex);

    glGetShaderiv(shaderProgram->vertex, GL_COMPILE_STATUS, &compiled);

    if (!compiled)
    {
        glGetShaderiv(shaderProgram->vertex, GL_INFO_LOG_LENGTH, &logLength);

        log = (char*) malloc((size_t)logLength);

        if (!log)
        {
            return GLUS_FALSE;
        }

        glGetShaderInfoLog(shaderProgram->vertex, logLength, &charsWritten, log);

        glusLogPrint(GLUS_LOG_ERROR, "Vertex shader compile error:");
        glusLogPrint(GLUS_LOG_ERROR, "%s", log);

        free(log);

        shaderProgram->vertex = 0;

        return GLUS_FALSE;
    }

    if (controlSource)
    {
        shaderProgram->control = glCreateShader(GLUS_TESS_CONTROL_SHADER);

        glShaderSource(shaderProgram->control, 1, (const char**) controlSource, 0);

        glCompileShader(shaderProgram->control);

        glGetShaderiv(shaderProgram->control, GL_COMPILE_STATUS, &compiled);

        if (!compiled)
        {
            glGetShaderiv(shaderProgram->control, GL_INFO_LOG_LENGTH, &logLength);

            log = (char*) malloc((size_t)logLength);

            if (!log)
            {
                glusDestroyProgram(shaderProgram);

                return GLUS_FALSE;
            }

            glGetShaderInfoLog(shaderProgram->control, logLength, &charsWritten, log);

            glusLogPrint(GLUS_LOG_ERROR, "Control shader compile error:");
            glusLogPrint(GLUS_LOG_ERROR, "%s", log);

            free(log);

            shaderProgram->control = 0;

            glusDestroyProgram(shaderProgram);

            return GLUS_FALSE;
        }
    }

    if (evaluationSource)
    {
        shaderProgram->evaluation = glCreateShader(GLUS_TESS_EVALUATION_SHADER);

        glShaderSource(shaderProgram->evaluation, 1, (const char**) evaluationSource, 0);

        glCompileShader(shaderProgram->evaluation);

        glGetShaderiv(shaderProgram->evaluation, GL_COMPILE_STATUS, &compiled);

        if (!compiled)
        {
            glGetShaderiv(shaderProgram->evaluation, GL_INFO_LOG_LENGTH, &logLength);

            log = (char*) malloc((size_t)logLength);

            if (!log)
            {
                glusDestroyProgram(shaderProgram);

                return GLUS_FALSE;
            }

            glGetShaderInfoLog(shaderProgram->evaluation, logLength, &charsWritten, log);

            glusLogPrint(GLUS_LOG_ERROR, "Evaluation shader compile error:");
            glusLogPrint(GLUS_LOG_ERROR, "%s", log);

            free(log);

            shaderProgram->evaluation = 0;

            glusDestroyProgram(shaderProgram);

            return GLUS_FALSE;
        }
    }

    if (geometrySource)
    {
        shaderProgram->geometry = glCreateShader(GLUS_GEOMETRY_SHADER);

        glShaderSource(shaderProgram->geometry, 1, (const char**) geometrySource, 0);

        glCompileShader(shaderProgram->geometry);

        glGetShaderiv(shaderProgram->geometry, GL_COMPILE_STATUS, &compiled);

        if (!compiled)
        {
            glGetShaderiv(shaderProgram->geometry, GL_INFO_LOG_LENGTH, &logLength);

            log = (char*) malloc((size_t)logLength);

            if (!log)
            {
                glusDestroyProgram(shaderProgram);

                return GLUS_FALSE;
            }

            glGetShaderInfoLog(shaderProgram->geometry, logLength, &charsWritten, log);

            glusLogPrint(GLUS_LOG_ERROR, "Geometry shader compile error:");
            glusLogPrint(GLUS_LOG_ERROR, "%s", log);

            free(log);

            shaderProgram->geometry = 0;

            glusDestroyProgram(shaderProgram);

            return GLUS_FALSE;
        }
    }

    shaderProgram->fragment = glCreateShader(GLUS_FRAGMENT_SHADER);

    glShaderSource(shaderProgram->fragment, 1, (const char**) fragmentSource, 0);

    glCompileShader(shaderProgram->fragment);

    glGetShaderiv(shaderProgram->fragment, GL_COMPILE_STATUS, &compiled);

    if (!compiled)
    {
        glGetShaderiv(shaderProgram->fragment, GL_INFO_LOG_LENGTH, &logLength);

        log = (char*) malloc((size_t)logLength);

        if (!log)
        {
            glusDestroyProgram(shaderProgram);

            return GLUS_FALSE;
        }

        glGetShaderInfoLog(shaderProgram->fragment, logLength, &charsWritten, log);

        glusLogPrint(GLUS_LOG_ERROR, "Fragment shader compile error:");
        glusLogPrint(GLUS_LOG_ERROR, "%s", log);

        free(log);

        shaderProgram->fragment = 0;

        glusDestroyProgram(shaderProgram);

        return GLUS_FALSE;
    }

    shaderProgram->program = glCreateProgram();

    glAttachShader(shaderProgram->program, shaderProgram->vertex);

    if (shaderProgram->control)
    {
        glAttachShader(shaderProgram->program, shaderProgram->control);
    }

    if (shaderProgram->evaluation)
    {
        glAttachShader(shaderProgram->program, shaderProgram->evaluation);
    }

    if (shaderProgram->geometry)
    {
        glAttachShader(shaderProgram->program, shaderProgram->geometry);
    }

    glAttachShader(shaderProgram->program, shaderProgram->fragment);

    return GLUS_TRUE;
}
コード例 #15
0
ファイル: Age_Imgui.cpp プロジェクト: Strongc/AGE
	bool Imgui::init(Engine *en)
	{
#ifdef AGE_ENABLE_IMGUI

		GetMainThread()->registerCallback<ImGuiKeyEvent>([this](ImGuiKeyEvent &msg)
		{
			ImGuiIO& io = ImGui::GetIO();
			io.KeysDown[int(msg.key)] = msg.down;
			if (msg.key == AgeKeys::AGE_LCTRL || msg.key == AgeKeys::AGE_RCTRL)
				io.KeyCtrl = msg.down;
			else if (msg.key == AgeKeys::AGE_LSHIFT || msg.key == AgeKeys::AGE_RSHIFT)
				io.KeyShift = msg.down;
			else if (msg.down)
			{
				char character = keyToAscii.find(msg.key)->second;
				if (character != UNDEFINED_CHARACTER)
					io.AddInputCharacter(character);
			}
		});

		GetMainThread()->registerCallback<ImGuiEndOfFrame>([this](ImGuiEndOfFrame &msg)
		{
			SCOPE_profile_cpu_i("ImGui", "Render");
			ImGui::Render();
		});

		GetMainThread()->registerCallback<ImGuiMouseStateEvent>([this](ImGuiMouseStateEvent &msg)
		{
			_lastMouseState = msg;
		});

		_engine = en;
		//HARDCODED WINDOW TO FIX
		//auto window = di->getInstance<AGE::Threads::Render>()->getCommandQueue()->safePriorityFutureEmplace<RendCtxCommand::GetScreenSize, glm::uvec2>().get();

		ImGuiIO& io = ImGui::GetIO();
		//HARDCODED WINDOW TO FIX
		auto screenSize = en->getInstance<IRenderContext>()->getScreenSize();
		io.DisplaySize = ImVec2((float)screenSize.x, (float)screenSize.y);        // Display size, in pixels. For clamping windows positions.
		io.DeltaTime = 1.0f / 60.0f;                          // Time elapsed since last frame, in seconds (in this sample app we'll override this every frame because our timestep is variable)
		io.KeyMap[ImGuiKey_Tab] = int(AgeKeys::AGE_TAB);             // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array.
		io.KeyMap[ImGuiKey_LeftArrow] =  int(AgeKeys::AGE_LEFT);
		io.KeyMap[ImGuiKey_RightArrow] = int(AgeKeys::AGE_RIGHT);
		io.KeyMap[ImGuiKey_UpArrow] =    int(AgeKeys::AGE_UP);
		io.KeyMap[ImGuiKey_DownArrow] =  int(AgeKeys::AGE_DOWN);
		io.KeyMap[ImGuiKey_Home] =       int(AgeKeys::AGE_HOME);
		io.KeyMap[ImGuiKey_End] =        int(AgeKeys::AGE_END);
		io.KeyMap[ImGuiKey_Delete] =     int(AgeKeys::AGE_DELETE);
		io.KeyMap[ImGuiKey_Backspace] =  int(AgeKeys::AGE_BACKSPACE);
		io.KeyMap[ImGuiKey_Enter] =      int(AgeKeys::AGE_RETURN);
		io.KeyMap[ImGuiKey_Escape] =     int(AgeKeys::AGE_ESCAPE);
		io.KeyMap[ImGuiKey_A] =          int(AgeKeys::AGE_a);
		io.KeyMap[ImGuiKey_C] =          int(AgeKeys::AGE_c);
		io.KeyMap[ImGuiKey_V] =          int(AgeKeys::AGE_v);
		io.KeyMap[ImGuiKey_X] =          int(AgeKeys::AGE_x);
		io.KeyMap[ImGuiKey_Y] =          int(AgeKeys::AGE_y);
		io.KeyMap[ImGuiKey_Z] =          int(AgeKeys::AGE_z);

		io.RenderDrawListsFn = renderDrawLists;

		//io.SetClipboardTextFn = ImImpl_SetClipboardTextFn;
		//io.GetClipboardTextFn = ImImpl_GetClipboardTextFn;

		const GLchar *vertex_shader =
			"#version 330\n"
			"uniform mat4 ProjMtx;\n"
			"in vec2 Position;\n"
			"in vec2 UV;\n"
			"in vec4 Color;\n"
			"out vec2 Frag_UV;\n"
			"out vec4 Frag_Color;\n"
			"void main()\n"
			"{\n"
			"	Frag_UV = UV;\n"
			"	Frag_Color = Color;\n"
			"	gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
			"}\n";

		const GLchar* fragment_shader =
			"#version 330\n"
			"uniform sampler2D Texture;\n"
			"in vec2 Frag_UV;\n"
			"in vec4 Frag_Color;\n"
			"out vec4 Out_Color;\n"
			"void main()\n"
			"{\n"
			"	Out_Color = Frag_Color * texture( Texture, Frag_UV.st);\n"
			"}\n";

		shader_handle = glCreateProgram();
		vert_handle = glCreateShader(GL_VERTEX_SHADER);
		frag_handle = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(vert_handle, 1, &vertex_shader, 0);
		glShaderSource(frag_handle, 1, &fragment_shader, 0);
		glCompileShader(vert_handle);
		glCompileShader(frag_handle);
		glAttachShader(shader_handle, vert_handle);
		glAttachShader(shader_handle, frag_handle);
		glLinkProgram(shader_handle);

		texture_location = glGetUniformLocation(shader_handle, "Texture");
		ortho_location = glGetUniformLocation(shader_handle, "ProjMtx");
		position_location = glGetAttribLocation(shader_handle, "Position");
		uv_location = glGetAttribLocation(shader_handle, "UV");
		colour_location = glGetAttribLocation(shader_handle, "Color");

		glGenBuffers(1, &vbo_handle);
		glBindBuffer(GL_ARRAY_BUFFER, vbo_handle);
		glBufferData(GL_ARRAY_BUFFER, vbo_max_size, NULL, GL_DYNAMIC_DRAW);

		glGenVertexArrays(1, &vao_handle);
		glBindVertexArray(vao_handle);
		glBindBuffer(GL_ARRAY_BUFFER, vbo_handle);
		glEnableVertexAttribArray(position_location);
		glEnableVertexAttribArray(uv_location);
		glEnableVertexAttribArray(colour_location);

		glVertexAttribPointer(position_location, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, pos));
		glVertexAttribPointer(uv_location, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, uv));
		glVertexAttribPointer(colour_location, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, col));
		glBindVertexArray(0);
		glBindBuffer(GL_ARRAY_BUFFER, 0);

		// Load font texture
		glGenTextures(1, &fontTex);
		glBindTexture(GL_TEXTURE_2D, fontTex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

		unsigned char* pixels;
		int width, height;
		io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
		io.Fonts->TexID = &fontTex;

		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

		// Cleanup (don't clear the input data if you want to append new fonts later)
		io.Fonts->ClearInputData();
		io.Fonts->ClearTexData();
#else
		UNUSED(en);
#endif //AGE_ENABLE_IMGUI
		return true;
	}
コード例 #16
0
ファイル: displacement.c プロジェクト: cbetz421/etna_viv
int main(int argc, char *argv[])
{
	EGLDisplay display;
	EGLint egl_major, egl_minor;
	EGLConfig config;
	EGLint num_config;
	EGLContext context;
	EGLSurface surface;
	GLuint vertex_shader;
	GLuint fragment_shader;
	GLuint program;
	GLint ret;
	GLint width, height;
#ifdef HOOK
        the_hook("/mnt/sdcard/egl2.fdr");
#endif

	const char *vertex_shader_source =
	  "uniform mat4 modelviewMatrix;\n"
	  "uniform mat4 modelviewprojectionMatrix;\n"
	  "uniform mat3 normalMatrix;\n"
	  "\n"
	  "attribute vec4 in_position;    \n"
	  "attribute vec3 in_normal;      \n"
	  "attribute vec2 in_texcoord;       \n"
	  "\n"
	  "vec4 lightSource = vec4(2.0, 2.0, 20.0, 0.0);\n"
	  "                             \n"
	  "varying vec4 vColor;         \n"
	  "varying vec2 vTexCoord;         \n"
          "uniform sampler2D s_texture;                      \n"
	  "                             \n"
	  "void main()                  \n"
	  "{                            \n"
          "    float texvalue = texture2D(s_texture, in_texcoord).x;\n"
	  "    gl_Position = modelviewprojectionMatrix * (in_position + vec4(0.2 * texvalue * in_normal, 0));\n"
	  "    vec3 vEyeNormal = normalMatrix * in_normal;\n"
	  "    vec4 vPosition4 = modelviewMatrix * in_position;\n"
	  "    vec3 vPosition3 = vPosition4.xyz / vPosition4.w;\n"
	  "    vec3 vLightDir = normalize(lightSource.xyz - vPosition3);\n"
	  "    float diff = max(0.0, dot(vEyeNormal, vLightDir));\n"
	  "    vColor = vec4(diff, 0.0, 0.0, 1.0);\n"
	  "    vTexCoord = in_texcoord;\n"
	  "}                            \n";

	const char *fragment_shader_source =
	  "precision mediump float;     \n"
	  "                             \n"
	  "varying vec4 vColor;         \n"
	  "varying vec2 vTexCoord;         \n"
	  "                             \n"
	  "void main()                  \n"
	  "{                            \n"
	  "    gl_FragColor = vColor;// * texture2D(s_texture, vTexCoord);   \n"
	  "}                            \n";
	
        display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
	if (display == EGL_NO_DISPLAY) {
		printf("Error: No display found!\n");
		return -1;
	}

	if (!eglInitialize(display, &egl_major, &egl_minor)) {
		printf("Error: eglInitialise failed!\n");
		return -1;
	}

	printf("Using display %p with EGL version %d.%d\n",
	       display, egl_major, egl_minor);

	printf("EGL Version \"%s\"\n", eglQueryString(display, EGL_VERSION));
	printf("EGL Vendor \"%s\"\n", eglQueryString(display, EGL_VENDOR));
	printf("EGL Extensions \"%s\"\n", eglQueryString(display, EGL_EXTENSIONS));

	/* get an appropriate EGL frame buffer configuration */
	eglChooseConfig(display, config_attribute_list, &config, 1, &num_config);

	/* create an EGL rendering context */
	context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list);
	if (context == EGL_NO_CONTEXT) {
		printf("Error: eglCreateContext failed: %d\n", eglGetError());
		return -1;
	}

	surface = eglCreatePbufferSurface(display, config, pbuffer_attribute_list);
	if (surface == EGL_NO_SURFACE) {
		printf("Error: eglCreatePbufferSurface failed: %d (%s)\n",
		       eglGetError(), eglStrError(eglGetError()));
		return -1;
	}

	if (!eglQuerySurface(display, surface, EGL_WIDTH, &width) ||
	    !eglQuerySurface(display, surface, EGL_HEIGHT, &height)) {
		printf("Error: eglQuerySurface failed: %d (%s)\n",
		       eglGetError(), eglStrError(eglGetError()));
		return -1;
	}
	printf("PBuffer: %dx%d\n", width, height);
        printf("GL Extensions \"%s\"\n", glGetString(GL_EXTENSIONS));

	/* connect the context to the surface */
	if (!eglMakeCurrent(display, surface, surface, context)) {
		printf("Error: eglMakeCurrent() failed: %d (%s)\n",
		       eglGetError(), eglStrError(eglGetError()));
		return -1;
	}

	vertex_shader = glCreateShader(GL_VERTEX_SHADER);
	if (!vertex_shader) {
		printf("Error: glCreateShader(GL_VERTEX_SHADER) failed: %d (%s)\n",
		       eglGetError(), eglStrError(eglGetError()));
		return -1;
	}


	glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
	glCompileShader(vertex_shader);

	glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &ret);
	if (!ret) {
		char *log;

		printf("Error: vertex shader compilation failed!:\n");
		glGetShaderiv(vertex_shader, GL_INFO_LOG_LENGTH, &ret);

		if (ret > 1) {
			log = malloc(ret);
			glGetShaderInfoLog(vertex_shader, ret, NULL, log);
			printf("%s", log);
		}
		return -1;
	} else
		printf("Vertex shader compilation succeeded!\n");

	fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
	if (!fragment_shader) {
		printf("Error: glCreateShader(GL_FRAGMENT_SHADER) failed: %d (%s)\n",
		       eglGetError(), eglStrError(eglGetError()));
		return -1;
	}


	glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
	glCompileShader(fragment_shader);

	glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &ret);
	if (!ret) {
		char *log;

		printf("Error: fragment shader compilation failed!:\n");
		glGetShaderiv(fragment_shader, GL_INFO_LOG_LENGTH, &ret);

		if (ret > 1) {
			log = malloc(ret);
			glGetShaderInfoLog(fragment_shader, ret, NULL, log);
			printf("%s", log);
		}
		return -1;
	} else
		printf("Fragment shader compilation succeeded!\n");

	program = glCreateProgram();
	if (!program) {
		printf("Error: failed to create program!\n");
		return -1;
	}
        
        GLfloat *vVertices;
        GLfloat *vNormals;
        GLfloat *vTexCoords;
        GLushort *vIndices;
        int numIndices = esGenSphere(40, 1.0f, &vVertices, &vNormals,
                                            &vTexCoords, &vIndices, NULL);
        GLuint texId = createSimpleTexture();
	
        glAttachShader(program, vertex_shader);
	glAttachShader(program, fragment_shader);

	glBindAttribLocation(program, 0, "in_position");
	glBindAttribLocation(program, 1, "in_normal");
	glBindAttribLocation(program, 2, "in_texcoord");

	glLinkProgram(program);

	glGetProgramiv(program, GL_LINK_STATUS, &ret);
	if (!ret) {
		char *log;

		printf("Error: program linking failed!:\n");
		glGetProgramiv(program, GL_INFO_LOG_LENGTH, &ret);

		if (ret > 1) {
			log = malloc(ret);
			glGetProgramInfoLog(program, ret, NULL, log);
			printf("%s", log);
		}
		return -1;
	} else
		printf("program linking succeeded!\n");

	glUseProgram(program);

	glViewport(0, 0, width, height);

	/* clear the color buffer */
	glClearColor(0.5, 0.5, 0.5, 1.0);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
	glEnableVertexAttribArray(0);

	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, vNormals);
	glEnableVertexAttribArray(1);

	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, vTexCoords);
	glEnableVertexAttribArray(2);

	ESMatrix modelview;
	esMatrixLoadIdentity(&modelview);
	esTranslate(&modelview, 0.0f, 0.0f, -8.0f);
	esRotate(&modelview, 45.0f, 1.0f, 0.0f, 0.0f);
	esRotate(&modelview, 45.0f, 0.0f, 1.0f, 0.0f);
	esRotate(&modelview, 10.0f, 0.0f, 0.0f, 1.0f);

	GLfloat aspect = (GLfloat)(height) / (GLfloat)(width);

	ESMatrix projection;
	esMatrixLoadIdentity(&projection);
	esFrustum(&projection, -1.8f, +1.8f, -1.8f * aspect, +1.8f * aspect, 6.0f, 10.0f);

	ESMatrix modelviewprojection;
	esMatrixLoadIdentity(&modelviewprojection);
	esMatrixMultiply(&modelviewprojection, &modelview, &projection);

	float normal[9];
	normal[0] = modelview.m[0][0];
	normal[1] = modelview.m[0][1];
	normal[2] = modelview.m[0][2];
	normal[3] = modelview.m[1][0];
	normal[4] = modelview.m[1][1];
	normal[5] = modelview.m[1][2];
	normal[6] = modelview.m[2][0];
	normal[7] = modelview.m[2][1];
	normal[8] = modelview.m[2][2];

	GLint modelviewmatrix_handle = glGetUniformLocation(program, "modelviewMatrix");
	GLint modelviewprojectionmatrix_handle = glGetUniformLocation(program, "modelviewprojectionMatrix");
	GLint normalmatrix_handle = glGetUniformLocation(program, "normalMatrix");
        GLint sampler_handle = glGetUniformLocation(program, "s_texture");

	glUniformMatrix4fv(modelviewmatrix_handle, 1, GL_FALSE, &modelview.m[0][0]);
	glUniformMatrix4fv(modelviewprojectionmatrix_handle, 1, GL_FALSE, &modelviewprojection.m[0][0]);
	glUniformMatrix3fv(normalmatrix_handle, 1, GL_FALSE, normal);

        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, texId);
        glUniform1i(sampler_handle, 0);

	glEnable(GL_CULL_FACE);
        glEnable(GL_DEPTH_TEST);

        glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, vIndices);

	glFlush();

	fflush(stdout);
        dump_gl_screen("/sdcard/egl2.bmp", width, height);

#ifdef HOOK
        close_hook();
#endif

	return 0;
}
コード例 #17
0
GLuint npProgramLoader::loadProgram(string  shader)
{
    
    GLuint vertShader, fragShader;
  
    GLint logLength;
    
    program = glCreateProgram();
    
      
    
    const GLchar *sourceV;
    sourceV=npTextFileLoader::loadChar  (shader,"vsh");
    
    vertShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertShader, 1, &sourceV, NULL);
    glCompileShader(vertShader);
    

    
    
    
    glGetShaderiv(vertShader, GL_INFO_LOG_LENGTH, &logLength);
    if (logLength > 1)
    {
        GLchar *log = (GLchar *)malloc(logLength);
        glGetShaderInfoLog(vertShader, logLength, &logLength, log);
        cout << "VertexShader compile log:"<<  log<< "\n";
        delete log;
    }
    
      const GLchar *sourceF;
    sourceF = npTextFileLoader::loadChar  (shader,"fsh");
    if (!sourceF)
    {
        cout << "fragment shader not found";
    }
    fragShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragShader, 1, &sourceF, NULL);
    glCompileShader(fragShader);
    
        
    
    glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &logLength);
    if (logLength > 1)
    {
        GLchar *log = (GLchar *)malloc(logLength);
        glGetShaderInfoLog(fragShader, logLength, &logLength, log);
        cout << "FragmentShader compile log:"<<  log<< "\n";
        delete log;
    }
    
    glAttachShader(program, vertShader);
    
    glAttachShader(program, fragShader);
    
    
    glDeleteShader(vertShader);
    glDeleteShader(fragShader);
    
    
  // delete [] sourceF;
  
   //  delete [] sourceV;
    
    return program;
    
}
コード例 #18
0
ファイル: main.cpp プロジェクト: ROOOO/LearningOpenGL
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);
#ifdef __APPLE__
  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
  
  GLFWwindow* window = glfwCreateWindow(800, 600, "EX_GS_HT_2", nullptr, nullptr);
  if (window == nullptr) {
    std::cout << "Create window failed" << std::endl;
    glfwTerminate();
    return -1;
  }
  glfwMakeContextCurrent(window);
  
  glfwSetKeyCallback(window, key_callback);
  
  glewExperimental = GL_TRUE;
  if (glewInit() != GLEW_OK) {
    std::cout << "GLEW INIT failed" << std::endl;
    glfwTerminate();
    return -1;
  }
  
  int width, height;
  glfwGetFramebufferSize(window, &width, &height);
  glViewport(0, 0, width, height);
  
  GLint success;
  GLchar infoLog[512];
  
  GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
  glShaderSource(vertexShader, 1, &vertexShaderSource, nullptr);
  glCompileShader(vertexShader);
  glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
  if (!success) {
    glGetShaderInfoLog(vertexShader, sizeof(infoLog), nullptr, infoLog);
    std::cout << "Compile vertex shader failed\n" << infoLog << std::endl;
    glfwTerminate();
    return -1;
  }
  
  GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(fragmentShader, 1, &fragmentShaderSource, nullptr);
  glCompileShader(fragmentShader);
  glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
  if (!success) {
    glGetShaderInfoLog(fragmentShader, sizeof(infoLog), nullptr, infoLog);
    std::cout << "Compile fragment shader failed\n" << infoLog << std::endl;
    glfwTerminate();
    return -1;
  }
  
  GLuint shaderProgram = glCreateProgram();
  glAttachShader(shaderProgram, vertexShader);
  glAttachShader(shaderProgram, fragmentShader);
  glLinkProgram(shaderProgram);
  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
  if (!success) {
    glGetProgramInfoLog(shaderProgram, sizeof(infoLog), nullptr, infoLog);
    std::cout << "Failed to Link Shaders\n" << infoLog << std::endl;
    glfwTerminate();
    return -1;
  }
  glDeleteShader(vertexShader);
  glDeleteShader(fragmentShader);
  
  GLfloat vertices1[] = {
    0.0f, -0.5f, 0.0f,
    -1.0f, -0.5f, 0.0f,
    -0.5f, 0.5f, 0.0f,
  };
  GLfloat vertices2[] = {
    1.0f, -0.5f, 0.0f,
    0.0f, -0.5f, 0.0f,
    0.5f, 0.5f, 0.0f,
  };
  
  GLuint VBO[2], VAO[2];
  glGenBuffers(2, VBO);
  glGenVertexArrays(2, VAO);
  
  glBindVertexArray(VAO[0]);
  glBindBuffer(GL_ARRAY_BUFFER, VBO[0]);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices1), vertices1, GL_STATIC_DRAW);
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);  // size
  glEnableVertexAttribArray(0);
  glBindBuffer(GL_ARRAY_BUFFER, 0);
  glBindVertexArray(0);
  
  glBindVertexArray(VAO[1]);
  glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices2), vertices2, GL_STATIC_DRAW);
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)0); //size
  glEnableVertexAttribArray(0);
  glBindBuffer(GL_ARRAY_BUFFER, 0);
  glBindVertexArray(0);
  
  while (!glfwWindowShouldClose(window)) {
    glfwPollEvents();
    
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
    
    glUseProgram(shaderProgram);
    glBindVertexArray(VAO[0]);
    glDrawArrays(GL_TRIANGLES, 0, 3);
    glBindVertexArray(0);
    
    glBindVertexArray(VAO[1]);
    glDrawArrays(GL_TRIANGLES, 0, 3);
    glBindVertexArray(0);
    
    glfwSwapBuffers(window);
  }
  
  glDeleteBuffers(sizeof(VBO), VBO);
  glDeleteVertexArrays(sizeof(VAO), VAO);
  
  glfwTerminate();
  return -1;
}
コード例 #19
0
ファイル: Shader.hpp プロジェクト: ArmandBiteau/mncrft
	void setSource(const char* src) {
		glShaderSource(m_nGLId, 1, &src, 0);
	}
コード例 #20
0
ファイル: renderer.cpp プロジェクト: JackDanny/cours-M1-IARF
int Renderer::initShader(std::string vsFileName, std::string fsFileName)
{

    // Les opérations devant être faites pour pouvoir utiliser des shaders OpenGL dans notre application sont les suivantes :
    // 1 - Vertex shader :
    //   1.1 - Charger le source depuis le fichier "../shaders/vertexdefault.glsl" en utilisant la fonction loaders::text::loadFile() de lecture d'un fichier texte
    char* vertexShaderSource = loaders::text::loadFile(vsFileName.c_str());
    //   1.2 - Créer un objet OpenGL VERTEX_SHADER et y associer le source
    int vertexShaderId;
    glAssert(vertexShaderId = glCreateShader(GL_VERTEX_SHADER));
    glAssert(glShaderSource(vertexShaderId, 1, (const GLchar **)&vertexShaderSource, NULL));
    //   1.3 - Compiler le shader
    glAssert(glCompileShader(vertexShaderId));
    //   1.4 - Vérifier les erreurs de compilation
    GLint compiled;
    glAssert(glGetShaderiv(vertexShaderId, GL_COMPILE_STATUS, &compiled));
    if (!compiled) {
        std::cerr << "[" << vsFileName << "] Vertex shader not compiled : " << std::endl;
        printShaderInfoLog(vertexShaderId);
        return 0;
    }

    // 2 - Fragment shader :
    //   2.1 - Charger le source depuis le fichier "../shaders/fragmentdefault.glsl" en utilisant la fonction loaders::text::loadFile() de lecture d'un fichier texte
    char *fragmentShaderSource;
    fragmentShaderSource = loaders::text::loadFile(fsFileName.c_str());
    //   2.2 - Créer un objet OpenGL FRAGMENT_SHADER et y associer le source
    int fragmentShaderId;
    glAssert(fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER));
    glAssert(glShaderSource(fragmentShaderId, 1, (const GLchar **)&fragmentShaderSource, NULL));
    //   2.3 - Compiler le shader
    glAssert(glCompileShader(fragmentShaderId));
    //   2.4 - Vérifier les erreurs de compilation
    glAssert(glGetShaderiv(fragmentShaderId, GL_COMPILE_STATUS, &compiled));
    if (!compiled) {
        std::cerr << "[" << fsFileName << "] fragment shader not compiled : " << std::endl;
        printShaderInfoLog(fragmentShaderId);
        return 0;
    }

    // 3 - Programme :
    //   3.1 - Créer un programme OpenGL, stocker son identifiant dans g_Program et y associer les shaders
    int program;
    glAssert(program = glCreateProgram());
    glAssert(glAttachShader(program, vertexShaderId));
    glAssert(glAttachShader(program, fragmentShaderId));
    //   3.2 - Fixer les positions des attributs géométriques en accord avec la classe MyGLMesh et les conventions
    //         d'écriture du source GLSL inPosition --> index 0, inNormal --> index 1 et inTexCoord --> index 2.
    glAssert(glBindAttribLocation(program, 0, "inPosition"));
    glAssert(glBindAttribLocation(program, 1, "inNormal"));
    glAssert(glBindAttribLocation(program, 2, "inTexCoord"));
    //   3.3 - Lier le programme
    glAssert(glLinkProgram(program));
    //   3.4 - Vérifier les erreurs d'édition de lien
    GLint linked;
    glAssert(glGetProgramiv(program, GL_LINK_STATUS, &linked));
    if (!linked) {
        std::cerr << "Program not linked" << std::endl;
        printProgramInfoLog(program);
    }
    return program;


}
コード例 #21
0
ファイル: main.c プロジェクト: wowk/OpenGL
int main(int argc, char *argv[])
{
    GLuint vao;
    GLuint vbo;
    GLfloat vertices[] = {
        0.5f,   -0.5f,  0.0f,   1.0f,   0.0f,   0.0f,
        -0.5f,  -0.5f,  0.0f,   0.0f,   1.0f,   0.0f,
        0.0f,   0.5f,   0.0f,   0.0f,   0.0f,   1.0f,
    };

    GLint status;
    GLuint vertexShader;
    GLuint fragmentShader;
    GLuint program;
    GLchar *pbuffer;
    GLchar buffer[4096];
    GLsizei bufferLen;
    GLchar logBuffer[256];
    GLsizei logBufferLen;

    GLboolean running = GL_FALSE;
    SDL_Window* window = NULL;
    SDL_GLContext glContext = NULL;

    if( 0 > SDL_Init(SDL_INIT_VIDEO) ){
        printf("SDL_Init(Video) failed: %s\n", SDL_GetError());
        goto error_sdl_init;
    }

    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);

    window = SDL_CreateWindow(argv[0], 100, 100, 800, 600, SDL_WINDOW_OPENGL);
    if( !window ){
        printf("SDL_CreateWindow failed: %s\n", SDL_GetError());
        goto error_sdl_create_window;
    }

    glContext = SDL_GL_CreateContext(window);
    if( !glContext ){
        printf("SDL_GL_CreateContext failed: %s\n", SDL_GetError());
        goto error_sdl_gl_create_context;
    }

    if( 0 == gladLoadGLLoader(SDL_GL_GetProcAddress) ){
        printf("gladLoadGLLoader failed\n");
        goto error_glad_load_error;
    }

    /* load vertex data */
    glGenVertexArrays(1, &vao);
    if( 0 == vao ){
        printf("glGenVertexArrays failed: %d\n", glGetError());
        goto error_gl_gen_vertex_arrays;
    }
    glBindVertexArray(vao);

    glGenBuffers(1, &vbo);
    if( 0 == vbo ){
        printf("glGenBuffers failed: %d\n", glGetError());
        goto error_gl_gen_buffers;
    }
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), NULL);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
    glEnableVertexAttribArray(1);

    glBindVertexArray(0);

    program = glCreateProgram();
    if( 0 == program ){
        printf("glCreateProgram failed: %d\n", glGetError());
        goto error_gl_create_program;
    }

    /* load vertex shader */
    bufferLen = sizeof(buffer);
    if( 0 == loadFile("../03_01_ShaderColorfulTriangle/shader.vert", buffer, &bufferLen) ){
        goto error_load_vertex_source;
    }

    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    if( 0 == vertexShader ){
        goto error_gl_create_vertex_shader;
    }

    pbuffer = buffer;
    glShaderSource(vertexShader, 1, &pbuffer, &bufferLen);
    glCompileShader(vertexShader);
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
    if( 0 == status ){
        glGetShaderInfoLog(vertexShader, sizeof(logBuffer), &logBufferLen, logBuffer);
        printf("compile shader failed:\n%s\nerror: %s\n", buffer, logBuffer);
        goto error_gl_compile_shader;
    }
    glAttachShader(program, vertexShader);
    glDeleteShader(vertexShader);
    vertexShader = 0;

    /* load fragment shader */
    bufferLen = sizeof(buffer);
    if( 0 == loadFile("../03_01_ShaderColorfulTriangle/shader.frag", buffer, &bufferLen) ){
        goto error_load_fragment_source;
    }

    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    if( 0 == fragmentShader ){
        goto error_gl_create_fragment_shader;
    }

    pbuffer = buffer;
    glShaderSource(fragmentShader, 1, &pbuffer, &bufferLen);
    glCompileShader(fragmentShader);
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &status);
    if( 0 == status ){
        glGetShaderInfoLog(fragmentShader, sizeof(logBuffer), &logBufferLen, logBuffer);
        printf("compile shader failed:\n%s\nerror: %s\n", buffer, logBuffer);
        goto error_gl_compile_fragment_shader;
    }
    glAttachShader(program, fragmentShader);

    /* link program */
    glLinkProgram(program);
    glGetProgramiv(program, GL_LINK_STATUS, &status);
    if( 0 == status ){
        glGetProgramInfoLog(program, sizeof(logBuffer), &logBufferLen, logBuffer);
        printf("link program failed: %s\n", logBuffer);
        goto error_link_program;
    }

    running = GL_TRUE;
    while( running ){
        SDL_Event event;
        while( SDL_PollEvent(&event)){
            if( event.type == SDL_KEYDOWN ){
                printf("quit\n");
                running = GL_FALSE;
                break;
            }
        }

        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glBindVertexArray(vao);
        glUseProgram(program);
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glUseProgram(0);
        glBindVertexArray(0);

        SDL_GL_SwapWindow(window);
    }

    glDeleteProgram(program);
    glDeleteBuffers(1, &vbo);
    glDeleteVertexArrays(1, &vao);
    SDL_GL_DeleteContext(glContext);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;

error_link_program:
error_gl_compile_fragment_shader:
    if( fragmentShader )
        glDeleteShader(fragmentShader);
error_gl_create_fragment_shader:
error_load_fragment_source:
error_gl_compile_shader:
    if( vertexShader )
        glDeleteShader(vertexShader);
error_gl_create_vertex_shader:
error_load_vertex_source:
    glDeleteProgram(program);
error_gl_create_program:
    glDeleteBuffers(1, &vbo);
error_gl_gen_buffers:
    glDeleteVertexArrays(1, &vao);
error_gl_gen_vertex_arrays:
error_glad_load_error:
    SDL_GL_DeleteContext(glContext);
error_sdl_gl_create_context:
    SDL_DestroyWindow(window);
error_sdl_create_window:
    SDL_Quit();
error_sdl_init:

    return -1;
}
コード例 #22
0
ファイル: piestate.c プロジェクト: blezek/warzone2100
// Read/compile/link shaders
static bool loadShaders(GLuint *program, const char *definitions,
						const char *vertexPath, const char *fragmentPath)
{
	GLint status;
	bool success = true; // Assume overall success
	char *buffer[2];

	*program = glCreateProgram();
	ASSERT_OR_RETURN(false, definitions != NULL, "Null in preprocessor definitions!");
	ASSERT_OR_RETURN(false, *program, "Could not create shader program!");

	*buffer = (char *)definitions;

	if (vertexPath)
	{
		success = false; // Assume failure before reading shader file

		if ((*(buffer + 1) = readShaderBuf(vertexPath)))
		{
			GLuint shader = glCreateShader(GL_VERTEX_SHADER);

			glShaderSource(shader, 2, (const char **)buffer, NULL);
			glCompileShader(shader);

			// Check for compilation errors
			glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
			if (!status)
			{
				debug(LOG_ERROR, "Vertex shader compilation has failed [%s]", vertexPath);
				printShaderInfoLog(LOG_ERROR, shader);
			}
			else
			{
				printShaderInfoLog(LOG_3D, shader);
				glAttachShader(*program, shader);
				success = true;
			}

			free(*(buffer + 1));
		}
	}

	if (success && fragmentPath)
	{
		success = false; // Assume failure before reading shader file

		if ((*(buffer + 1) = readShaderBuf(fragmentPath)))
		{
			GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);

			glShaderSource(shader, 2, (const char **)buffer, NULL);
			glCompileShader(shader);
			
			// Check for compilation errors
			glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
			if (!status)
			{
				debug(LOG_ERROR, "Fragment shader compilation has failed [%s]", fragmentPath);
				printShaderInfoLog(LOG_ERROR, shader);
			}
			else
			{
				printShaderInfoLog(LOG_3D, shader);
				glAttachShader(*program, shader);
				success = true;
			}

			free(*(buffer + 1));
		}
	}

	if (success)
	{
		glLinkProgram(*program);

		// Check for linkage errors
		glGetProgramiv(*program, GL_LINK_STATUS, &status);
		if (!status)
		{
			debug(LOG_ERROR, "Shader program linkage has failed [%s, %s]", vertexPath, fragmentPath);
			printProgramInfoLog(LOG_ERROR, *program);
			success = false;
		}
		else
		{
			printProgramInfoLog(LOG_3D, *program);
		}
	}

	return success;	
}
コード例 #23
0
ShaderProgram::operator GLuint() const
{
	if (!name)
	{
		GLint success;
		GLint length;

		name = glCreateProgram();

		typedef shader_set_t::const_iterator iter;
		for (iter i = shaders.begin(); i != shaders.end(); ++i)
		{
			GLenum type = i->first;
			const GLchar* source = i->second;

			GLuint shader = glCreateShader(type);
			glShaderSource(shader, 1, &source, 0);
			glCompileShader(shader);

			glGetShaderiv(shader, GL_COMPILE_STATUS, &success);

			glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
			if (length > 0)
			{
				std::string log(length, 0);
				glGetShaderInfoLog(shader, length, 0, &log[0]);
				std::clog << log << std::endl;
			}

			if (!success)
			{
				std::cerr << "error compiling shader" << std::endl;
				return 0;
			}

			glAttachShader(name, shader);
			glDeleteShader(shader);
		}

		glLinkProgram(name);

		glGetProgramiv(name, GL_LINK_STATUS, &success);
		if (!success)
			std::cerr << "error linking program" << std::endl;

		glGetProgramiv(name, GL_INFO_LOG_LENGTH, &length);
		if (length > 0)
		{
			std::string log(length, 0);
			glGetProgramInfoLog(name, length, 0, &log[0]);
			std::clog << log << std::endl;
		}

//		//print uniforms
//		{
//			GLint uniforms;
//			GLint maxlength;
//
//			glGetProgramiv(name, GL_ACTIVE_UNIFORMS, &uniforms);
//			glGetProgramiv(name, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxlength);
//
//			std::vector<GLchar> uname(maxlength);
//
//			for (GLint i = 0; i < uniforms; ++i)
//			{
//				GLsizei length;
//				GLint size;
//				GLenum type;
//
//				glGetActiveUniform(name, i, uname.size(), &length, &size,
//						&type, &uname[0]);
//
//				std::cout << type << " [" << size << "]: " << &uname[0]
//						<< std::endl;
//			}
//		}
	}

	return name;
}
コード例 #24
0
ファイル: main.cpp プロジェクト: benwang0912/OpenGL_-Shading
static unsigned int setup_shader(const char *vertex_shader, const char *fragment_shader)
{
	GLuint vs=glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vs, 1, (const GLchar**)&vertex_shader, nullptr);

	glCompileShader(vs);	//compile vertex shader

	int status, maxLength;
	char *infoLog=nullptr;
	glGetShaderiv(vs, GL_COMPILE_STATUS, &status);		//get compile status
	if(status==GL_FALSE)								//if compile error
	{
		glGetShaderiv(vs, GL_INFO_LOG_LENGTH, &maxLength);	//get error message length

		/* The maxLength includes the NULL character */
		infoLog = new char[maxLength];
		
		glGetShaderInfoLog(vs, maxLength, &maxLength, infoLog);		//get error message

		fprintf(stderr, "Vertex Shader Error: %s\n", infoLog);

		/* Handle the error in an appropriate way such as displaying a message or writing to a log file. */
		/* In this simple program, we'll just leave */
		delete [] infoLog;
		return 0;
	}
	//	for fragment shader --> same as vertex shader
	GLuint fs=glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fs, 1, (const GLchar**)&fragment_shader, nullptr);
	glCompileShader(fs);

	glGetShaderiv(fs, GL_COMPILE_STATUS, &status);
	if(status==GL_FALSE)
	{
		glGetShaderiv(fs, GL_INFO_LOG_LENGTH, &maxLength);

		/* The maxLength includes the NULL character */
		infoLog = new char[maxLength];

		glGetShaderInfoLog(fs, maxLength, &maxLength, infoLog);

		fprintf(stderr, "Fragment Shader Error: %s\n", infoLog);

		/* Handle the error in an appropriate way such as displaying a message or writing to a log file. */
		/* In this simple program, we'll just leave */
		delete [] infoLog;
		return 0;
	}

	unsigned int program=glCreateProgram();
	// Attach our shaders to our program
	glAttachShader(program, vs);
	glAttachShader(program, fs);

	glLinkProgram(program);

	glGetProgramiv(program, GL_LINK_STATUS, &status);

	if(status==GL_FALSE)
	{
		glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);


		/* The maxLength includes the NULL character */
		infoLog = new char[maxLength];
		glGetProgramInfoLog(program, maxLength, NULL, infoLog);

		glGetProgramInfoLog(program, maxLength, &maxLength, infoLog);

		fprintf(stderr, "Link Error: %s\n", infoLog);

		/* Handle the error in an appropriate way such as displaying a message or writing to a log file. */
		/* In this simple program, we'll just leave */
		delete [] infoLog;
		return 0;
	}
	return program;
}
コード例 #25
0
ファイル: liveview-glut.c プロジェクト: chrox/libcamiface
void setShaders() {

  const char * vv;
  const char * ff;
                char *vs,*fs;
                GLint status;
                GLhandleARB vertex_program,fragment_program;
                GLint sourceSize, shader_texture_source;

                vertex_program = glCreateShader(GL_VERTEX_SHADER);
                fragment_program = glCreateShader(GL_FRAGMENT_SHADER);

                vs = textFileRead(SHADER_DIR "demosaic.vrt");
                if (vs==NULL) {
                  fprintf(stderr,"ERROR: failed to read vertex shader %s\n",
			  SHADER_DIR "demosaic.vrt");
                  use_shaders = 0;
                  return;
                }
                fs = textFileRead(SHADER_DIR "demosaic.frg");
                if (fs==NULL) {
                  fprintf(stderr,"ERROR: failed to read fragment shader %s\n",
			  SHADER_DIR "demosaic.frg");
                  use_shaders = 0;
                  return;
                }

                vv = vs;
                ff = fs;

                glShaderSource(vertex_program, 1, &vv,NULL);
                glShaderSource(fragment_program, 1, &ff,NULL);

                free(vs);free(fs);

                glCompileShader(vertex_program);
                glGetShaderiv(vertex_program,GL_COMPILE_STATUS,&status);
                if (status!=GL_TRUE) {
                  fprintf(stderr,
                          "ERROR: GLSL vertex shader compile error, disabling shaders\n");
                  use_shaders = 0;
                  return;
                }

                glCompileShader(fragment_program);
                glGetShaderiv(fragment_program,GL_COMPILE_STATUS,&status);
                if (status!=GL_TRUE) {
                  fprintf(stderr,
                          "ERROR: GLSL fragment shader compile error, disabling shaders\n");
                  use_shaders = 0;
                  return;
                }

                printShaderInfoLog(vertex_program);
                printShaderInfoLog(fragment_program);

                glsl_program = glCreateProgram();
                glAttachShader(glsl_program,vertex_program);
                glAttachShader(glsl_program,fragment_program);
                glLinkProgram(glsl_program);

                printProgramInfoLog(glsl_program);

                glGetProgramiv(glsl_program,GL_LINK_STATUS,&status);
                if (status!=GL_TRUE) {
                  fprintf(stderr,"ERROR: GLSL link error, disabling shaders\n");
                  use_shaders = 0;
                  return;
                }

                glUseProgram(glsl_program);
                printf("GLSL shaders in use\n");


                sourceSize = glGetUniformLocation(glsl_program,"sourceSize");
                shader_texture_source = glGetUniformLocation(glsl_program,"source");

                glUniform4f(sourceSize,
                            PBO_stride,height,
                            1.0/PBO_stride,1.0/height);
                glUniform1i(shader_texture_source, 0);
}
コード例 #26
0
static void initShader(const GLchar* vShaderFile, const GLchar* fShaderFile)
{
    GLint status = glGetError()==GL_NO_ERROR;
    GLchar *vSource, *fSource;
    GLuint vShader, fShader;
    GLuint texMapLocation;

    /* read shader files */

    vSource = readShaderSource(vShaderFile);
    if(vSource==NULL)
    {
        printf( "Failed to read vertex shaderi\n");
        exit(EXIT_FAILURE);
    }


    fSource = readShaderSource(fShaderFile);
    if(fSource==NULL)
    {
        printf("Failed to read fragment shader");
        exit(EXIT_FAILURE);
    }

    /* create program and shader objects */

    vShader = glCreateShader(GL_VERTEX_SHADER);
    fShader = glCreateShader(GL_FRAGMENT_SHADER);
    program = glCreateProgram();

    /* attach shaders to the program object */

    glAttachShader(program, vShader);
    glAttachShader(program, fShader);

    /* read shaders */

    glShaderSource(vShader, 1, (const GLchar**) &vSource, NULL);
    glShaderSource(fShader, 1, (const GLchar**) &fSource, NULL);

    /* compile vertex shader */

    glCompileShader(vShader);

    /* error check */

    glGetShaderiv(vShader, GL_COMPILE_STATUS, &status);
    if(status==GL_FALSE)
    {
       printf("Failed to compile the vertex shader.\n");
       glGetShaderiv(vShader, GL_INFO_LOG_LENGTH, &elength);
       ebuffer = (GLchar *) malloc(elength*sizeof(char));
       glGetShaderInfoLog(vShader, elength, NULL, ebuffer);
       printf("%s\n", ebuffer);
       exit(EXIT_FAILURE);
    }

    /* compile fragment shader */

    glCompileShader(fShader);

    glGetShaderiv(fShader, GL_COMPILE_STATUS, &status);
    if(status==GL_FALSE)
    {
       printf("Failed to compile the fragment shader.\n");
       glGetShaderiv(fShader, GL_INFO_LOG_LENGTH, &elength);
       ebuffer = (GLchar *) malloc(elength*sizeof(char));
       glGetShaderInfoLog(fShader, elength, NULL, ebuffer);
       printf("%s\n", ebuffer);
       exit(EXIT_FAILURE);
    }


    /* link */

    glLinkProgram(program);
    glGetShaderiv(program, GL_LINK_STATUS, &status);
    if(status==GL_FALSE)
    {
       printf("Failed to link program object.\n");
       glGetProgramiv(program, GL_INFO_LOG_LENGTH, &elength);
       ebuffer = (GLchar *) malloc(elength*sizeof(char));
       glGetProgramInfoLog(program, elength, &elength, ebuffer);
       printf("%s\n", ebuffer);
       exit(EXIT_FAILURE);
    }


    /* use program object */

    glUseProgram(program);

    /* set up uniform parameter */

    texMapLocation = glGetUniformLocation(program, "texMap");
        glUniform1i(texMapLocation,0);
}
コード例 #27
0
ファイル: canvas.c プロジェクト: junxie6/nuklear
static void
device_init(struct device *dev)
{
    GLint status;
    static const GLchar *vertex_shader =
        NK_SHADER_VERSION
        "uniform mat4 ProjMtx;\n"
        "in vec2 Position;\n"
        "in vec2 TexCoord;\n"
        "in vec4 Color;\n"
        "out vec2 Frag_UV;\n"
        "out vec4 Frag_Color;\n"
        "void main() {\n"
        "   Frag_UV = TexCoord;\n"
        "   Frag_Color = Color;\n"
        "   gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n"
        "}\n";
    static const GLchar *fragment_shader =
        NK_SHADER_VERSION
        "precision mediump float;\n"
        "uniform sampler2D Texture;\n"
        "in vec2 Frag_UV;\n"
        "in vec4 Frag_Color;\n"
        "out vec4 Out_Color;\n"
        "void main(){\n"
        "   Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
        "}\n";

    nk_buffer_init_default(&dev->cmds);
    dev->prog = glCreateProgram();
    dev->vert_shdr = glCreateShader(GL_VERTEX_SHADER);
    dev->frag_shdr = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(dev->vert_shdr, 1, &vertex_shader, 0);
    glShaderSource(dev->frag_shdr, 1, &fragment_shader, 0);
    glCompileShader(dev->vert_shdr);
    glCompileShader(dev->frag_shdr);
    glGetShaderiv(dev->vert_shdr, GL_COMPILE_STATUS, &status);
    assert(status == GL_TRUE);
    glGetShaderiv(dev->frag_shdr, GL_COMPILE_STATUS, &status);
    assert(status == GL_TRUE);
    glAttachShader(dev->prog, dev->vert_shdr);
    glAttachShader(dev->prog, dev->frag_shdr);
    glLinkProgram(dev->prog);
    glGetProgramiv(dev->prog, GL_LINK_STATUS, &status);
    assert(status == GL_TRUE);

    dev->uniform_tex = glGetUniformLocation(dev->prog, "Texture");
    dev->uniform_proj = glGetUniformLocation(dev->prog, "ProjMtx");
    dev->attrib_pos = glGetAttribLocation(dev->prog, "Position");
    dev->attrib_uv = glGetAttribLocation(dev->prog, "TexCoord");
    dev->attrib_col = glGetAttribLocation(dev->prog, "Color");

    {
        /* buffer setup */
        GLsizei vs = sizeof(struct nk_glfw_vertex);
        size_t vp = offsetof(struct nk_glfw_vertex, position);
        size_t vt = offsetof(struct nk_glfw_vertex, uv);
        size_t vc = offsetof(struct nk_glfw_vertex, col);

        glGenBuffers(1, &dev->vbo);
        glGenBuffers(1, &dev->ebo);
        glGenVertexArrays(1, &dev->vao);

        glBindVertexArray(dev->vao);
        glBindBuffer(GL_ARRAY_BUFFER, dev->vbo);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dev->ebo);

        glEnableVertexAttribArray((GLuint)dev->attrib_pos);
        glEnableVertexAttribArray((GLuint)dev->attrib_uv);
        glEnableVertexAttribArray((GLuint)dev->attrib_col);

        glVertexAttribPointer((GLuint)dev->attrib_pos, 2, GL_FLOAT, GL_FALSE, vs, (void*)vp);
        glVertexAttribPointer((GLuint)dev->attrib_uv, 2, GL_FLOAT, GL_FALSE, vs, (void*)vt);
        glVertexAttribPointer((GLuint)dev->attrib_col, 4, GL_UNSIGNED_BYTE, GL_TRUE, vs, (void*)vc);
    }

    glBindTexture(GL_TEXTURE_2D, 0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    glBindVertexArray(0);
}
コード例 #28
0
int main()
{
	sf::ContextSettings settings;
	settings.depthBits = 24;
	settings.stencilBits = 8;
	settings.antialiasingLevel = 2;

	sf::Window window(sf::VideoMode(800, 600), "My triangle", sf::Style::Close, settings);

	glewExperimental = GL_TRUE;
	glewInit();

    GLfloat vertices[] = {
    //  Position      Color             Texcoords
        -0.5f,  0.5f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, // Top-left
         0.5f,  0.5f, 1.0f, 0.6f, 0.3f, 1.0f, 0.0f, // Top-right
         0.5f, -0.5f, 1.0f, 0.2f, 0.5f, 1.0f, 1.0f, // Bottom-right
        -0.5f, -0.5f, 1.0f, 1.0f, 0.1f, 0.0f, 1.0f  // Bottom-left
    };

	GLuint vbo;
	glGenBuffers(1, &vbo);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
	
	GLuint ebo;
	glGenBuffers(1, &ebo);

	GLuint elements[] = {
		0, 1, 2, 
		2, 3, 0
	};
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW);

	const GLchar* vs_source =
		"#version 430 core                           \n"
		"in vec2 vertex;                             \n"
		"in vec3 vertex_color;                       \n"
		"in vec2 texcoord;                           \n"
		"                                            \n"
		"out vec3 color;                             \n"
		"out vec2 Texcoord;                          \n"
		"                                            \n"
		"void main(void)                             \n"
		"{                                           \n"
		"	gl_Position = vec4(vertex, 0.0, 1.0);    \n"
		"   Texcoord = texcoord;                     \n"
		"	color = vertex_color;                    \n"
		"}                                           \n";

	const GLchar* fs_source = 
		"#version 430 core                           \n"
		"in vec3 color;                              \n"
		"in vec2 Texcoord;                           \n"
		"                                            \n"
		"out vec4 outColor;                          \n"
		"uniform sampler2D tex;                      \n"
		"void main(void)                             \n"
		"{                                           \n"
		"	outColor = texture(tex, Texcoord) * vec4(color, 1.0); \n"
		"}                                                        \n";

	GLuint vs = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vs, 1, &vs_source, NULL);
	glCompileShader(vs);

	GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fs, 1, &fs_source, NULL);
	glCompileShader(fs);

	//Shader compile status checker.
	GLint status;
	glGetShaderiv(vs, GL_COMPILE_STATUS, &status);
	char buffer[512];
	glGetShaderInfoLog(vs, 512, NULL, buffer);
	std::cout << status << std::endl;
	std::cout << buffer << std::endl;

	glGetShaderiv(fs, GL_COMPILE_STATUS, &status);
	glGetShaderInfoLog(fs, 512, NULL, buffer);
	std::cout << status << std::endl;
	std::cout << buffer << std::endl;

	GLuint shader_program = glCreateProgram();
	glAttachShader(shader_program, vs);
	glAttachShader(shader_program, fs);
	glLinkProgram(shader_program);
	glUseProgram(shader_program);


	GLint vertex_attrib = glGetAttribLocation(shader_program, "vertex");
	glEnableVertexAttribArray(vertex_attrib);
	glVertexAttribPointer(vertex_attrib, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 7, 0);

	GLint color_attrib = glGetAttribLocation(shader_program, "vertex_color");
	glEnableVertexAttribArray(color_attrib);
	glVertexAttribPointer(color_attrib, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 7, (void*)(sizeof(GLfloat) * 2));

	GLint texture_attrib = glGetAttribLocation(shader_program, "texcoord");
	glEnableVertexAttribArray(texture_attrib);
	glVertexAttribPointer(texture_attrib, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 7, (void*)(sizeof(GLfloat)*5));

    GLuint tex;
    glGenTextures(1, &tex);

    int width, height;
    unsigned char* image = SOIL_load_image("sample.png", &width, &height, 0, SOIL_LOAD_RGB);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
    SOIL_free_image_data(image);

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

	while(window.isOpen())
	{
		sf::Event windowEvent;
		while(window.pollEvent(windowEvent))
		{
			switch(windowEvent.type)
			{
			case sf::Event::Closed:
				window.close();
				break;
			case sf::Event::KeyPressed:
				if(windowEvent.key.code == sf::Keyboard::Escape)
					window.close();
				break;
			}
		}

		glClearColor(0.0f, 0.3f, 0.5f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

		window.display();
	}

	glDeleteProgram(shader_program);
	glDeleteShader(fs);
	glDeleteShader(vs);
	glDeleteBuffers(1, &ebo);
	glDeleteBuffers(1, &vbo);
	return 0;
}
コード例 #29
0
ファイル: Shader.cpp プロジェクト: ElkMonster/gloost-oma
bool
Shader::initInContext(unsigned int contextId)
{
  // handler for the single shaders
  GLuint vs = 0;
  GLuint fs = 0;
  GLuint gs = 0;

  // return values for the compile process
  GLint vsCompiled = 0;
  GLint fsCompiled = 0;
  GLint gsCompiled = 0;

  // iterator for program parameter
  std::map<GLenum,int>::iterator params;



#ifndef GLOOST_SYSTEM_DISABLE_OUTPUT_MESSAGES
  std::cerr << std::endl;
  std::cerr << std::endl << "Message from Message from Shader::initInContext() on SharedResource " << getSharedResourceId() << ":";
  std::cerr << std::endl << "             Building for context " << contextId << ".";
  std::cerr << std::endl;
#endif
  // remove this resource if it allready exists
  removeFromContext(contextId);


  /// create a vertex, a fragment and a geometry shader handle
  vs  = glCreateShader( GL_VERTEX_SHADER );
  fs  = glCreateShader( GL_FRAGMENT_SHADER );

  if (_geometryShaderSource)
  {
    gs  = glCreateShader( GL_GEOMETRY_SHADER );
  }


  /// send shader source to the driver
  glShaderSource(vs, 1, &_vertexShaderSource, NULL);
  glShaderSource(fs, 1, &_fragmentShaderSource, NULL);

  if (_geometryShaderSource)
  {
    glShaderSource(gs, 1, &_geometryShaderSource, NULL);
  }


  // vertex shader
  glCompileShader(vs);
  glGetShaderiv(vs, GL_COMPILE_STATUS, &vsCompiled);

  if (vsCompiled == GL_FALSE)
  {

#ifndef GLOOST_SYSTEM_DISABLE_OUTPUT_ERRORS
    std::cerr << std::endl;
    std::cerr << std::endl << "ERROR in shader::create() on SharedResource " << getSharedResourceId() << ":";
    std::cerr << std::endl << "         Can't compile vertexshader \"" << _vertexShaderFileName << "\"";
    std::cerr << std::endl;
#endif

  }

  // validate the vertex shader and print compiler log
  validateShader(vs, _vertexShaderFileName);



  // fragment shader
  glCompileShader( fs );
  glGetShaderiv(fs, GL_COMPILE_STATUS, &fsCompiled);


  if (fsCompiled == GL_FALSE)
  {

#ifndef GLOOST_SYSTEM_DISABLE_OUTPUT_ERRORS
    std::cerr << std::endl;
    std::cerr << std::endl << "ERROR in shader::create() on SharedResource " << getSharedResourceId() << ":";
    std::cerr << std::endl << "         Cant't compile fragmentshader \"" << _fragmentShaderFileName << "\"";
    std::cerr << std::endl;
#endif

  }

  // validate the fragment shader and print compiler log
  validateShader(fs, _fragmentShaderFileName);


  // geometry shader
  if (gs)
  {
    glCompileShader( gs );
    glGetShaderiv(gs, GL_COMPILE_STATUS, &gsCompiled);

    if (gsCompiled == GL_FALSE)
    {

#ifndef GLOOST_SYSTEM_DISABLE_OUTPUT_ERRORS
      std::cerr << std::endl;
      std::cerr << std::endl << "ERROR in shader::create() on SharedResource " << getSharedResourceId() << ":";
      std::cerr << std::endl << "         Cant't compile geometryshader \"" << _geometryShaderFileName << "\"";
      std::cerr << std::endl;
#endif

    }

    // validate the fragment shader and print compiler log
    validateShader(gs, _geometryShaderFileName);
  }
  else
  {
    // shader not used - set compile flag anyway
    gsCompiled = GL_TRUE;
  }// if (geometry shader exist)



  /// create a shader program and attache the compiled vertex, fragment and geometry binaries
  unsigned int shaderHandle = glCreateProgram();


  /// make a association between the context and the GL handle of this shader
  setResourceHandleForContext(shaderHandle, contextId);


  /// attache programs to shaderh handle
  glAttachShader( shaderHandle, fs );
  glAttachShader( shaderHandle, vs );

  if (gs)
  {
    glAttachShader( shaderHandle, gs );
    CheckErrorsGL(("Shader::initInContext() after attaching geometry shader for Shared Resource " + gloost::toString(getSharedResourceId())).c_str());

    for ( params =_programParameter.begin(); params != _programParameter.end(); params++ )
    {
        glProgramParameteriEXT(shaderHandle, (*params).first, (*params).second);
        CheckErrorsGL(("Shader::initInContext() after setting for Shared Resource " + gloost::toString(getSharedResourceId())).c_str());
    }
  }


  /// link programs
  glLinkProgram(shaderHandle);

//  		int temp;
//		glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT,&temp);
//		std::cerr << std::endl << "GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT: " << temp;


#ifndef GLOOST_SYSTEM_DISABLE_OUTPUT_MESSAGES
  if (vsCompiled == GL_TRUE && fsCompiled == GL_TRUE && gsCompiled == GL_TRUE)
  {
    std::cerr << std::endl;
    std::cerr << std::endl << "Message from Shader::compileToProgram() on SharedResource " << getSharedResourceId() << ":";
    std::cerr << std::endl << "             Successfully compiled and linked.";
    std::cerr << std::endl << "               \"" << _vertexShaderFileName << "\", ";
    std::cerr << std::endl << "               \"" << _fragmentShaderFileName << "\"";
    if (gs)
    {
      std::cerr << ", "<< std::endl << "               \"" << _geometryShaderFileName << "\"";
    }
    std::cerr << std::endl;
    return true;
  }
#endif

  return false;
}
コード例 #30
0
ファイル: org_lwjgl_opengl_GL20.c プロジェクト: Arcbe/GPVM
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglShaderSource(JNIEnv *env, jclass clazz, jint shader, jint count, jlong string, jint length, jlong function_pointer) {
	const GLchar *string_address = (const GLchar *)(intptr_t)string;
	glShaderSourcePROC glShaderSource = (glShaderSourcePROC)((intptr_t)function_pointer);
	glShaderSource(shader, count, (const GLchar **)&string_address, (const GLint*)&length);
}