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(); }
void StartReflaction(int x, int y, int z) { 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); GL.glPushMatrix(); GL.glRotated(90, 0, 1, 0); GL.glTranslatef(0, -4, 0); mirror.Draw(); GL.glPopMatrix(); 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(x, y, z); //swap on Z axis }
public void Scale(float x, float y, float z) { if (!isMatrixPushed) { GL.glPushMatrix(); isMatrixPushed = true; } GL.glScalef(x, y, z); }
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(); }
void FractalTreeRec(int level) { if (level == size) { GL.glPushMatrix(); GL.glRotated(rand.NextDouble() * 180, 0, 1, 0); GL.glCallList(STEM_AND_LEAVS_LIST + currentTree); for (int i = applesRate; i > 0; i--) { if (rand.Next(1, 3) == 1) { GL.glPushMatrix(); GL.glTranslatef(0, (float)1 / i, 0); GL.glCallList(APPLE_MAT); GL.glCallList(APPLE_LIST); GL.glCallList(TREE_MAT); GL.glPopMatrix(); } } GL.glPopMatrix(); } else { GL.glCallList(STEM_LIST + currentTree); GL.glPushMatrix(); GL.glRotated(rand.NextDouble() * 180, 0, 1, 0); GL.glTranslatef(0, 1 + size / 10, 0); GL.glScalef(0.7f, 0.7f, 0.7f); GL.glPushMatrix(); GL.glRotated(110 + rand.NextDouble() * 40, 0, 1, 0); GL.glRotated(30 + rand.NextDouble() * 20, 0, 0, 1); FractalTreeRec(level + 1); GL.glPopMatrix(); GL.glPushMatrix(); GL.glRotated(-130 + rand.NextDouble() * 40, 0, 1, 0); GL.glRotated(30 + rand.NextDouble() * 20, 0, 0, 1); FractalTreeRec(level + 1); GL.glPopMatrix(); GL.glPushMatrix(); GL.glRotated(-20 + rand.NextDouble() * 40, 0, 1, 0); GL.glRotated(30 + rand.NextDouble() * 20, 0, 0, 1); FractalTreeRec(level + 1); GL.glPopMatrix(); GL.glPopMatrix(); } }
private void DrawAll() { 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); DrawSea(); // 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.glEnable(GL.GL_CULL_FACE); GL.glScalef(1, 1, -1); //swap on Z axis GL.glCullFace(GL.GL_FRONT); DrawReflected(); GL.glCullFace(GL.GL_BACK); DrawReflected(); 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); DrawSea(); 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); DrawReflected(); }
void DrawBounds() { if (isBounds) { GL.glScalef(0.99f, 0.99f, 0.99f); GL.glLineWidth(2); GL.glColor3f(1.0f, 0.0f, 0.0f); GL.glDisable(GL.GL_LIGHTING); GL.glBegin(GL.GL_LINE_LOOP); GL.glVertex3f(-1, -1, -1); GL.glVertex3f(1, -1, -1); GL.glVertex3f(1, -1, 1); GL.glVertex3f(-1, -1, 1); GL.glEnd(); GL.glBegin(GL.GL_LINE_LOOP); GL.glVertex3f(-1, 1, -1); GL.glVertex3f(1, 1, -1); GL.glVertex3f(1, 1, 1); GL.glVertex3f(-1, 1, 1); GL.glEnd(); GL.glBegin(GL.GL_LINES); GL.glVertex3f(-1, -1, -1); GL.glVertex3f(-1, 1, -1); GL.glVertex3f(1, -1, -1); GL.glVertex3f(1, 1, -1); GL.glVertex3f(1, -1, 1); GL.glVertex3f(1, 1, 1); GL.glVertex3f(-1, -1, 1); GL.glVertex3f(-1, 1, 1); GL.glEnd(); GL.glScalef(1.0f / 0.99f, 1.0f / 0.99f, 1.0f / 0.99f); } GL.glEnable(GL.GL_COLOR_MATERIAL); GL.glEnable(GL.GL_LIGHTING); GL.glEnable(GL.GL_LIGHT0); GL.glTranslatef(0.1f, 0.2f, -0.7f); GL.glColor3f(0, 1, 0); GLU.gluSphere(obj, 0.05, 16, 16); GL.glTranslatef(-0.1f, -0.2f, 0.7f); GL.glDisable(GL.GL_LIGHTING); }
public void Draw(bool isForShades) { GL.glPushMatrix(); GL.glScalef(-1, 1, 1); GL.glRotatef(-90, 0, 1, 0); GL.glTranslatef(7, 0, 0); GL.glTranslatef(0, 0, (Drive % 46) - 23); if (!isForShades) { GL.glEnable(GL.GL_LIGHTING); GL.glCallList(CAR); } else { GL.glDisable(GL.GL_LIGHTING); GL.glCallList(CAR_SHADOW); } GL.glPopMatrix(); }
public void DrawShadowLeg(bool side) { GL.glPushMatrix(); if (side == false) { GL.glRotatef(LegLeftUpAngle, 0, 1, 0); } else { GL.glRotatef(LegRightUpAngle, 0, 1, 0); } GLU.gluSphere(obj, radius * 1.7, 20, 20); GL.glCallList(LEG_UP_SHADOW_LIST); if (side == false) { if (WeaponIndex == 1 || WeaponIndex == 2) { GL.glRotatef(LegLeftDownAngle, 0, 1, 0); } else { GL.glScalef(-1, 1, 1); GL.glRotatef(LegLeftDownAngle, 0, 1, 0); GL.glScalef(1, 1, 1); } } else if (WeaponIndex == 1 || WeaponIndex == 2) { GL.glRotatef(LegRightDownAngle, 0, 1, 0); } else { GL.glScalef(-1, 1, 1); GL.glRotatef(LegRightDownAngle, 0, 1, 0); GL.glScalef(1, 1, 1); } GL.glCallList(LEG_DOWN_SHADOW_LIST); GL.glPopMatrix(); }
private void drawGyroPyramid() { GL.glPushMatrix(); GL.glScalef(1.0f, -1.0f, 1.0f); // scale the position to draw the pyramid at vertical inversion drawSquareSurface(PyramidWidth, 0.0f, PyramidDepth, eAxis.Y); GL.glBegin(GL.GL_TRIANGLES); // first x axis GL.glNormal3f(-0.81373f, 0.58124f, 0); GL.glVertex3f(0.0f, 0.0f, 0.0f); GL.glVertex3f(PyramidWidth / 2, PyramidHeight, PyramidDepth / 2); GL.glVertex3f(0.0f, 0.0f, PyramidDepth); // second x axis GL.glNormal3f(0.81373f, 0.58124f, 0); GL.glVertex3f(PyramidWidth, 0.0f, 0.0f); GL.glVertex3f(PyramidWidth / 2, PyramidHeight, PyramidDepth / 2); GL.glVertex3f(PyramidWidth, 0.0f, PyramidDepth); // first Z axis GL.glNormal3f(0, 0.58124f, -0.81373f); GL.glVertex3f(0.0f, 0.0f, 0.0f); GL.glVertex3f(PyramidWidth / 2, PyramidHeight, PyramidDepth / 2); GL.glVertex3f(PyramidWidth, 0.0f, 0.0f); // second Z axis GL.glNormal3f(0, 0.58124f, 0.81373f); GL.glVertex3f(0.0f, 0.0f, PyramidDepth); GL.glVertex3f(PyramidWidth / 2, PyramidHeight, PyramidDepth / 2); GL.glVertex3f(PyramidWidth, 0.0f, PyramidDepth); GL.glEnd(); GL.glPopMatrix(); }
public void DrawFrame() { //draw the Frame of mirror radius = 0.18f; GL.glPushMatrix(); GL.glColor3f(0.3f, 0.1f, 0.0f); GL.glTranslatef(0, -1, 3); GLU.gluSphere(obj, radius, 20, 20); GL.glTranslatef(0, 1, -3); GL.glTranslatef(0, -1, -3f); GLU.gluCylinder(obj, radius, radius, radius * 33, 20, 20); GLU.gluSphere(obj, radius, 20, 20); GL.glTranslatef(0, -5.9f, 0); GLU.gluCylinder(obj, radius, radius, radius * 33, 20, 20); GLU.gluSphere(obj, radius, 20, 20); GL.glRotatef(-90, 1, 0, 0); GLU.gluCylinder(obj, radius, radius, radius * 33, 20, 20); GLU.gluSphere(obj, radius, 20, 20); GL.glScalef(-1, 1, 1); GL.glTranslatef(0, -6, 0); GLU.gluCylinder(obj, radius, radius, radius * 33, 20, 20); GLU.gluSphere(obj, radius, 20, 20); GL.glPopMatrix(); }
public void Draw(bool isForShades) { GL.glPushMatrix(); GL.glTranslatef(0, -7, 0); //adapt Robot size to models GL.glScalef(0.5f, 0.5f, 0.5f); GL.glTranslatef(0, Jump * 1.3f, 0); GL.glRotatef(Angle, 0, 0, 1); GL.glRotatef(AngleCrash / 4, 0, 0, 1); GL.glRotatef(AngleCrash, 1, 0, 0); GL.glRotatef(-AngleCrash * 2, 0, 1, 0); GL.glRotatef(AngleWeapon3, 0, 1, 0); GL.glTranslatef(0, -Jump * 1.3f, 0); //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! GL.glTranslatef(0, 3.7f, 0); if (!isForShades) { GL.glEnable(GL.GL_LIGHTING); GL.glColor3f(0.5f, 0.5f, 0.9f); GL.glCallList(Robot_LIST); } else { GL.glDisable(GL.GL_LIGHTING); GL.glColor3f(0, 0, 0); GL.glCallList(Robot_SHADOW_LIST); } GL.glPopMatrix(); }
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); }
/********************************************************************************************************** * * * * 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); }
void DrawMirrors() { //only wall, draw only to STENCIL buffer GL.glEnable(GL.GL_BLEND); GL.glEnable(GL.GL_STENCIL_TEST); GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE); // change stencil according to the object color GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF); // draw wall 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); // add mirrors for STENCIL buffer backMirrorSurface.Draw(backMinusArray); rightMirrorSurface.Draw(rightMinusArray); leftMirrorSurface.Draw(leftMinusArray); // 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); // keep object origenal color GL.glEnable(GL.GL_STENCIL_TEST); // draw reflected scene for back mirror GL.glPushMatrix(); GL.glScalef(1, 1, -1); //swap on Z axis GL.glTranslated(0, 0, mirrorWidth); rubiksCube.Draw(); GL.glPopMatrix(); // draw reflected left mirror scene for right mirror scene GL.glPushMatrix(); //GL.glScalef(-1, 1, 1); //swap on Z axis GL.glTranslated(mirrorWidth * 2, 0, 0); rubiksCube.Draw(); GL.glPopMatrix(); // draw reflected scene for right mirror GL.glPushMatrix(); GL.glScalef(-1, 1, 1); //swap on X axis GL.glTranslated(-mirrorWidth, 0, 0); leftMirrorSurface.Draw(leftMinusArray); rubiksCube.Draw(); GL.glPopMatrix(); // draw reflected right mirror scene for left mirror scene GL.glPushMatrix(); //GL.glScalef(-1, 1, 1); //swap on Z axis GL.glTranslated(-mirrorWidth * 2, 0, 0); rubiksCube.Draw(); GL.glPopMatrix(); // draw reflected scene for left mirror GL.glPushMatrix(); GL.glScalef(-1, 1, 1); //swap on X axis GL.glTranslated(mirrorWidth, 0, 0); rightMirrorSurface.Draw(rightMinusArray); rubiksCube.Draw(); GL.glPopMatrix(); // really draw wall //( half-transparent ( see its color's alpha byte))) // in order to see reflected objects GL.glDepthMask((byte)GL.GL_FALSE); backMirrorSurface.Draw(backMinusArray); Console.WriteLine((((-1.0 / 15) * (-90 - rightMirrorSurface.AngleY)))); Console.WriteLine(rightMirrorSurface.AngleY); if (ScrollValue[1] < (3 + 5 * ((-1.0 / 15) * (-90 - rightMirrorSurface.AngleY))) && ScrollValue[1] > -(3 + 5 * ((-1.0 / 15) * (-90 - rightMirrorSurface.AngleY)))) // TODO: need to consider with --> cGL.rightMirrorSurface.AngleY >= -90 { rightMirrorSurface.Draw(rightMinusArray); leftMirrorSurface.Draw(leftMinusArray); } else if (ScrollValue[1] < (3 + 5 * ((-1.0 / 15) * (-90 - rightMirrorSurface.AngleY)))) { leftMirrorSurface.DrawAsWall(leftWallColorArray, leftMinusArray); rightMirrorSurface.Draw(rightMinusArray); } else { rightMirrorSurface.DrawAsWall(rightWallColorArray, rightMinusArray); leftMirrorSurface.Draw(leftMinusArray); } 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); // GL.glEnable(GL.GL_DEPTH_TEST); //GL.glDisable(GL.GL_DEPTH_TEST); //GL.glClear(GL.GL_DEPTH_BUFFER_BIT); //GL.glDepthFunc(GL.GL_LESS); //GL.glDepthFunc(GL.GL_GREATER); // GL.glDisable(GL.GL_BLEND); }
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(); }
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(); }
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); }
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); }
private static void DrawTeapot(int grid, double scale, uint type) { float[ , , ] p = new float[4, 4, 3]; float[ , , ] q = new float[4, 4, 3]; float[ , , ] r = new float[4, 4, 3]; float[ , , ] s = new float[4, 4, 3]; long i, j, k, l; GL.glPushAttrib(GL.GL_ENABLE_BIT | GL.GL_EVAL_BIT); GL.glEnable(GL.GL_AUTO_NORMAL); GL.glEnable(GL.GL_NORMALIZE); GL.glEnable(GL.GL_MAP2_VERTEX_3); GL.glEnable(GL.GL_MAP2_TEXTURE_COORD_2); GL.glPushMatrix(); GL.glRotatef(270.0f, 1.0f, 0.0f, 0.0f); GL.glScalef(0.5f * (float)scale, 0.5f * (float)scale, 0.5f * (float)scale); GL.glTranslatef(0.0f, 0.0f, -1.5f); for (i = 0; i < 10; i++) { for (j = 0; j < 4; j++) { for (k = 0; k < 4; k++) { for (l = 0; l < 3; l++) { p[j, k, l] = cpdata[patchdata[i, j * 4 + k], l]; q[j, k, l] = cpdata[patchdata[i, j * 4 + (3 - k)], l]; if (l == 1) { q[j, k, l] *= -1.0f; } if (i < 6) { r[j, k, l] = cpdata[patchdata[i, j * 4 + (3 - k)], l]; if (l == 0) { r[j, k, l] *= -1.0f; } s[j, k, l] = cpdata[patchdata[i, j * 4 + k], l]; if (l == 0) { s[j, k, l] *= -1.0f; } if (l == 1) { s[j, k, l] *= -1.0f; } } } } } int cnt = 0; float[] tex1 = new float[8]; for (int d = 0; d < 2; d++) { for (int e = 0; e < 2; e++) { for (int f = 0; f < 2; f++) { tex1[cnt] = tex[d, e, f]; cnt++; } } } GL.glMap2f(GL.GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2, tex1); cnt = 0; float[] p1 = new float[48]; for (int d = 0; d < 4; d++) { for (int e = 0; e < 4; e++) { for (int f = 0; f < 3; f++) { p1[cnt] = p[d, e, f]; cnt++; } } } GL.glMap2f(GL.GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, p1); GL.glMapGrid2f(grid, 0.0f, 1.0f, grid, 0.0f, 1.0f); GL.glEvalMesh2(type, 0, grid, 0, grid); cnt = 0; int cnt1 = 0; int cnt2 = 0; float[] q1 = new float[48]; float[] r1 = new float[48]; float[] s1 = new float[48]; for (int d = 0; d < 4; d++) { for (int e = 0; e < 4; e++) { for (int f = 0; f < 3; f++) { q1[cnt] = q[d, e, f]; cnt++; } } } GL.glMap2f(GL.GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, q1); GL.glEvalMesh2(type, 0, grid, 0, grid); if (i < 6) { for (int d = 0; d < 4; d++) { for (int e = 0; e < 4; e++) { for (int f = 0; f < 3; f++) { r1[cnt1] = r[d, e, f]; cnt1++; } } } GL.glMap2f(GL.GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, r1); GL.glEvalMesh2(type, 0, grid, 0, grid); for (int d = 0; d < 4; d++) { for (int e = 0; e < 4; e++) { for (int f = 0; f < 3; f++) { s1[cnt2] = s[d, e, f]; cnt2++; } } } GL.glMap2f(GL.GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, s1); GL.glEvalMesh2(type, 0, grid, 0, grid); } } GL.glPopMatrix(); GL.glPopAttrib(); }
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); }
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); }
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); }
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); }