glNewList() private method

private glNewList ( uint list, uint mode ) : void
list uint
mode uint
return void
示例#1
0
        public void DrawShadow()
        {
            GL.glPushMatrix();
            GL.glNewList(Robot_SHADOW_LIST, GL.GL_COMPILE);
            //build the Robot
            GL.glTranslatef(0, Jump, 0);
            GL.glTranslatef(0, 1.3f, 0);
            // build Robot head
            GL.glCallList(HEAD_SHADOW_LIST);
            GL.glTranslatef(0, -1.3f, 0);
            // build Robot body
            GL.glCallList(BODY_SHADOW_LIST);
            //build Robot hands
            DrawShadowHand(false);  //left hand
            GL.glRotatef(180, 0, 1, 0);
            if (WeaponIndex == 1 || WeaponIndex == 2)
            {
                GL.glScalef(-1, 1, 1);
            }
            DrawShadowHand(true);  //right hand

            //build Robot legs
            GL.glRotatef(90, 1, 0, 0);
            GL.glTranslatef(0, 0, 1.9f);
            GL.glTranslatef(0, 0.3f, 0);
            DrawShadowLeg(false); //left leg
            GL.glTranslatef(0, -0.6f, 0);
            DrawShadowLeg(true);  //right leg

            GL.glEndList();
            GL.glPopMatrix();
        }
示例#2
0
 public void createStemAndLeafs()
 {
     GL.glNewList(STEM_AND_LEAVS_LIST + currentTree, GL.GL_COMPILE);
     GL.glPushMatrix();
     GL.glPushAttrib(GL.GL_LIGHTING_BIT);
     GL.glCallList(STEM_LIST + currentTree);
     GL.glCallList(LEAF_MAT);
     for (int i = 0; i < 3; i++)
     {
         GL.glTranslatef(0, (float)1 / 3, 0);
         GL.glRotatef(90, 0, 1, 0);
         GL.glPushMatrix();
         GL.glRotatef(50, 1, 0, 0);
         GL.glCallList(LEAF_LIST + currentTree);
         GL.glPopMatrix();
         GL.glPushMatrix();
         GL.glRotatef(180, 0, 1, 0);
         GL.glRotatef(60, 1, 0, 0);
         GL.glCallList(LEAF_LIST + currentTree);
         GL.glPopMatrix();
     }
     GL.glPopAttrib();
     GL.glPopMatrix();
     GL.glEndList();
 }
示例#3
0
        public void CreateRobotList()
        {
            GL.glPushMatrix();
            //
            // hierarchical list
            //
            GL.glNewList(ROBOT_LIST, GL.GL_COMPILE);

            // BASE : no rotations!!! Angle will be implemented in the CALL routine
            //                   before call to CreateRobotList()
            GL.glColor3f(0, 0, 0.5f);
            GLU.gluCylinder(obj, 3 * r, 3 * r, r * 1.2, 40, 20);
            GL.glTranslated(0, 0, r * 1.2);
            GLU.gluDisk(obj, 0, 3 * r, 40, 20);
            GL.glColor3f(0, 0, 1);
            GLU.gluSphere(obj, r * 1.2, 20, 20);
            // end base

            // transformations
            GL.glRotatef(SHOULDER_angle, 1, 0, 0);

            // call SHOULDER
            GL.glCallList(SHOULDER_LIST);

            // transformations
            //no need in glTranslated 0, 0, SHOULDER_length
            //it is located properly now !!!
            GL.glRotatef(ARM_angle, 1, 0, 0);

            // call ARM
            GL.glCallList(ARM_LIST);
            GL.glEndList();
            GL.glPopMatrix();
        }
示例#4
0
 public void createStemList()
 {
     GL.glNewList(STEM_LIST + currentTree, GL.GL_COMPILE);
     GL.glPushMatrix();
     GL.glRotatef(-90, 1, 0, 0);
     GLU.gluCylinder(obj, 0.1 * widhtScale, 0.08 * widhtScale, 1, 10, 10);
     GL.glPopMatrix();
     GL.glEndList();
 }
示例#5
0
 void CreateApple()
 {
     GL.glColor3d(1, 0, 0);
     GL.glNewList(APPLE_LIST, GL.GL_COMPILE);
     GL.glPushMatrix();
     GL.glRotatef(-90, 1, 0, 0);
     GLUT.glutSolidTorus(0.2, 0.1, 10, 10);
     GL.glPopMatrix();
     GL.glEndList();
 }
