wglSwapBuffers() private méthode

private wglSwapBuffers ( uint hdc ) : uint
hdc uint
Résultat uint
// ############################################################################
// ############################################################################
// ############################################################################
// ############################################################################

// ============================================================================
// The following can be used as an example of how to initialize OpenGL
// rendering.  A System.Windows.Forms object can use a window handle acquired
// from (uint)((this.Handle).ToInt32()) as the "HWND" parameter.
//
// Here is a crude illustration of the use of WGL.DemoInitOpenGL() by a Form:
//
//    // ----------------------------------------------------------------------
//    public static uint            m_uint_HWND = 0;
//    public static uint            m_uint_DC   = 0;
//    public static uint            m_uint_RC   = 0;
//
//    protected override void OnPaintBackground( PaintEventArgs e )
//    {
//    // This overrides the System.Windows.Forms.Control protected method
//    // "OnPaintBackground()" so that we don't clear the client area of
//    // this form window -- so the OpenGL doesn't flicker on each frame.
//    }
//
//    protected override void OnPaint( System.Windows.Forms.PaintEventArgs e )
//    {
//    if (0 == m_uint_RC)
//      {
//      m_uint_HWND = (uint)((this.Handle).ToInt32());
//      WGL.DemoInitOpenGL( m_uint_HWND, ref m_uint_DC, ref m_uint_RC );
//      }
//    if (0 != m_uint_RC)
//      {
//      WGL.DemoOpenGLDraw( this.Size.Width, this.Size.Height,  m_uint_DC );
//      }
//    System.Threading.Thread.Sleep( 10 ); // 10 msec --> 100 frames per second, max.
//    Invalidate(false); // Force OnPaint() to get called again.
//    }
//    // ----------------------------------------------------------------------
//
// ============================================================================
        public static void DemoInitOpenGL
        (
            uint uint_HWND,       // in
            ref uint ref_uint_DC, // out
            ref uint ref_uint_RC  // out
        )
        {
            ref_uint_DC = WGL.GetDC(uint_HWND);

            // CAUTION: Not doing the following WGL.wglSwapBuffers() on the DC will
            // result in a failure to subsequently create the RC.
            WGL.wglSwapBuffers(ref_uint_DC);

            WGL.DemoCreateRenderingContext(ref ref_uint_DC, ref ref_uint_RC);

            if (0 == ref_uint_RC)
            {
                WGL.MessageBox(0, "Failed to create OpenGL Rendering Context (RC)",
                               "WGL.DemoInitOpenGL() : ERROR", MB_OK);
                return;
            }
        }
Exemple #2
0
        public void Draw()
        {
            // MAIN FUNCTION
            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                MessageBox.Show("No screen dimension. Drawing canceled");
                return;
            }

            // GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);

            GL.glLoadIdentity();

            GL.glTranslatef(0.0f, 0.0f, -6.0f);

            GL.glRotatef(90.0f - GlobalProperties.CurrentVerticalViewAngle, -1.0f, 0.0f, 0.0f);
            GL.glRotatef(GlobalProperties.CurrentHorizontalViewAngle, 0.0f, 0.0f, 1.0f);

            GL.glEnable(GL.GL_LIGHTING);
            if (GlobalProperties.LightBeamOn)
            {
                GL.glEnable(GL.GL_LIGHT0);
            }
            else
            {
                GL.glDisable(GL.GL_LIGHT0);
            }

            // DrawAxes();
            DrawAll();
            GL.glDisable(GL.GL_LIGHTING);

            GL.glFlush();

            WGL.wglSwapBuffers(m_uint_DC);
        }
Exemple #3
0
        public void Draw()
        {
            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                return;
            }

            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
            GL.glLoadIdentity();

            GL.glTranslatef(0.0f, 0.0f, -3.0f); // Translate 3 Units Into The Screen

            createLightning();

            switch (m_gyroState)
            {
            case eGyroState.Rotating:
                gyroRotatingTransform();
                break;

            case eGyroState.Slowing:
                gyroSlowingTransform();
                break;

            case eGyroState.Stoping:
                gyroStopingTransform();
                break;
            }

            //drawAxes();
            drawGyro();

            GL.glFlush();

            WGL.wglSwapBuffers(m_uint_DC);
        }
Exemple #4
0
        public void Draw()
        {
            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                return;
            }

            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);

            GL.glLoadIdentity();
            GLU.gluLookAt(ScrollValue[1], 1, 10, 0, 0, 0, 0, 1, 0);
            GL.glTranslated(0, 0, -6);
            GL.glRotated(20, 1, 0, 0);

            //DrawAxes(Color.Red, Color.Green, Color.Blue);

            UpdateScrollInput();
            DrawLights();
            DrawMirrors();
            DrawFigures();

            GL.glFlush();
            WGL.wglSwapBuffers(m_uint_DC);
        }
// ############################################################################
// ############################################################################
// ############################################################################
// ############################################################################


