Saya membuat tata surya di OpenGL C++ di mana bumi berputar mengelilingi matahari.

Sekarang saya telah menghapus beberapa kode tambahan dari sini saya harap ini akan berhasil untuk kalian karena fungsi-fungsi itu tidak diperlukan atau membuat perubahan apa pun

                 #include "Solar.h"
        #include <stdlib.h>
        #include <glut.h>
        static GLenum spinMode = GL_TRUE;
        static GLenum singleStep = GL_FALSE;

        static float HourOfDay = 0.0;
        static float DayOfYear = 0.0;

        static float AnimateIncrement = 2.0;

        void Haxxan()
        {
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_LINES);
        glColor3f(0.1,0.3,0.9);
        glVertex2f(-0.9,0.5);
        glVertex2f(-0.9,0.0);

        glVertex2f(-0.9,0.25);
        glVertex2f(-0.7,0.25);
        glEnd();
        glFlush();
        }


        /*
         * Animate() handles the animation and the redrawing of the
         *      graphics window contents.
         */
        static void Animate(void)
        {
            // Clear the redering window
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        // Now Make stars Using the Vertex
        //glBegin(GL_LINES);
        //glColor3f(0.1,0.3,0.9);

        /*glVertex2f(-0.9,0.5);
        glVertex2f(-0.9,0.0);

        glVertex2f(-0.9,0.25);
        glVertex2f(-0.7,0.25);
          */
            if (spinMode) {
                // Update the animation state
                HourOfDay += AnimateIncrement;
                DayOfYear += AnimateIncrement/40.0;

                HourOfDay = HourOfDay - ((int)(HourOfDay/24))*24;
                DayOfYear = DayOfYear - ((int)(DayOfYear/365))*365;
                }

            // Clear the current matrix (Modelview)
            glLoadIdentity();

            // Back off eight units to be able to view from the origin.
            glTranslatef ( 0.0, 0.0, -8.0 );

            // Rotate the plane of the elliptic
            // (rotate the model's plane about the x axis by fifteen degrees)
            glRotatef( 15.0, 1.0, 0.0, 0.0 );

            // Draw the sun -- as a yellow, wireframe sphere
            glColor3f( 1.0, 1.0, 0.0 );
            glutWireSphere( 1.0, 15, 15 );
        // Now Draw Stars
        glColor3f(0.0,0.0,1.0);
        //glutWireSphere( 0.3, 18, 9 );
        //glLineStipple(0.1,0.1);
        glVertex2f(0.9,0.3);
        glVertex2f(0.6,0.3);

        //end stars
            // Draw the Earth
            // First position it around the sun
            //      Use DayOfYear to determine its position
            glRotatef( 360.0*DayOfYear/365.0, 0.0, 1.0, 0.0 );
            glTranslatef( 4.0, 0.0, 0.0 );
            glPushMatrix();                     // Save matrix state
            // Second, rotate the earth on its axis.
            //      Use HourOfDay to determine its rotation.
            glRotatef( 360.0*HourOfDay/24.0, 0.0, 1.0, 0.0 );
            // Third, draw the earth as a wireframe sphere.
            glColor3f( 0.2, 0.2, 1.0 );
            glutWireSphere( 0.4, 10, 10);
            glPopMatrix();                      // Restore matrix state

            // Draw the moon.
            //  Use DayOfYear to control its rotation around the earth
            glRotatef( 360.0*12.0*DayOfYear/365.0, 0.0, 1.0, 0.0 );
            glTranslatef( 0.7, 0.0, 0.0 );
            glColor3f( 0.3, 0.7, 0.3 );
            glutWireSphere( 0.1, 5, 5 );
        /* make me
        glRotatef( 360.0*12.0*DayOfYear/365.0, 0.0, 1.0, 0.0 );
            glTranslatef( 0.1, 1.0, 0.2 );
            glColor3f( 0.0, 0.7, 1.0 );
            glutWireSphere( 0.1, 3, 2 );
            */
            // Flush the pipeline, and swap the buffers
            glFlush();
            glutSwapBuffers();

            if ( singleStep ) {
                spinMode = GL_FALSE;
            }

            glutPostRedisplay();        // Request a re-draw for animation purposes

        }

        // Initialize OpenGL's rendering modes
        void OpenGLInit(void)
        {
          //  glClear(GL_COLOR_BUFFER_BIT);
        //glBegin(GL_LINES);
        //glColor3f(0.1,0.3,0.9);
        //glVertex2f(-0.9,0.5);
        //glVertex2f(-0.9,0.0);
          //  glutDisplayFunc(Haxxan);
            glShadeModel( GL_FLAT );
            glClearColor( 0.0, 0.0, 0.0, 0.0 ); 
            glClearDepth( 1.0 );
            glEnable( GL_DEPTH_TEST );
        }

        // ResizeWindow is called when the window is resized
        static void ResizeWindow(int w, int h)
        {
            float aspectRatio;
            h = (h == 0) ? 1 : h;
            w = (w == 0) ? 1 : w;
            glViewport( 0, 0, w, h );   // View port uses whole window
            aspectRatio = (float)w/(float)h;

            // Set up the projection view matrix (not very well!)
            glMatrixMode( GL_PROJECTION );
            glLoadIdentity();
            gluPerspective( 60.0, aspectRatio, 1.0, 30.0 );

            // Select the Modelview matrix
            glMatrixMode( GL_MODELVIEW );
        }
        // Main routine
        // Set up OpenGL, hook up callbacks, and start the main loop
        int main( int argc, char** argv )
        {
            // Need to double buffer for animation
            glutInit(&argc,argv);
            glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );

            // Create and position the graphics window
            glutInitWindowPosition( 0, 0 );
            glutInitWindowSize( 600, 360 );

            glutCreateWindow( "Solar System Demo" );

            // Initialize OpenGL.
            OpenGLInit();

            // Set up callback functions for key presses


            // Set up the callback function for resizing windows
            glutReshapeFunc( ResizeWindow );

            // Callback for graphics image redrawing
            glutDisplayFunc( Animate );

            // Start the main loop.  glutMainLoop never returns.
            glutMainLoop(  );

            return(0);
        }