Strange lighting problem - Printable Version

Code:

#include <GL/glut.h>



void display();

void init();



double xrotate=0;



GLfloat ambient[] = {0.1f, 0.1f, 0.1f, 0.1f};

GLfloat specular[] = {1.0f, 1.0f, 1.0f, 0.0f};

GLfloat diffuse[] = {1.0f, 1.0f, 1.0f, 0.0f};



GLfloat materialAmbient[]= { 0.2f, 0.2f, 0.2f, 0.0f };

GLfloat materialDiffuse[]= { 0.2f, 0.2f, 0.2f, 0.0f };

GLfloat materialSpecular[]= { 1.0f, 1.0f, 1.0f, 0.0f };

GLfloat materialShininess[]= { 1.0f };



GLfloat lightPos[] = {100.0f, 20.0f, -10.0f, 1.0f};



int main(int argc, char** argv)

{

    //create a window using glut

  glutInit(&argc, argv);

  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);

  glutInitWindowSize(640,480);

  glutInitWindowPosition(0,0);

  glutCreateWindow("Luke's Engine");

  glutDisplayFunc(display);

  glutIdleFunc(display);

    

  init();

  glutMainLoop();



  return 0;

}





void display()   //draw to the screen

{

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glMatrixMode(GL_MODELVIEW); 

  glLoadIdentity();



  glTranslatef(0, 0, -100);

  glRotatef(xrotate, 1.0, 0.0, 0.0);

  glutSolidSphere(20,20,20);



  //rotate object

  xrotate+=.5;

  if (xrotate == 360) 

    xrotate = 0;



  glFlush();

  glutSwapBuffers();

}



void init()   //initialize openGL

{

  //background clearing color

  glClearColor(0.0, 0.0, 0.0, 0.0);



  //viewing values

  glViewport(0,0,640,480); 

  glMatrixMode(GL_PROJECTION);

  glLoadIdentity();

  gluPerspective(45.0f, (GLfloat) 640 / (GLfloat) 480, 5.0f, 10000.0f);



  //lighting

  glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);

  glLightfv(GL_LIGHT1, GL_SPECULAR, specular);

  glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);

  glLightfv(GL_LIGHT1, GL_POSITION, lightPos);

  glEnable(GL_LIGHT1);

  glEnable(GL_LIGHTING);



  //material

  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, materialAmbient);

  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, materialSpecular);

  glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, materialDiffuse);

  glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, materialShininess);





  //other

  glShadeModel(GL_SMOOTH);

  glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

  glEnable(GL_TEXTURE_2D);

  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

  glEnable(GL_CULL_FACE);

  glEnable(GL_DEPTH_TEST);

 

}

Code:

/*

 * ---------------- www.spacesimulator.net --------------

 *   ---- Space simulators and 3d engine tutorials ----

 *

 * Author: Damiano Vitulli <info@spacesimulator.net>

 *

 * ALL RIGHTS RESERVED

 *

 *

 * Tutorial 5: Vectors and OpenGL lighting

 * 

 * 

 *

 * To compile this project you must include the following libraries:

 * opengl32.lib,glu32.lib,glut32.lib

 * You need also the header file glut.h in your compiler directory.

 *  

 */



/*

 * Spaceships credits:

 * fighter1.3ds - created by: Dario Vitulli 

 */



#ifdef __WIN32__

#include <windows.h>

#endif



#include <GL/glut.h>

#include "load_bmp.h"

#include "load_3ds.h"

#include "object.h"







/**********************************************************

 *

 * VARIABLES DECLARATION

 *

 *********************************************************/



// The width and height of your window, change them as you like

int screen_width=640;

int screen_height=480;



// Absolute rotation values (0-359 degrees) and rotation increments for each frame

double rotation_x=0, rotation_x_increment=0.1;

double rotation_y=0, rotation_y_increment=0.05;

double rotation_z=0, rotation_z_increment=0.03;

 

// Flag for rendering as lines or filled polygons

int filling=1; //0=OFF 1=ON



//Lights settings

GLfloat light_ambient[]= { 0.1f, 0.1f, 0.1f, 0.1f };

GLfloat light_diffuse[]= { 1.0f, 1.0f, 1.0f, 0.0f };

GLfloat light_specular[]= { 1.0f, 1.0f, 1.0f, 0.0f };

GLfloat light_position[]= { 100.0f, 0.0f, -10.0f, 1.0f };



//Materials settings

GLfloat mat_ambient[]= { 0.2f, 0.2f, 0.2f, 0.0f };

GLfloat mat_diffuse[]= { 0.2f, 0.2f, 0.2f, 0.0f };

GLfloat mat_specular[]= { 1.0f, 1.0f, 1.0f, 0.0f };

GLfloat mat_shininess[]= { 1.0f };







/**********************************************************

 *

 * SUBROUTINE init(void)

 *

 * Used to initialize OpenGL and to setup our world

 *

 *********************************************************/