// ============================================================================
// The following is an example of OpenGL rendering code, complete with
// buffer swapping.  This function can be called by a Form's "OnPaint()"
// method if a previous WGL.DemoInitOpenGL() call (for example) has
// already successfully established a valid Render Context (RC).
// ============================================================================

        public static void DemoOpenGLDraw
        (
            int int_WindowWidth,
            int int_WindowHeight,
            uint uint_DC
        )
        {
            int   int_Phase   = (int)(System.Environment.TickCount % 120000);
            float float_Phase = (float)(0.3f * (int_Phase));

            if (int_WindowWidth <= 0)
            {
                int_WindowWidth = 1;
            }
            if (int_WindowHeight <= 0)
            {
                int_WindowHeight = 1;
            }

            GL.glViewport(0, 0, int_WindowWidth, int_WindowHeight);

            GL.glEnable(GL.GL_DEPTH_TEST);
            GL.glDepthFunc(GL.GL_LEQUAL);
            GL.glEnable(GL.GL_CULL_FACE);
            GL.glCullFace(GL.GL_BACK);
            GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
            GL.glMatrixMode(GL.GL_PROJECTION);
            GL.glLoadIdentity();

            //GL.glOrtho( 0.0f, (float)(int_WindowWidth), 0.0f, (float)(int_WindowHeight), -1.0f, 1.0f );
            GLU.gluPerspective
            (
                60.0,  // Field of view angle (Y angle; degrees)
                ((double)(int_WindowWidth) / (double)(int_WindowHeight)),
                1.0,   // Near plane
                1000.0 // Far  plane
            );

            GL.glMatrixMode(GL.GL_MODELVIEW);
            GL.glLoadIdentity();

            // Translating the camera to +600.0f Z is essentially
            // adding -600.0f to all drawing commands.
            GL.glTranslatef(0.0f, 0.0f, -600.0f);

            GL.glRotatef((0.11f * float_Phase), 1.0f, 0.0f, 0.0f);
            GL.glRotatef((0.31f * float_Phase), 0.0f, 1.0f, 0.0f);
            GL.glRotatef((0.19f * float_Phase), 0.0f, 0.0f, 1.0f);

            float[][] vert_xyz = new float[8][]
            {
                new float[] { -100.0f, -100.0f, -100.0f }, // 0
                new float[] { -100.0f, -100.0f, 100.0f },  // 1
                new float[] { -100.0f, 100.0f, -100.0f },  // 2
                new float[] { -100.0f, 100.0f, 100.0f },   // 3
                new float[] { 100.0f, -100.0f, -100.0f },  // 4
                new float[] { 100.0f, -100.0f, 100.0f },   // 5
                new float[] { 100.0f, 100.0f, -100.0f },   // 6
                new float[] { 100.0f, 100.0f, 100.0f } // 7
            };
            int [][] tri_abc = new int [12][]
            {
                new int[] { 0, 2, 4 }, new int[] { 4, 2, 6 }, // Back
                new int[] { 0, 4, 1 }, new int[] { 1, 4, 5 }, // Bottom
                new int[] { 0, 1, 2 }, new int[] { 2, 1, 3 }, // Left
                new int[] { 4, 6, 5 }, new int[] { 5, 6, 7 }, // Right
                new int[] { 2, 3, 6 }, new int[] { 6, 3, 7 }, // Top
                new int[] { 1, 5, 3 }, new int[] { 3, 5, 7 } // Front
            };
            float[][] colors_rgb = new float[12][]
            {
                new float[] { 0.5f, 0.1f, 0.1f }, new float[] { 1.0f, 0.1f, 0.1f }, // Red
                new float[] { 0.5f, 0.5f, 0.1f }, new float[] { 1.0f, 1.0f, 0.1f }, // Yellow
                new float[] { 0.1f, 0.5f, 0.1f }, new float[] { 0.1f, 1.0f, 0.1f }, // Green
                new float[] { 0.1f, 0.5f, 0.5f }, new float[] { 0.1f, 1.0f, 1.0f }, // Cyan
                new float[] { 0.1f, 0.1f, 0.5f }, new float[] { 0.1f, 0.1f, 1.0f }, // Blue
                new float[] { 0.5f, 0.1f, 0.5f }, new float[] { 1.0f, 0.1f, 1.0f } // Magenta
            };

            int iTriTotal = 12;
            int iTriIndex = 0;

            GL.glBegin(GL.GL_TRIANGLES);
            for (iTriIndex = 0; iTriIndex < iTriTotal; iTriIndex++)
            {
                GL.glColor3fv(colors_rgb[iTriIndex]);
                GL.glVertex3fv(vert_xyz[tri_abc[iTriIndex][0]]);

                GL.glColor3fv(colors_rgb[iTriIndex]);
                GL.glVertex3fv(vert_xyz[tri_abc[iTriIndex][1]]);

                GL.glColor3fv(colors_rgb[iTriIndex]);
                GL.glVertex3fv(vert_xyz[tri_abc[iTriIndex][2]]);
            }
            GL.glEnd();

            WGL.wglSwapBuffers(uint_DC);
        }
Exemple #6
0
        /**********************************************************************************************************
        *
        *
        *
        * MAIN DRAW FUNCTION
        *
        *
        *
        **********************************************************************************************************/
        public void Draw()
        {
            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                return;
            }

            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);

            GL.glViewport(0, 0, Width, Height);
            GL.glLoadIdentity();

            GLU.gluLookAt(ScrollValue[0], ScrollValue[1], ScrollValue[2],
                          ScrollValue[3], ScrollValue[4], ScrollValue[5],
                          ScrollValue[6], ScrollValue[7], ScrollValue[8]);

            GL.glRotatef(xAngle, 1.0f, 0.0f, 0.0f);
            GL.glRotatef(yAngle, 0.0f, 1.0f, 0.0f);
            GL.glRotatef(zAngle, 0.0f, 0.0f, 1.0f);
            GL.glTranslatef(xShift, yShift, zShift);

            pos[0] = light_position[0] = ScrollValue[9];
            pos[1] = light_position[1] = ScrollValue[10];
            pos[2] = light_position[2] = ScrollValue[11];
            pos[3] = light_position[3] = 0;

            GL.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, light_ambient);
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, light_diffuse);
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, light_specular);
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position);

            GL.glLightModelfv(GL.GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
            GL.glEnable(GL.GL_LIGHT0);

            /*
             *
             * Reflection
             *
             */
            GL.glEnable(GL.GL_BLEND);
            GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
            if (reflectionOn)
            {
                //draw only to STENCIL buffer
                GL.glEnable(GL.GL_STENCIL_TEST);
                GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
                GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF);
                GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
                GL.glDisable(GL.GL_DEPTH_TEST);

                drawLake();

                // restore regular settings
                GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
                GL.glEnable(GL.GL_DEPTH_TEST);

                // reflection is drawn only where STENCIL buffer value equal to 1
                GL.glStencilFunc(GL.GL_EQUAL, 1, 0xFFFFFFFF);
                GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);

                /*
                 *
                 * draw reflected scene
                 *
                 */

                GL.glEnable(GL.GL_LIGHTING);
                for (currentTree = 0; currentTree < numOfTrees; currentTree++)
                {
                    GL.glPushMatrix();
                    //GL.glTranslated(randX[currentTree], 0,randZ[currentTree]);
                    GL.glTranslated(locationX[currentTree], 0, locationZ[currentTree]);
                    GL.glRotated(locationRotateY[currentTree], 0, 1, 0);
                    GL.glScalef(1, -1, 1); //swap on Z axis

                    if (scullFaceOn)
                    {
                        GL.glEnable(GL.GL_CULL_FACE);
                        GL.glCullFace(GL.GL_BACK);
                        GL.glCallList(TREE_LIST + currentTree);
                        GL.glCullFace(GL.GL_FRONT);
                        GL.glCallList(TREE_LIST + currentTree);
                        GL.glDisable(GL.GL_CULL_FACE);
                    }
                    else
                    {
                        GL.glCallList(TREE_LIST + currentTree);
                    }

                    GL.glPopMatrix();
                }

                drawLake();

                GL.glStencilFunc(GL.GL_NOTEQUAL, 1, 0xFFFFFFFF);
                GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);

                // really draw floor
                //( half-transparent ( see its color's alpha byte)))
                // in order to see reflected objects
                //GL.glDepthMask((byte)GL.GL_FALSE);
                GL.glDepthMask((byte)GL.GL_TRUE);
                if (!textureOn)
                {
                    drawFloor();
                }
                else
                {
                    drawFloorTextured();
                    DrawTexturedCube();
                }

                GL.glDisable(GL.GL_LIGHTING);
                GL.glDisable(GL.GL_STENCIL_TEST);
            }
            else
            {
                GL.glEnable(GL.GL_LIGHTING);
                drawLake();
                if (!textureOn)
                {
                    drawFloor();
                }
                else
                {
                    drawFloorTextured();
                    DrawTexturedCube();
                }
                GL.glDisable(GL.GL_LIGHTING);
            }

            DrawLight();

            /*
             * Draw trees
             */

            GL.glEnable(GL.GL_LIGHTING);
            GL.glPushMatrix();
            for (currentTree = 0; currentTree < numOfTrees; currentTree++)
            {
                GL.glPushMatrix();
                //GL.glTranslated(randX[currentTree], 0, randZ[currentTree]);
                GL.glTranslated(locationX[currentTree], 0, locationZ[currentTree]);
                GL.glRotated(locationRotateY[currentTree], 0, 1, 0);
                GL.glCallList(TREE_LIST + currentTree);
                GL.glPopMatrix();
            }
            GL.glPopMatrix();

            /*
             * Draw trees shadows
             */
            GL.glDisable(GL.GL_LIGHTING);
            GL.glColor3d(0, 0, 0);
            if (shadowOn)
            {
                GL.glPushMatrix();
                MakeShadowMatrix(ground);
                GL.glMultMatrixf(cubeXform);
                for (currentTree = 0; currentTree < numOfTrees; currentTree++)
                {
                    GL.glPushMatrix();
                    //GL.glTranslated(randX[currentTree], 0, randZ[currentTree]);
                    GL.glTranslated(locationX[currentTree], 0, locationZ[currentTree]);
                    GL.glRotated(locationRotateY[currentTree], 0, 1, 0);
                    GL.glCallList(TREE_LIST + currentTree);
                    GL.glPopMatrix();
                }
                GL.glPopMatrix();
            }

            GL.glFlush();
            WGL.wglSwapBuffers(m_uint_DC);
        }