示例#6
0
        public void CreateFloorList()
        {
            GL.glPushMatrix();
            GL.glNewList(floorMainList, GL.GL_COMPILE);

            GL.glCallList(floorStartPosition);
            GL.glCallList(floorList);

            GL.glEndList();
            GL.glPopMatrix();
        }
示例#7
0
 void CreateTree()
 {
     GL.glNewList(TREE_LIST + currentTree, GL.GL_COMPILE);
     GL.glPushMatrix();
     GL.glPushAttrib(GL.GL_LIGHTING_BIT);
     GL.glCallList(TREE_MAT);
     GL.glScaled(amplitude, amplitude, amplitude);
     FractalTreeRec(0);
     GL.glPopAttrib();
     GL.glPopMatrix();
     GL.glEndList();
 }
示例#8
0
 public void PrepareAndDrawShadow()
 {
     CAR_SHADOW_LIST = GL.glGenLists(1);
     CAR_SHADOW      = CAR_SHADOW_LIST + 1;
     GL.glPushMatrix();
     GL.glNewList(CAR_SHADOW, GL.GL_COMPILE);
     GL.glTranslatef(0, -5.5f, 0);
     GL.glScalef(0.1f, 0.1f, 0.1f);
     carModel.DrawModel(false, 1);
     GL.glPopMatrix();
     GL.glEndList();
     GL.glPopMatrix();
 }
示例#9
0
        public void createLeafList()
        {
            GL.glNewList(LEAF_LIST + currentTree, GL.GL_COMPILE);
            GL.glBegin(GL.GL_TRIANGLES);

            GL.glNormal3f(-0.1f, 0, leafScale);
            GL.glVertex3f(0, 0, 0);
            GL.glVertex3f(leafScale, leafScale, 0.1f);
            GL.glVertex3f(0, leafScale * 2, 0);

            GL.glNormal3f(0.1f, 0, leafScale);
            GL.glVertex3f(0, 0, 0);
            GL.glVertex3f(0, leafScale * 2, 0);
            GL.glVertex3f(leafScale, leafScale, 0.1f);

            GL.glEnd();
            GL.glEndList();
        }
示例#10
0
        /**********************************************************************************************************
        *
        * Setup materials parametrs for water,ground and tree components.
        *
        **********************************************************************************************************/

        public void SetupMaterials()
        {
            float[] tree_ambuse    = { 0.4f, 0.25f, 0.1f, 1.0f };
            float[] tree_specular  = { 0.0f, 0.0f, 0.0f, 1.0f };
            float[] tree_shininess = { 0 };

            float[] leaf_ambuse    = { 0.0f, 0.8f, 0.0f, 1.0f };
            float[] leaf_specular  = { 0.0f, 0.8f, 0.0f, 1.0f };
            float[] leaf_shininess = { 10 };

            float[] water_ambuse    = { 0.70f, 0.85f, 0.95f, ScrollValue[15] };
            float[] water_specular  = { 0.0f, 0.0f, 1.0f, 1.0f };
            float[] water_shininess = { 1 };

            float[] apple_ambuse    = { 0.57f, 0.04f, 0.04f, 1.0f };
            float[] apple_specular  = { 0.5f, 0.05f, 0.05f, 1.0f };
            float[] apple_shininess = { 0.1f };

            GL.glNewList(APPLE_MAT, GL.GL_COMPILE);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, apple_ambuse);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, apple_specular);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, apple_shininess);
            GL.glEndList();

            GL.glNewList(WATER_MAT, GL.GL_COMPILE);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, water_ambuse);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, water_specular);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, water_shininess);
            GL.glEndList();

            GL.glNewList(TREE_MAT, GL.GL_COMPILE);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, tree_ambuse);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, tree_specular);
            GL.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, tree_shininess);
            GL.glEndList();

            GL.glNewList(LEAF_MAT, GL.GL_COMPILE);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, leaf_ambuse);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, leaf_specular);
            GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, leaf_shininess);
            GL.glEndList();
        }
示例#11
0
        void PrepareLists()
        {
            float ARM_length, SHOULDER_length;

            ARM_length      = 2;
            ARM_angle       = -45;
            SHOULDER_length = 2.5f;
            SHOULDER_angle  = 10;
            ROBOT_angle     = 45;
            r = 0.3f;

            ROBOT_LIST    = GL.glGenLists(3);
            ARM_LIST      = ROBOT_LIST + 1;
            SHOULDER_LIST = ROBOT_LIST + 2;

            GL.glPushMatrix();
            GL.glNewList(ARM_LIST, GL.GL_COMPILE);
            //cone
            GL.glColor3f(0.5f, 0, 0);
            GLU.gluCylinder(obj, r, 0, ARM_length, 20, 20);
            GL.glTranslated(0, 0, ARM_length);
            //internal disk
            GL.glColor3f(1, 1, 0);
            GLU.gluDisk(obj, 0, r * 0.5, 20, 20);
            //external disk
            GL.glColor3f(1, 0, 0);
            GLU.gluDisk(obj, r * 0.5, r * 1.5, 20, 20);
            GL.glEndList();
            GL.glPopMatrix();

            GL.glPushMatrix();
            GL.glNewList(SHOULDER_LIST, GL.GL_COMPILE);
            GL.glColor3f(0, 0.5f, 0);
            GLU.gluCylinder(obj, r, r, SHOULDER_length, 20, 20);
            GL.glTranslated(0, 0, SHOULDER_length);
            GL.glColor3f(0, 1, 0);
            GLU.gluSphere(obj, r * 1.2, 20, 20);
            GL.glEndList();
            GL.glPopMatrix();

            CreateRobotList();
        }
示例#12
0
        void DrawDynamicShadowHand()
        {
            switch (WeaponIndex)
            {
            case 0:
                GL.glPushMatrix();
                GL.glNewList(SHOULDER_SHADOW_LIST, GL.GL_COMPILE);
                //shoulder
                GL.glTranslatef(0, 0.6f, 0);
                GL.glTranslated(0, 0, shoulderLength - 0.55);
                GL.glRotatef(55, 1, 0, 0);
                GLU.gluCylinder(obj, radius, radius, shoulderLength, 20, 20);
                GL.glTranslated(0, 0, shoulderLength);
                GLU.gluSphere(obj, 1.3 * radius, 20, 20);
                GL.glEndList();
                GL.glPopMatrix();

                GL.glPushMatrix();
                GL.glNewList(ARM_SHADOW_LIST, GL.GL_COMPILE);
                //arm
                GL.glRotatef(-30, 1, 0, 0);
                GLU.gluCylinder(obj, radius, radius, armLength, 20, 20);
                GL.glTranslated(0, 0, armLength);
                GLU.gluSphere(obj, radius * 2.2, 20, 20);

                GL.glEndList();
                GL.glPopMatrix();
                break;

            case 1:
                GL.glPushMatrix();
                GL.glNewList(SHOULDER_SHADOW_LIST, GL.GL_COMPILE);
                //shoulder
                GL.glTranslatef(0, 0.6f, 0);
                GL.glTranslated(0, 0, shoulderLength - 0.55);
                GL.glRotatef(65, 0, 1, 0);
                GLU.gluCylinder(obj, radius, radius, shoulderLength, 20, 20);
                GL.glTranslated(0, 0, shoulderLength);
                GLU.gluSphere(obj, 1.3 * radius, 20, 20);
                GL.glEndList();
                GL.glPopMatrix();

                GL.glPushMatrix();
                GL.glNewList(ARM_SHADOW_LIST, GL.GL_COMPILE);
                //arm
                GL.glRotatef(-80, 1, 0, 0);
                GL.glRotatef(20, 0, 1, 0);
                GLU.gluCylinder(obj, radius, radius, armLength, 20, 20);
                GL.glTranslated(0, 0, armLength);
                GLU.gluSphere(obj, radius * 2.2, 20, 20);

                //gun1
                GL.glTranslatef(0, 0.6f, 0);
                GL.glScalef(1.5f, 1.5f, 1.5f);
                gun1.DrawModel(false, 1);
                break;

            case 2:
                GL.glPushMatrix();
                GL.glNewList(SHOULDER_SHADOW_LIST, GL.GL_COMPILE);
                //shoulder
                GL.glTranslatef(0, 0.6f, 0);
                GL.glTranslated(0, 0, shoulderLength - 0.55);
                GL.glRotatef(65, 1, 0, 0);
                GLU.gluCylinder(obj, radius, radius, shoulderLength, 20, 20);
                GL.glTranslated(0, 0, shoulderLength);
                GLU.gluSphere(obj, 1.3 * radius, 20, 20);
                GL.glEndList();
                GL.glPopMatrix();

                GL.glPushMatrix();
                GL.glNewList(ARM_SHADOW_LIST, GL.GL_COMPILE);
                //arm
                GL.glRotatef(-80, 1, 0, 0);
                GL.glRotatef(90, 0, 1, 0);
                GLU.gluCylinder(obj, radius, radius, armLength, 20, 20);
                GL.glTranslated(0, 0, armLength);
                GLU.gluSphere(obj, radius * 2.2, 20, 20);

                //gun2
                GL.glRotatef(-30, 0, 0, 1);
                GL.glTranslatef(0, 0.6f, 0);
                GL.glScalef(1.3f, 1.3f, 1.3f);
                gun2.DrawModel(false, 1);
                break;

            case 3:
                GL.glPushMatrix();
                GL.glNewList(SHOULDER_SHADOW_LIST, GL.GL_COMPILE);
                //shoulder
                GL.glTranslatef(0, 0.6f, 0);
                GL.glTranslated(0, 0, shoulderLength - 0.55);
                GL.glRotatef(55, 1, 0, 0);
                GLU.gluCylinder(obj, radius, radius, shoulderLength, 20, 20);
                GL.glTranslated(0, 0, shoulderLength);
                GLU.gluSphere(obj, 1.3 * radius, 20, 20);
                GL.glEndList();
                GL.glPopMatrix();

                GL.glPushMatrix();
                GL.glNewList(ARM_SHADOW_LIST, GL.GL_COMPILE);
                //arm
                GL.glRotatef(-30, 1, 0, 0);
                GLU.gluCylinder(obj, radius, radius, armLength, 20, 20);
                GL.glTranslated(0, 0, armLength);
                GLU.gluSphere(obj, radius * 2.2, 20, 20);

                //sword
                GL.glScalef(0.3f, 0.3f, 0.3f);
                sword.DrawModel(false, 1);
                GL.glScalef(-0.3f, -0.3f, -0.3f);
                break;
            }
            GL.glEndList();
            GL.glPopMatrix();
        }
示例#13
0
        public void PrepareShadow()
        {
            radius = 0.18f;

            Robot_SHADOW_LIST    = GL.glGenLists(7);
            ARM_SHADOW_LIST      = Robot_SHADOW_LIST + 1;
            SHOULDER_SHADOW_LIST = Robot_SHADOW_LIST + 2;
            HAND_SHADOW_LIST     = Robot_SHADOW_LIST + 3;
            BODY_SHADOW_LIST     = Robot_SHADOW_LIST + 4;
            HEAD_SHADOW_LIST     = Robot_SHADOW_LIST + 5;
            LEG_UP_SHADOW_LIST   = Robot_SHADOW_LIST + 6;
            LEG_DOWN_SHADOW_LIST = Robot_SHADOW_LIST + 7;

            GL.glPushMatrix();
            GL.glNewList(HEAD_SHADOW_LIST, GL.GL_COMPILE);

            GL.glTranslatef(0, 1, 0);
            //head
            GL.glPushMatrix();
            GL.glTranslatef(0, 1, 0);
            GL.glRotatef(-90, 1, 0, 0);
            GLU.gluSphere(obj, radius * 3.5, 20, 20);
            GL.glRotatef(180, 1, 0, 0);
            GLU.gluCylinder(obj, 3.5 * radius, 3.5 * radius, radius * 2, 20, 20);
            GL.glTranslatef(0, 0, radius * 2);
            GLU.gluCylinder(obj, 3.5 * radius, 0.5, radius * 2, 20, 20);
            GL.glTranslatef(0, 0, radius * 2);
            GLU.gluCylinder(obj, 0.5, 0, radius * 2, 20, 20);
            GL.glPopMatrix();
            GL.glEndList();
            GL.glPopMatrix();

            GL.glPushMatrix();
            GL.glNewList(BODY_SHADOW_LIST, GL.GL_COMPILE);


            //ALL body
            //neck
            GL.glPushMatrix();
            GL.glRotatef(90, 1, 0, 0);
            GL.glTranslatef(0, 0, -2.0f);
            GLU.gluCylinder(obj, 1.5 * radius, 1.5 * radius, bodyLength, 20, 20);
            GL.glPopMatrix();

            ////body up
            GL.glRotatef(90, 1, 0, 0);
            GL.glTranslatef(0, 0, -1.2f);
            GLU.gluCylinder(obj, radius, 6 * radius, bodyLength / 4, 20, 20);
            GL.glTranslatef(0, 0, 1.2f);

            //body midle
            GL.glScalef(1.0f, -1.0f, 1.0f);
            GL.glTranslatef(0, 0, -(bodyLength / 4 + 0.2f));
            GLU.gluCylinder(obj, 6 * radius, 3 * radius, bodyLength / 1.5f, 20, 20);
            GL.glTranslatef(0, 0, (bodyLength / 4 + 0.2f));
            GL.glScalef(1.0f, 1.0f, 1.0f);

            //Tusik
            GLU.gluCylinder(obj, 3 * radius, 3 * radius, bodyLength / 1.5f, 20, 20);

            //body down
            GL.glTranslatef(0, 0, (bodyLength / 1.5f));
            GLU.gluCylinder(obj, 3 * radius, radius, bodyLength / 3.5f, 10, 10);
            GL.glTranslatef(0, 0, -(bodyLength / 1.5f));

            GL.glRotatef(-90, 1, 0, 0);
            GL.glEndList();
            GL.glPopMatrix();
            DrawDynamicShadowHand();

            GL.glPushMatrix();
            GL.glNewList(LEG_UP_SHADOW_LIST, GL.GL_COMPILE);
            //leg_up
            GLU.gluCylinder(obj, 1.5f * radius, 1.5f * radius, legUpLength, 20, 20);
            GL.glTranslated(0, 0, legUpLength);
            GLU.gluSphere(obj, radius * 1.7f, 20, 20);
            GL.glEndList();
            GL.glPopMatrix();


            GL.glPushMatrix();
            GL.glNewList(LEG_DOWN_SHADOW_LIST, GL.GL_COMPILE);
            //leg_down
            GLU.gluCylinder(obj, 1.5f * radius, 1.5f * radius, legDownLength, 20, 20);
            GL.glTranslated(0, 0, legDownLength);
            GLU.gluSphere(obj, 1.7f * radius, 20, 20);
            GL.glEndList();
            GL.glPopMatrix();
        }
示例#14
0
        public void CreateHandList()
        {
            GL.glPushMatrix();
            GL.glNewList(handList, GL.GL_COMPILE);

            switch (movingPart)
            {
            case 0:
                GL.glCallList(handBaseList);
                CallFingerList(1);
                CallFingerList(2);
                CallFingerList(3);
                CallFingerList(4);
                CallFingerList(5);
                break;

            case 1:     //Index finger move implementation
                GL.glCallList(handBaseList);
                CallFingerList(2);
                CallFingerList(3);
                CallFingerList(4);
                CallFingerList(5);
                GL.glCallList(indexFingerStart);
                GL.glRotatef(indexFingerAngle[0], 1, 0, 0);
                GL.glCallList(indexPhalanxList1);
                GL.glRotatef(indexFingerAngle[1], 1, 0, 0);
                GL.glCallList(indexPhalanxList2);
                GL.glRotatef(indexFingerAngle[2], 1, 0, 0);
                GL.glCallList(indexPhalanxList3);
                break;

            case 2:     //Middle finger move implementation
                GL.glCallList(handBaseList);
                CallFingerList(1);
                CallFingerList(3);
                CallFingerList(4);
                CallFingerList(5);
                GL.glCallList(middleFingerStart);
                GL.glRotatef(middleFingerAngle[0], 1, 0, 0);
                GL.glCallList(middlePhalanxList1);
                GL.glRotatef(middleFingerAngle[1], 1, 0, 0);
                GL.glCallList(middlePhalanxList2);
                GL.glRotatef(middleFingerAngle[2], 1, 0, 0);
                GL.glCallList(middlePhalanxList3);
                break;

            case 3:     //Ring finger move implementation
                GL.glCallList(handBaseList);
                CallFingerList(1);
                CallFingerList(2);
                CallFingerList(4);
                CallFingerList(5);
                GL.glCallList(ringFingerStart);
                GL.glRotatef(ringFingerAngle[0], 1, 0, 0);
                GL.glCallList(ringPhalanxList1);
                GL.glRotatef(ringFingerAngle[1], 1, 0, 0);
                GL.glCallList(ringPhalanxList2);
                GL.glRotatef(ringFingerAngle[2], 1, 0, 0);
                GL.glCallList(ringPhalanxList3);
                break;

            case 4:     //Pinky finger move implementation
                GL.glCallList(handBaseList);
                CallFingerList(1);
                CallFingerList(2);
                CallFingerList(3);
                CallFingerList(5);
                GL.glCallList(pinkyFingerStart);
                GL.glRotatef(pinkyFingerAngle[0], 1, 0, 0);
                GL.glCallList(pinkyPhalanxList1);
                GL.glRotatef(pinkyFingerAngle[1], 1, 0, 0);
                GL.glCallList(pinkyPhalanxList2);
                GL.glRotatef(pinkyFingerAngle[2], 1, 0, 0);
                GL.glCallList(pinkyPhalanxList3);
                break;

            case 5:     //Thumb finger move implementation
                GL.glCallList(handBaseList);
                CallFingerList(1);
                CallFingerList(2);
                CallFingerList(3);
                CallFingerList(4);
                GL.glCallList(thumbFingerStart);
                GL.glRotated(-45, 0, 0, 1);
                GL.glRotatef(thumbFingerAngle[0], 1, 0, 0);
                GL.glRotated(45, 0, 0, 1);
                GL.glCallList(thumbPhalanxList1);
                GL.glRotated(-45, 0, 0, 1);
                GL.glRotatef(thumbFingerAngle[1], 1, 0, 0);
                GL.glRotated(45, 0, 0, 1);
                GL.glCallList(thumbPhalanxList2);
                break;
            }

            GL.glEndList();
            GL.glPopMatrix();
        }
示例#15
0
        public void PrepareLists()
        {
            handList           = GL.glGenLists(21);
            handBaseList       = handList + 1;
            indexFingerStart   = handList + 2;
            middleFingerStart  = handList + 3;
            ringFingerStart    = handList + 4;
            pinkyFingerStart   = handList + 5;
            thumbFingerStart   = handList + 6;
            indexPhalanxList1  = handList + 7;
            indexPhalanxList2  = handList + 8;
            indexPhalanxList3  = handList + 9;
            middlePhalanxList1 = handList + 10;
            middlePhalanxList2 = handList + 11;
            middlePhalanxList3 = handList + 12;
            ringPhalanxList1   = handList + 13;
            ringPhalanxList2   = handList + 14;
            ringPhalanxList3   = handList + 15;
            pinkyPhalanxList1  = handList + 16;
            pinkyPhalanxList2  = handList + 17;
            pinkyPhalanxList3  = handList + 18;
            thumbPhalanxList1  = handList + 19;
            thumbPhalanxList2  = handList + 20;

            floorMainList      = GL.glGenLists(3);
            floorStartPosition = floorMainList + 1;
            floorList          = floorMainList + 2;

            //Floor Start Position
            GL.glPushMatrix();
            GL.glNewList(floorStartPosition, GL.GL_COMPILE);
            GL.glTranslated(0, 0, 0);
            GL.glEndList();
            GL.glPopMatrix();

            //Floor
            GL.glPushMatrix();
            GL.glNewList(floorList, GL.GL_COMPILE);
            DrawFloor();
            GL.glEndList();
            GL.glPopMatrix();

            //Hand Base
            GL.glPushMatrix();
            GL.glNewList(handBaseList, GL.GL_COMPILE);
            DrawHand();
            GL.glEndList();
            GL.glPopMatrix();

            //Index Finger Start Position
            GL.glPushMatrix();
            GL.glNewList(indexFingerStart, GL.GL_COMPILE);
            GL.glTranslated(2.5, 2.3, 0);
            GL.glEndList();
            GL.glPopMatrix();

            //Middle Finger Start Position
            GL.glPushMatrix();
            GL.glNewList(middleFingerStart, GL.GL_COMPILE);
            GL.glTranslated(0.9, 2.3, 0);
            GL.glEndList();
            GL.glPopMatrix();

            //Ring Finger Start Position
            GL.glPushMatrix();
            GL.glNewList(ringFingerStart, GL.GL_COMPILE);
            GL.glTranslated(-0.7, 2.3, 0);
            GL.glEndList();
            GL.glPopMatrix();

            //Pinky Finger Start Position
            GL.glPushMatrix();
            GL.glNewList(pinkyFingerStart, GL.GL_COMPILE);
            GL.glTranslated(-2.5, 2.3, 0);
            GL.glEndList();
            GL.glPopMatrix();

            //Thumb Finger Start Position
            GL.glPushMatrix();
            GL.glNewList(thumbFingerStart, GL.GL_COMPILE);
            GL.glTranslated(3.35, 0.6, 0);
            GL.glEndList();
            GL.glPopMatrix();

            //[1/3] - Index Finger
            GL.glPushMatrix();
            GL.glNewList(indexPhalanxList1, GL.GL_COMPILE);
            DrawSingleFinger(1, 0);
            GL.glEndList();
            GL.glPopMatrix();
            //[2/3]
            GL.glPushMatrix();
            GL.glNewList(indexPhalanxList2, GL.GL_COMPILE);
            DrawSingleFinger(2, 0);
            GL.glEndList();
            GL.glPopMatrix();
            //[3/3]
            GL.glPushMatrix();
            GL.glNewList(indexPhalanxList3, GL.GL_COMPILE);
            DrawSingleFinger(3, 2.5);
            GL.glEndList();
            GL.glPopMatrix();

            //[1/3] - Middle Finger
            GL.glPushMatrix();
            GL.glNewList(middlePhalanxList1, GL.GL_COMPILE);
            DrawSingleFinger(1, 0);
            GL.glEndList();
            GL.glPopMatrix();
            //[2/3]
            GL.glPushMatrix();
            GL.glNewList(middlePhalanxList2, GL.GL_COMPILE);
            DrawSingleFinger(2, 0);
            GL.glEndList();
            GL.glPopMatrix();
            //[3/3]
            GL.glPushMatrix();
            GL.glNewList(middlePhalanxList3, GL.GL_COMPILE);
            DrawSingleFinger(3, 0.9);
            GL.glEndList();
            GL.glPopMatrix();

            //[1/3] - Ring Finger
            GL.glPushMatrix();
            GL.glNewList(ringPhalanxList1, GL.GL_COMPILE);
            DrawSingleFinger(1, 0);
            GL.glEndList();
            GL.glPopMatrix();
            //[2/3]
            GL.glPushMatrix();
            GL.glNewList(ringPhalanxList2, GL.GL_COMPILE);
            DrawSingleFinger(2, 0);
            GL.glEndList();
            GL.glPopMatrix();
            //[3/3]
            GL.glPushMatrix();
            GL.glNewList(ringPhalanxList3, GL.GL_COMPILE);
            DrawSingleFinger(3, -0.7);
            GL.glEndList();
            GL.glPopMatrix();

            //[1/3] - Pinky Finger
            GL.glPushMatrix();
            GL.glNewList(pinkyPhalanxList1, GL.GL_COMPILE);
            DrawSingleFinger(1, 0);
            GL.glEndList();
            GL.glPopMatrix();
            //[2/3]
            GL.glPushMatrix();
            GL.glNewList(pinkyPhalanxList2, GL.GL_COMPILE);
            DrawSingleFinger(2, 0);
            GL.glEndList();
            GL.glPopMatrix();
            //[3/3]
            GL.glPushMatrix();
            GL.glNewList(pinkyPhalanxList3, GL.GL_COMPILE);
            DrawSingleFinger(3, -2.5);
            GL.glEndList();
            GL.glPopMatrix();

            //[1/2] - Thumb Finger
            GL.glPushMatrix();
            GL.glNewList(thumbPhalanxList1, GL.GL_COMPILE);
            DrawThumbFinger(1);
            GL.glEndList();
            GL.glPopMatrix();
            //[2/2]
            GL.glPushMatrix();
            GL.glNewList(thumbPhalanxList2, GL.GL_COMPILE);
            DrawThumbFinger(2);
            GL.glEndList();
            GL.glPopMatrix();


            CreateHandList();
            CreateFloorList();
        }