public void Draw()
{
float delta = 0;
double[] ModelViewMatrixBeforeTransforms = new double[16];
double[] CurrentTraslation = new double[16];
if (m_uint_DC == 0 || m_uint_RC == 0)
{
return;
}
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);
GL.glLoadIdentity();
if (enableLookAtValue)
{
GLU.gluLookAt(LookAtNumberValue[0], LookAtNumberValue[1], LookAtNumberValue[2],
LookAtNumberValue[3], LookAtNumberValue[4], LookAtNumberValue[5],
LookAtNumberValue[6], LookAtNumberValue[7], LookAtNumberValue[8]);
}
GL.glTranslatef(0.0f, 0.0f, -20.0f);
if (enableRotate)
{
GL.glRotatef(viewAngle, 0.0f, 1.0f, 0.0f);
viewAngle -= 2f;
}
DrawRoom();
DrawOldAxes();
DrawLightSource();
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, ModelViewMatrixBeforeTransforms);
GL.glLoadIdentity();
if (coordSysMoveDirection != 0)
{
delta = 5.0f * Math.Abs(coordSysMoveDirection) / coordSysMoveDirection;
switch (Math.Abs(coordSysMoveDirection))
{
case 1:
GL.glTranslatef(delta / 20, 0, 0);
break;
case 2:
GL.glTranslatef(0, delta / 20, 0);
break;
case 3:
GL.glTranslatef(0, 0, delta / 20);
break;
case 4:
GL.glRotatef(delta, 1, 0, 0);
break;
case 5:
GL.glRotatef(delta, 0, 1, 0);
break;
case 6:
GL.glRotatef(delta, 0, 0, 1);
break;
}
}
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, CurrentTraslation);
GL.glLoadMatrixd(AccumulatedTraslations);
GL.glMultMatrixd(CurrentTraslation);
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, AccumulatedTraslations);
GL.glLoadMatrixd(ModelViewMatrixBeforeTransforms);
GL.glMultMatrixd(AccumulatedTraslations);
DrawAxes();
GL.glCallList(handList);
if (enableReflection)
{
GL.glEnable(GL.GL_BLEND);
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
GL.glEnable(GL.GL_STENCIL_TEST);
GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF);
GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
GL.glDisable(GL.GL_DEPTH_TEST);
//DrawFloor();
GL.glCallList(floorMainList);
GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
GL.glEnable(GL.GL_DEPTH_TEST);
GL.glStencilFunc(GL.GL_EQUAL, 1, 0xFFFFFFFF);
GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);
GL.glEnable(GL.GL_STENCIL_TEST);
GL.glPushMatrix();
GL.glScalef(1, -1, 1);
GL.glEnable(GL.GL_CULL_FACE);
GL.glCullFace(GL.GL_BACK);
GL.glTranslated(0, 3, 0);
DrawFigures();
GL.glCullFace(GL.GL_FRONT);
DrawFigures();
GL.glDisable(GL.GL_CULL_FACE);
GL.glPopMatrix();
GL.glDepthMask((byte)GL.GL_FALSE);
//DrawFloor();
GL.glCallList(floorMainList);
GL.glDepthMask((byte)GL.GL_TRUE);
GL.glDisable(GL.GL_STENCIL_TEST);
}
GL.glFlush();
WGL.wglSwapBuffers(m_uint_DC);
}
public void Draw()
{
if (m_uint_DC == 0 || m_uint_RC == 0)
{
return;
}
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);
//TRIVIAL
GL.glViewport(0, 0, Width, Height);
GL.glLoadIdentity();
GL.glEnable(GL.GL_NORMALIZE);
GLU.gluLookAt(ScrollValue[0], ScrollValue[1], ScrollValue[2],
ScrollValue[3], ScrollValue[4], ScrollValue[5],
ScrollValue[6], ScrollValue[7], ScrollValue[8]);
pos[0] = light_position[0] = ScrollValue[9];
pos[1] = light_position[1] = ScrollValue[10];
pos[2] = light_position[2] = ScrollValue[11];
pos[3] = light_position[3] = 0;
light_position_reflected[0] = -ScrollValue[9];
light_position_reflected[1] = -ScrollValue[10];
light_position_reflected[2] = -ScrollValue[11];
light_position[3] = 0;
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position);
GL.glEnable(GL.GL_LIGHT0);
GL.glLightfv(GL.GL_LIGHT1, GL.GL_POSITION, light_position);
GL.glEnable(GL.GL_LIGHT1);
//beascender look angle
GL.glTranslatef(0.0f, -50.0f, -340.0f); //how far from the lake
GL.glTranslatef(0.0f, 1.0f, 0.0f); //height from the lake
GL.glRotatef(25, 1.0f, 0, 0); //look at lake angle
GL.glRotatef(xAngle, 1.0f, 0.0f, 0.0f);
if (checkBox)
{
GL.glRotatef((float)spirala * 0.018f, 0.0f, 1.0f, 0.0f);
GL.glRotatef((float)speed * 0.008f, 1.0f, 1.0f, 0.0f);
GL.glRotatef((float)speed * 0.008f, 0.0f, 1.0f, 1.0f);
GL.glRotatef((float)speed * -0.005f, 1.0f, 0.0f, 1.0f);
}
GL.glRotatef(yAngle, 0.0f, 1.0f, 0.0f);
GL.glRotatef(zAngle, 0.0f, 0.0f, 1.0f);
if (checkBox)
{
GL.glTranslatef(xShift, yShift + (float)-speed * 0.18f, zShift);
}
GL.glTranslatef(xShift, yShift, zShift);
/*
*
* Reflection drawing area start here
*
*/
GL.glPushMatrix();
GL.glEnable(GL.GL_BLEND);
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
//draw only to STENCIL buffer
GL.glEnable(GL.GL_STENCIL_TEST);
GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF);
GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
GL.glDisable(GL.GL_DEPTH_TEST);
Drawlake();//Draw area when we want to see reflect
// restore regular seascendings
GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
GL.glEnable(GL.GL_DEPTH_TEST);
// reflection is drawn only where STENCIL buffer value equal to 1
GL.glStencilFunc(GL.GL_EQUAL, 1, 0xFFFFFFFF);
GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);
/*
* draw reflected scene
*/
GL.glScalef(1, -1, 1); //swap axes down
GL.glPushMatrix();
DrawTexturedCube();
//reflected penguin
drawPenguin();
draw_sun();
draw_moon();
GL.glPopMatrix();
GL.glPopMatrix();
GL.glEnable(GL.GL_LIGHTING);
Drawlake();
GL.glDisable(GL.GL_LIGHTING);
GL.glStencilFunc(GL.GL_NOTEQUAL, 1, 0xFFFFFFFF);
GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);
GL.glDepthMask((byte)GL.GL_FALSE);
GL.glDepthMask((byte)GL.GL_TRUE);
drawFloorTextured();
draw_sun();
draw_moon();
GL.glDisable(GL.GL_STENCIL_TEST);
DrawTexturedCube(); //SKY BOX
/*
*
* paint main scene area - start here
*
*/
// drawaxe();
GL.glShadeModel(GL.GL_FLAT);
GL.glEnable(GL.GL_LIGHTING);
//Main Penguin
drawPenguin();
/////////
GL.glDisable(GL.GL_LIGHTING);
/*
*
* Draw shadows area - start here
*
*/
GL.glDisable(GL.GL_LIGHTING);
GL.glPushMatrix();
MakeShadowMatrix(ground); //sending fround matrix
GL.glMultMatrixf(cubeXform);
GL.glShadeModel(GL.GL_FLAT);
GL.glColor3d(0, 0, 0);//black
drawPenguinShade();
GL.glPopMatrix();
GL.glFlush();
WGL.wglSwapBuffers(m_uint_DC);
}
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()
{
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()
{
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);
}
void DrawFigures()
{
GL.glPushMatrix();
DrawLights();
switch (display_mod)
{
case 1:
DrawMirrors();
DrawObjects(false);
GL.glPopMatrix();
break;
case 2:
DrawWalls();
DrawObjects(false);
GL.glPopMatrix();
//SHADING begin
//we'll define cubeXform matrix in MakeShadowMatrix Sub
// Disable lighting, we'll just draw the shadow
//else instead of shadow we'll see stange projection of the same objects
GL.glDisable(GL.GL_LIGHTING);
/*
* // back shadow
* //!!!!!!!!!!!!!
* GL.glPushMatrix();
* backMirrorSurface.doRotations();
* //!!!!!!!!!!!!
* MakeShadowMatrix(backMirrorSurface.getSurf());
* GL.glMultMatrixf(cubeXform);
* DrawObjects(true);
* //!!!!!!!!!!!!!
* GL.glPopMatrix();
* //!!!!!!!!!!!!!
*/
// left shadow
//!!!!!!!!!!!!!
GL.glPushMatrix();
leftMirrorSurface.doRotations();
//!!!!!!!!!!!!
MakeShadowMatrix(leftMirrorSurface.getSurf());
GL.glMultMatrixf(shadowCubeXform);
DrawObjects(true);
//!!!!!!!!!!!!!
GL.glPopMatrix();
//!!!!!!!!!!!!!
// right shadow
//!!!!!!!!!!!!!
GL.glPushMatrix();
//!!!!!!!!!!!!
rightMirrorSurface.doRotations();
MakeShadowMatrix(rightMirrorSurface.getSurf());
GL.glMultMatrixf(shadowCubeXform);
DrawObjects(true);
//!!!!!!!!!!!!!
GL.glPopMatrix();
//!!!!!!!!!!!!!
break;
case 3:
DrawRoom();
GL.glEnable(GL.GL_LIGHTING);
GL.glTranslatef(0.0f, 0.0f, -7.4f);
DrawObjects(false);
GL.glTranslatef(0.0f, 0.0f, +7.4f);
GL.glPopMatrix();
GL.glDisable(GL.GL_LIGHTING);
break;
}
}
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);
}
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);
}
void DrawFigures()
{
//!!!!!!!!!!!!!
GL.glPushMatrix();
//!!!!!!!!!!!!!
GL.glEnable(GL.GL_TEXTURE_2D);
//plane grids
if (!rotate)
{
GL.glPushMatrix();
drawground();
GL.glDisable(GL.GL_TEXTURE_2D);
GL.glDisable(GL.GL_LIGHTING);
GL.glEnable(GL.GL_COLOR);
GL.glTranslatef(pos[0], pos[1], 10);
GL.glColor3f(1, 1, 0);
GLU.gluSphere(obj, 1, 16, 16);
GL.glTranslatef(-pos[0], -pos[1], -10);
GL.glEnd();
GL.glEnable(GL.GL_TEXTURE_2D);
GL.glPopMatrix();
}
else
{
GL.glPushMatrix();
angleG -= 0.2f;
GL.glRotatef(angleG, 0, 0, 0.1f);
drawground();
GL.glDisable(GL.GL_TEXTURE_2D);
GL.glDisable(GL.GL_LIGHTING);
GL.glEnable(GL.GL_COLOR);
GL.glTranslatef(pos[0], pos[1], 10);
GL.glColor3f(1, 1, 0);
GL.glRotatef(angleG, 0, 2, 0);
GLU.gluSphere(obj, 1, 16, 16);
GL.glTranslatef(-pos[0], -pos[1], -10);
GL.glEnd();
GL.glEnable(GL.GL_TEXTURE_2D);
GL.glPopMatrix();
}
DrawObjects(false, 1);
//end of regular showFfron
//!!!!!!!!!!!!!
GL.glPopMatrix();
//!!!!!!!!!!!!!
//SHADING begin
//we'll define cubeXform matrix in MakeShadowMatrix Sub
// Disable lighting, we'll just draw the shadow
//else instead of shadow we'll see stange projection of the same objects
GL.glDisable(GL.GL_LIGHTING);
// floor shadow
//!!!!!!!!!!!!!
GL.glPushMatrix();
//!!!!!!!!!!!!
MakeShadowMatrix(ground);
GL.glMultMatrixf(cubeXform);
DrawObjects(true, 1);
//!!!!!!!!!!!!!
GL.glPopMatrix();
}
void DrawFigures()
{
skyBox.DrawSkyBox();
MainLightSource.DrawLightSource(new float[] { 1, 1, 0 });
StaticRedLightSource.DrawLightSource(new float[] { 1, 0, 0 });
StaticBlueLightSource.DrawLightSource(new float[] { 0, 0, 1 });
//Banner Light source
GL.glTranslatef(bannerLightPos[0], bannerLightPos[1], bannerLightPos[2]);
Random r = new Random();
GL.glColor3d(r.NextDouble(), r.NextDouble(), r.NextDouble());
GLUT.glutSolidSphere(0.1, 8, 8);
GL.glTranslatef(-bannerLightPos[0], -bannerLightPos[1], -bannerLightPos[2]);
GL.glEnd();
GL.glDisable(GL.GL_DEPTH_TEST);
GL.glDisable(GL.GL_LIGHTING);
// Start Drawing Floor Shadow
GL.glPushMatrix();
GL.glEnable(GL.GL_BLEND);
GL.glColor4d(0, 0, 0, 0.25);
mainShadowManager.MakeShadowMatrix(mainShadowManager.Ground, cubeXform);
GL.glMultMatrixf(cubeXform);
m_SideMachine.DrawSideMachines(new double[3] {
0, -0.4, 6
}, true);
m_SideMachine.DrawSideMachines(new double[3] {
0, -0.4, -6
}, true);
GL.glCallList(SHADOW_LIST);
//GL.glColor4d(0.05, 0, 0, 0.25);
//redShadowManager.MakeShadowMatrix(redShadowManager.Ground, cubeXform);
//GL.glMultMatrixf(cubeXform);
//m_SideMachine.DrawSideMachines(new double[3] { 0, -0.4, 6 }, true);
//m_SideMachine.DrawSideMachines(new double[3] { 0, -0.4, -6 }, true);
//GL.glCallList(SHADOW_LIST);
//GL.glColor4d(0, 0, 0.05, 0.25);
//blueShadowManager.MakeShadowMatrix(blueShadowManager.Ground, cubeXform);
//GL.glMultMatrixf(cubeXform);
//m_SideMachine.DrawSideMachines(new double[3] { 0, -0.4, 6 }, true);
//m_SideMachine.DrawSideMachines(new double[3] { 0, -0.4, -6 }, true);
//GL.glCallList(SHADOW_LIST);
GL.glDisable(GL.GL_BLEND);
GL.glPopMatrix();
//for (int i = 0; i < 4; i++)
//{
// GL.glPushMatrix();
// shadowManager.MakeShadowMatrix(shadowManager.Walls[i], cubeXform);
// GL.glMultMatrixf(cubeXform);
// m_SideMachine.DrawSideMachines(new double[3] { 0, -0.4, 6 }, true);
// m_SideMachine.DrawSideMachines(new double[3] { 0, -0.4, -6 }, true);
// GL.glCallList(SHADOW_LIST);
// GL.glPopMatrix();
//}
//End Drawing Floor Shadow
GL.glEnable(GL.GL_DEPTH_TEST);
GL.glEnable(GL.GL_COLOR_MATERIAL);
GL.glEnable(GL.GL_LIGHT0);
GL.glEnable(GL.GL_LIGHT1);
GL.glEnable(GL.GL_LIGHT2);
GL.glEnable(GL.GL_LIGHT3);
GL.glEnable(GL.GL_LIGHTING);
GL.glPushMatrix();
m_SideMachine.DrawSideMachines(new double[3] {
0, -0.4, 6
}, false);
m_SideMachine.DrawSideMachines(new double[3] {
0, -0.4, -6
}, false);
//toyCar.DrawToy(new double[3] { 1.4, 0.3, 0 }, new double[4] { 40, 0, 1, 0 }, false);
GL.glCallList(CLAW_MACHINE_LIST);
GL.glPopMatrix();
GL.glDisable(GL.GL_COLOR_MATERIAL);
GL.glDisable(GL.GL_LIGHTING);
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
}
