teksture opengl earth with class

 #include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <SDL/SDL.h>
#include<stdlib.h>
SDL_Surface* surface;
#define SCREEN_WIDTH 800
#define SCREEN_HEIGHT 600
#define SCREEN_BPP 255
#define FALSE 0
#define TRUE 1

/*
with class compile like this:
g++ sdle.cpp -o sdle -L/usr/X11R6/lib/ -lGL -lGLU -lglut -lSDL

*/



namespace glut
{
class magic
{
public:
 GLuint year;
GLuint day;
GLuint texture[1];
 GLuint earthX;
GLuint earthY;
GLuint earthZ;

void earth();
void moon();

}control;

void magic::earth()
{

glPushMatrix();

 GLUquadricObj *sphere=NULL;
  sphere = gluNewQuadric();
  gluQuadricDrawStyle(sphere, GLU_FILL);
  gluQuadricTexture(sphere, TRUE);
  gluQuadricNormals(sphere, GLU_SMOOTH);

glRotatef (33, 27.0, 0, 0.0);
 glBindTexture( GL_TEXTURE_2D, control.texture[0] );
  gluSphere(sphere, 1.0, 20, 20);
  glPopMatrix();
 glFlush();
}


void magic::moon()
{

glPushMatrix();
 GLUquadricObj *sphere=NULL;
  sphere = gluNewQuadric();
  gluQuadricDrawStyle(sphere, GLU_FILL);
  gluQuadricTexture(sphere, TRUE);
  gluQuadricNormals(sphere, GLU_SMOOTH);
glBindTexture( GL_TEXTURE_2D, control.texture[1] );
glRotatef (control.year, 0.0, 1.0, 0.0);
glTranslatef (2.0, 0.0, 0.0);
glRotatef (control.day, 0.0, 1.0, 0.0);
  gluSphere(sphere, 0.4, 20, 20);


 glPopMatrix();
 glFlush();

}


void init(void)
{

GLfloat light_position[] = { 1.0, 1.0, -2.0, 0.0 };

GLfloat light1_ambient[] = { 0.2, 0.2, 0.2, 1.0 };

glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);

glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient);

glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_DEPTH_TEST);
}

void display(void)
{

magic *wizird= new magic;
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
if( (control.year<180) ){
wizird->moon();
wizird->earth();
}
else{
wizird->earth();
wizird->moon();
}
glutSwapBuffers();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
void keyboard (unsigned char key, int x, int y)
{
switch (key) {
case 'd':
control.day = (control.day + 10) % 360;
glutPostRedisplay();
break;
case 'D':
control.day = (control.day - 10) % 360;
glutPostRedisplay();
break;
case 'y':
control.year = (control.year + 5) % 360;
glutPostRedisplay();
break;
case 'k':
control.earthX = control.earthX - 65;
glutPostRedisplay();
break;

case 's':
control.earthY = control.earthY - 65;
glutPostRedisplay();
break;
case 'a':
control.earthZ = control.earthZ - 65;
glutPostRedisplay();
break;
default:
break;
}
}


};

namespace SDL
{

int LoadGLTextures( )
{
    /* Status indicator */
    int Status = FALSE;
 glut::magic *stoz= new glut::magic;
    /* Create storage space for the texture */
    SDL_Surface *TextureImage;

    /* Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit */
    if ( ( TextureImage= SDL_LoadBMP( "abb.bmp" ) ) )
        {

        /* Set the status to true */
        Status = TRUE;
       
        /* Create The Texture */
        glGenTextures( 1, &glut::control.texture[0] );

        /* Typical Texture Generation Using Data From The Bitmap */
        glBindTexture( GL_TEXTURE_2D,glut::control.texture[0]);

        /* Generate The Texture */
      gluBuild2DMipmaps(GL_TEXTURE_2D, 3,TextureImage->w  , TextureImage->h,  GL_BGR, GL_UNSIGNED_BYTE, TextureImage->pixels);
        glGetError();

        /* Linear Filtering */
        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

    glEnable(GL_TEXTURE_2D);
        }
   /* Status indicator */


    /* Create storage space for the texture */


    /* Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit */
    if ( ( TextureImage= SDL_LoadBMP( "moon.bmp" ) ) )
        {

        /* Set the status to true */
        Status = TRUE;
       
        /* Create The Texture */
        glGenTextures( 1, &glut::control.texture[1] );

        /* Typical Texture Generation Using Data From The Bitmap */
        glBindTexture( GL_TEXTURE_2D, glut::control.texture[1] );

        /* Generate The Texture */
      gluBuild2DMipmaps(GL_TEXTURE_2D, 3,TextureImage->w  , TextureImage->h,  GL_BGR, GL_UNSIGNED_BYTE, TextureImage->pixels);
        glGetError();

        /* Linear Filtering */
        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

    glEnable(GL_TEXTURE_2D);
        }

}
};
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
glut::init();
 SDL::LoadGLTextures();
glutDisplayFunc(glut::display);
glutReshapeFunc(glut::reshape);
glutKeyboardFunc(glut::keyboard);

glutMainLoop();
return 0;
}