| private glLightfv ( uint light, uint pname, float paramsx ) : void | ||
| light | uint | |
| pname | uint | |
| paramsx | float | |
| return | void | |
void DrawLight()
{
// call this function in order to apply lightning on the objects
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, LightPosition);
GL.glDisable(GL.GL_LIGHTING); //disable lightning in order to glColor3f to work, otherwise spehre color will not been affected
//Draw Yellow Light Source
light.Color = Color.Yellow;
light.Radius = 0.1f;
light.Translate(LightPosition[0], LightPosition[1], LightPosition[2]);
light.Draw();
////draw projection line from source to plane
//GL.glBegin(GL.GL_LINES);
//GL.glColor3d(0.5, 0.5, 0);
//GL.glVertex3d(LightPosition[0], LightPosition[1], LightPosition[2]);
//GL.glVertex3d(LightPosition[0], floor[0, 2] - 0.01, LightPosition[2]);
//GL.glEnd();
axes.XLen = 6;
axes.YLen = 6;
axes.ZLen = 6;
axes.XColor = Color.Red;
axes.YColor = Color.Green;
axes.ZColor = Color.Blue;
// axes.Translate(3.0f, -3.0f, 0.0f);
// axes.Rotate(90.0f, 1.0f, 0.0f, 0.0f);
//axes.Draw();
}
void DrawOldAxes()
{
//for this time
//Lights positioning is here!!!
float [] pos = new float[4];
pos[0] = 10; pos[1] = 10; pos[2] = 10; pos[3] = 1;
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, pos);
GL.glDisable(GL.GL_LIGHTING);
//INITIAL axes
GL.glEnable(GL.GL_LINE_STIPPLE);
GL.glLineStipple(1, 0xFF00); // dotted
GL.glBegin(GL.GL_LINES);
//x RED
GL.glColor3f(1.0f, 0.0f, 0.0f);
GL.glVertex3f(-3.0f, 0.0f, 0.0f);
GL.glVertex3f(3.0f, 0.0f, 0.0f);
//y GREEN
GL.glColor3f(0.0f, 1.0f, 0.0f);
GL.glVertex3f(0.0f, -3.0f, 0.0f);
GL.glVertex3f(0.0f, 3.0f, 0.0f);
//z BLUE
GL.glColor3f(0.0f, 0.0f, 1.0f);
GL.glVertex3f(0.0f, 0.0f, -3.0f);
GL.glVertex3f(0.0f, 0.0f, 3.0f);
GL.glEnd();
GL.glDisable(GL.GL_LINE_STIPPLE);
}
private void DrawLightSource()
{
float distance = 0.8f;
float[] pos = { 0, 0, distance };
float[] intensity = { 1, 1, 1, 1 };
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, pos);
GL.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, intensity);
float[] diff = { 0.6f, 0.6f, 0.75f };
GL.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, diff);
}
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();
//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 };
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.glPopMatrix();
tank.drawSelf();
DrawBullets();
//REFLECTION e
if (networkconnected)
{
enemytank.drawSelf();
}
update();
WGL.wglSwapBuffers(m_uint_DC);
}
public cOGL(Control pb)
{
p = pb;
Width = p.Width;
Height = p.Height;
obj = GLU.gluNewQuadric();
InitializeGL();
//3 points of ground plane
ground[0, 0] = 1;
ground[0, 1] = 0;
ground[0, 2] = 0;
ground[1, 0] = -1;
ground[1, 1] = 0;
ground[1, 2] = 0;
ground[2, 0] = 0;
ground[2, 1] = 0;
ground[2, 2] = -1;
//light position
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_reflected[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.glLightfv(GL.GL_LIGHT1, GL.GL_AMBIENT, light_ambient);
GL.glLightfv(GL.GL_LIGHT1, GL.GL_DIFFUSE, light_diffuse);
GL.glLightfv(GL.GL_LIGHT1, GL.GL_SPECULAR, light_specular);
GL.glLightfv(GL.GL_LIGHT1, GL.GL_POSITION, light_position_reflected);
GL.glLightModelfv(GL.GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
}
void DrawLights()
{
//GL.glPushMatrix();
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, lightPos);
//Draw Light Source
GL.glDisable(GL.GL_LIGHTING);
GL.glTranslatef(lightPos[0], lightPos[1], lightPos[2]);
//Yellow Light source
GL.glColor3f(1, 1, 0);
GLUT.glutSolidSphere(0.05, 8, 8);
GL.glTranslatef(-lightPos[0], -lightPos[1], -lightPos[2]);
//main System draw
GL.glEnable(GL.GL_LIGHTING);
//GL.glPopMatrix();
}
protected void DrawLightSource()
{
if (enableLightSource)
{
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, lightPosition);
GL.glEnable(GL.GL_LIGHTING);
GL.glEnable(GL.GL_COLOR_MATERIAL);
GL.glTranslated(lightPosition[0], lightPosition[1], lightPosition[2]);
GL.glColor3d(1, 1, 0);
GLUT.glutSolidSphere(0.5, 50, 50);
GL.glTranslated(-lightPosition[0], -lightPosition[1], -lightPosition[2]);
}
else
{
GL.glDisable(GL.GL_LIGHTING);
}
}
void DrawFiguresRef()
{
GL.glPushMatrix();
// must be in scene to be reflected too
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, pos);
//Draw Light Source
GL.glDisable(GL.GL_LIGHTING);
GL.glTranslatef(pos[0], pos[1], pos[2]);
//Yellow Light source
GL.glColor3f(1, 1, 0);
GL.glTranslatef(-pos[0], -pos[1], -pos[2]);
//projection line from source to plane
GL.glBegin(GL.GL_LINES);
GL.glColor3d(0.5, 0.5, 0);
GL.glVertex3d(pos[0], pos[1], 0);
GL.glVertex3d(pos[0], pos[1], pos[2]);
GL.glEnd();
GL.glEnable(GL.GL_LIGHTING);
GL.glRotated(intOptionB, 0, 0, 1);
GL.glColor3f(1, 0, 0);
GL.glTranslated(0, -0.5, 1);
GL.glRotated(intOptionC, 1, 1, 1);
GL.glRotated(-intOptionC, 1, 1, 1);
GL.glTranslated(0, -0.5, -1);
GL.glTranslated(1, 2, 1.5);
GL.glRotated(90, 1, 0, 0);
GL.glColor3d(0, 1, 1);
GL.glRotated(intOptionB, 1, 0, 0);
GL.glRotated(-intOptionB, 1, 0, 0);
GL.glRotated(-90, 1, 0, 0);
GL.glTranslated(-1, -2, -1.5);
GL.glRotated(intOptionB, 0, 0, 1);
GL.glPopMatrix();
}
public void DrawFigures()
{
GL.glPushMatrix();
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, pos);
//Draw Light Source
GL.glDisable(GL.GL_LIGHTING);
GL.glTranslatef(pos[0], pos[1], pos[2]);
//Yellow Light source
GL.glColor3f(1, 1, 0);
GLUT.glutSolidSphere(0.05, 8, 8);
GL.glTranslatef(-pos[0], -pos[1], -pos[2]);
//main System draw
GL.glEnable(GL.GL_LIGHTING);
DrawRobot(false);
drawStars(false);
//end of regular show
//!!!!!!!!!!!!!
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);
// wall shadow
//!!!!!!!!!!!!!
GL.glPushMatrix();
//!!!!!!!!!!!!
MakeShadowMatrix(ground);
GL.glMultMatrixf(cubeXform);
DrawRobot(true);
drawStars(true);
//!!!!!!!!!!!!!
GL.glPopMatrix();
//!!!!!!!!!!!!!
}
private void createLightning()
{
GL.glPushMatrix();
float[] lightPos = new float[4];
lightPos[0] = -2.0f;
lightPos[1] = 1f;
lightPos[2] = 0.8f;
lightPos[3] = 1;
// draw light source as solid sphere
/*GL.glColor3f(1, 1, 1);
* GL.glTranslatef(lightPos[0], lightPos[1], lightPos[2]);
* GLUT.glutSolidSphere(0.1, 16, 16);*/
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, lightPos);
GL.glEnable(GL.GL_LIGHTING);
GL.glEnable(GL.GL_LIGHT0);
GL.glEnable(GL.GL_COLOR_MATERIAL);
GL.glPopMatrix();
}
/*
*
* Constructor
*
*/
public cOGL(Control pb)
{
p = pb;
Width = p.Width;
Height = p.Height;
InitializeGL();
obj = GLU.gluNewQuadric();
//Display lists declaration
TREE_LIST = GL.glGenLists(MAX_NUMBER_OF_TREES);
STEM_LIST = GL.glGenLists(MAX_NUMBER_OF_TREES);
LEAF_LIST = GL.glGenLists(MAX_NUMBER_OF_TREES);
//APPLE_LIST= GL.glGenLists(MAX_NUMBER_OF_TREES);
APPLE_LIST = GL.glGenLists(1);
STEM_AND_LEAVS_LIST = GL.glGenLists(MAX_NUMBER_OF_TREES);
TREE_MAT = GL.glGenLists(4);
LEAF_MAT = TREE_MAT + 1;
WATER_MAT = TREE_MAT + 3;
APPLE_MAT = TREE_MAT + 2;
//3 points of ground plane
ground[0, 0] = 1;
ground[0, 1] = 0f;
ground[0, 2] = 0;
ground[1, 0] = -1;
ground[1, 1] = 0f;
ground[1, 2] = 0;
ground[2, 0] = 0;
ground[2, 1] = 0f;
ground[2, 2] = -1;
//light position
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;
//light0 default properties
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);
randX = new int[MAX_NUMBER_OF_TREES];
randZ = new int[MAX_NUMBER_OF_TREES];
locationX = new double[MAX_NUMBER_OF_TREES];
locationZ = new double[MAX_NUMBER_OF_TREES];
locationRotateY = new double[MAX_NUMBER_OF_TREES];
randX[0] = 0;
randZ[0] = 0;
//rand position for trees,or default value 0 for tree locations.
for (int i = 0; i < MAX_NUMBER_OF_TREES; i++)
{
randX[i] = rand.Next(-90, 90);
randZ[i] = rand.Next(-90, 90);
locationX[i] = 0;
locationZ[i] = 0;
locationRotateY[i] = 0;
}
}
/**********************************************************************************************************
*
*
*
* MAIN DRAW FUNCTION
*
*
*
**********************************************************************************************************/
public void Draw()
{
if (m_uint_DC == 0 || m_uint_RC == 0)
{
return;
}
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);
GL.glViewport(0, 0, Width, Height);
GL.glLoadIdentity();
GLU.gluLookAt(ScrollValue[0], ScrollValue[1], ScrollValue[2],
ScrollValue[3], ScrollValue[4], ScrollValue[5],
ScrollValue[6], ScrollValue[7], ScrollValue[8]);
GL.glRotatef(xAngle, 1.0f, 0.0f, 0.0f);
GL.glRotatef(yAngle, 0.0f, 1.0f, 0.0f);
GL.glRotatef(zAngle, 0.0f, 0.0f, 1.0f);
GL.glTranslatef(xShift, yShift, zShift);
pos[0] = light_position[0] = ScrollValue[9];
pos[1] = light_position[1] = ScrollValue[10];
pos[2] = light_position[2] = ScrollValue[11];
pos[3] = light_position[3] = 0;
GL.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, light_ambient);
GL.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, light_diffuse);
GL.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, light_specular);
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position);
GL.glLightModelfv(GL.GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
GL.glEnable(GL.GL_LIGHT0);
/*
*
* Reflection
*
*/
GL.glEnable(GL.GL_BLEND);
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
if (reflectionOn)
{
//draw only to STENCIL buffer
GL.glEnable(GL.GL_STENCIL_TEST);
GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF);
GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
GL.glDisable(GL.GL_DEPTH_TEST);
drawLake();
// restore regular settings
GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
GL.glEnable(GL.GL_DEPTH_TEST);
// reflection is drawn only where STENCIL buffer value equal to 1
GL.glStencilFunc(GL.GL_EQUAL, 1, 0xFFFFFFFF);
GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);
/*
*
* draw reflected scene
*
*/
GL.glEnable(GL.GL_LIGHTING);
for (currentTree = 0; currentTree < numOfTrees; currentTree++)
{
GL.glPushMatrix();
//GL.glTranslated(randX[currentTree], 0,randZ[currentTree]);
GL.glTranslated(locationX[currentTree], 0, locationZ[currentTree]);
GL.glRotated(locationRotateY[currentTree], 0, 1, 0);
GL.glScalef(1, -1, 1); //swap on Z axis
if (scullFaceOn)
{
GL.glEnable(GL.GL_CULL_FACE);
GL.glCullFace(GL.GL_BACK);
GL.glCallList(TREE_LIST + currentTree);
GL.glCullFace(GL.GL_FRONT);
GL.glCallList(TREE_LIST + currentTree);
GL.glDisable(GL.GL_CULL_FACE);
}
else
{
GL.glCallList(TREE_LIST + currentTree);
}
GL.glPopMatrix();
}
drawLake();
GL.glStencilFunc(GL.GL_NOTEQUAL, 1, 0xFFFFFFFF);
GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);
// really draw floor
//( half-transparent ( see its color's alpha byte)))
// in order to see reflected objects
//GL.glDepthMask((byte)GL.GL_FALSE);
GL.glDepthMask((byte)GL.GL_TRUE);
if (!textureOn)
{
drawFloor();
}
else
{
drawFloorTextured();
DrawTexturedCube();
}
GL.glDisable(GL.GL_LIGHTING);
GL.glDisable(GL.GL_STENCIL_TEST);
}
else
{
GL.glEnable(GL.GL_LIGHTING);
drawLake();
if (!textureOn)
{
drawFloor();
}
else
{
drawFloorTextured();
DrawTexturedCube();
}
GL.glDisable(GL.GL_LIGHTING);
}
DrawLight();
/*
* Draw trees
*/
GL.glEnable(GL.GL_LIGHTING);
GL.glPushMatrix();
for (currentTree = 0; currentTree < numOfTrees; currentTree++)
{
GL.glPushMatrix();
//GL.glTranslated(randX[currentTree], 0, randZ[currentTree]);
GL.glTranslated(locationX[currentTree], 0, locationZ[currentTree]);
GL.glRotated(locationRotateY[currentTree], 0, 1, 0);
GL.glCallList(TREE_LIST + currentTree);
GL.glPopMatrix();
}
GL.glPopMatrix();
/*
* Draw trees shadows
*/
GL.glDisable(GL.GL_LIGHTING);
GL.glColor3d(0, 0, 0);
if (shadowOn)
{
GL.glPushMatrix();
MakeShadowMatrix(ground);
GL.glMultMatrixf(cubeXform);
for (currentTree = 0; currentTree < numOfTrees; currentTree++)
{
GL.glPushMatrix();
//GL.glTranslated(randX[currentTree], 0, randZ[currentTree]);
GL.glTranslated(locationX[currentTree], 0, locationZ[currentTree]);
GL.glRotated(locationRotateY[currentTree], 0, 1, 0);
GL.glCallList(TREE_LIST + currentTree);
GL.glPopMatrix();
}
GL.glPopMatrix();
}
GL.glFlush();
WGL.wglSwapBuffers(m_uint_DC);
}
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()
{
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()
{
//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);
}
