Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 9 of 9

Thread: OpenGL primitive Restart

  1. #1
    Junior Member Newbie
    Join Date
    Jul 2013
    Posts
    5

    OpenGL primitive Restart

    Im learning about opengl 4.3 and I am doing an reference guide book's example using SDL 2.0.
    The only thing that i can see is a black window, i dont know what i should do. Anyone can help me?

    Here is my code:

    This is Demo_OGL_2.h:
    Code :
    #ifndef DEMO_OGL_II_H_
    #define DEMO_OGL_II_H_
    #include <iostream>
    #include <GL/gl3w.h>
    #include <GL/gl3.h>
    #include "SDL2/SDL.h"
    #include "LoadShaders.h"
     
    class Demo_OGL_2 {
    private:
        bool running;
        SDL_Window* window;
        SDL_GLContext ctxt;
     
        static const uint32_t   WIN_HEIGHT = 768; //px
        static const uint32_t   WIN_WIDTH  = 1024; //px
        static const char*      WIN_TITLE; //px
     
        /***************************************************/
        /***************************************************/
        /***************************************************/
     
     
        float aspect;
        static const GLfloat cube_positions[];
        static const GLfloat cube_colors[];
        static const GLushort cube_indices[];
        GLuint ebo[1];
        GLuint vao[1];
        GLuint vbo[1];
     
        GLuint render_prog;
        GLuint render_model_matrix_loc;
        GLuint render_projection_matrix_loc;
     
        /*
        enum VAO_IDs { Triangles, NumVAOs };
        enum Buffer_IDs { ArrayBuffer, NumBuffers };
        enum Attrib_IDs { vPosition = 0, vColor = 1 };
     
        GLuint  VAOs[NumVAOs];
        GLuint  Buffers[NumBuffers];
     
        static const GLuint  NumVertices = 6;*/
    public:
     
        Demo_OGL_2();
        int Execute(){ return OnExecute(); }
        bool Init(){ return OnInit(); }
        void Loop(){ return OnLoop(); }
        void Render(){ return OnRender(); }
        void Cleanup(){ return OnCleanup(); }
        void Event(SDL_Event* Event){ OnEvent(Event); }
     
     
     
        int OnExecute();
     
        bool OnInit();
        void OnEvent(SDL_Event* Event);
        void OnLoop();
        void OnRender();
        void OnCleanup();
     
     
     
        void setupOpenGl();
     
        /***************************************************/
        /***************************************************/
        /***************************************************/
     
        void exInit();
    };
     
     
    #endif /* DEMO_OGL_I_H_ */


    And this is my Demo_OGL_2.cpp:

    Code :
    #include <iostream>
    #include "Demo_OGL_2.h"
    #include "../../LibsNUtils/vmath.h"
    #include <GL/gl3w.h>
    #include <GL/gl3.h>
    #include "LoadShaders.h"
    //#define BUFFER_OFFSET(offset) ((void *) (offset))
     
    const char* Demo_OGL_2::WIN_TITLE = "Titulo de la Ventana";
    const GLfloat Demo_OGL_2::cube_positions[] = {
            -1.0f, -1.0f, -1.0f, 1.0f,
            -1.0f, -1.0f,  1.0f, 1.0f,
            -1.0f,  1.0f, -1.0f, 1.0f,
            -1.0f,  1.0f,  1.0f, 1.0f,
             1.0f, -1.0f, -1.0f, 1.0f,
             1.0f, -1.0f,  1.0f, 1.0f,
             1.0f,  1.0f, -1.0f, 1.0f,
             1.0f,  1.0f,  1.0f, 1.0f
    };
    const GLfloat Demo_OGL_2::cube_colors[] = {
             1.0f,  1.0f,  1.0f,  1.0f,
             1.0f,  1.0f,  0.0f,  1.0f,
             1.0f,  0.0f,  1.0f,  1.0f,
             1.0f,  0.0f,  0.0f,  1.0f,
             0.0f,  1.0f,  1.0f,  1.0f,
             0.0f,  1.0f,  0.0f,  1.0f,
             0.0f,  0.0f,  1.0f,  1.0f,
             0.5f,  0.5f,  0.5f,  1.0f
    };
    const GLushort Demo_OGL_2::cube_indices[] = {
            0, 1, 2, 3, 6, 7, 4, 5, // First strip
            0xFFFF, // <<-- This is the restart index
            2, 6, 0, 4, 1, 5, 3, 7 // Second strip
    };
     
    Demo_OGL_2::Demo_OGL_2() : running(false), window(NULL), ctxt(NULL),
                aspect(0), ebo(), vao(), vbo(),
                render_prog(0), render_model_matrix_loc(0), render_projection_matrix_loc(0){}
     
    void Demo_OGL_2::OnEvent(SDL_Event* event) {
        switch (event->type) {
            case SDL_KEYUP:
                switch(event->key.keysym.sym){
                    case SDLK_v:
                        std::cout << glGetString(GL_VERSION) << std::endl;
                        break;
                    case SDLK_ESCAPE:
                        running = false;
                        break;
                    default:
                        break;
                }
                break;
            case SDL_QUIT:
                running = false;
                break;
            default:
                break;
        }
    }
    void Demo_OGL_2::OnLoop() {}
     
    void Demo_OGL_2::OnRender() {
     
        float t = float(GetTickCount() & 0x1FFF) / float(0x1FFF);
        //static float q = 0.0f;
        static const vmath::vec3 X(1.0f, 0.0f, 0.0f);
        static const vmath::vec3 Y(0.0f, 1.0f, 0.0f);
        static const vmath::vec3 Z(0.0f, 0.0f, 1.0f);
     
        glEnable(GL_CULL_FACE);
        glDisable(GL_DEPTH_TEST);
     
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     
        glUseProgram(render_prog);
     
        vmath::mat4 model_matrix(vmath::translate(0.0f, 0.0f, -5.0f) *
                                    vmath::rotate(t * 360.0f, Y) *
                                    vmath::rotate(t * 720.0f, Z));
        vmath::mat4 projection_matrix(vmath::frustum(-1.0f, 1.0f, -aspect, aspect, 1.0f, 500.0f));
     
        glUniformMatrix4fv(render_model_matrix_loc, 4, GL_FALSE, model_matrix);
        glUniformMatrix4fv(render_projection_matrix_loc, 1, GL_FALSE, projection_matrix);
     
        glBindVertexArray( vao[0] );
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo[0]);
     
     
    #define USE_PRIMITIVE_RESTART 0
    #if USE_PRIMITIVE_RESTART
        // When primitive restart is on, we can call one draw command
        glEnable(GL_PRIMITIVE_RESTART);
        glPrimitiveRestartIndex(0xFFFF);
        glDrawElements(GL_TRIANGLE_STRIP, 17, GL_UNSIGNED_SHORT, NULL);
    #else
        // Without primitive restart, we need to call two draw commands
        glDrawElements(GL_TRIANGLE_STRIP, 8, GL_UNSIGNED_SHORT, NULL);
        glDrawElements(GL_TRIANGLE_STRIP, 8, GL_UNSIGNED_SHORT,
        (const GLvoid *)(9 * sizeof(GLushort)));
    #endif
     
     
        SDL_GL_SwapWindow(window);
    }
     
    void Demo_OGL_2::OnCleanup() {
        glUseProgram(0);
        glDeleteProgram(render_prog);
        glDeleteVertexArrays(1, vao);
        glDeleteBuffers(1, vbo);
        SDL_GL_DeleteContext(ctxt);
        SDL_DestroyWindow(window);
        SDL_Quit();
    }
     
    bool Demo_OGL_2::OnInit() {
        if(SDL_Init(SDL_INIT_EVERYTHING) < 0)
            return false;
     
        window = SDL_CreateWindow(WIN_TITLE,
                SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
                WIN_WIDTH, WIN_HEIGHT,
                SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
        if(!window)
            return false;
     
        setupOpenGl();
        exInit();
     
        running = true;
     
        return true;
    }
    void Demo_OGL_2::setupOpenGl(){
       //SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
       //SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
       SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
       SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
       ctxt = SDL_GL_CreateContext(window);
     
       //vsync ON
       SDL_GL_SetSwapInterval(1);
     
       if (gl3wInit()) {
           std::cout << "Error al Inicializar GL3W" << std::endl;
       }
     
     
    }
    void Demo_OGL_2::exInit(){
     
        ShaderInfo shaders[] = {
             { GL_VERTEX_SHADER, "Resources/Demo_OGL_II/primitive_restart.vs.glsl" },
             { GL_FRAGMENT_SHADER, "Resources/Demo_OGL_II/primitive_restart.fs.glsl" },
             { GL_NONE, NULL }
        };
     
        render_prog = LoadShaders( shaders );
        glUseProgram( render_prog );
     
        render_model_matrix_loc = glGetUniformLocation(render_prog, "model_matrix");
        render_projection_matrix_loc = glGetUniformLocation(render_prog, "projection_matrix");
     
     
        glGenBuffers(1, ebo);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo[0]);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_indices), cube_indices, GL_STATIC_DRAW);
     
        glGenVertexArrays(1, vao);
        glBindVertexArray(vao[0]);
     
        glGenBuffers(1, vbo);
        glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
        glBufferData(GL_ARRAY_BUFFER, sizeof(cube_positions) + sizeof(cube_colors), NULL, GL_STATIC_DRAW);
        glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(cube_positions), cube_positions );
        glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_positions), sizeof(cube_colors), cube_colors);
     
        glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
        glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, (const GLvoid*)sizeof(cube_positions));
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);
     
        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     
     
     
        glViewport(0, 0, WIN_WIDTH, WIN_HEIGHT);
        aspect = float(WIN_HEIGHT) / float(WIN_WIDTH);
    }
     
    int Demo_OGL_2::OnExecute() {
        if (!Init())
            return -1;
     
        SDL_Event event;
     
        while (running) {
     
            while (SDL_PollEvent(&event))
                Event(&event);
     
            Loop();
            Render();
        }
     
        Cleanup();
     
        return 0;
    }

    Vertex Shader:

    Code :
    #version 330
     
    uniform mat4 model_matrix;
    uniform mat4 projection_matrix;
     
    layout (location = 0) in vec4 position;
    layout (location = 1) in vec4 color;
     
    out vec4 vs_fs_color;
     
    void main(void)
    {
        vs_fs_color = color;
        gl_Position = projection_matrix * (model_matrix * position);
    }

    And the simplest fragment shader

    Code :
    #version 430
     
    in vec4 vs_fs_color;
     
    layout (location = 0) out vec4 color;
     
    void main(void)
    {
        color = vs_fs_color;
    }
    Last edited by korgan00; 07-14-2013 at 05:53 AM. Reason: using code tags andd add shaders

  2. #2
    Senior Member OpenGL Pro
    Join Date
    Jan 2012
    Location
    Australia
    Posts
    1,101
    Code :
    vmath::mat4 model_matrix(vmath::translate(0.0f, 0.0f, -5.0f) *
    vmath::rotate(t * 360.0f, Y) *
    vmath::rotate(t * 720.0f, Z));


    These rotation do nothing but I would keep my roations in the range 0 <= r < 360.

    You have placed your camera at 0,0,-5 looking down the -z axis
    You have placed your object at 0,0,0

    So you are not looking at your object

    vmath::mat4 model_matrix(vmath::translate(0.0f, 0.0f, 5.0f)

    In general it is easier to use a lookat function to place cameras

  3. #3
    Junior Member Newbie
    Join Date
    Jul 2013
    Posts
    5
    "t" is between 0-1, rotate use a fraction of 360 and 720, i think that this rotations are alright.

    model_matrix is a transformation matrix for cube, not for camera, then, camera is on 0,0,0 looking at -Z and cube on 0,0,-5. thats alright? i was testing with 0,0,5 , 0,5,0 , 0,-5,0 ... And still black window. I dont know what should i do. Any suggestion?
    Last edited by korgan00; 07-14-2013 at 03:12 PM.

  4. #4
    Senior Member OpenGL Pro
    Join Date
    Jan 2012
    Location
    Australia
    Posts
    1,101
    Try changing your projection matrix. Perhaps 1,-1, and aspect are too narrow. Or you could try the alternate way of setting the projection matrix with angle and aspect

  5. #5
    Junior Member Newbie
    Join Date
    Jul 2013
    Posts
    5
    Those are normalized values if im on the right way. Anyway, i tryed bigger values and still the same result.
    Im sure, that im forgetting something. Someone can compile and test it?

  6. #6
    Senior Member OpenGL Pro
    Join Date
    Apr 2010
    Location
    Germany
    Posts
    1,099
    Code :
    glUniformMatrix4fv(render_model_matrix_loc, 4, GL_FALSE, model_matrix);

    Replace 4 with 1. model_matrix is a single matrix and not an array of 4 matrices. I suppose you're getting an INVALID_OPERATION here, thus no model is uploaded and thus no transformation is happening.

  7. #7
    Junior Member Newbie
    Join Date
    Jul 2013
    Posts
    5
    Oh thx, it is working now!!! i can continue with my learning
    manythx again!

  8. #8
    Senior Member OpenGL Pro
    Join Date
    Apr 2010
    Location
    Germany
    Posts
    1,099
    You're welcome.

    Oh thx, it is working now!!! i can continue with my learning
    A sound advice: In case of emergency, always check for GL errors first!

  9. #9
    Junior Member Newbie
    Join Date
    Jul 2013
    Posts
    5
    Thx, i will!

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •