Clever Geek Handbook

OpenGL SkyBox not showing

I am making a skybox in openGL C ++, now I have followed some tutorials on skyboxes, I have the whole image configured, but my skybox fails to draw at all! (I only see opengl black background)

So here is my code, what could be the problem? I've been looking at this for hours and I can't find anything, I'm new to openGL, so if you find any bad code please tell me! Thank!

 #include <iostream>
#include <stdlib.h>


#ifdef __APPLE__
#include <OpenGL/OpenGL.h>
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

#include "imageloader.h"

using namespace std;

//angle of rotation
GLfloat xpos = 0, ypos = 0, zpos = 0, xrot = 0, yrot = 0, angle=0.0;
GLuint _textureId;           //The OpenGL id of the texture
GLuint _skybox[5];
float lastx, lasty;
bool leftMouseButton = false;
float PI = 3.141592654f;

//Makes the image into a texture, and returns the id of the texture
GLuint __loadTexture(Image* image) {
    GLuint textureId;
    glGenTextures(1, &textureId);
    glBindTexture(GL_TEXTURE_2D, textureId);
    glTexImage2D(GL_TEXTURE_2D,
        0,
        GL_RGB,
        image->width, image->height,
        0,
        GL_RGB,
        GL_UNSIGNED_BYTE,
        image->pixels);
    return textureId;
}


GLuint __loadMipmappedTexture(Image *image) {
    GLuint textureId;
    glGenTextures(1, &textureId);
    glBindTexture(GL_TEXTURE_2D, textureId);
    gluBuild2DMipmaps(GL_TEXTURE_2D,
                      GL_RGB,
                      image->width, image->height,
                      GL_RGB,
                      GL_UNSIGNED_BYTE,
                      image->pixels);
    return textureId;
}
void initRendering() {
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_NORMALIZE);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_CULL_FACE);
    glShadeModel (GL_SMOOTH); //set the shader to smooth shader

    Image* image = loadBMP("artesis.bmp");
    _textureId = __loadMipmappedTexture(image);
    image = loadBMP("skybox/deep_ft.bmp");
    _skybox[0] = __loadMipmappedTexture(image);
    image = loadBMP("skybox/deep_lf.bmp");
    _skybox[1] = __loadMipmappedTexture(image);
    image = loadBMP("skybox/deep_bk.bmp");
    _skybox[2] = __loadMipmappedTexture(image);
    image = loadBMP("skybox/deep_rt.bmp");
    _skybox[3] = __loadMipmappedTexture(image);
    image = loadBMP("skybox/deep_up.bmp");
    _skybox[4] = __loadMipmappedTexture(image);
    image = loadBMP("skybox/deep_dn.bmp");
    _skybox[5] = __loadMipmappedTexture(image);
    delete image;

}

void handleResize(int w, int h) {
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0, (double)w / (double)h, 1.0, 100.0);
    glViewport (0, 0, w, h);
    glMatrixMode(GL_MODELVIEW);
    glutPostRedisplay();
}

void mouseMovement(int x, int y) {

    if (leftMouseButton == true)
    {
        GLfloat diffx = (x-lastx)/20; //check the difference between the current x and the last x position
        GLfloat diffy = (y-lasty)/20; //check the difference between the current y and the last y position
        lastx = x; //set lastx to the current x position
        lasty = y; //set lasty to the current y position

        xrot += (float) diffy; //set the xrot to xrot with the addition of the difference in the y position
        yrot += (float) diffx;    //set the xrot to yrot with the addition of the difference in the x position
    }
    else if( leftMouseButton == false)
    {
        GLfloat diffx = x-lastx; //check the difference between the current x and the last x position
        GLfloat diffy = y-lasty; //check the difference between the current y and the last y position
        lastx = x; //set lastx to the current x position
        lasty = y; //set lasty to the current y position
    }
}

void mouseButtons(int button, int state, int x, int y) {
    if ((state == GLUT_DOWN) && (button == GLUT_LEFT_BUTTON)) 
    {
        leftMouseButton = true;
    }

    else if ((state == GLUT_DOWN) && (button == GLUT_RIGHT_BUTTON)) 
    {
        leftMouseButton = false;
    }
}