void init(void)

{

    glClearColor(0.0, 0.0, 0.0, 0.0); // Clear background color to black



    // Viewport transformation

    glViewport(0,0,screen_width,screen_height);  



    // Projection transformation

    glMatrixMode(GL_PROJECTION); // Specifies which matrix stack is the target for matrix operations 

    glLoadIdentity(); // We initialize the projection matrix as identity

    gluPerspective(45.0f,(GLfloat)screen_width/(GLfloat)screen_height,5.0f,10000.0f); // We define the "viewing volume"

   

    //Lights initialization and activation

    glLightfv (GL_LIGHT1, GL_AMBIENT, light_ambient);

    glLightfv (GL_LIGHT1, GL_DIFFUSE, light_diffuse);

    glLightfv (GL_LIGHT1, GL_DIFFUSE, light_specular);

    glLightfv (GL_LIGHT1, GL_POSITION, light_position);    

    glEnable (GL_LIGHT1);

    glEnable (GL_LIGHTING);



    //Materials initialization and activation

    glMaterialfv (GL_FRONT, GL_AMBIENT, mat_ambient);

    glMaterialfv (GL_FRONT, GL_DIFFUSE, mat_diffuse);

    glMaterialfv (GL_FRONT, GL_DIFFUSE, mat_specular);

    glMaterialfv (GL_FRONT, GL_POSITION, mat_shininess);    



    //Other initializations

    glShadeModel(GL_SMOOTH); // Type of shading for the polygons

    glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Texture mapping perspective correction (OpenGL... thank you so much!)

    glEnable(GL_TEXTURE_2D); // Texture mapping ON

    glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); // Polygon rasterization mode (polygon filled)

    glEnable(GL_CULL_FACE); // Enable the back face culling

    glEnable(GL_DEPTH_TEST); // Enable the depth test (also called z buffer)



    //Objects loading

    ObjLoad ("fighter1.3ds","skull.bmp");

}







/**********************************************************

 *

 * SUBROUTINE resize(int p_width, int p_height)

 *

 * This routine must be called everytime we resize our window.

 *

 * Input parameters: p_width = width in pixels of our viewport

 *                     p_height = height in pixels of our viewport

 * 

 *********************************************************/



void resize (int p_width, int p_height)

{

    if (screen_width==0 && screen_height==0) exit(0);

    screen_width=p_width; // We obtain the new screen width values and store it

    screen_height=p_height; // Height value



    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // We clear both the color and the depth buffer so to draw the next frame

    glViewport(0,0,screen_width,screen_height); // Viewport transformation



    glMatrixMode(GL_PROJECTION); // Projection transformation

    glLoadIdentity(); // We initialize the projection matrix as identity

    gluPerspective(45.0f,(GLfloat)screen_width/(GLfloat)screen_height,5.0f,10000.0f);



    glutPostRedisplay (); // This command redraw the scene (it calls the same routine of glutDisplayFunc)

}





/**********************************************************

 *

 * SUBROUTINE display(void)

 *

 * This is our main rendering subroutine, called each frame

 * 

 *********************************************************/



void display(void)

{

    //int j;



    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // This clear the background color to dark blue

    glMatrixMode(GL_MODELVIEW); // Modeling transformation

    glLoadIdentity(); // Initialize the model matrix as identity



    glTranslatef(0.0,0.0,-20); // We move the object forward (the model matrix is multiplied by the translation matrix)

 

    rotation_x = rotation_x + rotation_x_increment;

    rotation_y = rotation_y + rotation_y_increment;

    rotation_z = rotation_z + rotation_z_increment;



    if (rotation_x > 359) rotation_x = 0;

    if (rotation_y > 359) rotation_y = 0;

    if (rotation_z > 359) rotation_z = 0;



    glRotatef(rotation_x,1.0,0.0,0.0); // Rotations of the object (the model matrix is multiplied by the rotation matrices)

    glRotatef(rotation_y,0.0,1.0,0.0);

    glRotatef(rotation_z,0.0,0.0,1.0);



    glutSolidSphere(5,20,20);

    glFlush(); // This force the execution of OpenGL commands

    glutSwapBuffers(); // In double buffered mode we invert the positions of the visible buffer and the writing buffer

}







/**********************************************************

 *

 * The main routine

 * 

 *********************************************************/



int main(int argc, char **argv)

{

    // We use the GLUT utility to initialize the window, to handle the input and to interact with the windows system

    glutInit(&argc, argv);    

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

    glutInitWindowSize(screen_width,screen_height);

    glutInitWindowPosition(0,0);

    glutCreateWindow("www.spacesimulator.net - 3d engine tutorials - To exit press ESC");    

    glutDisplayFunc(display);

    glutIdleFunc(display);

    glutReshapeFunc (resize);

    init();

    glutMainLoop();



    return(0);    

}