Exemple #7
0
        public void Draw()
        {
            pos[0] = -4 + (float)xExisOrigin + (float)ScrollValue[11];
            pos[1] = 15 + (float)yExisOrigin + (float)ScrollValue[12];
            pos[2] = 15 + (float)ScrollValue[13];


            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                return;
            }

            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);

            GL.glLoadIdentity();


            // not trivial
            double [] ModelVievMatrixBeforeSpecificTransforms = new double[16];
            double [] CurrentRotationTraslation = new double[16];

            GLU.gluLookAt(ScrollValue[0], ScrollValue[1], ScrollValue[2],
                          ScrollValue[3], ScrollValue[4], ScrollValue[5],
                          ScrollValue[6], ScrollValue[7], ScrollValue[8]);
            GL.glTranslatef(0.0f, 0.0f, -30.0f);

            GL.glRotatef(105, 0, 0, 1);
            GL.glRotatef(70, 0, 1, 0);
            GL.glRotatef(15, 1, 0, 0);
            //save current ModelView Matrix values
            //in ModelVievMatrixBeforeSpecificTransforms array
            //ModelView Matrix ========>>>>>> ModelVievMatrixBeforeSpecificTransforms
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
            //ModelView Matrix was saved, so
            GL.glLoadIdentity(); // make it identity matrix

            //make transformation in accordance to KeyCode
            float delta;

            if (intOptionC != 0)
            {
                delta = 5.0f * Math.Abs(intOptionC) / intOptionC; // signed 5

                switch (Math.Abs(intOptionC))
                {
                case 1:
                    GL.glRotatef(delta, 1, 0, 0);
                    break;

                case 2:
                    GL.glRotatef(delta, 0, 1, 0);
                    break;

                case 3:
                    GL.glRotatef(delta, 0, 0, 1);
                    break;

                case 4:
                    GL.glTranslatef(delta / 20, 0, 0);
                    break;

                case 5:
                    GL.glTranslatef(0, delta / 20, 0);
                    break;

                case 6:
                    GL.glTranslatef(0, 0, delta / 20);
                    break;
                }
            }
            //as result - the ModelView Matrix now is pure representation
            //of KeyCode transform and only it !!!

            //save current ModelView Matrix values
            //in CurrentRotationTraslation array
            //ModelView Matrix =======>>>>>>> CurrentRotationTraslation
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, CurrentRotationTraslation);

            //The GL.glLoadMatrix function replaces the current matrix with
            //the one specified in its argument.
            //The current matrix is the
            //projection matrix, modelview matrix, or texture matrix,
            //determined by the current matrix mode (now is ModelView mode)
            GL.glLoadMatrixd(AccumulatedRotationsTraslations); //Global Matrix

            //The GL.glMultMatrix function multiplies the current matrix by
            //the one specified in its argument.
            //That is, if M is the current matrix and T is the matrix passed to
            //GL.glMultMatrix, then M is replaced with M • T
            GL.glMultMatrixd(CurrentRotationTraslation);

            //save the matrix product in AccumulatedRotationsTraslations
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, AccumulatedRotationsTraslations);

            //replace ModelViev Matrix with stored ModelVievMatrixBeforeSpecificTransforms
            GL.glLoadMatrixd(ModelVievMatrixBeforeSpecificTransforms);
            //multiply it by KeyCode defined AccumulatedRotationsTraslations matrix
            GL.glMultMatrixd(AccumulatedRotationsTraslations);


            //REFLECTION//DrawAxes();

            //REFLECTION b
            intOptionB += 1;  //for rotation
            intOptionC += 10; //for rotation
            // without REFLECTION was only DrawAll();
            // now
            //!!!!------sky box
            GL.glPushMatrix();
            GL.glPushAttrib(GL.GL_CURRENT_BIT);
            GL.glColor4f(1.0f, 1.0f, 1.0f, 0.5f);


            GL.glEnable(GL.GL_TEXTURE_2D);
            GL.glDisable(GL.GL_BLEND);
            GL.glRotatef(90, 1, 0, 0);
            DrawTexturedCube();
            GL.glPopAttrib();
            GL.glPopMatrix();
            /////
            GL.glEnable(GL.GL_BLEND);
            GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);


            //only floor, draw only to STENCIL buffer
            GL.glEnable(GL.GL_STENCIL_TEST);
            GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
            GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF); // draw floor always
            GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
            GL.glDisable(GL.GL_DEPTH_TEST);

            DrawFloor3();

            // restore regular settings
            GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
            GL.glEnable(GL.GL_DEPTH_TEST);

            // reflection is drawn only where STENCIL buffer value equal to 1
            GL.glStencilFunc(GL.GL_EQUAL, 1, 0xFFFFFFFF);
            GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);

            GL.glEnable(GL.GL_STENCIL_TEST);

            // draw reflected scene
            GL.glPushMatrix();
            GL.glScalef(1, 1, -1); //swap on Z axis
            GL.glEnable(GL.GL_CULL_FACE);
            GL.glCullFace(GL.GL_BACK);
            DrawFigures();

            GL.glCullFace(GL.GL_FRONT);
            DrawFigures();

            GL.glDisable(GL.GL_CULL_FACE);
            GL.glPopMatrix();

            // really draw floor
            //( half-transparent ( see its color's alpha byte)))
            // in order to see reflected objects
            GL.glDepthMask((byte)GL.GL_FALSE);

            DrawFloor3();

            GL.glDepthMask((byte)GL.GL_TRUE);
            // Disable GL.GL_STENCIL_TEST to show All, else it will be cut on GL.GL_STENCIL
            GL.glDisable(GL.GL_STENCIL_TEST);



            DrawFigures();



            GL.glDisable(GL.GL_TEXTURE_2D);

            GL.glFlush();
            WGL.wglSwapBuffers(m_uint_DC);
        }
Exemple #8
0
        public void Draw()
        {
            float delta = 0;

            double[] ModelViewMatrixBeforeTransforms = new double[16];
            double[] CurrentTraslation = new double[16];

            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                return;
            }

            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);
            GL.glLoadIdentity();

            if (enableLookAtValue)
            {
                GLU.gluLookAt(LookAtNumberValue[0], LookAtNumberValue[1], LookAtNumberValue[2],
                              LookAtNumberValue[3], LookAtNumberValue[4], LookAtNumberValue[5],
                              LookAtNumberValue[6], LookAtNumberValue[7], LookAtNumberValue[8]);
            }

            GL.glTranslatef(0.0f, 0.0f, -20.0f);

            if (enableRotate)
            {
                GL.glRotatef(viewAngle, 0.0f, 1.0f, 0.0f);
                viewAngle -= 2f;
            }

            DrawRoom();
            DrawOldAxes();
            DrawLightSource();

            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelViewMatrixBeforeTransforms);
            GL.glLoadIdentity();

            if (coordSysMoveDirection != 0)
            {
                delta = 5.0f * Math.Abs(coordSysMoveDirection) / coordSysMoveDirection;

                switch (Math.Abs(coordSysMoveDirection))
                {
                case 1:
                    GL.glTranslatef(delta / 20, 0, 0);
                    break;

                case 2:
                    GL.glTranslatef(0, delta / 20, 0);
                    break;

                case 3:
                    GL.glTranslatef(0, 0, delta / 20);
                    break;

                case 4:
                    GL.glRotatef(delta, 1, 0, 0);
                    break;

                case 5:
                    GL.glRotatef(delta, 0, 1, 0);
                    break;

                case 6:
                    GL.glRotatef(delta, 0, 0, 1);
                    break;
                }
            }

            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, CurrentTraslation);
            GL.glLoadMatrixd(AccumulatedTraslations);
            GL.glMultMatrixd(CurrentTraslation);
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, AccumulatedTraslations);
            GL.glLoadMatrixd(ModelViewMatrixBeforeTransforms);
            GL.glMultMatrixd(AccumulatedTraslations);

            DrawAxes();
            GL.glCallList(handList);

            if (enableReflection)
            {
                GL.glEnable(GL.GL_BLEND);
                GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
                GL.glEnable(GL.GL_STENCIL_TEST);
                GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
                GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF);
                GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
                GL.glDisable(GL.GL_DEPTH_TEST);

                //DrawFloor();
                GL.glCallList(floorMainList);

                GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
                GL.glEnable(GL.GL_DEPTH_TEST);
                GL.glStencilFunc(GL.GL_EQUAL, 1, 0xFFFFFFFF);
                GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);
                GL.glEnable(GL.GL_STENCIL_TEST);
                GL.glPushMatrix();
                GL.glScalef(1, -1, 1);
                GL.glEnable(GL.GL_CULL_FACE);
                GL.glCullFace(GL.GL_BACK);

                GL.glTranslated(0, 3, 0);
                DrawFigures();

                GL.glCullFace(GL.GL_FRONT);

                DrawFigures();

                GL.glDisable(GL.GL_CULL_FACE);
                GL.glPopMatrix();
                GL.glDepthMask((byte)GL.GL_FALSE);

                //DrawFloor();
                GL.glCallList(floorMainList);

                GL.glDepthMask((byte)GL.GL_TRUE);
                GL.glDisable(GL.GL_STENCIL_TEST);
            }

            GL.glFlush();
            WGL.wglSwapBuffers(m_uint_DC);
        }
        public void Draw()
        {
            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                return;
            }

            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);

            //TRIVIAL
            GL.glViewport(0, 0, Width, Height);
            GL.glLoadIdentity();
            GL.glEnable(GL.GL_NORMALIZE);

            GLU.gluLookAt(ScrollValue[0], ScrollValue[1], ScrollValue[2],
                          ScrollValue[3], ScrollValue[4], ScrollValue[5],
                          ScrollValue[6], ScrollValue[7], ScrollValue[8]);



            pos[0] = light_position[0] = ScrollValue[9];
            pos[1] = light_position[1] = ScrollValue[10];
            pos[2] = light_position[2] = ScrollValue[11];
            pos[3] = light_position[3] = 0;

            light_position_reflected[0] = -ScrollValue[9];
            light_position_reflected[1] = -ScrollValue[10];
            light_position_reflected[2] = -ScrollValue[11];
            light_position[3]           = 0;

            GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position);
            GL.glEnable(GL.GL_LIGHT0);

            GL.glLightfv(GL.GL_LIGHT1, GL.GL_POSITION, light_position);
            GL.glEnable(GL.GL_LIGHT1);

            //beascender look angle
            GL.glTranslatef(0.0f, -50.0f, -340.0f); //how far from the lake
            GL.glTranslatef(0.0f, 1.0f, 0.0f);      //height from the lake
            GL.glRotatef(25, 1.0f, 0, 0);           //look at lake angle

            GL.glRotatef(xAngle, 1.0f, 0.0f, 0.0f);
            if (checkBox)
            {
                GL.glRotatef((float)spirala * 0.018f, 0.0f, 1.0f, 0.0f);
                GL.glRotatef((float)speed * 0.008f, 1.0f, 1.0f, 0.0f);
                GL.glRotatef((float)speed * 0.008f, 0.0f, 1.0f, 1.0f);
                GL.glRotatef((float)speed * -0.005f, 1.0f, 0.0f, 1.0f);
            }
            GL.glRotatef(yAngle, 0.0f, 1.0f, 0.0f);
            GL.glRotatef(zAngle, 0.0f, 0.0f, 1.0f);
            if (checkBox)
            {
                GL.glTranslatef(xShift, yShift + (float)-speed * 0.18f, zShift);
            }
            GL.glTranslatef(xShift, yShift, zShift);



            /*
             *
             * Reflection drawing area start here
             *
             */

            GL.glPushMatrix();

            GL.glEnable(GL.GL_BLEND);
            GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);

            //draw only to STENCIL buffer
            GL.glEnable(GL.GL_STENCIL_TEST);
            GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
            GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF);
            GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
            GL.glDisable(GL.GL_DEPTH_TEST);

            Drawlake();//Draw area when we want to see reflect

            // restore regular seascendings
            GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
            GL.glEnable(GL.GL_DEPTH_TEST);

            // reflection is drawn only where STENCIL buffer value equal to 1
            GL.glStencilFunc(GL.GL_EQUAL, 1, 0xFFFFFFFF);
            GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);


            /*
             * draw reflected scene
             */

            GL.glScalef(1, -1, 1); //swap axes down


            GL.glPushMatrix();
            DrawTexturedCube();

            //reflected penguin
            drawPenguin();

            draw_sun();
            draw_moon();
            GL.glPopMatrix();


            GL.glPopMatrix();
            GL.glEnable(GL.GL_LIGHTING);

            Drawlake();

            GL.glDisable(GL.GL_LIGHTING);


            GL.glStencilFunc(GL.GL_NOTEQUAL, 1, 0xFFFFFFFF);
            GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);

            GL.glDepthMask((byte)GL.GL_FALSE);
            GL.glDepthMask((byte)GL.GL_TRUE);

            drawFloorTextured();

            draw_sun();
            draw_moon();


            GL.glDisable(GL.GL_STENCIL_TEST);

            DrawTexturedCube();    //SKY BOX



            /*
             *
             * paint main scene area - start here
             *
             */

            // drawaxe();



            GL.glShadeModel(GL.GL_FLAT);

            GL.glEnable(GL.GL_LIGHTING);

            //Main Penguin
            drawPenguin();



            /////////

            GL.glDisable(GL.GL_LIGHTING);



            /*
             *
             * Draw shadows area - start here
             *
             */
            GL.glDisable(GL.GL_LIGHTING);


            GL.glPushMatrix();

            MakeShadowMatrix(ground);  //sending fround matrix
            GL.glMultMatrixf(cubeXform);

            GL.glShadeModel(GL.GL_FLAT);
            GL.glColor3d(0, 0, 0);//black

            drawPenguinShade();

            GL.glPopMatrix();



            GL.glFlush();
            WGL.wglSwapBuffers(m_uint_DC);
        }
Exemple #10
0
        public void Draw()
        {
            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                return;
            }

            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);

            GL.glLoadIdentity();

            if (Weaponchanged)
            {
                //if WeaponIndex changed create lists again!
                Robot.PrepareAndDraw();
                Robot.PrepareAndDrawShadow();
                Weaponchanged = false;
            }

            GLU.gluLookAt(ScrollValue[0], ScrollValue[1], ScrollValue[2],
                          ScrollValue[3], ScrollValue[4], ScrollValue[5],
                          ScrollValue[6], ScrollValue[7], ScrollValue[8]);

            #region Mouse Control
            GL.glTranslatef(-X, -Y, -Z);
            GL.glRotatef(rotX, 1.0f, 0.0f, 0.0f);
            GL.glRotatef(rotY, 0.0f, 1.0f, 0.0f);
            GL.glRotatef(rotZ, 0.0f, 0.0f, 1.0f);
            #endregion


            //move camera to initial position - center of cube and above floor
            GL.glTranslatef(0.0f, 0.0f, -1.0f);
            GL.glTranslatef(0.0f, 5.0f, 0.0f);
            GL.glRotatef(-90.0f, 0.0f, 1.0f, 0.0f);


            //update light position
            LightPosition[0] = ScrollValue[10];
            LightPosition[1] = ScrollValue[11];
            LightPosition[2] = ScrollValue[12];
            LightPosition[3] = 1.0f;

            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
            GL.glLoadIdentity(); // make it identity matrix

            MoveRobotByDirection();

            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, CurrentRotationTraslation);
            GL.glLoadMatrixd(AccumulatedRotationsTraslations); //Global Matrix
            GL.glMultMatrixd(CurrentRotationTraslation);
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, AccumulatedRotationsTraslations);
            GL.glLoadMatrixd(ModelVievMatrixBeforeSpecificTransforms);
            GL.glMultMatrixd(AccumulatedRotationsTraslations);


            //draw actual cube
            cube.Scale(xMaxOfCube, yMaxOfCube, zMaxOfCube);
            cube.Draw(1);

            GL.glRotatef(180, 0, 1, 0);
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);

            GL.glPushMatrix();
            GL.glLoadIdentity();
            GL.glLoadMatrixd(ModelVievMatrixBeforeSpecificTransforms);
            GL.glMultMatrixd(AccumulatedRotationsTraslations);


            //!!!!!!!!!!! draw orginal Robot
            GL.glPushMatrix();
            RotateRobotByDirection();
            GL.glCullFace(GL.GL_BACK);
            GL.glDisable(GL.GL_CULL_FACE);
            GL.glEnable(GL.GL_LIGHTING);
            GL.glRotatef(-Robot.WalkAngle, 0, 1, 0);
            Robot.Draw(false);
            GL.glPopMatrix();


            GL.glLoadMatrixd(AccumulatedRotationsTraslations); //Global Matrix

            RobotPlace[0]        = AccumulatedRotationsTraslations[12];
            RobotPlaceForward[0] = RobotPlaceBackward[0] = RobotPlaceRight[0] = RobotPlaceLeft[0] = AccumulatedRotationsTraslations[12];
            RobotPlace[1]        = AccumulatedRotationsTraslations[14];
            RobotPlaceForward[1] = RobotPlaceBackward[1] = RobotPlaceRight[1] = RobotPlaceLeft[1] = AccumulatedRotationsTraslations[14];

            switch (WhatWillDirection)
            {
            case arrow.forward:
                //Look future to get wallk forward
                RobotPlaceForward = WillPlace(2.1f, 0, 0);
                break;

            case arrow.backward:
                //Look future to get wallk backward
                RobotPlaceBackward = WillPlace(-2.1f, 0, 0);
                break;

            case arrow.right:
                //Look future to get wallk right
                RobotPlaceRight = WillPlace(0, 0, 2.1f);
                break;

            case arrow.left:
                //Look future to get wallk left
                RobotPlaceLeft = WillPlace(0, 0, -2.1f);
                break;
            }

            if (((RobotPlace[0] < ((car.Drive % 46) - 23) + 7) && (RobotPlace[0] > ((car.Drive % 46) - 23) - 4)) && //in car length
                RobotPlace[1] > 5 && RobotPlace[1] < 10 && !Robot.IsJumping)     //in car width & not jumping
            {
                Robot.IsCrashWithCar = true;
            }

            //!!!!!!!!!!!
            GL.glDisable(GL.GL_CULL_FACE);
            GL.glPopMatrix();
            GL.glRotatef(-180, 0, 1, 0);

            #region Reflaction to cube
            StartReflaction(-1, 1, -1);     //Reflaction to cube

            cube.Scale(xMaxOfCube - 0.002f, yMaxOfCube - 0.002f, zMaxOfCube - 0.002f);
            cube.Draw(-1);       //decrease 0.002 from each dimension of cube to avoid unexpected lines and -1 for mirrow efect
            GL.glDisable(GL.GL_CULL_FACE);
            GL.glPopMatrix();
            #endregion

            // really draw mirror
            //( half-transparent ( see its color's alpha byte)))
            // in order to see reflected objects
            //GL.glPushMatrix();
            //GL.glTranslatef(0, -4, 0);
            //GL.glDepthMask((byte)GL.GL_FALSE);
            //GL.glRotatef(90,0,1,0);
            //DrawMirror();
            //GL.glDepthMask((byte)GL.GL_TRUE);
            //GL.glPopMatrix();

            GL.glScalef(-1, 1, 1);//Some rotation for normal Cube direction
            GL.glRotatef(180, 0, 1, 0);

            #region Reflaction to Robot
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
            StartReflaction(-1, 1, 1);  //Start Reflaction to Robot
            GL.glLoadIdentity();
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, CurrentRotationTraslation);
            GL.glLoadMatrixd(AccumulatedRotationsTraslations);
            GL.glMultMatrixd(CurrentRotationTraslation);
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, AccumulatedRotationsTraslations);
            GL.glLoadMatrixd(ModelVievMatrixBeforeSpecificTransforms);
            GL.glMultMatrixd(AccumulatedRotationsTraslations);



            //draw reflected Robot
            GL.glPushMatrix();
            RotateRobotByDirection();
            GL.glCullFace(GL.GL_BACK);
            GL.glCullFace(GL.GL_FRONT);
            GL.glDisable(GL.GL_CULL_FACE);
            GL.glRotatef(-Robot.WalkAngle, 0, 1, 0);
            Robot.Draw(false);
            GL.glPopMatrix();
            GL.glDisable(GL.GL_CULL_FACE);
            GL.glPopMatrix();


            //draw all Robot shadows in the mirror!!
            MakeShadow(ModelVievMatrixBeforeSpecificTransforms, CurrentRotationTraslation);
            DrawLight();   //draw reflected light
            GL.glDisable(GL.GL_STENCIL_TEST);
            #endregion

            GL.glScalef(1, 1, -1);                                                          //Some rotation for normal Cube direction
            GL.glRotatef(180, 0, 1, 0);
            DrawLight();                                                                    //draw actual light
            MakeShadow(ModelVievMatrixBeforeSpecificTransforms, CurrentRotationTraslation); //draw all Robot shadows


            car.Drive += 0.5f;    //for animation of car moving

            //draw car reflection
            StartReflaction(-1, 1, 1);
            car.Draw(false);

            //draw car reflection shadow on floor
            StartReflaction(-1, 1, 1);
            GL.glDisable(GL.GL_LIGHTING);
            GL.glPushMatrix();
            MakeShadowMatrix(floorCoordForShadow);
            GL.glMultMatrixf(cubeXform);
            car.Draw(true);
            GL.glPopMatrix();

            //draw car reflection shadow on back wall
            StartReflaction(-1, 1, 1);
            GL.glDisable(GL.GL_LIGHTING);
            GL.glPushMatrix();
            MakeShadowMatrix(backWallCoordForShadow);
            GL.glMultMatrixf(cubeXform);
            car.Draw(true);
            GL.glPopMatrix();

            //draw car reflection shadow on front wall
            StartReflaction(-1, 1, 1);
            GL.glDisable(GL.GL_LIGHTING);
            GL.glPushMatrix();
            MakeShadowMatrix(frontWallCoordForShadow);
            GL.glMultMatrixf(cubeXform);
            car.Draw(true);
            GL.glPopMatrix();
            GL.glDisable(GL.GL_STENCIL_TEST);

            //draw the Frame of mirror
            mirror.DrawFrame();

            //draw mirror again to cover car from being shown on the other side of mirror
            GL.glPushMatrix();
            GL.glTranslatef(0, -4, 0);
            GL.glRotatef(90, 0, 1, 0);
            mirror.Draw();
            GL.glPopMatrix();

            //draw car
            car.Draw(false);

            //draw shadow car on floor
            GL.glPushMatrix();
            MakeShadowMatrix(floorCoordForShadow);
            GL.glMultMatrixf(cubeXform);
            car.Draw(true);
            GL.glPopMatrix();

            //draw shadow car on back wall
            GL.glPushMatrix();
            MakeShadowMatrix(backWallCoordForShadow);
            GL.glMultMatrixf(cubeXform);
            car.Draw(true);
            GL.glPopMatrix();

            //draw shadow car on front wall
            GL.glPushMatrix();
            MakeShadowMatrix(frontWallCoordForShadow);
            GL.glMultMatrixf(cubeXform);
            car.Draw(true);
            GL.glPopMatrix();


            GL.glFlush();
            WGL.wglSwapBuffers(m_uint_DC);
        }
Exemple #11
0
        public void Draw()
        {
            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);
            GL.glMatrixMode(GL.GL_MODELVIEW);
            GL.glLoadIdentity();

            GL.glTranslatef(0.0f, -1.5f, -6.0f);
            GL.glRotatef(10, 1.0f, 0.0f, 0.0f);
            GL.glRotatef(-tank.rotation, 0.0f, 1.0f, 0.0f);
            GL.glRotatef(-tank.turretRotation, 0.0f, 1.0f, 0.0f);
            GL.glTranslatef(-tank.posX, 0.0f, -tank.posZ);

            //DrawAxes();
            DrawAll();

            //target
            target.Drawself();

            //LIGHT - before transforms
            //  hence it is in const position
            GL.glPushMatrix();
            GL.glEnable(GL.GL_LIGHTING);
            GL.glEnable(GL.GL_LIGHT0);
            GL.glTranslatef(0, 11, -35);
            float[] ambient = { 0, 0, 0.3f, 1 };
            if (tank.TankType == 2)
            {
                ambient[2] = 0.2f;
            }
            else
            {
                ambient[0] = 0.2f;
            }
            float[] diffuse  = { 1, 1, 1, 1 };
            float[] specular = { 0.5f, 0.5f, 0.5f, 1f };
            float[] pos      = { 0, 1f, -0.5f, 0 };
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, ambient);
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, diffuse);
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, specular);
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, pos);

            GL.glColor3f(1, 1, 0);
            GL.glDisable(GL.GL_LIGHTING);
            GLU.gluSphere(obj, 1, 12, 12);    //SUN
            GL.glEnable(GL.GL_LIGHTING);
            GL.glPopMatrix();

            if (!stelthmode)
            {
                GL.glEnable(GL.GL_BLEND);
                GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
                GL.glEnable(GL.GL_STENCIL_TEST);
                GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
                GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF); // draw floor always
                GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
                GL.glDisable(GL.GL_DEPTH_TEST);
                DrawMirror(false);
                // restore regular settings
                GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
                GL.glEnable(GL.GL_DEPTH_TEST);

                // reflection is drawn only where STENCIL buffer value equal to 1
                GL.glStencilFunc(GL.GL_EQUAL, 1, 0xFFFFFFFF);
                GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);

                GL.glEnable(GL.GL_STENCIL_TEST);
                // draw reflected scene
                GL.glPushMatrix();
                GL.glScalef(-1, 1, 1); //swap on Z axis
                GL.glEnable(GL.GL_CULL_FACE);
                GL.glCullFace(GL.GL_BACK);
                tank.drawSelf();
                DrawBullets();
                GL.glCullFace(GL.GL_FRONT);
                tank.drawSelf();
                DrawBullets();
                GL.glDisable(GL.GL_CULL_FACE);
                GL.glPopMatrix();

                GL.glDepthMask((byte)GL.GL_FALSE);
                DrawMirror(false);
                GL.glDepthMask((byte)GL.GL_TRUE);
                // Disable GL.GL_STENCIL_TEST to show All, else it will be cut on GL.GL_STENCIL
                GL.glDisable(GL.GL_STENCIL_TEST);
            }
            else
            {
                GL.glEnable(GL.GL_BLEND);
                GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
                GL.glEnable(GL.GL_STENCIL_TEST);
                GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
                GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF); // draw floor always
                GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
                GL.glDisable(GL.GL_DEPTH_TEST);
                DrawMirror(false);
                // restore regular settings
                GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
                GL.glEnable(GL.GL_DEPTH_TEST);

                // reflection is drawn only where STENCIL buffer value equal to 1
                GL.glStencilFunc(GL.GL_EQUAL, 1, 0xFFFFFFFF);
                GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);

                GL.glEnable(GL.GL_STENCIL_TEST);
                // draw reflected scene
                GL.glPushMatrix();
                GL.glScalef(-1, 1, 1); //swap on Z axis
                GL.glEnable(GL.GL_CULL_FACE);
                GL.glCullFace(GL.GL_BACK);
                DrawBullets();
                GL.glCullFace(GL.GL_FRONT);
                DrawBullets();
                GL.glDisable(GL.GL_CULL_FACE);
                GL.glPopMatrix();

                GL.glDepthMask((byte)GL.GL_FALSE);
                DrawMirror(false);
                GL.glDepthMask((byte)GL.GL_TRUE);
                // Disable GL.GL_STENCIL_TEST to show All, else it will be cut on GL.GL_STENCIL
                GL.glDisable(GL.GL_STENCIL_TEST);
            }

            if (!stelthmode)
            {
                tank.drawSelf();
            }
            else
            {
                tank.drawstelth();
            }

            DrawMirror(true);
            DrawBullets();
            //REFLECTION e

            update();
            WGL.wglSwapBuffers(m_uint_DC);
        }
Exemple #12
0
        public void Draw()
        {
            //Shadows
            pos[0] = 0;//ScrollValue[9];
            pos[1] = ScrollValue[8];
            pos[2] = ScrollValue[7];
            pos[3] = ScrollValue[9];


            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                return;
            }

            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

            GL.glLoadIdentity();



            // not trivial
            double[] ModelVievMatrixBeforeSpecificTransforms = new double[16];
            double[] CurrentRotationTraslation = new double[16];

            GLU.gluLookAt(ScrollValue[0], ScrollValue[1], ScrollValue[2],
                          ScrollValue[3], ScrollValue[4], ScrollValue[5],
                          ScrollValue[6], ScrollValue[7], ScrollValue[8]);
            GL.glTranslatef(0.0f, 0.0f, -1.0f);


            if (!bPerspective)
            {
                GL.glTranslatef(0.0f, 0.0f, 8.0f);
            }



            //3D model b3
            GL.glTranslatef(0.0f, -5.0f, -15.0f);
            GL.glRotated(180, 0, 1, 0);
            //3D model e



            //save current ModelView Matrix values
            //in ModelVievMatrixBeforeSpecificTransforms array
            //ModelView Matrix ========>>>>>> ModelVievMatrixBeforeSpecificTransforms
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
            //ModelView Matrix was saved, so
            //  GL.glLoadIdentity(); // make it identity matrix
            GL.glLoadIdentity(); // make it identity matrix

            //make transformation in accordance to KeyCode
            float delta;

            if (intOptionC != 0)
            {
                delta = 5.0f * Math.Abs(intOptionC) / intOptionC; // signed 5

                switch (Math.Abs(intOptionC))
                {
                case 1:
                    GL.glRotatef(delta, 1, 0, 0);
                    break;

                case 2:
                    GL.glRotatef(delta, 0, 1, 0);
                    break;

                case 3:
                    GL.glRotatef(delta, 0, 0, 1);
                    break;

                case 4:
                    GL.glTranslatef(delta / 20, 0, 0);
                    break;

                case 5:
                    GL.glTranslatef(0, delta / 20, 0);
                    break;

                case 6:
                    GL.glTranslatef(0, 0, delta / 20);
                    break;
                }
            }
            //as result - the ModelView Matrix now is pure representation
            //of KeyCode transform and only it !!!

            //save current ModelView Matrix values
            //in CurrentRotationTraslation array
            //ModelView Matrix =======>>>>>>> CurrentRotationTraslation
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, CurrentRotationTraslation);

            //The GL.glLoadMatrix function replaces the current matrix with
            //the one specified in its argument.
            //The current matrix is the
            //projection matrix, modelview matrix, or texture matrix,
            //determined by the current matrix mode (now is ModelView mode)
            GL.glLoadMatrixd(AccumulatedRotationsTraslations); //Global Matrix

            //The GL.glMultMatrix function multiplies the current matrix by
            //the one specified in its argument.
            //That is, if M is the current matrix and T is the matrix passed to
            //GL.glMultMatrix, then M is replaced with M • T
            GL.glMultMatrixd(CurrentRotationTraslation);

            //save the matrix product in AccumulatedRotationsTraslations
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, AccumulatedRotationsTraslations);

            //replace ModelViev Matrix with stored ModelVievMatrixBeforeSpecificTransforms
            GL.glLoadMatrixd(ModelVievMatrixBeforeSpecificTransforms);
            //multiply it by KeyCode defined AccumulatedRotationsTraslations matrix
            GL.glMultMatrixd(AccumulatedRotationsTraslations);

            GL.glEnable(GL.GL_TEXTURE_2D);


            if (!rotate)
            {
                GL.glRotatef(0, 0, 20, 0);
                GL.glDepthRange(1, 1);////////if the zebra behind the cube, change to (1,1)
                GL.glPushMatrix();

                DrawTexturedCube();

                GL.glPopMatrix();
            }
            else
            {
                GL.glRotatef(0, 0, 20, 0);
                GL.glDepthRange(1, 1);
                GL.glPushMatrix();
                angle -= 0.1f;
                GL.glRotatef(angle, 0, 2, 0);
                DrawTexturedCube();

                GL.glPopMatrix();
            }


            GL.glRotated(100, 0, 90, 0);
            GL.glScaled(0.05, 0.05, 0.05);



            GL.glRotated(-90, 180, 0, 0);
            GL.glScaled(30, 30, 30);

            DrawFigures();


            GL.glEnable(GL.GL_BLEND);
            GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);


            //only floor, draw only to STENCIL buffer
            GL.glEnable(GL.GL_STENCIL_TEST);
            GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
            GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF); // draw floor always
            GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
            GL.glDisable(GL.GL_DEPTH_TEST);


            // restore regular settings
            GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
            GL.glEnable(GL.GL_DEPTH_TEST);


            GL.glEnable(GL.GL_STENCIL_TEST);

            // draw reflected scene
            GL.glPushMatrix();
            GL.glScalef(1, 1, -1); //swap on Z axis
            GL.glEnable(GL.GL_CULL_FACE);
            GL.glCullFace(GL.GL_BACK);
            DrawFigures();
            GL.glCullFace(GL.GL_FRONT);
            DrawFigures();
            GL.glDisable(GL.GL_CULL_FACE);
            GL.glPopMatrix();


            // really draw floor
            //( half-transparent ( see its color's alpha byte)))
            // in order to see reflected objects
            GL.glDepthMask((byte)GL.GL_FALSE);
            DrawFloor();
            GL.glDepthMask((byte)GL.GL_TRUE);
            // Disable GL.GL_STENCIL_TEST to show All, else it will be cut on GL.GL_STENCIL
            GL.glDisable(GL.GL_STENCIL_TEST);
            DrawFigures();
            //REFLECTION e
            GL.glFlush();

            WGL.wglSwapBuffers(m_uint_DC);
        }
        public void Draw()
        {
            //Light position for shadows
            MainLightSource.X = ScrollValue[10];
            MainLightSource.Y = ScrollValue[11];
            MainLightSource.Z = ScrollValue[12];
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, MainLightSource.LightLocation());
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, new float[] { 0f, 0f, 0f, 1f });
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, new float[] { 1f, 1f, 1f });
            GL.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, new float[] { 0.628281f, 0.555802f, 0.366065f });

            GL.glLightfv(GL.GL_LIGHT2, GL.GL_POSITION, StaticRedLightSource.LightLocation());
            GL.glLightfv(GL.GL_LIGHT2, GL.GL_AMBIENT, new float[] { 0f, 0f, 0f, 1f });
            GL.glLightfv(GL.GL_LIGHT2, GL.GL_DIFFUSE, new float[] { 1f, 0f, 0f });
            GL.glLightfv(GL.GL_LIGHT2, GL.GL_SPECULAR, new float[] { 0.628281f, 0.555802f, 0.366065f });

            GL.glLightfv(GL.GL_LIGHT3, GL.GL_POSITION, StaticBlueLightSource.LightLocation());
            GL.glLightfv(GL.GL_LIGHT3, GL.GL_AMBIENT, new float[] { 0f, 0f, 0f, 1f });
            GL.glLightfv(GL.GL_LIGHT3, GL.GL_DIFFUSE, new float[] { 0f, 0f, 1f });
            GL.glLightfv(GL.GL_LIGHT3, GL.GL_SPECULAR, new float[] { 0.628281f, 0.555802f, 0.366065f });

            //GL.glLightfv(GL.GL_LIGHT1, GL.GL_POSITION, bannerLightPos);
            if (m_DeviceContext == 0 || m_RenderingContext == 0)
            {
                return;
            }

            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

            GL.glLoadIdentity();

            // not trivial
            double[] ModelVievMatrixBeforeSpecificTransforms = new double[16];
            double[] CurrentRotationTraslation = new double[16];

            GLU.gluLookAt(ScrollValue[0], ScrollValue[1], ScrollValue[2],
                          ScrollValue[3], ScrollValue[4], ScrollValue[5],
                          ScrollValue[6], ScrollValue[7], ScrollValue[8]);
            GL.glTranslatef(0.0f, 0.0f, -3.0f);

            DrawOldAxes();

            //save current ModelView Matrix values
            //in ModelVievMatrixBeforeSpecificTransforms array
            //ModelView Matrix ========>>>>>> ModelVievMatrixBeforeSpecificTransforms
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
            //ModelView Matrix was saved, so
            GL.glLoadIdentity(); // make it identity matrix

            //make transformation in accordance to KeyCode
            float delta;

            if (intOptionC != 0)
            {
                delta = 3.0f * Math.Abs(intOptionC) / intOptionC; // signed 5

                switch (Math.Abs(intOptionC))
                {
                case 1:
                    GL.glRotatef(delta, 1, 0, 0);
                    break;

                case 2:
                    GL.glRotatef(delta, 0, 1, 0);
                    break;

                case 3:
                    GL.glRotatef(delta, 0, 0, 1);
                    break;

                case 4:
                    GL.glTranslatef(delta / 20, 0, 0);
                    break;

                case 5:
                    GL.glTranslatef(0, delta / 20, 0);
                    break;

                case 6:
                    GL.glTranslatef(0, 0, delta / 20);
                    break;
                }
            }
            //as result - the ModelView Matrix now is pure representation
            //of KeyCode transform and only it !!!

            //save current ModelView Matrix values
            //in CurrentRotationTraslation array
            //ModelView Matrix =======>>>>>>> CurrentRotationTraslation
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, CurrentRotationTraslation);

            //The GL.glLoadMatrix function replaces the current matrix with
            //the one specified in its argument.
            //The current matrix is the
            //projection matrix, modelview matrix, or texture matrix,
            //determined by the current matrix mode (now is ModelView mode)
            GL.glLoadMatrixd(AccumulatedRotationsTraslations); //Global Matrix

            //The GL.glMultMatrix function multiplies the current matrix by
            //the one specified in its argument.
            //That is, if M is the current matrix and T is the matrix passed to
            //GL.glMultMatrix, then M is replaced with M • T
            GL.glMultMatrixd(CurrentRotationTraslation);

            //save the matrix product in AccumulatedRotationsTraslations
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, AccumulatedRotationsTraslations);

            //replace ModelViev Matrix with stored ModelVievMatrixBeforeSpecificTransforms
            GL.glLoadMatrixd(ModelVievMatrixBeforeSpecificTransforms);
            //multiply it by KeyCode defined AccumulatedRotationsTraslations matrix
            GL.glMultMatrixd(AccumulatedRotationsTraslations);
            GL.glPushMatrix();             // save the current matrix
            GL.glScalef(zoom, zoom, zoom); // scale the matrix
            DrawAxes();
            DrawFigures();
            GL.glPopMatrix(); // load the unscaled matrix
            GL.glFlush();

            WGL.wglSwapBuffers(m_DeviceContext);
        }
