private void DrawInit()
{
//Uncoment next procedure to take material properties in account
SetMaterial();
//only for demostration of possibilities, not very accurate
SetLight();
//Gl.glViewport(0, 0, this.ClientSize.Width, this.ClientSize.Height);
Gl.glClearColor(0, 0, 0, 0);
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glEnable(Gl.GL_DEPTH_TEST);
Gl.glEnable(Gl.GL_BLEND);
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
Gl.glGenTextures(2, Texture);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, Texture[0]);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
LoadTexture.loadBMP("saturn.jpg", this.Pict);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, Texture[1]);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
LoadTexture.loadRings();
CalculateDisk();
quadObj = Glu.gluNewQuadric();
Glu.gluQuadricTexture(quadObj, Gl.GL_TRUE);
}
private void DrawAgarrador(bool esIzquierdo)
{
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glPushMatrix();
Gl.glEnable(Gl.GL_LIGHTING);
Glu.GLUquadric quad = Glu.gluNewQuadric();
Gl.glTranslated((esIzquierdo ? -1 : 1) * ANCHO_RECTANGULO / 3d, LARGO_BASE + LARGO_PARAGOLPE + (LARGO_AGARRADOR / 2d), -RADIO_AGARRADOR);
Gl.glRotated(90, 1, 0, 0);
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT, LUZ_AZUL);
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, LUZ_AZUL);
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, this.LuzBrillo);
Gl.glMateriali(Gl.GL_FRONT, Gl.GL_SHININESS, this.Shininess);
Glu.gluCylinder(quad, RADIO_AGARRADOR, RADIO_AGARRADOR, LARGO_AGARRADOR, 20, 20);
Gl.glRotated(180, 1, 0, 0);
Glu.gluDisk(quad, 0, RADIO_AGARRADOR, 20, 20);
Glu.gluCylinder(quad, RADIO_AGARRADOR * 2d, RADIO_AGARRADOR * 2d, LARGO_AGARRADOR * 0.2, 20, 20);
Gl.glTranslated(0, 0, LARGO_AGARRADOR * 0.2d);
Glu.gluDisk(quad, 0, RADIO_AGARRADOR * 2d, 20, 20);
Glu.gluDeleteQuadric(quad);
Gl.glDisable(Gl.GL_LIGHTING);
Gl.glPopMatrix();
}
public Sphere(float xMin, float yMin, float zMin, float xMax, float yMax, float zMax)
: base(xMin, yMin, zMin, xMax, yMax, zMax)
{
if (xMax > xMin)
{
m_radius = xMax - xMin;
}
else
{
m_radius = xMin - xMax;
}
m_quadric = Glu.gluNewQuadric();
try
{
Glu.gluQuadricTexture(m_quadric, Gl.GL_TRUE);
Glu.gluQuadricDrawStyle(m_quadric, Glu.GLU_FILL);
Glu.gluQuadricNormals(m_quadric, Glu.GLU_SMOOTH);
Glu.gluQuadricOrientation(m_quadric, Glu.GLU_OUTSIDE);
}
finally //if any errors, delete quadric
{
Glu.gluDeleteQuadric(m_quadric);
}
}
protected void doorKnob()
{
int cullFace;
Gl.glGetBooleanv(Gl.GL_CULL_FACE, out cullFace);
Gl.glDisable(Gl.GL_CULL_FACE);
Glu.GLUquadric q = Glu.gluNewQuadric();
//Gl.glColor3d(1,1,1);
Gl.glColor3d(1, 1, 0);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, this.texturaKnob);
Glu.gluQuadricTexture(q, Gl.GL_TRUE);
Glu.gluQuadricNormals(q, Gl.GL_SMOOTH);
Gl.glPushMatrix();
Glu.gluCylinder(q, 5, 1, 1, 15, 3);
Glu.gluCylinder(q, 1, 1, 4, 10, 1);
Gl.glPushMatrix();
Gl.glTranslated(0, 0, 5);
Gl.glScaled(1, 1, .5);
Glu.gluSphere(q, 4, 10, 10);
Gl.glPopMatrix();
Gl.glPopMatrix();
Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);
Glu.gluDeleteQuadric(q);
if (cullFace != Gl.GL_FALSE)
{
Gl.glEnable(Gl.GL_CULL_FACE);
}
}
/// <summary>
/// Draws three selected vertices as spheres.
/// </summary>
private void DrawVertices()
{
Glu.GLUquadric quadobj = Glu.gluNewQuadric();
Glu.gluQuadricDrawStyle(quadobj, Glu.GLU_FILL);
if (vertices[0])
{
Gl.glColor3fv(aColor);
Gl.glPushMatrix();
Gl.glTranslatef(owner.TriVertices[0], owner.TriVertices[1], owner.TriVertices[2]);
Glu.gluSphere(quadobj, 2, 10, 10);
Gl.glPopMatrix();
}
if (vertices[1])
{
Gl.glColor3fv(bColor);
Gl.glPushMatrix();
Gl.glTranslatef(owner.TriVertices[3], owner.TriVertices[4], owner.TriVertices[5]);
Glu.gluSphere(quadobj, 2, 10, 10);
Gl.glPopMatrix();
}
if (vertices[2])
{
Gl.glColor3fv(cColor);
Gl.glPushMatrix();
Gl.glTranslatef(owner.TriVertices[6], owner.TriVertices[7], owner.TriVertices[8]);
Glu.gluSphere(quadobj, 2, 10, 10);
Gl.glPopMatrix();
}
Glu.gluDeleteQuadric(quadobj);
}
protected void pintaBisagra()
{
#region bisagras
Gl.glBindTexture(Gl.GL_TEXTURE_2D, this.texturaBisagra);
Gl.glColor3d(1, 1, 1);
Glu.GLUquadric q = Glu.gluNewQuadric();
Glu.gluQuadricTexture(q, Gl.GL_TRUE);
double h = (height - border) / 3;
double m = (height - border) / 2 - 4;
Gl.glPushMatrix();
Gl.glTranslated(0, m, 0);
Gl.glRotated(90, -1, 0, 0);
Glu.gluCylinder(q, 1, 1, 8, 10, 10);
Gl.glPopMatrix();
Gl.glPushMatrix();
Gl.glTranslated(0, m - h, 0);
Gl.glRotated(90, -1, 0, 0);
Glu.gluCylinder(q, 1, 1, 8, 10, 10);
Gl.glPopMatrix();
Gl.glPushMatrix();
Gl.glTranslated(0, m + h, 0);
Gl.glRotated(90, -1, 0, 0);
Glu.gluCylinder(q, 1, 1, 8, 10, 10);
Gl.glPopMatrix();
Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);
Glu.gluDeleteQuadric(q);
#endregion
}
/// <summary>
/// All setup for OpenGL goes here.
/// </summary>
/// <returns>
/// Returns <c>true</c> on success, otherwise <c>false</c>.
/// </returns>
private static bool InitGL() // All Setup For OpenGL Goes Here
{
if (!LoadGLTextures()) // If Loading The Textures Failed
{
return(false); // Return False
}
Gl.glEnable(Gl.GL_TEXTURE_2D); // Enable Texture Mapping
Gl.glShadeModel(Gl.GL_SMOOTH); // Enable Smooth Shading
Gl.glClearColor(0, 0, 0, 0.5f); // Black Background
Gl.glClearDepth(1); // Depth Buffer Setup
Gl.glEnable(Gl.GL_DEPTH_TEST); // Enables Depth Testing
Gl.glDepthFunc(Gl.GL_LEQUAL); // The Type Of Depth Testing To Do
Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST); // Really Nice Perspective Calculations
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_AMBIENT, LightAmbient); // Setup The Ambient Light
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_DIFFUSE, LightDiffuse); // Setup The Diffuse Light
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_POSITION, LightPosition); // Position The Light
Gl.glEnable(Gl.GL_LIGHT1); // Enable Light One
quadratic = Glu.gluNewQuadric(); // Create A Pointer To The Quadric Object (Return 0 If No Memory)
Glu.gluQuadricNormals(quadratic, Glu.GLU_SMOOTH); // Create Smooth Normals
Glu.gluQuadricTexture(quadratic, Gl.GL_TRUE); // Create Texture Coords
Gl.glTexGeni(Gl.GL_S, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_SPHERE_MAP); // Set The Texture Generation Mode For S To Sphere Mapping (NEW)
Gl.glTexGeni(Gl.GL_T, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_SPHERE_MAP); // Set The Texture Generation Mode For T To Sphere Mapping (NEW)
return(true); // Initialization Went OK
}
public void DrawCylinder()
{
if (!bCylinderDefined)
{
Gl.glNewList(LISTCYLINDER, Gl.GL_COMPILE);
Gl.glPushMatrix();
Glu.GLUquadric quadratic = Glu.gluNewQuadric(); // Create A Pointer To The Quadric Object
Glu.gluQuadricNormals(quadratic, Glu.GLU_SMOOTH); // Create Smooth Normals
Glu.gluQuadricTexture(quadratic, 32); // Create Texture Coords
Gl.glTranslatef(0.0f, 0.0f, -0.5f); // Center The Cylinder
Glu.gluQuadricOrientation(quadratic, Glu.GLU_OUTSIDE);
Glu.gluCylinder(quadratic, 0.5f, 0.5f, 1.0f, 32, 32);
//glTranslatef(0.0f,0.0f,-0.5f);
Gl.glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
Glu.gluDisk(quadratic, 0.0f, 0.5f, 32, 32);
Gl.glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
Gl.glTranslatef(0.0f, 0.0f, 1.0f);
Glu.gluDisk(quadratic, 0.0f, 0.5f, 32, 32);
Gl.glPopMatrix();
Gl.glEndList();
bCylinderDefined = true;
}
Gl.glCallList(LISTCYLINDER);
}
protected void pintaCadena()
{
#if drawCenter
Gl.glPushMatrix();
Gl.glTranslated(position.X, position.Y, position.Z);
Glu.GLUquadric q = Glu.gluNewQuadric();
Gl.glColor3d(1, 1, 0);
Glu.gluSphere(q, 2, 5, 5);
Glu.gluDeleteQuadric(q);
Gl.glPopMatrix();
#endif
Gl.glPushMatrix();
Gl.glTranslated(position.X, position.Y + yeslabon, position.Z);
Gl.glColor3d(128 / 256.0, 64 / 256.0, 64 / 256.0);
int cantidadEslabones = (int)Math.Ceiling(length / (yeslabon - breadth));
//for (double d =0; d <= length; d+=yeslabon+breadth)
for (int i = 0; i < cantidadEslabones; i++)
{
Gl.glTranslated(0, -yeslabon + breadth, 0);
Gl.glRotated(90, 0, 1, 0);
pintaEslabon();
}
Gl.glPopMatrix();
}
void DrawSelectionHandle()
{
graphics.PushMatrix();
graphics.Scale(1.5, 1.5, 1.5);
Glu.GLUquadric quadratic = Glu.gluNewQuadric(); // Create A Pointer To The Quadric Entity
Glu.gluQuadricNormals(quadratic, Glu.GLU_SMOOTH); // Create Smooth Normals
Glu.gluQuadricOrientation(quadratic, Glu.GLU_OUTSIDE);
graphics.Translate(0.0f, 0.0f, -0.025f); // Center The Cylinder
Glu.gluCylinder(quadratic, 0.5f, 0.5f, 0.05f, 20, 3);
Glu.gluQuadricOrientation(quadratic, Glu.GLU_INSIDE);
Glu.gluCylinder(quadratic, 0.48f, 0.5f, 0.05f, 20, 3);
Glu.gluQuadricOrientation(quadratic, Glu.GLU_OUTSIDE);
graphics.Rotate(180.0f, 1.0f, 0.0f, 0.0f);
Glu.gluDisk(quadratic, 0.48f, 0.5f, 20, 3);
graphics.Rotate(180.0f, 1.0f, 0.0f, 0.0f);
graphics.Translate(0.0f, 0.0f, 0.05f);
Glu.gluDisk(quadratic, 0.48f, 0.5f, 20, 3);
graphics.PopMatrix();
}
private void RenderAvatars(RegionContextBase rcontext, RegionRenderInfo rri)
{
OMV.Vector3 avatarColor = ModuleParams.ParamVector3(m_renderer.m_moduleName + ".OGL.Avatar.Color");
float avatarTransparancy = ModuleParams.ParamFloat(m_renderer.m_moduleName + ".OGL.Avatar.Transparancy");
float[] m_avatarMaterialColor = { avatarColor.X, avatarColor.Y, avatarColor.Z, avatarTransparancy };
lock (rri.renderAvatarList) {
foreach (RenderableAvatar rav in rri.renderAvatarList.Values)
{
GL.PushMatrix();
GL.Translate(rav.avatar.RegionPosition.X,
rav.avatar.RegionPosition.Y,
rav.avatar.RegionPosition.Z);
GL.Material(MaterialFace.FrontAndBack, MaterialParameter.Diffuse, m_avatarMaterialColor);
GL.Disable(EnableCap.Texture2D);
Glu.GLUquadric quad = Glu.gluNewQuadric();
Glu.gluSphere(quad, 0.5d, 10, 10);
Glu.gluDeleteQuadric(quad);
GL.PopMatrix();
}
}
}
/* Create a display list to draw a galaxy,
* since To draw even a small polygon such a number of times is very expensive*/
private void CreateDisplayList(int a)
{
// generation of the display list
DisplayListNom[a] = Gl.glGenLists(a);
// Start creating a list
Gl.glNewList(DisplayListNom[a], Gl.GL_COMPILE);
Gl.glPushMatrix();
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, GalacticForm.mGlTextureObject[a]);
Gl.glTranslated(0, 0, 0);
Gl.glBegin(Gl.GL_QUADS);
Glu.GLUquadric myEarth = Glu.gluNewQuadric();
Glu.gluQuadricTexture(myEarth, Gl.GL_TRUE);
//Glu.gluSphere(myEarth, 0.1, 32, 32);
Glu.gluDisk(myEarth, 0.001, size, 32, 32);
//Glut.glutSolidSphere(0.05, 32, 32);
Glu.gluDeleteQuadric(myEarth);
Gl.glPopMatrix();
Gl.glDisable(Gl.GL_TEXTURE_2D);
//Glut.glutSolidSphere(0.05, 32, 32);
Gl.glEnd();
Gl.glPushMatrix();
// Finish drawing the galaxy
Gl.glEndList();
// Flag - display list is created
isDisplayList = true;
}
/// <summary>
/// All setup for OpenGL goes here.
/// </summary>
/// <returns>
/// Returns <c>true</c> on success, otherwise <c>false</c>.
/// </returns>
private static bool InitGL() // All Setup For OpenGL Goes Here
{
if (!LoadGLTextures()) // If Loading The Textures Failed
{
return(false); // Return False
}
Gl.glShadeModel(Gl.GL_SMOOTH); // Enable Smooth Shading
Gl.glClearColor(0.2f, 0.5f, 1, 1); // Background
Gl.glClearDepth(1); // Depth Buffer Setup
Gl.glClearStencil(0); // Clear The Stencil Buffer To 0
Gl.glEnable(Gl.GL_DEPTH_TEST); // Enables Depth Testing
Gl.glDepthFunc(Gl.GL_LEQUAL); // The Type Of Depth Testing To Do
Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST); // Really Nice Perspective Calculations
Gl.glEnable(Gl.GL_TEXTURE_2D); // Enable 2D Texture Mapping
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_AMBIENT, LightAmb); // Set The Ambient Lighting For Light0
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_DIFFUSE, LightDif); // Set The Diffuse Lighting For Light0
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, LightPos); // Set The Position For Light0
Gl.glEnable(Gl.GL_LIGHT0); // Enable Light 0
Gl.glEnable(Gl.GL_LIGHTING); // Enable Lighting
q = Glu.gluNewQuadric(); // Create A New Quadratic
Glu.gluQuadricNormals(q, Gl.GL_SMOOTH); // Generate Smooth Normals For The Quad
Glu.gluQuadricTexture(q, Gl.GL_TRUE); // Enable Texture Coords For The Quad
Gl.glTexGeni(Gl.GL_S, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_SPHERE_MAP); // Set Up Sphere Mapping
Gl.glTexGeni(Gl.GL_T, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_SPHERE_MAP); // Set Up Sphere Mapping
return(true); // Initialization Went OK
}
protected override void Particular()
{
//Gl.glColor3d(0.26171875,0.55078125,0.69140625);
Gl.glColor3d(1, 1, 1);
Gl.glPushMatrix();
Gl.glBindTexture(Gl.GL_TEXTURE_2D, GlUtils.Texture("COLCHON"));
GlUtils.PintaOrtoedro(largo, 10, ancho, true);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, GlUtils.Texture("WOOD1"));
Glu.GLUquadric q = Glu.gluNewQuadric();
Glu.gluQuadricTexture(q, Gl.GL_TRUE);
Gl.glTranslated(-largo + 5, -10, -ancho + 5);
Gl.glRotated(90, 1, 0, 0);
Glu.gluCylinder(q, 5, 2, 20, 20, 20);
Gl.glRotated(-90, 1, 0, 0);
Gl.glTranslated(0, 0, 2 * ancho - 10);
Gl.glRotated(90, 1, 0, 0);
Glu.gluCylinder(q, 5, 2, 20, 20, 20);
Gl.glRotated(-90, 1, 0, 0);
Gl.glTranslated(2 * largo - 10, 0, 0);
Gl.glRotated(90, 1, 0, 0);
Glu.gluCylinder(q, 5, 2, 20, 20, 20);
Gl.glRotated(-90, 1, 0, 0);
Gl.glTranslated(0, 0, -2 * ancho + 10);
Gl.glRotated(90, 1, 0, 0);
Glu.gluCylinder(q, 5, 2, 20, 20, 20);
Gl.glRotated(-90, 1, 0, 0);
Gl.glPopMatrix();
// yInc = 30;
Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);
}
/// <summary>
/// Draws the corners of one selected Triangle as spheres.
/// </summary>
private void DrawCorners()
{
Glu.GLUquadric quadobj = Glu.gluNewQuadric();
Glu.gluQuadricDrawStyle(quadobj, Glu.GLU_FILL);
Gl.glColor3fv(aColor);
Gl.glPushMatrix();
Gl.glTranslatef(owner.Corners[0], owner.Corners[1], owner.Corners[2]);
Glu.gluSphere(quadobj, scale / 400, 10, 10);
Gl.glPopMatrix();
Gl.glColor3fv(bColor);
Gl.glPushMatrix();
Gl.glTranslatef(owner.Corners[3], owner.Corners[4], owner.Corners[5]);
Glu.gluSphere(quadobj, scale / 400, 10, 10);
Gl.glPopMatrix();
Gl.glColor3fv(cColor);
Gl.glPushMatrix();
Gl.glTranslatef(owner.Corners[6], owner.Corners[7], owner.Corners[8]);
Glu.gluSphere(quadobj, scale / 400, 10, 10);
Gl.glPopMatrix();
Glu.gluDeleteQuadric(quadobj);
}
public override void Render()
{
if (!canCullFace)
{
Gl.glGetBooleanv(Gl.GL_CULL_FACE, out cullFace);
Gl.glDisable(Gl.GL_CULL_FACE);
}
#region Pintar una gran esfera en el 0,0 del objeto
#if drawCenter
Gl.glPushMatrix();
Gl.glTranslated(center.X, center.Y, center.Z);
Glu.GLUquadric q = Glu.gluNewQuadric();
Gl.glColor3d(1, 0, 0);
Glu.gluSphere(q, 2, 5, 5);
Glu.gluDeleteQuadric(q);
Gl.glPopMatrix();
#endif
#endregion
Gl.glPushMatrix();
Gl.glTranslated(center.X, center.Y + YInc, center.Z);
Gl.glRotated(angle, 0, 1, 0);
if (this.customRendering)
{
this.customRenderer();
}
else
{
Gl.glCallList(idObject);
}
Gl.glPopMatrix();
if (!canCullFace && cullFace != Gl.GL_FALSE)
{
Gl.glEnable(Gl.GL_CULL_FACE);
}
}
protected override void Particular()
{
Gl.glBindTexture(Gl.GL_TEXTURE_2D, GlUtils.Texture("old7"));
Gl.glLightModeli(Gl.GL_LIGHT_MODEL_TWO_SIDE, 1);
Glu.GLUquadric q = Glu.gluNewQuadric();
Glu.gluQuadricTexture(q, Gl.GL_TRUE);
Gl.glColor3d(1, 1, 1);
Gl.glPushMatrix();
Gl.glRotated(90, 1, 4, 0);
Glu.gluDisk(q, 0, 5 * 2, 20, 20);
Gl.glRotated(180, 1, 0, 0);
Glu.gluCylinder(q, 5 * 2, 8 * 2, 3 * 2, 20, 20);
Gl.glTranslated(0, 0, 2.5 * 2);
Gl.glColor3d(0, 0, 0);
Glu.gluDisk(q, 14.8, 15, 20, 20);
Gl.glTranslated(0, 0, -2.5 * 2);
Gl.glRotated(90, 1, 4, 0);
Gl.glPopMatrix();
yInc = 0;
Gl.glColor3d(1, 1, 1);
Glu.gluDeleteQuadric(q);
Gl.glLightModeli(Gl.GL_LIGHT_MODEL_TWO_SIDE, 0);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);
}
/// <summary>
/// Zeichenroutine für o2Object wird überschieben, da Sonne eine Lichtquelle sind
/// </summary>
public override void DrawObject()
{
float X = Position.x;
float Y = Position.y;
float Z = Position.z;
float r = Size;
float[] Color = { Farbe[0], Farbe[1], Farbe[2], Mass / PlanetAdvanced2.initSunMass };
Gl.glDisable(Gl.GL_LIGHTING); // Beleuchtung Ausmachen, da die Sonne ja die LichtQuelle ist.
Gl.glPushMatrix();
Gl.glTranslatef(X, Y, Z);
float[] light0Pos = { 0f, 0f, 0f, 1.0f };
Gl.glLightfv(_light, Gl.GL_POSITION, light0Pos); // Lichtquelle0 in der Sonne
Gl.glEnable(_light);
Gl.glColor3f(Farbe[0], Farbe[1], Farbe[2]);
Glu.GLUquadric obj = Glu.gluNewQuadric();
Glu.gluSphere(obj, r, 20, 20);
Gl.glPopMatrix();
if (StaticVars.Light)
{
Gl.glEnable(Gl.GL_LIGHTING);
}
}
/// <summary> Рисует гирлянду из сфер. </summary>
private void DrawSpheres()
{
Glu.GLUquadric quad = Glu.gluNewQuadric();
for (int i = 0; i < 50; i++)
{
Vector3D position =
new Vector3D((float)((2.0 + 3.0 * i / 50.0) * Math.Sin(i)),
(float)((2.0 + 3.0 * i / 50.0) * Math.Cos(i)),
(float)(-4.0 + 9.0 * i / 50.0));
Gl.glPushMatrix();
Gl.glTranslatef(position.X * (float)(Math.Sin(time / 100.0)),
position.Y * (float)(Math.Cos(time / 100.0)),
position.Z * (float)(0.5 + 0.5 * Math.Sin(time / 100.0)));
Gl.glColor3fv(Vector3D.Abs(position / 5.0f).ToArray());
Glu.gluSphere(quad, 0.3f, 20, 20);
Gl.glPopMatrix();
}
Glu.gluDeleteQuadric(quad);
}
public Sphere(float xMin, float yMin, float zMin, float xMax, float yMax, float zMax)
: base(xMin, yMin, zMin, xMax, yMax, zMax)
{
if (xMax > xMin)
{
m_radius = xMax - xMin;
}
else
{
m_radius = xMin - xMax;
}
m_quadric = Glu.gluNewQuadric();
try
{
Glu.gluQuadricTexture(m_quadric, Gl.GL_TRUE);
Glu.gluQuadricDrawStyle(m_quadric, Glu.GLU_FILL);
Glu.gluQuadricNormals(m_quadric, Glu.GLU_SMOOTH);
Glu.gluQuadricOrientation(m_quadric, Glu.GLU_OUTSIDE);
}
finally //if any errors, delete quadric
{
Glu.gluDeleteQuadric(m_quadric);
}
}
public override void Recompile()
{
this.abaj.Recompile();
Gl.glNewList(idVisualizar, Gl.GL_COMPILE);
Gl.glPushMatrix();
Gl.glDisable(Gl.GL_CULL_FACE);
Glu.GLUquadric sph = Glu.gluNewQuadric();
Glu.gluQuadricOrientation(sph, Glu.GLU_OUTSIDE);
Gl.glTranslated(start.x, start.y, start.z);
Gl.glTranslated(-(Math.Sqrt(Math.Pow(this.alto, 2) - Math.Pow(this.alto, 2) / 4)), 0, 0);
Gl.glRotated(15, 0, 0, 1);
Gl.glColor3fv(color);
Gl.glClipPlane(Gl.GL_CLIP_PLANE0, new double[] { 1.0, 0.0, 0, -(Math.Sqrt(Math.Pow(this.alto, 2) - Math.Pow(this.alto, 2) / 4)) });
Gl.glEnable(Gl.GL_CLIP_PLANE0);
Glu.gluQuadricNormals(sph, Glu.GLU_SMOOTH);
Glu.gluCylinder(sph, this.alto, this.alto, this.largo, 32, 32);
sph = Glu.gluNewQuadric();
Glu.gluQuadricNormals(sph, Glu.GLU_SMOOTH);
Glu.gluDisk(sph, 0, this.alto, 32, 32);
sph = Glu.gluNewQuadric();
Glu.gluQuadricNormals(sph, Glu.GLU_SMOOTH);
Gl.glTranslated(0, 0, this.largo);
Glu.gluDisk(sph, 0, this.alto, 32, 32);
Gl.glDisable(Gl.GL_CLIP_PLANE0);
Gl.glEnable(Gl.GL_CULL_FACE);
Gl.glPopMatrix();
Gl.glEndList();
}
}// drawCylinder
public static void drawCylinderTranslucent(Vector3d u, Vector3d v, double r, Color c)
{
Gl.glEnable(Gl.GL_BLEND);
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
Gl.glDisable(Gl.GL_CULL_FACE);
Glu.GLUquadric quad = Glu.gluNewQuadric();
double height = (u - v).Length();
Vector3d dir = (v - u).normalize();
double angle = Math.Acos(dir.z / dir.Length()) * 180 / Math.PI;
drawSphere(u, r, c);
Gl.glColor3ub(c.R, c.G, c.B);
Gl.glPushMatrix();
Gl.glTranslated(u.x, u.y, u.z);
Gl.glRotated(angle, -dir.y, dir.x, 0);
Glu.gluCylinder(quad, r, r, height, _NSlices, _NSlices);
Gl.glPopMatrix();
drawSphere(v, r, c);
Glu.gluDeleteQuadric(quad);
Gl.glDisable(Gl.GL_BLEND);
Gl.glDisable(Gl.GL_CULL_FACE);
}// drawCylinderTranslucent
/// <summary>Нарисовать дерево</summary>
private void DrawTrees()
{
Glu.GLUquadric q = Glu.gluNewQuadric();
Glu.gluQuadricTexture(q, Gl.GL_TRUE);
Glu.gluQuadricDrawStyle(q, Glu.GLU_FILL);
Gl.glTranslated(0.0, -0.5, 0.0);
Gl.glRotated(90, -1.0, 0.0, 0.0);
{ // рисуем ствол
// включаем режим текстурирования, указывая индификатор WoodTexture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, WoodTexture);
// рисуем цилиндр
Glu.gluCylinder(q, 0.2, 0.2, 2, 50, 50);
}
{ // рисуем крону
// включаем режим текстурирования, указывая индификатор TreeTexture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, TreeTexture);
// рисуем сферу
Gl.glTranslated(0.0, 0.0, 2.0);
Glu.gluSphere(q, 1, 50, 50);
Gl.glTranslated(0.0, 0.0, -2.0);
}
Gl.glRotated(90, 1.0, 0.0, 0.0);
Gl.glTranslated(0.0, 0.5, 0.0);
Glu.gluDeleteQuadric(q);
}
public override void Render()
{
#if drawCenter
Gl.glPushMatrix();
Gl.glTranslated(position.X, position.Y, position.Z);
Glu.GLUquadric qu = Glu.gluNewQuadric();
Gl.glColor3d(1, 1, 0);
Glu.gluSphere(qu, 2, 5, 5);
Glu.gluDeleteQuadric(qu);
Gl.glPopMatrix();
#endif
Glu.GLUquadric q = Glu.gluNewQuadric();
Gl.glPushMatrix();
Gl.glTranslated(position.X, position.Y, position.Z);
Gl.glColor3d(128 / 256.0, 64 / 256.0, 64 / 256.0);
Gl.glColor3d(.55, .425, .425);
Gl.glRotated(90, 1, 0, 0);
Glu.gluCylinder(q, 10, 1, 3, 10, 5);
Gl.glPopMatrix();
Glu.gluDeleteQuadric(q);
c.Render();
Gl.glTranslated(position.X, position.Y - length - 30, position.Z);
renderLamp();
Gl.glPopMatrix();
}
private void Init(double Base, int Slices, int Stacks)
{
mBase = Base;
mSlices = Slices;
mStacks = Stacks;
mQuadric = Glu.gluNewQuadric();
//Glu.gluQuadricOrientation(mQuadricDisk, Glu.GLU_INSIDE);
}
private void Init(double Base, double Height, int Slices, int Stacks)
{
mBase = Base;
mHeight = Height;
mSlices = Slices;
mStacks = Stacks;
mQuadricCone = Glu.gluNewQuadric();
mQuadricDisk = Glu.gluNewQuadric();
Glu.gluQuadricOrientation(mQuadricDisk, Glu.GLU_INSIDE);
}
private void Init(_Vector3D p1, _Vector3D p2)
{
mBegin = p1;
mEnd = p2;
ChangeMatrix();
pObj = Glu.gluNewQuadric();
Glu.gluQuadricDrawStyle(pObj, Glu.GLU_FILL);
Glu.gluQuadricNormals(pObj, Glu.GLU_SMOOTH);
Glu.gluQuadricOrientation(pObj, Glu.GLU_OUTSIDE);
Glu.gluQuadricTexture(pObj, Glu.GLU_FALSE);
}
}// drawCylinderTranslucent
public static void drawSphere(Vector3d o, double r, Color c)
{
Gl.glShadeModel(Gl.GL_SMOOTH);
Glu.GLUquadric quad = Glu.gluNewQuadric();
Gl.glColor3ub(c.R, c.G, c.B);
Gl.glPushMatrix();
Gl.glTranslated(o.x, o.y, o.z);
Glu.gluSphere(quad, r / 2, _NSlices, _NSlices);
Gl.glPopMatrix();
Glu.gluDeleteQuadric(quad);
}// drawSphere
void pintaPata(double alto)
{
Glu.GLUquadric q = Glu.gluNewQuadric();
Glu.gluQuadricTexture(q, Gl.GL_TRUE);
Gl.glTranslated(0, -alto, 0);
Gl.glRotated(90, -1, 0, 0);
Glu.gluCylinder(q, 5, 8, 2 * alto, 20, 20);
Gl.glRotated(-90, -1, 0, 0);
Gl.glTranslated(0, alto, 0);
Glu.gluDeleteQuadric(q);
}
private void DrawLinterna(bool prenderLinterna)
{
float[] locomotora_light_color = new float[4] {
1.0f, 1.0f, 1.0f, 1.0f
};
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glPushMatrix();
Gl.glEnable(Gl.GL_LIGHTING);
Glu.GLUquadric quad = Glu.gluNewQuadric();
Gl.glTranslated(0, LARGO_BASE - LARGO_BASE * 0.1d, RADIO_TROMPA * 2d);
Gl.glLightfv(Gl.GL_LIGHT6, Gl.GL_POSITION, light_linterna_position);
Gl.glLightfv(Gl.GL_LIGHT6, Gl.GL_SPOT_DIRECTION, light_linterna_direction);
Gl.glLightfv(Gl.GL_LIGHT6, Gl.GL_DIFFUSE, locomotora_light_color);
Gl.glLightfv(Gl.GL_LIGHT6, Gl.GL_AMBIENT, new float[4] {
0f, 0f, 0f, 1f
});
Gl.glLightfv(Gl.GL_LIGHT6, Gl.GL_SPECULAR, new float[4] {
1f, 1f, 1f, 1f
});
Gl.glLightfv(Gl.GL_LIGHT6, Gl.GL_LINEAR_ATTENUATION, new float[] { .01f });
Gl.glLightfv(Gl.GL_LIGHT6, Gl.GL_SPOT_CUTOFF, new float[] { 30.0f });
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT, LUZ_ROJO);
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_DIFFUSE, LUZ_ROJO);
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, this.LuzBrillo);
Gl.glMateriali(Gl.GL_FRONT, Gl.GL_SHININESS, this.Shininess);
Glu.gluCylinder(quad, RADIO_SOSTENEDOR_LUZ, RADIO_SOSTENEDOR_LUZ, ALTO_SOSTENEDOR_LUZ, 20, 20);
Gl.glTranslated(0, ANCHO_CONTENEDOR_LUZ * 0.5d, ALTO_SOSTENEDOR_LUZ + RADIO_CONTENEDOR_LUZ);
Gl.glRotated(90, 1, 0, 0);
Glu.gluCylinder(quad, RADIO_CONTENEDOR_LUZ, RADIO_CONTENEDOR_LUZ, ANCHO_CONTENEDOR_LUZ, 20, 20);
Gl.glTranslated(0, 0, ANCHO_CONTENEDOR_LUZ);
Glu.gluDisk(quad, 0, RADIO_CONTENEDOR_LUZ, 20, 20);
if (prenderLinterna)
{
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_EMISSION, this.luzEmicionPrendida);
}
Gl.glTranslated(0, 0, -(ANCHO_CONTENEDOR_LUZ * 0.8d));
Gl.glRotated(180, 1, 0, 0);
//Gl.glScaled(0.5d, 1, 2);
Glu.gluDisk(quad, 0, RADIO_CONTENEDOR_LUZ, 20, 20);
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_EMISSION, this.luzEmicionApagada);
Glu.gluDeleteQuadric(quad);
Gl.glDisable(Gl.GL_LIGHTING);
Gl.glPopMatrix();
}
public void Create()
{
Glu.GLUquadric quadratic = Glu.gluNewQuadric();
Glu.gluQuadricNormals(quadratic, Glu.GLU_SMOOTH);
Glu.gluQuadricTexture(quadratic, Gl.GL_TRUE);
list = Gl.glGenLists(1);
Gl.glNewList(list, Gl.GL_COMPILE);
Gl.glPushMatrix();
Gl.glRotated(270, 1, 0, 0);
Glu.gluSphere(quadratic, 2, 32, 32);
Gl.glPopMatrix();
Gl.glEndList();
}
public GluSphere(CubeMapTexture texture, Vector3f position, float radius, int slices)
{
this.texture = texture;
this.position = position;
this.radius = radius;
this.slices = slices;
quad = Glu.gluNewQuadric();
Glu.gluQuadricNormals(quad, Glu.GLU_SMOOTH); // Create Smooth Normals ( NEW )
Glu.gluQuadricTexture(quad, Gl.GL_TRUE); // Create Texture Coords ( NEW )
Glu.gluQuadricDrawStyle(quad, Glu.GLU_FILL);
angle = 0.0f;
x_axis = 0.0f;
y_axis = 0.0f;
z_axis = 0.0f;
}
/// <summary>
/// All setup for OpenGL goes here.
/// </summary>
/// <returns>
/// Returns <c>true</c> on success, otherwise <c>false</c>.
/// </returns>
private static bool InitGL()
{
// All Setup For OpenGL Goes Here
if(!LoadGLTextures()) { // If Loading The Textures Failed
return false; // Return False
}
Gl.glEnable(Gl.GL_TEXTURE_2D); // Enable Texture Mapping
Gl.glShadeModel(Gl.GL_SMOOTH); // Enable Smooth Shading
Gl.glClearColor(0, 0, 0, 0.5f); // Black Background
Gl.glClearDepth(1); // Depth Buffer Setup
Gl.glEnable(Gl.GL_DEPTH_TEST); // Enables Depth Testing
Gl.glDepthFunc(Gl.GL_LEQUAL); // The Type Of Depth Testing To Do
Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST); // Really Nice Perspective Calculations
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_AMBIENT, LightAmbient); // Setup The Ambient Light
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_DIFFUSE, LightDiffuse); // Setup The Diffuse Light
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_POSITION,LightPosition); // Position The Light
Gl.glEnable(Gl.GL_LIGHT1); // Enable Light One
quadratic = Glu.gluNewQuadric(); // Create A Pointer To The Quadric Object (Return 0 If No Memory)
Glu.gluQuadricNormals(quadratic, Glu.GLU_SMOOTH); // Create Smooth Normals
Glu.gluQuadricTexture(quadratic, Gl.GL_TRUE); // Create Texture Coords
Gl.glTexGeni(Gl.GL_S, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_SPHERE_MAP); // Set The Texture Generation Mode For S To Sphere Mapping (NEW)
Gl.glTexGeni(Gl.GL_T, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_SPHERE_MAP); // Set The Texture Generation Mode For T To Sphere Mapping (NEW)
return true; // Initialization Went OK
}
/// <summary>
/// All setup for OpenGL goes here.
/// </summary>
/// <returns>
/// <c>true</c> on successful initialization, otherwise <c>false</c>.
/// </returns>
private static bool InitGL()
{
if(!LoadGLTextures()) { // Jump To Texture Loading Routine
return false; // If Texture Didn't Load Return False
}
Gl.glEnable(Gl.GL_TEXTURE_2D); // Enable Texture Mapping
Gl.glShadeModel(Gl.GL_SMOOTH); // Enable Smooth Shading
Gl.glClearColor(0, 0, 0, 0.5f); // Black Background
Gl.glClearDepth(1); // Depth Buffer Setup
Gl.glEnable(Gl.GL_DEPTH_TEST); // Enables Depth Testing
Gl.glDepthFunc(Gl.GL_LEQUAL); // The Type Of Depth Testing To Do
Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST); // Really Nice Perspective Calculations
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_AMBIENT, lightAmbient); // Setup The Ambient Light
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_DIFFUSE, lightDiffuse); // Setup The Diffuse Light
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_POSITION, lightPosition); // Position The Light
Gl.glEnable(Gl.GL_LIGHT1); // Enable Light One
quadratic = Glu.gluNewQuadric(); // Create A Pointer To The Quadric Object (Return 0 If No Memory) (NEW)
Glu.gluQuadricNormals(quadratic, Glu.GLU_SMOOTH); // Create Smooth Normals (NEW)
Glu.gluQuadricTexture(quadratic, Gl.GL_TRUE); // Create Texture Coords (NEW)
return true;
}
private void Initialize()
{
lights_enabled = false;
//yellow lights
light_red = 255;
light_green = 255;
light_blue = 77;
//camera + -
cameraControl = -5;
float[] ambient = { 0.2f, 0.2f, 0.2f, 1.0f };
float[] diffuse = { 1.0f, 1.0f, 1.0f, 1.0f };
//float[] ambiental = { 0.5f, 0.5f, 0.5f, 1.0f };
Bitmap image; // promenljiva u koju ucitavamo sadrzaj slike
Gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
Gl.glEnable(Gl.GL_DEPTH_TEST);
Gl.glEnable(Gl.GL_CULL_FACE);
Gl.glLoadIdentity();
Gl.glLightModelfv(Gl.GL_LIGHT_MODEL_AMBIENT, ambient);
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_SPOT_DIRECTION, new float[] { 0, 1, 0 });
//cut-off 30
Gl.glLightf(Gl.GL_LIGHT0, Gl.GL_SPOT_CUTOFF, 30f);
//ukljucivanje svetla i normalizacije
Gl.glEnable(Gl.GL_LIGHTING);
Gl.glEnable(Gl.GL_LIGHT0);
//Gl.glEnable(Gl.GL_LIGHT1);
Gl.glEnable(Gl.GL_NORMALIZE);
//color tracking
Gl.glEnable(Gl.GL_COLOR_MATERIAL);
Gl.glColorMaterial(Gl.GL_FRONT, Gl.GL_AMBIENT_AND_DIFFUSE);
//teksture
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glTexEnvi(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_MODULATE);
// Ucitaj slike i kreiraj teksture
Gl.glGenTextures(textureCount, textures);
for (int i = 0; i < textureCount; ++i)
{
// Pridruzi teksturu odgovarajucem identifikatoru
Gl.glBindTexture(Gl.GL_TEXTURE_2D, textures[i]);
// Ucitaj sliku i podesi parametre teksture
image = new Bitmap(textureFiles[i]);
// rotiramo sliku zbog koordinantog sistema opengl-a
image.RotateFlip(RotateFlipType.RotateNoneFlipY);
Rectangle rect = new Rectangle(0, 0, image.Width, image.Height);
// RGBA format (dozvoljena providnost slike tj. alfa kanal)
BitmapData imageData = image.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly,
PixelFormat.Format32bppArgb);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGBA8, image.Width, image.Height, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, imageData.Scan0);
// TODO 1: Podesiti texture filtre: max = linear, min=linear_mipmap_linear,
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
image.UnlockBits(imageData);
image.Dispose();
}
//inicijalizacija 30 sijalica
mf_sijalice = new List<Glu.GLUquadric>();
int broj_sijalica = 30;
for (int i = 0; i < broj_sijalica; i++)
{
Glu.GLUquadric tmp = Glu.gluNewQuadric();
Glu.gluQuadricTexture(tmp, Gl.GL_TRUE);
Glu.gluQuadricNormals(tmp, Glu.GLU_SMOOTH);
mf_sijalice.Add(tmp);
}
light_source = Glu.gluNewQuadric();
Glu.gluQuadricNormals(light_source, Glu.GLU_SMOOTH);
Draw();
}
/// <summary>
/// Crta sijalice.
/// </summary>
private void DrawBulbs()
{
Gl.glPushMatrix();
Gl.glColor3f((float)color[0]/255, (float)color[1]/255, (float)color[2]/255);
// TODO 2d Ukljuci automatsko generisanje normala.
Gl.glEnable(Gl.GL_NORMALIZE);
gluObject = Glu.gluNewQuadric();
Glu.gluQuadricOrientation(gluObject, Glu.GLU_OUTSIDE);
Gl.glScalef(sFactor, sFactor, sFactor);
Gl.glTranslatef(-240f, 16.0f, 760.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(480.0f, 0.0f, 1520f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glTranslatef(0.0f, 0.0f, -117.0f);
Glu.gluSphere(gluObject, 13.0f, 8, 8);
Gl.glPopMatrix();
}
public void initialize()
{
m_gluObj = Glu.gluNewQuadric();
Glu.gluQuadricNormals(m_gluObj, Glu.GLU_SMOOTH);
//Glu.gluQuadricTexture(m_gluObj, Gl.GL_TRUE);
}
private void AnT_Load(object sender, EventArgs e)
{
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
Gl.glClearColor(0, 0, 0, 1);
Gl.glViewport(0, 0, AnT.Width, AnT.Height);
Gl.glEnable(Gl.GL_DEPTH_TEST);
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Glu.gluPerspective(45, (float)AnT.Width / (float)AnT.Height, 0.1, 5000);
Gl.glTranslated(0, 0, -6);
Gl.glEnable(Gl.GL_TEXTURE_2D); // Enable Texture Mapping ( NEW )
Gl.glShadeModel(Gl.GL_SMOOTH); // Enable Smooth Shading
Gl.glClearColor(0, 0, 0, 0.5f); // Black Background
Gl.glClearDepth(1); // Depth Buffer Setup
Gl.glEnable(Gl.GL_DEPTH_TEST); // Enables Depth Testing
Gl.glDepthFunc(Gl.GL_LEQUAL); // The Type Of Depth Testing To Do
Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST);
quadratic = Glu.gluNewQuadric();
Glu.gluQuadricNormals(quadratic, Glu.GLU_SMOOTH); // Create Smooth Normals (NEW)
Glu.gluQuadricTexture(quadratic, Gl.GL_TRUE); // Create Texture Coords (NEW)
Bitmap[] textureImage = new Bitmap[3];
textureImage[0] = new Bitmap("22.bmp");
textureImage[1] = new Bitmap("666.bmp");
textureImage[2] = new Bitmap("stars-2.jpg");
Gl.glGenTextures(3, texture); // Create The Texture
textureImage[0].RotateFlip(RotateFlipType.RotateNoneFlipY); // Flip The Bitmap Along The Y-Axis
textureImage[1].RotateFlip(RotateFlipType.RotateNoneFlipY);
textureImage[2].RotateFlip(RotateFlipType.RotateNoneFlipY);
//Rectangle For Locking The Bitmap In Memory
Rectangle rectangle = new Rectangle(0, 0, textureImage[0].Width, textureImage[0].Height);
Rectangle rectangle1 = new Rectangle(0, 0, textureImage[1].Width, textureImage[1].Height);
Rectangle rectangle2 = new Rectangle(0, 0, textureImage[2].Width, textureImage[2].Height);
//Get The Bitmap's Pixel Data From The Locked Bitmap
System.Drawing.Imaging.BitmapData bitmapData = textureImage[0].LockBits(rectangle, System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
System.Drawing.Imaging.BitmapData bitmapData1 = textureImage[1].LockBits(rectangle1, System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
System.Drawing.Imaging.BitmapData bitmapData2 = textureImage[2].LockBits(rectangle2, System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[1]);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB8, textureImage[1].Width, textureImage[1].Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData1.Scan0);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
textureImage[1].UnlockBits(bitmapData1); // Unlock The Pixel Data From Memory
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[1]);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[0]);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB8, textureImage[0].Width, textureImage[0].Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
textureImage[0].UnlockBits(bitmapData); // Unlock The Pixel Data From Memory
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[0]);
Gl.glViewport(0, 0, AnT.Width, AnT.Height);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[2]);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB8, textureImage[2].Width, textureImage[2].Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData2.Scan0);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
textureImage[2].UnlockBits(bitmapData2); // Unlock The Pixel Data From Memory
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[2]);
Gl.glViewport(0, 0, AnT.Width, AnT.Height);
Gl.glShadeModel(Gl.GL_SMOOTH);
Gl.glEnable(Gl.GL_LINE_SMOOTH);
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
Gl.glHint(Gl.GL_LINE_SMOOTH_HINT, Gl.GL_DONT_CARE);
Gl.glEnable(Gl.GL_ALPHA_TEST);
Gl.glEnable(Gl.GL_BLEND);
Gl.glFlush();
timer1.Start();
}
private void DrawInit()
{
//Uncoment next procedure to take material properties in account
SetMaterial();
//only for demostration of possibilities, not very accurate
SetLight();
//Gl.glViewport(0, 0, this.ClientSize.Width, this.ClientSize.Height);
Gl.glClearColor(0, 0, 0, 0);
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glEnable(Gl.GL_DEPTH_TEST);
Gl.glEnable(Gl.GL_BLEND);
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
Gl.glGenTextures(2, Texture);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, Texture[0]);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
LoadTexture.loadBMP("saturn.jpg", this.Pict);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, Texture[1]);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
LoadTexture.loadRings();
CalculateDisk();
quadObj = Glu.gluNewQuadric();
Glu.gluQuadricTexture(quadObj, Gl.GL_TRUE);
}
private void draw()
{
string fff = Gl.glGetString(Gl.GL_VERSION);
string ggg = fff;
//Очищение экрана
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
//Нормирование матрицы
Gl.glLoadIdentity();
//Кладем матрицу в стек для того, чтобы не испортить при вычислениях
Gl.glPushMatrix();
//Отрисовка космоса. Сначала переносим цент и поворачиваем на нужный угол пространство. Подгружаем текстуры и совершаем обратные действия
Gl.glRotated(90, 1, 0, 0);
Gl.glRotated(-45, 0, 0, 1);
Gl.glRotated(-x_r / 15, 0, 0, 1);
Gl.glTranslated(0, 0, -4000);
quadr = Glu.gluNewQuadric();
Glu.gluQuadricTexture(quadr, Gl.GL_TRUE);
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, space_tex);
Glu.gluCylinder(quadr, ATMOSPHERE_HEIGHT_Z * 0.0025 / ZOOMER, ATMOSPHERE_HEIGHT_Z * 0.0025 / ZOOMER, 8000, 64, 64);
Gl.glDisable(Gl.GL_TEXTURE_2D);
Gl.glTranslated(0, 0, 4000);
Gl.glRotated(x_r / 15, 0, 0, 1);
Gl.glRotated(45, 0, 0, 1);
Gl.glRotated(-90, 1, 0, 0);
Gl.glColor3f(0, 0, 0);
//Завершение отрисовки космоса
//Установление ограничений на сдвиг вдоль экрана.
int I_DONT_NOW_WHAT_IS_IT = 300;
if (Math.Abs(x_r) > I_DONT_NOW_WHAT_IS_IT)
x_r = Math.Sign(x_r) * I_DONT_NOW_WHAT_IS_IT;
if (Math.Abs(y_r) > I_DONT_NOW_WHAT_IS_IT)
y_r = Math.Sign(y_r) * I_DONT_NOW_WHAT_IS_IT;
float angle_cam = (float)Math.Atan(y_r / (x_r - D_NUM));
float circ_abroad = (float)Math.Sqrt(EARTH_RADIUS_Z * EARTH_RADIUS_Z * (1 - 5 * 5 * zoom * zoom / max_zoom / max_zoom)) / 2 + 5;
//Ограничение на движение экрана к центру Земли - для того, чтобы нельзя было посмотреть "внутренности" Земли
//Все коэффициенты определены практическим путем
if (zoom < 1.83)
{
if (Math.Abs(x_r) < Math.Abs(Math.Cos(angle_cam) * circ_abroad) + D_NUM)
x_r = Math.Sign(x_r + D_NUM) * Math.Cos(angle_cam) * circ_abroad;
if (Math.Abs(y_r) < Math.Abs(Math.Sin(angle_cam) * circ_abroad))
y_r = Math.Sign(x_r) * Math.Sin(angle_cam) * circ_abroad;
}
//Преобразование изображение в соответствии с действиями пользователя. То есть сдвиг.
Gl.glTranslated(x_r * 2, -y_r * 2, -EARTH_RADIUS_Z * 5 * zoom / (max_zoom-3));
Gl.glRotated(180, 1, 0, 0);
float ang = +(90 - angle) - (90 - angle) * (min_zoom / zoom);
Gl.glColor3f(1.0f, 0, 0);
//Отрисовка Земли. Действия как и с космосом
Gl.glRotated(90, 1, 0, 0);
Gl.glRotated(180, 0, 1, 0);
quadr = Glu.gluNewQuadric();
Glu.gluQuadricTexture(quadr, Gl.GL_TRUE);
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, earth_tex);
Glu.gluSphere(quadr, EARTH_RADIUS_Z, 64, 64);
Gl.glDisable(Gl.GL_TEXTURE_2D);
Gl.glColor3f(1.0f, 0, 1.0f);
Gl.glRotated(-180, 0, 1, 0);
Gl.glRotated(-90, 1, 0, 0);
//Завершение отрисоовки Земли
//Изображение слоев атмосферы
if (Ekzos.Checked == true)
{
Gl.glColor3f(1, 1f, 1.0f);
Glut.glutWireSphere(EARTH_RADIUS_Z + Ekzosphere_r_z, 64, 64);
}
if (Termos.Checked == true)
{
Gl.glColor3f(0.85f, 0.95f, 1.0f);
Glut.glutWireSphere(EARTH_RADIUS_Z + Termosphere_r_z, 64, 64);
}
if (Mezos.Checked == true)
{
Gl.glColor3f(0.5f, 0.85f, 1.0f);
Glut.glutWireSphere(EARTH_RADIUS_Z + Mezosphere_r_z, 64, 64);
}
if (Stratos.Checked == true)
{
Gl.glColor3f(0.25f, 0.75f, 1.0f);
Glut.glutWireSphere(EARTH_RADIUS_Z + Stratosphere_r_z, 64, 64);
}
if (Tropos.Checked == true)
{
Gl.glColor3f(0, 0.65f, 1.0f);
Glut.glutWireSphere(EARTH_RADIUS_Z + Troposphere_r_z, 64, 64);
}
//Преобразование координат для отрисовки траектории
Gl.glTranslated(0, -start_height * ZOOMER - EARTH_RADIUS_Z, 0);
Gl.glColor3f(0.5f, 0.25f, 0);
Gl.glLineWidth(1);
//Определение временного промежутка, вплоть до которого дошел метеорит
int last_index = (int)(time / dt);
if (count_render_points < last_index)
{
last_index = count_render_points;
}
last_graph = last_index;
//Отрисовка траектории
if (state != 0)
{
Gl.glColor3f(0.9f, 1.0f, 0);
Gl.glLineWidth(1);
Gl.glBegin(Gl.GL_LINE_STRIP);
for (int i = 0; i <= last_index; i++)
{
Gl.glVertex3f(trajectory[i, 0], trajectory[i, 1], 0);
}
Gl.glEnd();
/*Gl.glColor3f(0.9f, 0f, 0);
Gl.glBegin(Gl.GL_LINES);
for (int i = 0; i < last_index; i++)
{
Gl.glVertex3f(trajectory[i, 0], trajectory[i, 1], 0);
Gl.glVertex3f(F_air[i, 0], F_air[i, 1], 0);
}
Gl.glEnd();*/
Gl.glTranslated(trajectory[last_index, 0], trajectory[last_index, 1], 0);
Gl.glLineWidth(1);
if (last_index + 5 > MAX_ARRAY_SIZE && !err_message)
{
err_message = true;
MessageBox.Show("Памяти, выделяемой компьютером, не хватает для того, чтобы отобразить всю траекторию");
}
}
//Изменеие данных на панели инструментов
labelTime.Text = "Время полета: " + ((int)time_m[last_index]).ToString()+" c";
labelHeight.Text = "Высота над уровнем моря в данный момент: " + height[last_index].ToString() + " км";
if (last_index == count_render_points && rend)
{
but.Text = "Начать новый эксперимент";
rend = false;
state = 2;
}
//Текстурирование и отрисовка метеорита. (его не видно, так что по сути это абсолютно бесполезные строчки)
quadr = Glu.gluNewQuadric();
Glu.gluQuadricTexture(quadr, Gl.GL_TRUE);
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, meteor_tex);
Glu.gluSphere(quadr, radius * ZOOMER, 32, 32);
Gl.glDisable(Gl.GL_TEXTURE_2D);
Gl.glColor3f(0, 1f, 0);
Glut.glutWireCube(zoom*60000 * ZOOMER);
Gl.glColor3f(1.0f, 0, 1.0f);
//END METEOR
Gl.glPopMatrix();
Gl.glFlush();
//Инвалидация получившегося изображения. То есть перенесение на экран
Graf.Invalidate();
}
// Draw Our Ball
void DrawObject()
{
Gl.glColor3f(1.0f, 1.0f, 1.0f); // Set Color To White
Gl.glBindTexture(Gl.GL_TEXTURE_2D, Otros.texture[1]); // Select Texture 2 (1)
Glu.GLUquadric q;
q = Glu.gluNewQuadric(); // Create A New Quadratic
Glu.gluQuadricNormals(q,Gl.GL_SMOOTH); // Generate Smooth Normals For The Quad
Glu.gluQuadricTexture(q,Gl.GL_TRUE);
Glu.gluSphere(q, 0.35f, 32, 16); // Draw First Sphere
Gl.glBindTexture(Gl.GL_TEXTURE_2D, Otros.texture[0]); // Select Texture 3 (2)
Gl.glColor4f(1.0f, 1.0f, 1.0f, 0.4f); // Set Color To White With 40% Alpha
Gl.glEnable(Gl.GL_BLEND); // Enable Blending
Gl.glBlendFunc(Gl.GL_SRC_ALPHA,Gl.GL_ONE); // Set Blending Mode To Mix Base111d On SRC Alpha
Gl.glEnable(Gl.GL_TEXTURE_GEN_S); // Enable Sphere Mapping
Gl.glEnable(Gl.GL_TEXTURE_GEN_T); // Enable Sphere Mapping
Glu.gluSphere(q, 0.35f, 32, 16); // Draw Another Sphere Using New Texture
// Textures Will Mix Creating A MultiTexture Effect (Reflection)
Gl.glDisable(Gl.GL_TEXTURE_GEN_S); // Disable Sphere Mapping
Gl.glDisable(Gl.GL_TEXTURE_GEN_T); // Disable Sphere Mapping
Gl.glDisable(Gl.GL_BLEND); // Disable Blending
}
/// <summary>
/// All setup for OpenGL goes here.
/// </summary>
/// <returns>
/// Returns <c>true</c> on success, otherwise <c>false</c>.
/// </returns>
private static bool InitGL() { // All Setup For OpenGL Goes Here
if(!LoadGLTextures()) { // If Loading The Textures Failed
return false; // Return False
}
Gl.glShadeModel(Gl.GL_SMOOTH); // Enable Smooth Shading
Gl.glClearColor(0.2f, 0.5f, 1, 1); // Background
Gl.glClearDepth(1); // Depth Buffer Setup
Gl.glClearStencil(0); // Clear The Stencil Buffer To 0
Gl.glEnable(Gl.GL_DEPTH_TEST); // Enables Depth Testing
Gl.glDepthFunc(Gl.GL_LEQUAL); // The Type Of Depth Testing To Do
Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST); // Really Nice Perspective Calculations
Gl.glEnable(Gl.GL_TEXTURE_2D); // Enable 2D Texture Mapping
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_AMBIENT, LightAmb); // Set The Ambient Lighting For Light0
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_DIFFUSE, LightDif); // Set The Diffuse Lighting For Light0
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, LightPos); // Set The Position For Light0
Gl.glEnable(Gl.GL_LIGHT0); // Enable Light 0
Gl.glEnable(Gl.GL_LIGHTING); // Enable Lighting
q = Glu.gluNewQuadric(); // Create A New Quadratic
Glu.gluQuadricNormals(q, Gl.GL_SMOOTH); // Generate Smooth Normals For The Quad
Glu.gluQuadricTexture(q, Gl.GL_TRUE); // Enable Texture Coords For The Quad
Gl.glTexGeni(Gl.GL_S, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_SPHERE_MAP); // Set Up Sphere Mapping
Gl.glTexGeni(Gl.GL_T, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_SPHERE_MAP); // Set Up Sphere Mapping
return true; // Initialization Went OK
}
/// <summary>
/// Initialize OpenGL
/// </summary>
protected override void InitGL()
{
Events.KeyboardDown += new EventHandler<KeyboardEventArgs>(this.KeyDown);
Keyboard.EnableKeyRepeat(60, 60);
LoadGLTextures();
// Enable Texture Mapping
Gl.glEnable(Gl.GL_TEXTURE_2D);
// Enable Smooth Shading
Gl.glShadeModel(Gl.GL_SMOOTH);
// Black Background
Gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
// Depth Buffer Setup
Gl.glClearDepth(1.0f);
// Enables Depth Testing
Gl.glEnable(Gl.GL_DEPTH_TEST);
// The Type Of Depth Testing To Do
Gl.glDepthFunc(Gl.GL_LEQUAL);
// Really Nice Perspective Calculations
Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST);
// Setup The Ambient Light
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_AMBIENT, this.GetLightAmbient());
// Setup The Diffuse Light
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_DIFFUSE, this.GetLightDiffuse());
// Position The Light
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_POSITION, this.GetLightPosition());
// Enable Light One
Gl.glEnable(Gl.GL_LIGHT1);
// Create A Pointer To The Quadric Object (Return 0 If No Memory) (NEW)
this.quadratic = Glu.gluNewQuadric();
// Create Smooth Normals (NEW)
Glu.gluQuadricNormals(this.quadratic, Glu.GLU_SMOOTH);
// Create Texture Coords (NEW)
Glu.gluQuadricTexture(this.quadratic, (byte)Gl.GL_TRUE);
if (this.Light)
{
// If lighting, enable it to start
Gl.glEnable(Gl.GL_LIGHTING);
}
}
/// <summary>
/// Korisnicka inicijalizacija i podesavanje OpenGL parametara.
/// </summary>
private void Initialize()
{
// Boja pozadine je tamno plava
Gl.glClearColor(0.0f, 0.0f, 0.2f, 1.0f);
Gl.glEnable(Gl.GL_DEPTH_TEST);
Gl.glEnable(Gl.GL_CULL_FACE);
Gl.glFrontFace(Gl.GL_CCW);
gluObject = Glu.gluNewQuadric();
// Tacka 1 faza 2: Ukljuciti color tracking mehanizam i podesiti da se pozivom metode glColor
// definise ambijentalna i difuzna komponenta materijala
Gl.glEnable(Gl.GL_COLOR_MATERIAL);
Gl.glColorMaterial(Gl.GL_FRONT, Gl.GL_AMBIENT_AND_DIFFUSE);
Gl.glEnable(Gl.GL_LIGHTING);
// Tacka 2 faza 2: Definisati reflektorski izvor (cut-off=30) bele boje
float[] ambient = { 0.0f, 0.0f, 0.0f, 1.0f };
float[] diffuse = { 1.0f, 1.0f, 1.0f, 1.0f };
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_AMBIENT, ambient);
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_DIFFUSE, diffuse);
float[] direction = { 0.0f, 1.0f, 0.0f };
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_SPOT_DIRECTION, direction);
Gl.glLightf(Gl.GL_LIGHT1, Gl.GL_SPOT_CUTOFF, 30.0f);
Gl.glEnable(Gl.GL_LIGHT1);
// Tacka 9 faza 2: Definisati tackasti svetlosni izvor narandzaste boje
float[] ambient1 = { 0.0f, 0.0f, 0.0f, 1.0f };
float[] diffuse1 = { 1.0f, 0.5f, 0.0f, 1.0f };
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_AMBIENT, ambient1);
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_DIFFUSE, diffuse1);
Gl.glLightf(Gl.GL_LIGHT0, Gl.GL_SPOT_CUTOFF, 180.0f);
Gl.glEnable(Gl.GL_LIGHT0);
// Ukljuci automatsku normalizaciju nad normalama
Gl.glEnable(Gl.GL_NORMALIZE);
// Tacka 3 faza 2: Nacin stapanja teksture sa materijalom modulate
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glTexEnvi(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_MODULATE);
// Ucitaj slike i kreiraj teksture
Gl.glGenTextures(m_textureCount, m_textures);
for (int i = 0; i < m_textureCount; ++i)
{
// Pridruzi teksturu odgovarajucem identifikatoru
Gl.glBindTexture(Gl.GL_TEXTURE_2D, m_textures[i]);
// Ucitaj sliku i podesi parametre teksture
Bitmap image = new Bitmap(m_textureFiles[i]);
// rotiramo sliku zbog koordinantog sistema opengl-a
image.RotateFlip(RotateFlipType.RotateNoneFlipY);
Rectangle rect = new Rectangle(0, 0, image.Width, image.Height);
// RGBA format (dozvoljena providnost slike tj. alfa kanal)
BitmapData imageData = image.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, (int)Gl.GL_RGBA8, image.Width, image.Height, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, imageData.Scan0);
Gl.glTexParameteri((int)Gl.GL_TEXTURE_2D, (int)Gl.GL_TEXTURE_MIN_FILTER, (int)Gl.GL_LINEAR); // Linear Filtering
Gl.glTexParameteri((int)Gl.GL_TEXTURE_2D, (int)Gl.GL_TEXTURE_MAG_FILTER, (int)Gl.GL_LINEAR); // Linear Filtering
// Tacka 3 faza 2: Za teksture podesiti wrapping da bude GL_REPEAT po obema osama
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
// Tacka 3 faza 2: Podesiti filtere za teksture tako da se koristi mipmap linearno filtriranje.
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
image.UnlockBits(imageData);
image.Dispose();
}
}
// Draws The Floor
void DrawFloor()
{
Gl.glBindTexture(Gl.GL_TEXTURE_2D,Otros.texture[9]);
Gl.glPushMatrix();
Gl.glDisable(Gl.GL_CULL_FACE);
q=Glu.gluNewQuadric();
Glu.gluQuadricOrientation(q,Glu.GLU_OUTSIDE);
Glu.gluQuadricTexture(q,Glu.GLU_TRUE);
Glu.gluQuadricNormals(q,Glu.GLU_SMOOTH);
Glu.gluDisk(q,0,7,32,32);
Gl.glBindTexture(Gl.GL_TEXTURE_2D,0);
Gl.glEnable(Gl.GL_CULL_FACE);
Gl.glPopMatrix();
}
