void draw_level(GLint level)
{
for(int k =0;k<levels[level].n_troncos;k++)
draw_troncos(k,level);
/*desenho do tunel*/
if(level ==0)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,tex[1]);
}
else if(level ==1)
{
glEnable(GL_TEXTURE_2D);
glColor4f(GRAY2);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); // blending + textura
glBindTexture(GL_TEXTURE_2D,tex[3]);
}
glPushMatrix();
glTranslatef(levels[level].tunelPos[0],levels[level].tunelPos[1],levels[level].tunelPos[2]);
GLUquadricObj* y = gluNewQuadric( );
gluQuadricDrawStyle(y, GLU_FILL);
gluQuadricNormals(y, GLU_SMOOTH);
gluQuadricTexture(y,GL_TRUE);
gluCylinder(y,levels[level].tunelDim[0],levels[level].tunelDim[1],levels[level].tunelDim[2],32,32);
gluDeleteQuadric(y);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
}
void Psphere::draw(){
GLUquadricObj *qObj = gluNewQuadric();
gluQuadricNormals(qObj, GLU_SMOOTH);
gluQuadricTexture(qObj, GL_TRUE);
glEnable(GL_TEXTURE_2D);
gluSphere(qObj,radius,slices,stacks);
}
GLuint GLTexobj::makeObject( const QImage& tex1, const QImage& tex2 )
{
GLUquadricObj* q = gluNewQuadric();
GLuint cylinderObj = glGenLists(1);
glNewList( cylinderObj, GL_COMPILE );
glTranslatef( 0.0, 0.0, -1.0 );
// cylinder
glTexImage2D( GL_TEXTURE_2D, 0, 3, tex1.width(), tex1.height(), 0,
GL_RGBA, GL_UNSIGNED_BYTE, tex1.bits() );
gluQuadricTexture( q, GL_TRUE );
gluCylinder(q, 0.6, 0.6, 2.0, 24, 1);
// end cap
glTexImage2D( GL_TEXTURE_2D, 0, 3, tex2.width(), tex2.height(), 0,
GL_RGBA, GL_UNSIGNED_BYTE, tex2.bits() );
glTranslatef( 0.0, 0.0, 2.0 );
gluDisk( q, 0.0, 0.6, 24, 1 );
// other end cap
glTranslatef( 0.0, 0.0, -2.0 );
gluQuadricOrientation( q, (GLenum)GLU_INSIDE );
gluDisk( q, 0.0, 0.6, 24, 1 );
glEndList();
gluDeleteQuadric( q );
return cylinderObj;
}
void GLWidget::initializeGL()
{
glClearColor (0.35f, 0.35f, 0.4f, 0.5f); // Background color
glColor4f(0.35f, 0.35f, 0.4f,1.0f);
glClearDepth (1.0f); // Depth Buffer Setup
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing (Less Or Equal)
glEnable(GL_DEPTH_TEST); // Enable Depth Testing
glShadeModel(GL_FLAT); // Select Flat Shading (Nice Definition Of Objects)
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Set Perspective Calculations To Most Accurate
quadratic = gluNewQuadric(); // Create A Pointer To The Quadric Object
gluQuadricNormals(quadratic, GLU_SMOOTH); // Create Smooth Normals
gluQuadricTexture(quadratic, GL_TRUE); // Create Texture Coords
glMatrixMode(GL_TEXTURE);
// glEnable(GL_LIGHTING); // Enable Lighting
// glEnable(GL_COLOR_MATERIAL); // Enable Color Material
// glEnable(GL_LIGHT0); // Enable Default Light
// glEnable(GL_LIGHT1);
// float light_diffuse[] = {0.4, 0.4, 0.8, 1.0};
// float light_position[] = {0.0,-1000.0,0.0,0.0};
// float light_position1[] = {0.0,0.0,100.0,0.0};
// glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
// glLightfv(GL_LIGHT0, GL_POSITION, light_position);
// glLightfv(GL_LIGHT1, GL_POSITION, light_position1);
// float material[] = { 0.5, 0.5, 0.5, 1.0};
// glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,material);
// glEnable(GL_NORMALIZE);
}
Sample_18::Sample_18()
: m_xrot(0.0f)
, m_yrot(0.0f)
, m_xspeed(0.1f)
, m_yspeed(0.1f)
, m_z(-5.0f)
, m_filter(0)
, m_light(false)
, m_part1(0)
, m_part2(0)
, m_p1(0)
, m_p2(1)
, m_quadratic(NULL)
, m_object(0)
{
for (int i = 0; i < TEX_QTY; ++i)
{
m_texture[i] = 0;
}
m_image.loadBMP( "data/wall.bmp" );
m_quadratic=gluNewQuadric(); // Create A Pointer To The Quadric Object
gluQuadricNormals(m_quadratic, GLU_SMOOTH); // Create Smooth Normals
gluQuadricTexture(m_quadratic, GL_TRUE); // Create Texture Coords
}
void Ring :: draw(double radiusScale, Point3 currentPosition) {
if (enabled == true)
{
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GLUquadricObj *quadratic = NULL;
quadratic = gluNewQuadric(); // Create A Pointer To The Quadric Object
gluQuadricDrawStyle(quadratic, GLU_FILL);
gluQuadricTexture(quadratic, GL_TRUE); // Create Texture Coords
gluQuadricNormals(quadratic, GLU_SMOOTH); // Create Smooth Normals
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // Linear Filtering
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glBindTexture(GL_TEXTURE_2D,textureId);
glPushMatrix();
glTranslated(currentPosition.x, currentPosition.y, currentPosition.z);
glRotated(ringRotation + 90, 1, 0, 0);
glBegin(GL_QUAD_STRIP);
for (double angle=0; angle<=360; angle+= 0.2)
{
glNormal3f(0.0,0.0,1.0);
glTexCoord2f (0.0, 1.0);
glVertex3d (outerRadius * radiusScale * cos(angle), outerRadius * radiusScale * sin(angle), 0.0);
glNormal3f (0.0, 0.0, 1.0);
glTexCoord2f (1.0, 0.0);
glVertex3d (innerRadius * radiusScale * cos(angle), innerRadius * radiusScale * sin(angle), 0.0);
}
glEnd();
glPopMatrix();
}
}
void drawCar(int index, bool drawingShadow) {
switch (index % 3) {
case 0:
glColor3f(1.0, 0.0, 0.0);
break;
case 1:
glColor3f(0.0, 1.0, 0.0);
break;
case 2:
glColor3f(0.0, 0.0, 1.0);
break;
}
if (drawingShadow) {
glColor3f(0.1, 0.1, 0.1);
}
glTranslated(0, 0.5, 0);
if (index == 1) {
glEnable(GL_TEXTURE_2D);
glTexImage2D(GL_TEXTURE_2D, 0, 3, texball_w, texball_h, 0, GL_RGB, GL_UNSIGNED_BYTE, texball);
GLUquadricObj *quadratic;
quadratic = gluNewQuadric();
gluQuadricTexture(quadratic, GL_TRUE);
drawCube(0, 0, 0, 1);
glScaled(2, 0.5, 2);
glRotated(-90.0f, 1.0f, 0.0f, 0.0f);
gluCylinder(quadratic,0.1f,0.1f,3.0f,32,32);
glDisable(GL_TEXTURE_2D);
} else {
drawCube(0, 0, 0, 1);
}
glPopMatrix();
}
void rysujKsiezyc()
{
GLUquadricObj* quadro = gluNewQuadric();
gluQuadricNormals(quadro, GLU_SMOOTH);
gluQuadricTexture(quadro, GL_TRUE);
glEnable(GL_TEXTURE_2D);
glPushMatrix();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glPushMatrix();
//nachylenie
glRotatef(Pziemia, 0.0, 0.0, 1.0);
//wokó³ s³oñca
glRotatef(RotacjaWokolSlonca*(1 / Sziemia) * 100000, 0.0, 1.0, 0.0);
glTranslatef(Oziemia, 0.0, 0.0);
//wokó³ w³asnej osi
glRotatef(360.0 *(ObrotPlanet / 1)*4, 0.0, 1.0, 0.0);
//oddalenie od ziemi
glTranslatef(0.5, 0.0, 0.0);
glBindTexture(GL_TEXTURE_2D, Tksiezyc);
gluSphere(quadro, 0.04, 48, 48);
glPopMatrix();
glPopMatrix();
glDisable(GL_TEXTURE_2D);
gluDeleteQuadric(quadro);
}
void Collectable::Draw(){
float color[3] = {0.0, 0.0, 0.0};
switch(apply){
case Collectable::Flip:
color[0]=1.0;
break;
case Collectable::SpeedUp:
color[1]=1.0;
break;
case Collectable::SlowDown:
color[2]=1.0;
break;
}
glPushMatrix();
glTranslatef(position.x, 1, position.z);
rot+=1;
glRotatef(rot, 0, 1,0);
Material::setColor(color[0], color[1], color[2]);
GLUquadric *qobj = gluNewQuadric();
gluQuadricTexture(qobj,GL_TRUE);
glEnable(GL_TEXTURE_2D);
//glBindTexture(GL_TEXTURE_2D,Texture::getSeatId());
gluSphere(qobj,1,15,10);
gluDeleteQuadric(qobj);
glDisable(GL_TEXTURE_2D);
glPopMatrix();
}
int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
if (!LoadGLTextures()) // If Loading The Textures Failed
{
return FALSE; // Return False
}
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearColor(0.2f, 0.5f, 1.0f, 1.0f); // Background
glClearDepth(1.0f); // Depth Buffer Setup
glClearStencil(0); // Clear The Stencil Buffer To 0
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
glEnable(GL_TEXTURE_2D); // Enable 2D Texture Mapping
glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmb); // Set The Ambient Lighting For Light0
glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDif); // Set The Diffuse Lighting For Light0
glLightfv(GL_LIGHT0, GL_POSITION, LightPos); // Set The Position For Light0
glEnable(GL_LIGHT0); // Enable Light 0
glEnable(GL_LIGHTING); // Enable Lighting
q = gluNewQuadric(); // Create A New Quadratic
gluQuadricNormals(q, GL_SMOOTH); // Generate Smooth Normals For The Quad
gluQuadricTexture(q, GL_TRUE); // Enable Texture Coords For The Quad
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); // Set Up Sphere Mapping
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); // Set Up Sphere Mapping
return TRUE; // Initialization Went OK
}
void rysujPlanete(GLfloat nachylenie, GLfloat dlugoscRoku, GLfloat oddalenieOdSrodka, GLfloat obrotOsi, GLuint tekstura, GLfloat promien)
{
GLUquadricObj* quadro = gluNewQuadric();
gluQuadricNormals(quadro, GLU_SMOOTH);
gluQuadricTexture(quadro, GL_TRUE);
glEnable(GL_TEXTURE_2D);
glPushMatrix();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glPushMatrix();
glRotatef(nachylenie, 0.0, 0.0, 1.0);
//wokó³ s³oñca
if (dlugoscRoku!=0.0)
glRotatef(RotacjaWokolSlonca*(1/dlugoscRoku)*100000, 0.0, 1.0, 0.0);
glTranslatef(oddalenieOdSrodka, 0.0, 0.0);
//wokó³ w³asnej osi
glRotatef(360.0 *(ObrotPlanet/obrotOsi), 0.0, 1.0, 0.0);
//obrócenie w celu normalnoœci planety - pieguny na górze
glRotatef(-90.0, 1.0, 0.0, 0.0);
glBindTexture(GL_TEXTURE_2D, tekstura);
gluSphere(quadro, promien, 48, 48);
glPopMatrix();
glPopMatrix();
glDisable(GL_TEXTURE_2D);
gluDeleteQuadric(quadro);
}
Ambient::Ambient(string id)
{
this->id = id;
skyApp = new CGFappearance();
kApp = new CGFappearance();
sApp = new CGFappearance();
mApp = new CGFappearance();
tileGApp = new CGFappearance();
tileKApp = new CGFappearance();
tileSApp = new CGFappearance();
tileMApp = new CGFappearance();
// sets texture's wrap
skyApp->setTextureWrap(GL_REPEAT, GL_REPEAT);
kApp->setTextureWrap(GL_CLAMP, GL_CLAMP);
sApp->setTextureWrap(GL_CLAMP, GL_CLAMP);
mApp->setTextureWrap(GL_CLAMP, GL_CLAMP);
tileGApp->setTextureWrap(GL_REPEAT, GL_REPEAT);
tileKApp->setTextureWrap(GL_REPEAT, GL_REPEAT);
tileSApp->setTextureWrap(GL_REPEAT, GL_REPEAT);
tileMApp->setTextureWrap(GL_REPEAT, GL_REPEAT);
// sky
sphereQuadric = gluNewQuadric();
gluQuadricDrawStyle(sphereQuadric, GLU_FILL);
gluQuadricNormals(sphereQuadric, GLU_SMOOTH);
gluQuadricOrientation(sphereQuadric, GLU_INSIDE);
gluQuadricTexture(sphereQuadric, GL_TRUE);
}
//------------------------------------------------------------------------------
void DrawCylinderDL()
{
GLUquadricObj *gluObject = NULL;
gluObject = gluNewQuadric();
gluQuadricDrawStyle (gluObject, GLU_FILL);
gluQuadricTexture (gluObject, TRUE);
gluQuadricNormals (gluObject, GLU_SMOOTH);
//Making a display list
// mysphereID = glGenLists(1);
// glNewList(mysphereID, GL_COMPILE);
glPushMatrix(); //update to not use a pushMatrix, zz debug
glRotatef (180.0f, 0.0f, 0.0f, 1.0f); //orient world texture for coord 0,0
gluCylinder (gluObject, 1.0, 1.0, 2.0, 24, 1);
glRotatef (180.0f, 1.0f, 0.0f, 0.0f); //flips the disk over
gluDisk (gluObject, 0.0, 1.0, 24, 1); //draw bottom disk
glRotatef (180.0f, 0.0f, 1.0f, 0.0f); //flip to right-side up
glTranslatef (0.0f, 0.0f, 2.0f); //translate to the top
gluDisk (gluObject, 0.0, 1.0, 24, 1); //draw top disk
glPopMatrix();
// glEndList();
// gluDeleteQuadric(sphere); ``````````````//zz debug, should use this
}
void Cylinder::draw(float textS, float textT) {
glBegin(GL_POLYGON);
for (int i = slices; i > 0; i--) {
float theta = 2. * acos(-1.) * float(i) / float(slices);
float x = base * cosf(theta);
float y = base * sinf(theta);
glTexCoord2f(y * textT, x * textS);
glNormal3f(x / sqrt(pow(x, 2) + pow(y, 2)), y / sqrt(pow(x, 2) + pow(y, 2)), 0);
glVertex2f(x, y);
}
glEnd();
gluQuadricTexture(this->cylin, GL_TRUE);
gluCylinder(this->cylin, this->base, this->top, this->height, this->slices, this->stacks);
glPushMatrix();
glTranslatef(0., 0., height);
glBegin(GL_POLYGON);
for (int i = 0; i < slices; i++) {
float theta = 2. * acos(-1.) * float(i) / float(slices);
float x = top * cosf(theta);
float y = top * sinf(theta);
glTexCoord2f(y * textT, x * textS);
glNormal3f(x / sqrt(pow(x, 2) + pow(y, 2)), y / sqrt(pow(x, 2) + pow(y, 2)), 0);
glVertex2f(x, y);
}
glEnd();
glPopMatrix();
};
void Castle::DrawHead()
{
glColor3ub(0, 100, 0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texId); // Tell openGL which texture buffer to apply as texture
glColor3f(1.0, 1.0, 1.0); // Set the base colour of the quad
glPushMatrix();
{
GLUquadricObj *quadratic;
quadratic = gluNewQuadric();
gluQuadricNormals(quadratic, GLU_SMOOTH);
gluQuadricTexture(quadratic, GLU_TRUE);
glRotatef(90.0f, 1.0f, 0.0f, 0.0f);
//glScaled(100, 2, 2);
gluCylinder(quadratic,0.4f,0.4f,0.4f,32,32);
glTranslated(0, 0, 0.4);
DrawCircle(0.4,360);
}
glPopMatrix();
glBindTexture(GL_TEXTURE_2D, 0); // Bind to the blank buffer to stop ourselves accidentaly using the wrong texture in the next draw call
glDisable(GL_TEXTURE_2D);
//glTranslatef(0, 0.2, 0);
glPushMatrix();
{
//glColor3ub(0, 100, 0);
glColor3f(0.4, 0.4, 0.4);
glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
glutSolidCone(0.6, 1.2, 32, 32);
glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
DrawCircle(0.6,360);
glColor3ub(0, 100, 0);
}
glPopMatrix();
}
int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
if (!LoadGLTextures()) // Jump To Texture Loading Routine
{
return FALSE; // If Texture Didn't Load Return FALSE
}
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); // Setup The Ambient Light
glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); // Setup The Diffuse Light
glLightfv(GL_LIGHT1, GL_POSITION,LightPosition); // Position The Light
glEnable(GL_LIGHT1); // Enable Light One
quadratic=gluNewQuadric(); // Create A Pointer To The Quadric Object (Return 0 If No Memory) (NEW)
gluQuadricNormals(quadratic, GLU_SMOOTH); // Create Smooth Normals (NEW)
gluQuadricTexture(quadratic, GL_TRUE); // Create Texture Coords (NEW)
return TRUE; // Initialization Went OK
}
CMoonImage::CMoonImage (float distance)
{
// Load DXT texture
strncpy (ddsFilename, "ART/MOONMAP_256.dds",511);
CImageDXT *dxt = new CImageDXT (ddsFilename);
texid = CTextureManager::Instance().BindTexture (ddsFilename, dxt);
SAFE_DELETE (dxt);
// Rendering size and distance are arbitrarily chosen so that moon is has the
// correct apparent size and appears far away from the observer
this->distance = distance;
size = 8000.0f;
// Initialize GLU quadric for sphere rendering
q = gluNewQuadric ();
gluQuadricDrawStyle (q, GL_FILL);
gluQuadricOrientation (q, GLU_OUTSIDE);
gluQuadricTexture (q, GL_TRUE);
gluQuadricNormals(q, GLU_SMOOTH);
// Create textured sphere in display list
dlOrb = glGenLists (1);
glNewList (dlOrb, GL_COMPILE);
gluSphere (q, size, 16, 16);
glEndList ();
}
Minigun::Minigun( World * world ) :
AWeapon( world, 10000, 200, 200 )
{
mQuadric = gluNewQuadric();
gluQuadricTexture( mQuadric, GL_TRUE );
mName = "Minigun";
mDrawn = false;
mReload = false;
mCoolDown = 0.1f;
mFired = false;
mRange = 100.0f;
mTrailRadius = 0.01f;
mDamage = 1.0f;
mRotation = 0.0f;
mMaterial = new Material( scene()->glWidget(), "BlackSteel" );
mFireSound = new AudioSample( "minigun" );
mFireSound->setLooping( true );
mImpactParticleMaterial = new Material( scene()->glWidget(), "DirtParticle" );
mImpactParticles = new ParticleSystem( 128 );
mImpactParticles->setSize( 0.5f );
mImpactParticles->setGravity( QVector3D( 0.0f, -80.0f, 0.0f ) );
mImpactParticles->setDrag( 0.25f );
mImpactParticles->setMinLife( 1.0f );
mImpactParticles->setMaxLife( 2.0f );
}
void draw_cannon() {
GLUquadricObj *quadric;
quadric = gluNewQuadric();
gluQuadricDrawStyle(quadric, GLU_FILL);
gluQuadricTexture(quadric, GL_TRUE);
/* Wheel 1 */
glPushMatrix();
glTranslatef ( 0.0 , 1.0 , 0.0 );
draw_wheel() ;
glPopMatrix();
/* Wheel 2 */
glPushMatrix();
glTranslatef ( 0.0 , -1.0 , 0.0 );
draw_wheel() ;
glPopMatrix();
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture_granite);
/* Barrel sits on this thing */
glPushMatrix();
glRotatef (90, 1.0, 0.0, 0.0);
glTranslatef ( -3.0 , 0.0 , -0.6 );
draw_barrel_leg() ;
glPopMatrix();
glPushMatrix();
glRotatef (90, 1.0, 0.0, 0.0);
glTranslatef ( -3.0 , 0.0 , 0.6 );
draw_barrel_leg() ;
glPopMatrix();
/* Axle */
glPushMatrix();
glRotatef (90, 1.0, 0.0, 0.0);
glTranslatef ( 0.0 , 1.0 , 0.0 );
glTranslatef ( 0.0 , 0.0 , -1.0 );
gluCylinder(quadric, 0.25, 0.25, 2.00, 30, 30);
glPopMatrix();
/* Barrel */
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture_granite);
glPushMatrix();
glTranslatef ( -2.0 , 0.0 , 0.0 );
glTranslatef ( 0.0 , 0.0 , 1.0 );
glRotatef ((GLfloat) 60.0, 0.0, 1.0, 0.0);
gluCylinder(quadric, 0.5, 0.5, 3.00, 30, 30);
gluSphere(quadric, 0.52 , 30, 30);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
gluDeleteQuadric(quadric);
}
/* default init procedure for GLUT */
void init(void)
{
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
/* texture stuff */
/* fill in checkimage array*/
makeCheckImage(0);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
/* generate '1' texture and return the ID in address starting at &texName*/
glGenTextures(1, &texName);
/* set the current texture to texture ID in texName*/
glBindTexture(GL_TEXTURE_2D, texName);
/* wrap the texture around the s- and t-dimension*/
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
/* if texture is too small or too big for the surface,
* magnify or minify it by using the texel coordinate
* nearest the pixel to be colored.
*/
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
/* apply the checkimage array to the current texture*/
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth,
checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
checkImage);
/* lighting stuff */
glShadeModel (GL_SMOOTH);
/* specular highlights have color 'mat_specular'*/
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
/* shininess ('N') = mat_shininess*/
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
glEnable(GL_LIGHTING); /* enable lighting */
glEnable(GL_LIGHT0); /* enable light0 */
/* quadratic stuff */
quadratic=gluNewQuadric();
gluQuadricNormals(quadratic, GLU_SMOOTH);
gluQuadricTexture(quadratic, GL_TRUE);
/* normalize all normal vectors for lighting and shading */
glEnable(GL_NORMALIZE);
}
CylinderDrawable::CylinderDrawable(const Matrix4& orientation, const Point3Df& position, float length, float widthBase, float widthTop) :
m_orientation(orientation), m_position(position), m_length(length), m_widthBase(widthBase), m_widthTop(widthTop)
{
m_pQuadric = gluNewQuadric();
gluQuadricNormals(m_pQuadric, GLU_SMOOTH);
gluQuadricTexture(m_pQuadric, GL_TRUE);
gluQuadricOrientation(m_pQuadric, GLU_OUTSIDE);
}
SceneGraph::Cylinder::Cylinder( const HelperGl::Material & material, float baseRadius/*=1.0*/, float topRadius/*=1.0*/, float height/*=1.0*/, int slices/*=20*/, int stacks/*=1*/ ) : m_material(material), m_quadric(gluNewQuadric()), m_baseRadius(baseRadius), m_topRadius(topRadius), m_height(height), m_slices(slices), m_stacks(stacks)
{
gluQuadricNormals(m_quadric, GLU_SMOOTH) ;
if(m_material.hasTexture())
{
gluQuadricTexture(m_quadric, true);
}
}
void LoadManTextures() {
man_tex = TextureLoad("textures/security.bmp", GL_FALSE, GL_LINEAR, GL_LINEAR, GL_REPEAT);
man_face_tex = TextureLoad("textures/face.bmp", GL_FALSE, GL_LINEAR, GL_LINEAR, GL_REPEAT);
quadric = gluNewQuadric();
gluQuadricNormals(quadric, GLU_SMOOTH);
gluQuadricTexture(quadric, GL_TRUE);
}
void Sphere::walk_gl()
{
GLUquadricObj* q = gluNewQuadric();
gluQuadricNormals(q, GLU_SMOOTH);
gluQuadricTexture(q, GL_TRUE);
gluQuadricDrawStyle(q, GLU_FILL);
gluSphere(q,1,20,20);
}
SceneGraph::Sphere::Sphere( const HelperGl::Material & material, float radius/*=1.0*/, int slices/*=20*/, int stacks/*=20*/ ) : m_material(material), m_quadric(gluNewQuadric()), m_radius(radius), m_slices(slices), m_stacks(stacks)
{
gluQuadricNormals(m_quadric, GLU_SMOOTH) ;
if(m_material.hasTexture())
{
gluQuadricTexture(m_quadric, true);
}
}
void InitVars()
{
//create palnes
pl1._Position=TVector(0,-300,0);
pl1._Normal=TVector(0,1,0);
pl2._Position=TVector(300,0,0);
pl2._Normal=TVector(-1,0,0);
pl3._Position=TVector(-300,0,0);
pl3._Normal=TVector(1,0,0);
pl4._Position=TVector(0,0,300);
pl4._Normal=TVector(0,0,-1);
pl5._Position=TVector(0,0,-300);
pl5._Normal=TVector(0,0,1);
//create cylinders
cyl1._Position=TVector(0,0,0);
cyl1._Axis=TVector(0,1,0);
cyl1._Radius=60+20;
/*cyl2._Position=TVector(200,-300,0);
cyl2._Axis=TVector(0,0,1);
cyl2._Radius=60+20;
cyl3._Position=TVector(-200,0,0);
cyl3._Axis=TVector(0,1,1);
cyl3._Axis.unit();
cyl3._Radius=30+20;*/
//create quadratic object to render cylinders
cylinder_obj= gluNewQuadric();
gluQuadricTexture(cylinder_obj, GL_TRUE);
//Set initial positions and velocities of balls
//also initialize array which holds explosions
NrOfBalls=1;
ArrayVel[0]=veloc;
ArrayPos[0]=TVector(199,180,10);
/*ExplosionArray[0]._Alpha=0;
ExplosionArray[0]._Scale=1;
ArrayVel[1]=veloc;
ArrayPos[1]=TVector(0,150,100);
ExplosionArray[1]._Alpha=0;
ExplosionArray[1]._Scale=1;
ArrayVel[2]=veloc;
ArrayPos[2]=TVector(-100,180,-100);
ExplosionArray[2]._Alpha=0;
ExplosionArray[2]._Scale=1;
for (int i=3; i<10; i++)
{
ArrayVel[i]=veloc;
ArrayPos[i]=TVector(-500+i*75, 300, -500+i*50);
ExplosionArray[i]._Alpha=0;
ExplosionArray[i]._Scale=1;
}
for (int i=10; i<20; i++)
{
ExplosionArray[i]._Alpha=0;
ExplosionArray[i]._Scale=1;
}*/
}
void init_scene()
{
static GLfloat lightpos[4]={50.0f, 50.0f, -320.f, 1.0f};
GLubyte* tex;
/* Clear error */
glGetError();
/* draw a perspective scene */
glMatrixMode(GL_PROJECTION);
glFrustumf(-100.f, 100.f, -100.f, 100.f, 320.f, 640.f);
glMatrixMode(GL_MODELVIEW);
/* turn on features */
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
/* place light 0 in the right place */
glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
/* enable filtering */
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
tex=make_texture(256, 256);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 256, 256, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, tex);
free(tex);
disk_fill=gluNewQuadric();
gluQuadricDrawStyle(disk_fill, GLU_FILL);
gluQuadricNormals(disk_fill, GLU_SMOOTH);
disk_fill_flat=gluNewQuadric();
gluQuadricDrawStyle(disk_fill_flat, GLU_FILL);
gluQuadricNormals(disk_fill_flat, GLU_FLAT);
disk_fill_texture=gluNewQuadric();
gluQuadricDrawStyle(disk_fill_texture, GLU_FILL);
gluQuadricNormals(disk_fill_texture, GLU_SMOOTH);
gluQuadricTexture(disk_fill_texture, GLU_TRUE);
disk_point=gluNewQuadric();
gluQuadricDrawStyle(disk_point, GLU_POINT);
gluQuadricNormals(disk_point, GLU_SMOOTH);
disk_line=gluNewQuadric();
gluQuadricDrawStyle(disk_line, GLU_LINE);
gluQuadricNormals(disk_line, GLU_SMOOTH);
disk_silh=gluNewQuadric();
gluQuadricDrawStyle(disk_silh, GLU_SILHOUETTE);
if (glGetError())
{
printf("Oops! I screwed up my OpenGL ES calls somewhere\n");
}
}
void GameBoard::initializeGL( QGLWidget & target ) {
QImage wall( "textures/wall.jpg" );
this->wallTexture = target.bindTexture( wall );
QImage grass( "textures/grass.jpg" );
this->grassTexture = target.bindTexture( grass );
QImage roof( "textures/roof.jpg" );
this->roofTexture = target.bindTexture( roof );
QImage tiles( "textures/tiles.jpg" );
this->ghostsStartTexture = target.bindTexture( tiles );
QImage dot( "textures/dot.png" );
this->dotTexture = target.bindTexture( dot );
this->staticList = glGenLists( 1 );
glNewList( this->staticList, GL_COMPILE );
{
for ( int y = 0; y < this->height; ++y ) {
for ( int x = 0; x < this->width; ++x ) {
if ( GameBoard::Wall == this->blocks[ y ][ x ] ) {
this->addWallBlock( x, y );
}
else if ( GameBoard::Path == this->blocks[ y ][ x ] ) {
this->addGrassBlock( x, y );
}
else if ( GameBoard::Dot == this->blocks[ y ][ x ] ) {
this->addGrassBlock( x, y );
}
else if ( GameBoard::Powerup == this->blocks[ y ][ x ] ) {
this->addGrassBlock( x, y );
}
else if ( GameBoard::Teleport1 == this->blocks[ y ][ x ] ) {
this->addGrassBlock( x, y );
}
else if ( GameBoard::PlayerStart == this->blocks[ y ][ x ] ) {
this->addGrassBlock( x, y );
}
else if ( GameBoard::PlayerWall == this->blocks[ y ][ x ] ) {
this->addFloorBlock( x, y, this->roofTexture, this->defaultMaterial );
}
else if ( GameBoard::GhostsStart == this->blocks[ y ][ x ] ) {
this->addFloorBlock(
x, y, this->ghostsStartTexture, this->defaultMaterial
);
}
}
}
}
glEndList();
this->dotList = glGenLists( 1 );
this->dotQuadric = gluNewQuadric();
gluQuadricTexture( this->dotQuadric, true );
glNewList( this->dotList, GL_COMPILE );
{
glBindTexture( GL_TEXTURE_2D, this->dotTexture );
gluSphere( this->dotQuadric, 0.1f, 360 / 30, 180 / 30 );
}
glEndList();
}
BasketBall::BasketBall() :
Ball(MyGlobal::BASKETBALL_RADIUS)
{
quadric = gluNewQuadric();
gluQuadricNormals(quadric, GL_SMOOTH);
gluQuadricTexture(quadric, GL_TRUE);
if (texture == -1)
texture = GLAid::loadTexture(MyGlobal::BASKETBALL_TEXTURE_PATH);
}
Dummy::Dummy( World * world ) : ACreature( world )
{
mQuadric = gluNewQuadric();
gluQuadricTexture( mQuadric, GL_TRUE );
mHeightAboveGround = 6.0f;
mVelocityY = 0.0f;
mMaterial = new Material( scene()->glWidget(), "KirksEntry" );
}