Exemple #14
0
        public void Draw()
        {
            if (m_uint_DC == 0 || m_uint_RC == 0)
            {
                return;
            }

            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

            GL.glLoadIdentity();

            // not trivial
            double [] ModelVievMatrixBeforeSpecificTransforms = new double[16];
            double [] CurrentRotationTraslation = new double[16];

            GLU.gluLookAt(ScrollValue[0], ScrollValue[1], ScrollValue[2],
                          ScrollValue[3], ScrollValue[4], ScrollValue[5],
                          ScrollValue[6], ScrollValue[7], ScrollValue[8]);
            GL.glTranslatef(0.0f, 0.0f, -1.0f);

            DrawOldAxes();

            //save current ModelView Matrix values
            //in ModelVievMatrixBeforeSpecificTransforms array
            //ModelView Matrix ========>>>>>> ModelVievMatrixBeforeSpecificTransforms
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
            //ModelView Matrix was saved, so
            GL.glLoadIdentity(); // make it identity matrix

            //make transformation in accordance to KeyCode
            float delta;

            if (intOptionC != 0)
            {
                delta = 5.0f * Math.Abs(intOptionC) / intOptionC; // signed 5

                switch (Math.Abs(intOptionC))
                {
                case 1:
                    GL.glRotatef(delta, 1, 0, 0);
                    break;

                case 2:
                    GL.glRotatef(delta, 0, 1, 0);
                    break;

                case 3:
                    GL.glRotatef(delta, 0, 0, 1);
                    break;

                case 4:
                    GL.glTranslatef(delta / 20, 0, 0);
                    break;

                case 5:
                    GL.glTranslatef(0, delta / 20, 0);
                    break;

                case 6:
                    GL.glTranslatef(0, 0, delta / 20);
                    break;
                }
            }
            //as result - the ModelView Matrix now is pure representation
            //of KeyCode transform and only it !!!

            //save current ModelView Matrix values
            //in CurrentRotationTraslation array
            //ModelView Matrix =======>>>>>>> CurrentRotationTraslation
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, CurrentRotationTraslation);

            //The GL.glLoadMatrix function replaces the current matrix with
            //the one specified in its argument.
            //The current matrix is the
            //projection matrix, modelview matrix, or texture matrix,
            //determined by the current matrix mode (now is ModelView mode)
            GL.glLoadMatrixd(AccumulatedRotationsTraslations); //Global Matrix

            //The GL.glMultMatrix function multiplies the current matrix by
            //the one specified in its argument.
            //That is, if M is the current matrix and T is the matrix passed to
            //GL.glMultMatrix, then M is replaced with M • T
            GL.glMultMatrixd(CurrentRotationTraslation);

            //save the matrix product in AccumulatedRotationsTraslations
            GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, AccumulatedRotationsTraslations);

            //replace ModelViev Matrix with stored ModelVievMatrixBeforeSpecificTransforms
            GL.glLoadMatrixd(ModelVievMatrixBeforeSpecificTransforms);
            //multiply it by KeyCode defined AccumulatedRotationsTraslations matrix
            GL.glMultMatrixd(AccumulatedRotationsTraslations);

            DrawAxes();

            DrawFigures();

            GL.glFlush();

            WGL.wglSwapBuffers(m_uint_DC);
        }