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 3 of 3

Thread: opengl superbible book example spinny cube doesn't work

  1. #1
    Junior Member Newbie
    Join Date
    Jun 2017
    Posts
    6

    opengl superbible book example spinny cube doesn't work

    Hello, I'm trying to run the example spinny cube from the github repositories of the opengl superbible 7th edition book and it doesn't show the cube as it is supposed to do.
    I am a beginner so I have problem to find the bug.
    This is the code:

    Code :
    /*
     
    #include <sb7.h>
    #include <vmath.h>
     
    // Remove this to draw only a single cube!
    // #define MANY_CUBES
     
    class singlepoint_app : public sb7::application
    {
        void init()
        {
            static const char title[] = "OpenGL SuperBible - Spinny Cube";
     
            sb7::application::init();
     
            memcpy(info.title, title, sizeof(title));
        }
     
        virtual void startup()
        {
            static const char * vs_source[] =
            {
                "#version 410 core                                                  \n"
                "                                                                   \n"
                "in vec4 position;                                                  \n"
                "                                                                   \n"
                "out VS_OUT                                                         \n"
                "{                                                                  \n"
                "    vec4 color;                                                    \n"
                "} vs_out;                                                          \n"
                "                                                                   \n"
                "uniform mat4 mv_matrix;                                            \n"
                "uniform mat4 proj_matrix;                                          \n"
                "                                                                   \n"
                "void main(void)                                                    \n"
                "{                                                                  \n"
                "    gl_Position = proj_matrix * mv_matrix * position;              \n"
                "    vs_out.color = position * 2.0 + vec4(0.5, 0.5, 0.5, 0.0);      \n"
                "}                                                                  \n"
            };
     
            static const char * fs_source[] =
            {
                "#version 410 core                                                  \n"
                "                                                                   \n"
                "out vec4 color;                                                    \n"
                "                                                                   \n"
                "in VS_OUT                                                          \n"
                "{                                                                  \n"
                "    vec4 color;                                                    \n"
                "} fs_in;                                                           \n"
                "                                                                   \n"
                "void main(void)                                                    \n"
                "{                                                                  \n"
                "    color = fs_in.color;                                           \n"
                "}                                                                  \n"
            };
     
            program = glCreateProgram();
            GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
            glShaderSource(fs, 1, fs_source, NULL);
            glCompileShader(fs);
     
            GLuint vs = glCreateShader(GL_VERTEX_SHADER);
            glShaderSource(vs, 1, vs_source, NULL);
            glCompileShader(vs);
     
            glAttachShader(program, vs);
            glAttachShader(program, fs);
     
            glLinkProgram(program);
     
            mv_location = glGetUniformLocation(program, "mv_matrix");
            proj_location = glGetUniformLocation(program, "proj_matrix");
     
            glGenVertexArrays(1, &vao);
            glBindVertexArray(vao);
     
            static const GLfloat vertex_positions[] =
            {
                -0.25f,  0.25f, -0.25f,
                -0.25f, -0.25f, -0.25f,
                 0.25f, -0.25f, -0.25f,
     
                 0.25f, -0.25f, -0.25f,
                 0.25f,  0.25f, -0.25f,
                -0.25f,  0.25f, -0.25f,
     
                 0.25f, -0.25f, -0.25f,
                 0.25f, -0.25f,  0.25f,
                 0.25f,  0.25f, -0.25f,
     
                 0.25f, -0.25f,  0.25f,
                 0.25f,  0.25f,  0.25f,
                 0.25f,  0.25f, -0.25f,
     
                 0.25f, -0.25f,  0.25f,
                -0.25f, -0.25f,  0.25f,
                 0.25f,  0.25f,  0.25f,
     
                -0.25f, -0.25f,  0.25f,
                -0.25f,  0.25f,  0.25f,
                 0.25f,  0.25f,  0.25f,
     
                -0.25f, -0.25f,  0.25f,
                -0.25f, -0.25f, -0.25f,
                -0.25f,  0.25f,  0.25f,
     
                -0.25f, -0.25f, -0.25f,
                -0.25f,  0.25f, -0.25f,
                -0.25f,  0.25f,  0.25f,
     
                -0.25f, -0.25f,  0.25f,
                 0.25f, -0.25f,  0.25f,
                 0.25f, -0.25f, -0.25f,
     
                 0.25f, -0.25f, -0.25f,
                -0.25f, -0.25f, -0.25f,
                -0.25f, -0.25f,  0.25f,
     
                -0.25f,  0.25f, -0.25f,
                 0.25f,  0.25f, -0.25f,
                 0.25f,  0.25f,  0.25f,
     
                 0.25f,  0.25f,  0.25f,
                -0.25f,  0.25f,  0.25f,
                -0.25f,  0.25f, -0.25f
            };
     
            glGenBuffers(1, &buffer);
            glBindBuffer(GL_ARRAY_BUFFER, buffer);
            glBufferData(GL_ARRAY_BUFFER,
                         sizeof(vertex_positions),
                         vertex_positions,
                         GL_STATIC_DRAW);
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
            glEnableVertexAttribArray(0);
     
            glEnable(GL_CULL_FACE);
            glFrontFace(GL_CW);
     
            glEnable(GL_DEPTH_TEST);
            glDepthFunc(GL_LEQUAL);
        }
     
        virtual void render(double currentTime)
        {
            static const GLfloat green[] = { 0.0f, 0.25f, 0.0f, 1.0f };
            static const GLfloat one = 1.0f;
     
            glViewport(0, 0, info.windowWidth, info.windowHeight);
            glClearBufferfv(GL_COLOR, 0, green);
            glClearBufferfv(GL_DEPTH, 0, &one);
     
            glUseProgram(program);
     
            glUniformMatrix4fv(proj_location, 1, GL_FALSE, proj_matrix);
     
    #ifdef MANY_CUBES
            int i;
            for (i = 0; i < 24; i++)
            {
                float f = (float)i + (float)currentTime * 0.3f;
                vmath::mat4 mv_matrix = vmath::translate(0.0f, 0.0f, -6.0f) *
                                        vmath::rotate((float)currentTime * 45.0f, 0.0f, 1.0f, 0.0f) *
                                        vmath::rotate((float)currentTime * 21.0f, 1.0f, 0.0f, 0.0f) *
                                        vmath::translate(sinf(2.1f * f) * 2.0f,
                                                         cosf(1.7f * f) * 2.0f,
                                                         sinf(1.3f * f) * cosf(1.5f * f) * 2.0f);
                glUniformMatrix4fv(mv_location, 1, GL_FALSE, mv_matrix);
                glDrawArrays(GL_TRIANGLES, 0, 36);
            }
    #else
            float f = (float)currentTime * 0.3f;
            vmath::mat4 mv_matrix = vmath::translate(0.0f, 0.0f, -4.0f) *
                                    vmath::translate(sinf(2.1f * f) * 0.5f,
                                                        cosf(1.7f * f) * 0.5f,
                                                        sinf(1.3f * f) * cosf(1.5f * f) * 2.0f) *
                                    vmath::rotate((float)currentTime * 45.0f, 0.0f, 1.0f, 0.0f) *
                                    vmath::rotate((float)currentTime * 81.0f, 1.0f, 0.0f, 0.0f);
            glUniformMatrix4fv(mv_location, 1, GL_FALSE, mv_matrix);
            glDrawArrays(GL_TRIANGLES, 0, 36);
    #endif
        }
     
        virtual void shutdown()
        {
            glDeleteVertexArrays(1, &vao);
            glDeleteProgram(program);
            glDeleteBuffers(1, &buffer);
        }
     
        void onResize(int w, int h)
        {
            sb7::application::onResize(w, h);
     
            aspect = (float)w / (float)h;
            proj_matrix = vmath::perspective(50.0f, aspect, 0.1f, 1000.0f);
        }
     
    private:
        GLuint          program;
        GLuint          vao;
        GLuint          buffer;
        GLint           mv_location;
        GLint           proj_location;
     
        float           aspect;
        vmath::mat4     proj_matrix;
    };
     
    DECLARE_MAIN(singlepoint_app)

  2. #2
    Intern Contributor
    Join Date
    Dec 2016
    Location
    Ocean Shores, WA USA
    Posts
    72
    Just curious because you said you are a beginner.... how much of a beginner with this code are you? Is this your first coding attempt with opengl? Or do you have other successfully compiled and run examples?

    Thanks,
    Jeff

    P.S. Also, what all does the program do, exactly?

  3. #3
    Junior Member Newbie
    Join Date
    Jun 2017
    Posts
    6
    Quote Originally Posted by OceanJeff40 View Post
    Just curious because you said you are a beginner.... how much of a beginner with this code are you? Is this your first coding attempt with opengl? Or do you have other successfully compiled and run examples?

    Thanks,
    Jeff

    P.S. Also, what all does the program do, exactly?
    I have other succesfully compiled and run examples.
    The code should show a cube that moves into the world space.


    It works if I maximize window size!
    Because projection matrix was not set! It is set in onResize method only.
    Last edited by blob84; 06-07-2017 at 12:36 AM.

Posting Permissions

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