public void DrawShadow()
{
GL.glPushMatrix();
GL.glNewList(Robot_SHADOW_LIST, GL.GL_COMPILE);
//build the Robot
GL.glTranslatef(0, Jump, 0);
GL.glTranslatef(0, 1.3f, 0);
// build Robot head
GL.glCallList(HEAD_SHADOW_LIST);
GL.glTranslatef(0, -1.3f, 0);
// build Robot body
GL.glCallList(BODY_SHADOW_LIST);
//build Robot hands
DrawShadowHand(false); //left hand
GL.glRotatef(180, 0, 1, 0);
if (WeaponIndex == 1 || WeaponIndex == 2)
{
GL.glScalef(-1, 1, 1);
}
DrawShadowHand(true); //right hand
//build Robot legs
GL.glRotatef(90, 1, 0, 0);
GL.glTranslatef(0, 0, 1.9f);
GL.glTranslatef(0, 0.3f, 0);
DrawShadowLeg(false); //left leg
GL.glTranslatef(0, -0.6f, 0);
DrawShadowLeg(true); //right leg
GL.glEndList();
GL.glPopMatrix();
}
public void CreateRobotList()
{
GL.glPushMatrix();
//
// hierarchical list
//
GL.glNewList(ROBOT_LIST, GL.GL_COMPILE);
// BASE : no rotations!!! Angle will be implemented in the CALL routine
// before call to CreateRobotList()
GL.glColor3f(0, 0, 0.5f);
GLU.gluCylinder(obj, 3 * r, 3 * r, r * 1.2, 40, 20);
GL.glTranslated(0, 0, r * 1.2);
GLU.gluDisk(obj, 0, 3 * r, 40, 20);
GL.glColor3f(0, 0, 1);
GLU.gluSphere(obj, r * 1.2, 20, 20);
// end base
// transformations
GL.glRotatef(SHOULDER_angle, 1, 0, 0);
// call SHOULDER
GL.glCallList(SHOULDER_LIST);
// transformations
//no need in glTranslated 0, 0, SHOULDER_length
//it is located properly now !!!
GL.glRotatef(ARM_angle, 1, 0, 0);
// call ARM
GL.glCallList(ARM_LIST);
GL.glEndList();
GL.glPopMatrix();
}
public void draw_sun()
{
GL.glPushMatrix();
GL.glColor3d(1, 1, 1);
GL.glEnable(GL.GL_TEXTURE_2D);
GL.glBindTexture(GL.GL_TEXTURE_2D, Textures[6]);
quad = GLU.gluNewQuadric();
GLU.gluQuadricTexture(quad, 40);
GL.glTranslatef(pos[0], pos[1], pos[2]);
// rotating sun as well as all planets to Y axis
GL.glTranslatef(0.0f, 0.0f + (float)-speed * 0.03f, 0.0f); //y - up down
GL.glTranslatef(0.0f, 0.0f, 0.0f + (float)-speed * 0.01f); //z - back forward
GL.glRotatef((float)moon, 0.0f, 1.0f, 0.0f);
GLU.gluSphere(quad, 45, 1000, 1000);
GL.glPopMatrix();
moon += 0.04f;
}
public void draw_moon()
{
GL.glPushMatrix();
GL.glColor3d(1, 1, 1);
GL.glEnable(GL.GL_TEXTURE_2D);
GL.glBindTexture(GL.GL_TEXTURE_2D, Textures[1]);
quad = GLU.gluNewQuadric();
GLU.gluQuadricTexture(quad, 40);
GL.glTranslatef(-200, 200, -300);
// rotating moon as well as all planets to Y axis
GL.glTranslatef(0.0f + (float)speed * 0.01f, 0.0f, 0.0f);
GL.glTranslatef(0.0f, 0.0f + (float)speed * 0.01f, 0.0f);
GL.glRotatef((float)moon++ *0.5f, 1.0f, 1.0f, 0.0f);
GLU.gluSphere(quad, 18, 200, 200);
GL.glPopMatrix();
}
public void createStemAndLeafs()
{
GL.glNewList(STEM_AND_LEAVS_LIST + currentTree, GL.GL_COMPILE);
GL.glPushMatrix();
GL.glPushAttrib(GL.GL_LIGHTING_BIT);
GL.glCallList(STEM_LIST + currentTree);
GL.glCallList(LEAF_MAT);
for (int i = 0; i < 3; i++)
{
GL.glTranslatef(0, (float)1 / 3, 0);
GL.glRotatef(90, 0, 1, 0);
GL.glPushMatrix();
GL.glRotatef(50, 1, 0, 0);
GL.glCallList(LEAF_LIST + currentTree);
GL.glPopMatrix();
GL.glPushMatrix();
GL.glRotatef(180, 0, 1, 0);
GL.glRotatef(60, 1, 0, 0);
GL.glCallList(LEAF_LIST + currentTree);
GL.glPopMatrix();
}
GL.glPopAttrib();
GL.glPopMatrix();
GL.glEndList();
}
void drawFloor()
{
GL.glEnable(GL.GL_LIGHTING);
GL.glPushMatrix();
GL.glColor3d(0, 1, 0);
GL.glTranslated(0, -0.01, 0);
float[] grass_ambuse = { 0.03f, 0.56f, 0.19f, 1.0f };
float[] grass_specular = { 0.0f, 0.0f, 0.0f, 1.0f };
float[] grass_shininess = { 10 };
GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, grass_ambuse);
GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, grass_specular);
GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, grass_shininess);
GL.glBegin(GL.GL_QUADS);
GL.glNormal3f(0, 1, 0);
GL.glVertex3f(-200, 0, -200);
GL.glVertex3f(-200, 0, 200);
GL.glVertex3f(200, 0, 200);
GL.glVertex3f(200, 0, -200);
GL.glEnd();
GL.glDisable(GL.GL_LIGHTING);
GL.glPopMatrix();
}
void StartReflaction(int x, int y, int z)
{
GL.glEnable(GL.GL_BLEND);
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
//only floor, draw only to STENCIL buffer
GL.glEnable(GL.GL_STENCIL_TEST);
GL.glStencilOp(GL.GL_REPLACE, GL.GL_REPLACE, GL.GL_REPLACE);
GL.glStencilFunc(GL.GL_ALWAYS, 1, 0xFFFFFFFF); // draw floor always
GL.glColorMask((byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE, (byte)GL.GL_FALSE);
GL.glDisable(GL.GL_DEPTH_TEST);
GL.glPushMatrix();
GL.glRotated(90, 0, 1, 0);
GL.glTranslatef(0, -4, 0);
mirror.Draw();
GL.glPopMatrix();
GL.glColorMask((byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE, (byte)GL.GL_TRUE);
GL.glEnable(GL.GL_DEPTH_TEST);
// reflection is drawn only where STENCIL buffer value equal to 1
GL.glStencilFunc(GL.GL_EQUAL, 1, 0xFFFFFFFF);
GL.glStencilOp(GL.GL_KEEP, GL.GL_KEEP, GL.GL_KEEP);
GL.glEnable(GL.GL_STENCIL_TEST);
// draw reflected scene
GL.glPushMatrix();
GL.glScalef(x, y, z); //swap on Z axis
}
private void DrawTower()
{
const double baseRadius = 0.25, topRadius = 0.16, height = 2.3, diskHeight = 0.06;
const double diskRadius = topRadius + 0.2;
float lightBeamLength = GlobalProperties.LightBeamLength;
GL.glPushMatrix();
DrawPillar(baseRadius, topRadius, height);
GL.glTranslatef(0.0f, 0.0f, (float)height);
DrawDisk(diskHeight, diskRadius);
GL.glTranslatef(0.0f, 0.0f, (float)diskHeight);
DrawWindow();
GL.glTranslatef(0.0f, 0.0f, -(float)diskHeight / 2);
GL.glRotatef(GlobalProperties.LightBeamHorizontalAngle, 0.0f, 0.0f, 1.0f);
GL.glRotatef(GlobalProperties.LightBeamVerticalAngle, 0.0f, 1.0f, 0.0f);
if (GlobalProperties.LightBeamOn)
{
DrawLightBeam();
DrawLightSource();
}
GL.glPopMatrix();
}
public void createStemList()
{
GL.glNewList(STEM_LIST + currentTree, GL.GL_COMPILE);
GL.glPushMatrix();
GL.glRotatef(-90, 1, 0, 0);
GLU.gluCylinder(obj, 0.1 * widhtScale, 0.08 * widhtScale, 1, 10, 10);
GL.glPopMatrix();
GL.glEndList();
}
/// <summary>
/// Rotate camera in local(camera) space
/// </summary>
public void rotateLocal(float deg, float x, float y, float z)
{
GL.glMatrixMode(GL.GL_MODELVIEW);
GL.glPushMatrix();
GL.glLoadMatrixf(maf_matrix);
GL.glRotatef(deg, x, y, z);
GL.glGetFloatv(GL.GL_MODELVIEW_MATRIX, maf_matrix);
GL.glPopMatrix();
}
public void ApplyTransformation()
{
if (isMatrixPushed)
{
//translate and rotate axes
GL.glPopMatrix();
isMatrixPushed = false;
}
}
void CreateApple()
{
GL.glColor3d(1, 0, 0);
GL.glNewList(APPLE_LIST, GL.GL_COMPILE);
GL.glPushMatrix();
GL.glRotatef(-90, 1, 0, 0);
GLUT.glutSolidTorus(0.2, 0.1, 10, 10);
GL.glPopMatrix();
GL.glEndList();
}
void DrawRoom()
{
GL.glPushMatrix();
update_cube_map_prespective();
GL.glLoadIdentity();
update_cube_map_rotations();
GL.glPopMatrix();
GL.glLoadIdentity();
}
public void CreateFloorList()
{
GL.glPushMatrix();
GL.glNewList(floorMainList, GL.GL_COMPILE);
GL.glCallList(floorStartPosition);
GL.glCallList(floorList);
GL.glEndList();
GL.glPopMatrix();
}
void CreateTree()
{
GL.glNewList(TREE_LIST + currentTree, GL.GL_COMPILE);
GL.glPushMatrix();
GL.glPushAttrib(GL.GL_LIGHTING_BIT);
GL.glCallList(TREE_MAT);
GL.glScaled(amplitude, amplitude, amplitude);
FractalTreeRec(0);
GL.glPopAttrib();
GL.glPopMatrix();
GL.glEndList();
}
public void PrepareAndDrawShadow()
{
CAR_SHADOW_LIST = GL.glGenLists(1);
CAR_SHADOW = CAR_SHADOW_LIST + 1;
GL.glPushMatrix();
GL.glNewList(CAR_SHADOW, GL.GL_COMPILE);
GL.glTranslatef(0, -5.5f, 0);
GL.glScalef(0.1f, 0.1f, 0.1f);
carModel.DrawModel(false, 1);
GL.glPopMatrix();
GL.glEndList();
GL.glPopMatrix();
}
/// <summary>
/// Rotate camera in world space
/// </summary>
public void rotateGlobal(float deg, float x, float y, float z)
{
float dx = x * maf_matrix[0] + y * maf_matrix[1] + z * maf_matrix[2];
float dy = x * maf_matrix[4] + y * maf_matrix[5] + z * maf_matrix[6];
float dz = x * maf_matrix[8] + y * maf_matrix[9] + z * maf_matrix[10];
GL.glMatrixMode(GL.GL_MODELVIEW);
GL.glPushMatrix();
GL.glLoadMatrixf(maf_matrix);
GL.glRotatef(deg, dx, dy, dz);
GL.glGetFloatv(GL.GL_MODELVIEW_MATRIX, maf_matrix);
GL.glPopMatrix();
}
public void Drawfloor()
{
GL.glPushMatrix();
GL.glColor3f(0.0f, 1.0f, 0.0f);
GL.glTranslatef(0, -0.001f, 0);
GL.glBegin(GL.GL_QUADS);
GL.glNormal3f(0, 1, 0);
GL.glVertex3f(-100, 0, -100);
GL.glVertex3f(-100, 0, 100);
GL.glVertex3f(100, 0, 100);
GL.glVertex3f(100, 0, -100);
GL.glEnd();
GL.glPopMatrix();
}
void FractalTreeRec(int level)
{
if (level == size)
{
GL.glPushMatrix();
GL.glRotated(rand.NextDouble() * 180, 0, 1, 0);
GL.glCallList(STEM_AND_LEAVS_LIST + currentTree);
for (int i = applesRate; i > 0; i--)
{
if (rand.Next(1, 3) == 1)
{
GL.glPushMatrix();
GL.glTranslatef(0, (float)1 / i, 0);
GL.glCallList(APPLE_MAT);
GL.glCallList(APPLE_LIST);
GL.glCallList(TREE_MAT);
GL.glPopMatrix();
}
}
GL.glPopMatrix();
}
else
{
GL.glCallList(STEM_LIST + currentTree);
GL.glPushMatrix();
GL.glRotated(rand.NextDouble() * 180, 0, 1, 0);
GL.glTranslatef(0, 1 + size / 10, 0);
GL.glScalef(0.7f, 0.7f, 0.7f);
GL.glPushMatrix();
GL.glRotated(110 + rand.NextDouble() * 40, 0, 1, 0);
GL.glRotated(30 + rand.NextDouble() * 20, 0, 0, 1);
FractalTreeRec(level + 1);
GL.glPopMatrix();
GL.glPushMatrix();
GL.glRotated(-130 + rand.NextDouble() * 40, 0, 1, 0);
GL.glRotated(30 + rand.NextDouble() * 20, 0, 0, 1);
FractalTreeRec(level + 1);
GL.glPopMatrix();
GL.glPushMatrix();
GL.glRotated(-20 + rand.NextDouble() * 40, 0, 1, 0);
GL.glRotated(30 + rand.NextDouble() * 20, 0, 0, 1);
FractalTreeRec(level + 1);
GL.glPopMatrix();
GL.glPopMatrix();
}
}
void drawStar(Star star, bool isForShade)
{
if (star.toDraw == true)
{
GL.glPushMatrix();
GL.glTranslatef(0f, 0f, 1f);
GL.glTranslatef(star.X + (float)xExisOrigin, star.Y + (float)yExisOrigin, 3 - Math.Abs(2f * (float)Math.Cos(ballZMovement)));
GL.glRotatef(ballZtranslate, 0, 0, 1f);
if (!isForShade)
{
GL.glEnable(GL.GL_TEXTURE_2D);
GL.glColor3f(1.0f, 1.0f, 1.0f);
GL.glBindTexture(GL.GL_TEXTURE_2D, Textures[6]);
GL.glEnable(GL.GL_TEXTURE_GEN_S);
GL.glEnable(GL.GL_TEXTURE_GEN_T);
GL.glTexGeni(GL.GL_S, GL.GL_TEXTURE_GEN_MODE, (int)GL.GL_SPHERE_MAP);
GL.glTexGeni(GL.GL_T, GL.GL_TEXTURE_GEN_MODE, (int)GL.GL_SPHERE_MAP);
}
else
{
GL.glColor3d(0.2, 0.2, 0.2);
}
for (int i = 0; i < 5; i++)
{
GL.glRotatef(72, 1, 0, 0);
GL.glBegin(GL.GL_QUADS);
GL.glVertex3f(0f, 0f, 0);
GL.glVertex3f(0f, (float)Math.Sin(36), 1);
GL.glVertex3f(0f, 0, 3f);
GL.glVertex3f(0f, -(float)Math.Sin(36), 1);
GL.glEnd();
}
if (!isForShade)
{
GL.glDisable(GL.GL_TEXTURE_GEN_S);
GL.glDisable(GL.GL_TEXTURE_GEN_T);
GL.glDisable(GL.GL_TEXTURE_2D);
}
GL.glPopMatrix();
}
}
public void Draw()
{
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);
GL.glMatrixMode(GL.GL_MODELVIEW);
GL.glLoadIdentity();
GL.glTranslatef(0.0f, -1.5f, -6.0f);
GL.glRotatef(10, 1.0f, 0.0f, 0.0f);
GL.glRotatef(-tank.rotation, 0.0f, 1.0f, 0.0f);
GL.glRotatef(-tank.turretRotation, 0.0f, 1.0f, 0.0f);
GL.glTranslatef(-tank.posX, 0.0f, -tank.posZ);
//DrawAxes();
DrawAll();
//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);
}
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 Drawlake()
{
float[] lake_ambuse = { 0.0117f, 0.4296f, 0.6562f, 0.3f };
GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, lake_ambuse);
for (int ll = 0; ll < 6; ll++)
{
GL.glPushMatrix();
GL.glTranslated(160 - (ll * 70), 0, 0);
GL.glColor4f(0.0117f, 0.4296f, 0.6562f, 0.5f);
GL.glRotatef(90, 1, 0, 0);
GLU.gluDisk(obj, 0, lake_size, 30, 30);// size of lake
GL.glPopMatrix();
}
}
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();
}
void drawLake()
{
GL.glEnable(GL.GL_LIGHTING);
GL.glCallList(WATER_MAT);
GL.glPushMatrix();
if (ScrollValue[16] >= 0)
{
GL.glScaled(1, 1, 1 + ScrollValue[16]);
}
else
{
GL.glScaled(1 + ScrollValue[16], 1, 1);
}
GL.glTranslated(ScrollValue[12], 0, ScrollValue[13]);
GL.glRotated(90, 1, 0, 0);
GLU.gluDisk(obj, 0, ScrollValue[14], 30, 30);
GL.glPopMatrix();
GL.glDisable(GL.GL_LIGHTING);
}
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();
//!!!!!!!!!!!!!
}
public void Draw(bool isForShades)
{
GL.glPushMatrix();
GL.glScalef(-1, 1, 1);
GL.glRotatef(-90, 0, 1, 0);
GL.glTranslatef(7, 0, 0);
GL.glTranslatef(0, 0, (Drive % 46) - 23);
if (!isForShades)
{
GL.glEnable(GL.GL_LIGHTING);
GL.glCallList(CAR);
}
else
{
GL.glDisable(GL.GL_LIGHTING);
GL.glCallList(CAR_SHADOW);
}
GL.glPopMatrix();
}
void PrepareLists()
{
float ARM_length, SHOULDER_length;
ARM_length = 2;
ARM_angle = -45;
SHOULDER_length = 2.5f;
SHOULDER_angle = 10;
ROBOT_angle = 45;
r = 0.3f;
ROBOT_LIST = GL.glGenLists(3);
ARM_LIST = ROBOT_LIST + 1;
SHOULDER_LIST = ROBOT_LIST + 2;
GL.glPushMatrix();
GL.glNewList(ARM_LIST, GL.GL_COMPILE);
//cone
GL.glColor3f(0.5f, 0, 0);
GLU.gluCylinder(obj, r, 0, ARM_length, 20, 20);
GL.glTranslated(0, 0, ARM_length);
//internal disk
GL.glColor3f(1, 1, 0);
GLU.gluDisk(obj, 0, r * 0.5, 20, 20);
//external disk
GL.glColor3f(1, 0, 0);
GLU.gluDisk(obj, r * 0.5, r * 1.5, 20, 20);
GL.glEndList();
GL.glPopMatrix();
GL.glPushMatrix();
GL.glNewList(SHOULDER_LIST, GL.GL_COMPILE);
GL.glColor3f(0, 0.5f, 0);
GLU.gluCylinder(obj, r, r, SHOULDER_length, 20, 20);
GL.glTranslated(0, 0, SHOULDER_length);
GL.glColor3f(0, 1, 0);
GLU.gluSphere(obj, r * 1.2, 20, 20);
GL.glEndList();
GL.glPopMatrix();
CreateRobotList();
}
void DrawFigures()
{
GL.glPushMatrix();
GL.glEnable(GL.GL_COLOR_MATERIAL);
DrawLightSource();
GL.glCallList(handList);
GL.glEnd();
GL.glPopMatrix();
GL.glPushMatrix();
if (enableLightSource)
{
MakeShadowMatrix(ground);
}
GL.glMultMatrixf(cubeXform);
GL.glPopMatrix();
}
public void DrawAxes()
{
GL.glPushMatrix();
GL.glDisable(GL.GL_LIGHTING);
GL.glBegin(GL.GL_LINES);
//x RED
GL.glColor3f(1.0f, 0.0f, 0.0f);
GL.glVertex3f(0.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, 0.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, 0.0f);
GL.glVertex3f(0.0f, 0.0f, 3.0f);
GL.glEnd();
GL.glEnable(GL.GL_LIGHTING);
GL.glPopMatrix();
}