void drawGrid(float size, float step)
{
    // disable lighting
    glDisable(GL_LIGHTING);

    glBegin(GL_LINES);

    glColor3f(0.3f, 0.3f, 0.3f);
    for(float i=step; i <= size; i+= step)
    {
        glVertex3f(-size, 0,  i);   // lines parallel to X-axis
        glVertex3f( size, 0,  i);
        glVertex3f(-size, 0, -i);   // lines parallel to X-axis
        glVertex3f( size, 0, -i);

        glVertex3f( i, 0, -size);   // lines parallel to Z-axis
        glVertex3f( i, 0,  size);
        glVertex3f(-i, 0, -size);   // lines parallel to Z-axis
        glVertex3f(-i, 0,  size);
    }

    // x-axis
    glColor3f(0.5f, 0, 0);
    glVertex3f(-size, 0, 0);
    glVertex3f( size, 0, 0);

    // z-axis
    glColor3f(0,0,0.5f);
    glVertex3f(0, 0, -size);
    glVertex3f(0, 0,  size);

    glEnd();

    // enable lighting back
    glEnable(GL_LIGHTING);
}

void keyboard (unsigned char key, int x, int y) {
    float xrotrad, yrotrad;
    switch(key) {
    case 'a':
        xrot += 1;
        if(xrot > 360) xrot -= 360;
        break;
    case 'w':
        xrot -= 1;
        if(xrot < -360) xrot += 360;
        break;
    case 'z':   
        yrotrad = (yrot / 180 * PI);
        xrotrad = (xrot / 180 * PI); 
        xpos += float(sin(yrotrad));
        zpos -= float(cos(yrotrad));
        ypos -= float(sin(xrotrad));
        break;
    case 's':   
        yrotrad = (yrot / 180 * PI);
        xrotrad = (xrot / 180 * PI); 
        xpos -= float(sin(yrotrad));
        zpos += float(cos(yrotrad));
        ypos += float(sin(xrotrad));
        break;
    case 'd':
        yrot += 1;
        if (yrot >360) yrot -= 360;
        break;
    case 'q':
        yrot -= 1;
        if (yrot < -360)yrot += 360;
        break;

    case 27:
        exit(0);
        break;
    }
}

void camera (void) {
    glRotatef(xrot,1.0,0.0,0.0);  //rotate our camera on teh x-axis (left and right)
    glRotatef(yrot,0.0,1.0,0.0);  //rotate our camera on the y-axis (up and down)
    glTranslated(-xpos,-ypos,-zpos); //translate the screen to the position of our camera
}

