/// <summary>
/// Event handler called when the form is loaded. It retrieves the controls
/// window handle and device context and creates the rendering context.
/// </summary>
protected virtual void InitializeGL(object sender, EventArgs e)
{
m_uint_HWND = (uint)this.Handle.ToInt32();
m_uint_DC = WGL.GetDC(m_uint_HWND);
// CAUTION: Not doing the following WGL.wglSwapBuffers() on the DC will
// result in a failure to subsequently create the RC.
WGL.wglSwapBuffers(m_uint_DC);
//Get the pixel format
WGL.PIXELFORMATDESCRIPTOR pfd = new WGL.PIXELFORMATDESCRIPTOR();
WGL.ZeroPixelDescriptor(ref pfd);
pfd.nVersion = 1;
pfd.dwFlags = (WGL.PFD_DRAW_TO_WINDOW | WGL.PFD_SUPPORT_OPENGL | WGL.PFD_DOUBLEBUFFER);
pfd.iPixelType = (byte)(WGL.PFD_TYPE_RGBA);
pfd.cColorBits = 32;
pfd.cDepthBits = 32;
pfd.iLayerType = (byte)(WGL.PFD_MAIN_PLANE);
int pixelFormatIndex = 0;
pixelFormatIndex = WGL.ChoosePixelFormat(m_uint_DC, ref pfd);
if (pixelFormatIndex == 0)
{
MessageBox.Show("Unable to retrieve pixel format");
return;
}
if (WGL.SetPixelFormat(m_uint_DC, pixelFormatIndex, ref pfd) == 0)
{
MessageBox.Show("Unable to set pixel format");
return;
}
//Create rendering context
m_uint_RC = WGL.wglCreateContext(m_uint_DC);
if (m_uint_RC == 0)
{
MessageBox.Show("Unable to get rendering context");
return;
}
if (WGL.wglMakeCurrent(m_uint_DC, m_uint_RC) == 0)
{
MessageBox.Show("Unable to make rendering context current");
return;
}
//Set up OpenGL related characteristics
ResizeGL(null, null);
GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
GL.glEnable(GL.GL_DEPTH_TEST);
GL.glDepthFunc(GL.GL_LEQUAL);
//GL.glEnable(GL.GL_CULL_FACE);
GL.glCullFace(GL.GL_BACK);
}
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();
}
public void Draw(int picFrontSide)
{
GL.glDisable(GL.GL_LIGHTING);
GL.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
GL.glEnable(GL.GL_TEXTURE_2D);
GL.glEnable(GL.GL_BLEND);
GL.glEnable(GL.GL_CULL_FACE);
if (picFrontSide == 1)
{
GL.glCullFace(GL.GL_FRONT); //front side of pictures
}
else
{
GL.glCullFace(GL.GL_BACK); //back side of pictures
}
DrawWallsWithTextures(picFrontSide);
ApplyTransformation();
}
// ############################################################################
// ############################################################################
// ############################################################################
// ############################################################################
// ============================================================================
// 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);
}
/**********************************************************************************************************
*
*
*
* 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);
}
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()
{
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);
}
void MakeShadow(double[] ModelVievMatrixBeforeSpecificTransforms, double[] CurrentRotationTraslation)
{
#region Shadow Robot floor
GL.glPushMatrix();
MakeShadowMatrix(floorCoordForShadow);
GL.glMultMatrixf(cubeXform);
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
GL.glLoadIdentity(); // make it identity matrix
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 Robot shadow on floor
GL.glPushMatrix();
RotateRobotByDirection();
GL.glCullFace(GL.GL_BACK);
GL.glCullFace(GL.GL_FRONT);
GL.glDisable(GL.GL_CULL_FACE);
GL.glDisable(GL.GL_LIGHTING);
GL.glRotatef(-Robot.WalkAngle, 0, 1, 0);
Robot.Draw(true);
//GL.glRotatef(180, 0, 1, 0);
GL.glPopMatrix();
GL.glDisable(GL.GL_CULL_FACE);
GL.glPopMatrix();
GL.glPopMatrix();
#endregion
#region Shadow Robot back wall
GL.glPushMatrix();
MakeShadowMatrix(backWallCoordForShadow);
GL.glMultMatrixf(cubeXform);
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
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 Robot shadow on back wall
GL.glPushMatrix();
RotateRobotByDirection();
GL.glCullFace(GL.GL_BACK);
GL.glCullFace(GL.GL_FRONT);
GL.glDisable(GL.GL_CULL_FACE);
GL.glDisable(GL.GL_LIGHTING);
GL.glRotatef(-Robot.WalkAngle, 0, 1, 0);
Robot.Draw(true);
GL.glPopMatrix();
GL.glDisable(GL.GL_CULL_FACE);
GL.glPopMatrix();
GL.glPopMatrix();
#endregion
#region Shadow Robot front wall
GL.glPushMatrix();
MakeShadowMatrix(frontWallCoordForShadow);
GL.glMultMatrixf(cubeXform);
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
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 Robot shadow on front wall
GL.glPushMatrix();
RotateRobotByDirection();
GL.glCullFace(GL.GL_BACK);
GL.glCullFace(GL.GL_FRONT);
GL.glDisable(GL.GL_CULL_FACE);
GL.glDisable(GL.GL_LIGHTING);
GL.glRotatef(-Robot.WalkAngle, 0, 1, 0);
Robot.Draw(true);
GL.glPopMatrix();
GL.glDisable(GL.GL_CULL_FACE);
GL.glPopMatrix();
GL.glPopMatrix();
#endregion
#region Shadow Robot right wall
GL.glPushMatrix();
MakeShadowMatrix(rightWallCoordForShadow);
GL.glMultMatrixf(cubeXform);
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
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 Robot shadow on right wall
GL.glPushMatrix();
RotateRobotByDirection();
GL.glCullFace(GL.GL_BACK);
GL.glCullFace(GL.GL_FRONT);
GL.glDisable(GL.GL_CULL_FACE);
GL.glDisable(GL.GL_LIGHTING);
GL.glRotatef(-Robot.WalkAngle, 0, 1, 0);
Robot.Draw(true);
GL.glPopMatrix();
GL.glDisable(GL.GL_CULL_FACE);
GL.glPopMatrix();
GL.glPopMatrix();
#endregion
#region Shadow Robot left wall
GL.glPushMatrix();
MakeShadowMatrix(leftWallCoordForShadow);
GL.glMultMatrixf(cubeXform);
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
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 Robot shadow on left wall
GL.glPushMatrix();
RotateRobotByDirection();
GL.glCullFace(GL.GL_BACK);
GL.glCullFace(GL.GL_FRONT);
GL.glDisable(GL.GL_CULL_FACE);
GL.glDisable(GL.GL_LIGHTING);
GL.glRotatef(-Robot.WalkAngle, 0, 1, 0);
Robot.Draw(true);
GL.glPopMatrix();
GL.glDisable(GL.GL_CULL_FACE);
GL.glPopMatrix();
GL.glPopMatrix();
#endregion
#region Shadow Robot roof
GL.glPushMatrix();
MakeShadowMatrix(ceilingCoordForShadow);
GL.glMultMatrixf(cubeXform);
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelVievMatrixBeforeSpecificTransforms);
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 Robot shadow on roof
GL.glPushMatrix();
RotateRobotByDirection();
GL.glCullFace(GL.GL_BACK);
GL.glCullFace(GL.GL_FRONT);
GL.glDisable(GL.GL_CULL_FACE);
GL.glDisable(GL.GL_LIGHTING);
GL.glRotatef(-Robot.WalkAngle, 0, 1, 0);
Robot.Draw(true);
GL.glPopMatrix();
GL.glDisable(GL.GL_CULL_FACE);
GL.glPopMatrix();
GL.glPopMatrix();
#endregion
}
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()
{
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()
{
//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);
}