void drawScene() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    GLfloat lightKa[] = {.0f, .0f, .0f, 1.0f};      // ambient light
    GLfloat lightKd[] = {.9f, .9f, .9f, 1.0f};      // diffuse light
    GLfloat lightKs[] = {1, 1, 1, 1};               // specular light
    glLightfv(GL_LIGHT0, GL_AMBIENT, lightKa);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightKd);
    glLightfv(GL_LIGHT0, GL_SPECULAR, lightKs);

    // position the light
    float lightPos[4] = {0, 10, 10, 0};
    glLightfv(GL_LIGHT0, GL_POSITION, lightPos);

    camera();

    //call the skybox
    // Store the current matrix
    glPushMatrix();

    // Reset and transform the matrix.
    glLoadIdentity();

    /* EDIT: I really dont know how to set gluLookAt, I guess it should be the camera positions??? */
    gluLookAt(
        0.0,0.0,0.0,
        0.1, 0.0, 0.1,
        0.0,1.0,0.0);

    // Enable/Disable features
    glPushAttrib(GL_ENABLE_BIT);
    glEnable(GL_TEXTURE_2D);
    glDisable(GL_DEPTH_TEST);
    glDepthMask(false);
    glDisable(GL_LIGHTING);
    glDisable(GL_BLEND);

    // Just in case we set all vertices to white.
    glColor4f(1,1,1,1);

    // Render the front quad
    glBindTexture(GL_TEXTURE_2D, _skybox[0]);
    glBegin(GL_QUADS);
        glTexCoord2f(0, 0); glVertex3f(  0.5f, -0.5f, -0.5f );
        glTexCoord2f(1, 0); glVertex3f( -0.5f, -0.5f, -0.5f );
        glTexCoord2f(1, 1); glVertex3f( -0.5f,  0.5f, -0.5f );
        glTexCoord2f(0, 1); glVertex3f(  0.5f,  0.5f, -0.5f );
    glEnd();

    // Render the left quad
    glBindTexture(GL_TEXTURE_2D, _skybox[1]);
    glBegin(GL_QUADS);
        glTexCoord2f(0, 0); glVertex3f(  0.5f, -0.5f,  0.5f );
        glTexCoord2f(1, 0); glVertex3f(  0.5f, -0.5f, -0.5f );
        glTexCoord2f(1, 1); glVertex3f(  0.5f,  0.5f, -0.5f );
        glTexCoord2f(0, 1); glVertex3f(  0.5f,  0.5f,  0.5f );
    glEnd();

    // Render the back quad
    glBindTexture(GL_TEXTURE_2D, _skybox[2]);
    glBegin(GL_QUADS);
        glTexCoord2f(0, 0); glVertex3f( -0.5f, -0.5f,  0.5f );
        glTexCoord2f(1, 0); glVertex3f(  0.5f, -0.5f,  0.5f );
        glTexCoord2f(1, 1); glVertex3f(  0.5f,  0.5f,  0.5f );
        glTexCoord2f(0, 1); glVertex3f( -0.5f,  0.5f,  0.5f );

    glEnd();

    // Render the right quad
    glBindTexture(GL_TEXTURE_2D, _skybox[3]);
    glBegin(GL_QUADS);
        glTexCoord2f(0, 0); glVertex3f( -0.5f, -0.5f, -0.5f );
        glTexCoord2f(1, 0); glVertex3f( -0.5f, -0.5f,  0.5f );
        glTexCoord2f(1, 1); glVertex3f( -0.5f,  0.5f,  0.5f );
        glTexCoord2f(0, 1); glVertex3f( -0.5f,  0.5f, -0.5f );
    glEnd();

    // Render the top quad
    glBindTexture(GL_TEXTURE_2D, _skybox[4]);
    glBegin(GL_QUADS);
        glTexCoord2f(0, 1); glVertex3f( -0.5f,  0.5f, -0.5f );
        glTexCoord2f(0, 0); glVertex3f( -0.5f,  0.5f,  0.5f );
        glTexCoord2f(1, 0); glVertex3f(  0.5f,  0.5f,  0.5f );
        glTexCoord2f(1, 1); glVertex3f(  0.5f,  0.5f, -0.5f );
    glEnd();

    // Render the bottom quad
    glBindTexture(GL_TEXTURE_2D, _skybox[5]);
    glBegin(GL_QUADS);
        glTexCoord2f(0, 0); glVertex3f( -0.5f, -0.5f, -0.5f );
        glTexCoord2f(0, 1); glVertex3f( -0.5f, -0.5f,  0.5f );
        glTexCoord2f(1, 1); glVertex3f(  0.5f, -0.5f,  0.5f );
        glTexCoord2f(1, 0); glVertex3f(  0.5f, -0.5f, -0.5f );
    glEnd();

    // Restore enable bits and matrix
    glPopAttrib();
    glPopMatrix();
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glEnable(GL_BLEND);
    glDepthMask(true);
    glClear(GL_DEPTH_BUFFER_BIT);

    drawGrid(20, 1);

    glutSwapBuffers(); //swap the buffers

}

void update(int value) {
    angle++; //increase the angle
    glutPostRedisplay(); //Tell GLUT that the display has changed

    //Tell GLUT to call update again in 25 milliseconds
    glutTimerFunc(25, update, 0);
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(800, 800);

    glutCreateWindow("Block Position");
    initRendering();

    glutDisplayFunc(drawScene);
    glutKeyboardFunc(keyboard);
    glutIdleFunc(drawScene);

    glutReshapeFunc(handleResize);
    glutPassiveMotionFunc(mouseMovement); 
    glutTimerFunc(25, update, 0); //Add a timer
    glutMouseFunc(mouseButtons);
    glutMainLoop();
    return 0;
}
+3


source to share


2 answers


You should start with minimal rendering, for example, no lightning, no culling, but only white triangles. So if you see white, then at least your camera position is probably good. Then you can turn on culling if everything disappears then that's your problem - the normals are in the wrong direction. Then if everything is ok, turn on the lighting, then texture - and always check what changes.



so don't look at it too hard, but remove the complexity - even check to see if a simple triangle will display at the expected position.

+1


source


If nothing appears at all, it might be because the sky window is not in the scene, because it is culled

(or not displayed) on the screen.

In your code, you are specifying 100.0

for zFar

:



gluPerspective(45.0, (double)w / (double)h, 1.0, 100.0);

Change the value zFar

to match the size of the sky field (say 500.0) and it should appear.

+1


source






More articles:


All Articles