/* filled cone */
static Bool myCone(float radius)
{
#if 0
GLUquadricObj *quadObj;
if ((quadObj = gluNewQuadric()) == 0)
return False;
gluQuadricDrawStyle(quadObj, (GLenum) GLU_FILL);
gluCylinder(quadObj, radius, 0, radius * 2, 8, 1);
gluDeleteQuadric(quadObj);
#else
cone (0, 0, 0,
0, 0, radius * 2,
radius, 0,
8, True, True, False);
#endif
return True;
}
//
// Translate into a GLU quadric object in a list.
//
void Ellipsoid3D::Update() {
GLUquadricObj *glq = gluNewQuadric();
mList.Start();
if (mFlags & kGFWire) { // Wire Frame
gluQuadricDrawStyle(glq, GLU_LINE);
mColor.Draw();
} else {
RunMaterial();
}
glPushMatrix();
glTranslatef(mOrigin.mX, mOrigin.mY, mOrigin.mZ);
gluSphere(glq, mAxes[0].mX, 20, 20);
glPopMatrix();
mList.End();
gluDeleteQuadric(glq);
}
void tglDrawDisk(const TPointD &c, double r)
{
if (r <= 0)
return;
double pixelSize = 1;
int slices = 60;
if (slices <= 0)
slices = computeSlices(r, pixelSize) >> 1;
glPushMatrix();
glTranslated(c.x, c.y, 0.0);
GLUquadric *quadric = gluNewQuadric();
gluDisk(quadric, 0, r, slices, 1);
gluDeleteQuadric(quadric);
glPopMatrix();
}
void GLWidget::gl_draw() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if(m_data == 0)
return;
GLUquadricObj *pObj;
pObj = gluNewQuadric();
glTranslatef(0.0,0.0,m_z);
glRotatef(m_angle,1.0,0.0,0.0);
glTranslatef(-(float) m_data->getDimension(0)/2.0 + m_dx,-(float) m_data->getDimension(1)/2.0 + m_dy,0.0);
//draw spins
for(unsigned int i = 0; i < m_arrows.size(); i++)
m_arrows.at(i).draw(pObj);
gluDeleteQuadric(pObj);
}
/**
* @brief Print a Dome that actually is a sphere.
* This function print a sphere whith the texture of a beautifull sky.
*/
void underTheDome(){
//i'm not a big fan of the series but after breaking bad i start to whatch it.
glPushAttrib(GL_LIGHTING_BIT);
GLfloat material_col[] = {1.0, 1.0, 1.0};
glMaterialfv(GL_FRONT, GL_EMISSION, material_col);
glPushMatrix();
GLUquadric *qobj = gluNewQuadric();
gluQuadricTexture(qobj,GL_TRUE);
glRotatef(90, 1, 0, 0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texSky);
gluSphere(qobj,100,1000,1000);
// drawBox(50, GL_QUADS);
gluDeleteQuadric(qobj);
glDisable(GL_TEXTURE_2D);
glPopMatrix();
glPopAttrib();
}
// Draw function
void Arc::drawFunc()
{
BEGIN_DLIST
GLUquadricObj* qobj = gluNewQuadric();
if (isFilled()) {
gluQuadricDrawStyle(qobj, GLU_FILL);
}
else {
gluQuadricDrawStyle(qobj, GLU_SILHOUETTE);
}
if (connected) {
gluPartialDisk(qobj, 0, getRadius(), getSlices(), 2, startAngle, arcLength);
}
else {
gluPartialDisk(qobj, getRadius(), getRadius(), getSlices(), 2, startAngle, arcLength);
}
gluDeleteQuadric(qobj);
END_DLIST
}
/*******************************************************************************
Graphics main loop function.
*******************************************************************************/
void displayFunction(void)
{
// Setup model transformations.
glMatrixMode(GL_MODELVIEW);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
setupGraphicsState();
drawAxes(sphereRadius*3.0);
// Draw the fixed sphere.
static const hduVector3Dd fixedSpherePosition(0, 0, 0);
static const float fixedSphereColor[4] = {.2, .8, .8, .8};
GLUquadricObj* pQuadObj = gluNewQuadric();
drawSphere(pQuadObj, fixedSpherePosition, fixedSphereColor, sphereRadius);
// Get the current position of end effector.
DeviceDisplayState state;
hdScheduleSynchronous(DeviceStateCallback, &state,
HD_MIN_SCHEDULER_PRIORITY);
// Draw a sphere to represent the haptic cursor and the dynamic
// charge.
static const float dynamicSphereColor[4] = { .8, .2, .2, .8 };
drawSphere(pQuadObj,
state.position,
dynamicSphereColor,
sphereRadius);
// Create the force vector.
hduVector3Dd forceVector = 400.0 * forceField(state.position);
drawForceVector(pQuadObj,
state.position,
forceVector,
sphereRadius*.1);
gluDeleteQuadric(pQuadObj);
glPopMatrix();
glutSwapBuffers();
}
void drawRightEar() {
glRotatef(earsRot, 0, 0, 1);
glRotatef(-90.0f, 1, 0, 0);
glRotatef(9.0f, 0, 1, 0);
glTranslatef(4.0, 0, 5);
glColor3f(1.0, 1.0, 1.0);
GLUquadricObj* ear = gluNewQuadric();
gluCylinder(ear, 1.0, 1.0, 6, 100, 20);
glPushMatrix();
glColor3f(0.0, 0.0, 0.0);
glTranslatef(0, 0, 6);
glutSolidCone(1.0, 2, 100, 10);
glPopMatrix();
gluDeleteQuadric(ear);
}
void draw_food()
{
GLUquadric *params;
extern t_client t;
extern GLuint type7;
glPushMatrix();
params = gluNewQuadric();
glBindTexture(GL_TEXTURE_2D, type7);
glColor3ub(255, 255, 255);
gluQuadricTexture(params, GL_TRUE);
glTranslated(t.x_pos * 2 + 1, t.y_pos * 2 + 1, 0);
gluCylinder(params, 0.5, 0.5, 0.8, 20, 1);
glTranslated(0, 0, 0.8);
glRotated(90, 0, 0, 1);
gluDisk(params, 0, 0.5, 20, 1);
gluDeleteQuadric(params);
glPopMatrix();
}
void drawSphere(float Radius, GLint Slices, GLint Rings)
{
GLUquadricObj* SpherePointer;
glPushMatrix();
SpherePointer = gluNewQuadric();
gluQuadricDrawStyle(SpherePointer, Wired_or_Shade);
gluSphere(SpherePointer, Radius, Slices, Rings);
gluDeleteQuadric(SpherePointer);
glPopMatrix();
}
// Draw the cursor
void drawCursor()
{
static const int kCursorTess = 15;
// Haptic cursor position in "world coordinates"
double cursorPosWC[3];
// Must synch before data is valid
gHaptics.synchFromServo();
gHaptics.getPosition(cursorPosWC);
// The color will depend on the button state.
gCurrentColor = gHaptics.isButtonDown() ? colorRed : colorTeal;
GLUquadricObj *qobj = 0;
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_LIGHTING_BIT);
glPushMatrix();
// Page 505-506 of The Red Book recommends using a display list
// for static quadrics such as spheres
if (!gCursorDisplayList)
{
gCursorDisplayList = glGenLists(1);
glNewList(gCursorDisplayList, GL_COMPILE);
qobj = gluNewQuadric();
gluSphere(qobj, gCursorRadius, kCursorTess, kCursorTess);
gluDeleteQuadric(qobj);
glEndList();
}
glTranslatef(cursorPosWC[0], cursorPosWC[1], cursorPosWC[2]);
glEnable(GL_COLOR_MATERIAL);
glColor3fv(gCurrentColor);
glCallList(gCursorDisplayList);
glPopMatrix();
glPopAttrib();
}
/* simple filled sphere */
static Bool mySphere(float radius)
{
#if 0
GLUquadricObj *quadObj;
if((quadObj = gluNewQuadric()) == 0)
return False;
gluQuadricDrawStyle(quadObj, (GLenum) GLU_FILL);
gluSphere(quadObj, radius, 16, 16);
gluDeleteQuadric(quadObj);
#else
glPushMatrix();
glScalef (radius, radius, radius);
glRotatef (90, 1, 0, 0);
unit_sphere (16, 16, False);
glPopMatrix();
#endif
return True;
}
void Sphere::drawShape(GLuint texture) {
this->quad = gluNewQuadric();
gluQuadricTexture(this->quad, GL_TRUE);
gluQuadricOrientation(this->quad, GLU_OUTSIDE);
gluQuadricNormals(this->quad, GLU_SMOOTH);
glPushMatrix();
this->ctm_multiply();
glEnable(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, texture);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
gluSphere(this->quad, radius, 50, 50);
//glColor4f(color[0], color[1], color[2], color[3]);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
gluDeleteQuadric(this->quad);
}
// [Assignment2] you may need to revise this function
void Skeleton::display() {
if (root == NULL) {
return;
}
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glScalef(0.05, 0.05, 0.05);
GLUquadric* quad = gluNewQuadric(); //Create a new quadric to allow you to draw cylinders
if (quad == 0) {
printf("Not enough memory to allocate space to draw\n");
exit(EXIT_FAILURE);
}
//Actually draw the skeleton
display(root, quad);
gluDeleteQuadric(quad);
glPopMatrix();
}
void makeMickey()
{
GLUquadricObj* qsphere = gluNewQuadric();
glNewList(MICKEY, GL_COMPILE);
gluQuadricDrawStyle(qsphere, GLU_FILL);
gluQuadricNormals(qsphere, GLU_SMOOTH);
gluQuadricOrientation(qsphere, GLU_OUTSIDE);
gluQuadricTexture(qsphere, GL_FALSE);
glColor3f(1,1,0);
gluSphere(qsphere, 13, 20, 20);
glTranslatef(14,14,0);
gluSphere(qsphere, 10, 20, 20);
glTranslatef(-28,0,0);
gluSphere(qsphere, 10, 20, 20);
glEndList();
gluDeleteQuadric(qsphere);
}
/* draw a given stroke - just a single dot (only one point) */
static void gp_draw_stroke_point(bGPDspoint *points, short thickness, short dflag, short sflag,
int offsx, int offsy, int winx, int winy)
{
/* set point thickness (since there's only one of these) */
glPointSize((float)(thickness + 2) * points->pressure);
/* draw point */
if (sflag & GP_STROKE_3DSPACE) {
glBegin(GL_POINTS);
glVertex3fv(&points->x);
glEnd();
}
else {
float co[2];
/* get coordinates of point */
gp_calc_2d_stroke_xy(points, sflag, offsx, offsy, winx, winy, co);
/* if thickness is less than GP_DRAWTHICKNESS_SPECIAL, simple dot looks ok
* - also mandatory in if Image Editor 'image-based' dot
*/
if ((thickness < GP_DRAWTHICKNESS_SPECIAL) ||
((dflag & GP_DRAWDATA_IEDITHACK) && (sflag & GP_STROKE_2DSPACE)))
{
glBegin(GL_POINTS);
glVertex2fv(co);
glEnd();
}
else {
/* draw filled circle as is done in circf (but without the matrix push/pops which screwed things up) */
GLUquadricObj *qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj, GLU_FILL);
/* need to translate drawing position, but must reset after too! */
glTranslate2fv(co);
gluDisk(qobj, 0.0, thickness, 32, 1);
glTranslatef(-co[0], -co[1], 0.0);
gluDeleteQuadric(qobj);
}
}
}
void SimpleDraw::DrawCylinder( const Vec& center, const Vec& direction /*= Vec(0,0,1)*/,
float height, float radius /*= 1.0f*/, float radius2 /*= -1*/ )
{
glPushMatrix();
glTranslatef(center.x, center.y, center.z);
glMultMatrixd(qglviewer::Quaternion(Vec(0,0,1), direction).matrix());
GLUquadricObj *quadObj = gluNewQuadric();
gluQuadricDrawStyle(quadObj, GLU_FILL);
gluQuadricNormals(quadObj, GLU_SMOOTH);
if(radius2 < 0)
radius2 = radius;
gluCylinder(quadObj, radius, radius2, height, 16, 16);
gluDeleteQuadric(quadObj);
glPopMatrix();
}
void SphereParts::draw(GLContext &c)
{
const dReal * m = getRotation();
// R(gl)
const dReal *pos_ = getPosition();
Position pos(pos_[0], pos_[1], pos_[2]);
DEF_R(r, pos, m);
glMultMatrixd(r);
double radius = m_cmpnt->radius();
GLUquadricObj *quad = gluNewQuadric();
gluQuadricDrawStyle(quad, GLU_FILL);
gluSphere(quad, radius, 10, 10);
gluDeleteQuadric(quad);
}
void Gl1_Cylinder::drawCylinder(bool wire, Real radius, Real length, const Quaternionr& shift) const
{
glPushMatrix();
GLUquadricObj *quadObj = gluNewQuadric();
gluQuadricDrawStyle(quadObj, (GLenum) (wire ? GLU_SILHOUETTE : GLU_FILL));
gluQuadricNormals(quadObj, (GLenum) GLU_SMOOTH);
gluQuadricOrientation(quadObj, (GLenum) GLU_OUTSIDE);
AngleAxisr aa(shift);
glRotatef(aa.angle()*180.0/Mathr::PI,aa.axis()[0],aa.axis()[1],aa.axis()[2]);
gluCylinder(quadObj, radius, radius, length, glutSlices,glutStacks);
gluQuadricOrientation(quadObj, (GLenum) GLU_INSIDE);
glutSolidSphere(radius,glutSlices,glutStacks);
glTranslatef(0.0,0.0,length);
glutSolidSphere(radius,glutSlices,glutStacks);
// gluDisk(quadObj,0.0,radius,glutSlices,_loops);
gluDeleteQuadric(quadObj);
glPopMatrix();
}
void CALLBACK display(void)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glDisable(GL_LIGHTING);
glColor3f (1, 1, 1);
for(int j=0;j<8;j++)
{
glBegin(GL_LINE_LOOP);
for (int i = 0; i < 360; i++)
{
glVertex3f(cos(i*3.14/180)*r1[j] , 0, sin(i*3.14/180)*r1[j]);
}
glEnd();
}
glEnable(GL_LIGHTING);
glPushMatrix();
auxSolidSphere(0.9);
glPopMatrix();
glEnable(GL_TEXTURE_2D);
for(int i=0;i<8;i++)
{
glPushMatrix();
glRotatef(year[i],0,1,0);
glTranslatef( r1[i] ,0,0);
glRotatef(day[i],0,1,0);
glBindTexture(GL_TEXTURE_2D, texture_id[i]);
{
GLUquadricObj* p = gluNewQuadric();
gluQuadricTexture (p, GL_TRUE);
gluSphere(p, r2[i], 16, 16);
gluDeleteQuadric(p);
}
glPopMatrix();
}
glDisable(GL_TEXTURE_2D);
glFlush();
auxSwapBuffers();
}
void drawBall() {
glTranslatef(10.0f, 10.0f, 5.5f);
glRotatef(ballRot, 0, 0, 1);
glRotatef(20.0f, 1, 0, 0);
glRotatef(180.0f, 0, 1, 0);
glColor3f(1.0f, 0.0f, 0.0f);
drawHemisphere(20, 20, 7, true);
glColor3f(1.0f, 1.0f, 1.0f);
drawHemisphere(20, 20, 7, false);
glPushMatrix();
glColor3f(0.0, 0.0, 0.0);
glRotatef(90.0f, 1.0, 0.0, 0.0);
GLUquadricObj* ring = gluNewQuadric();
gluCylinder(ring, 7, 7, 1.5, 100, 10);
gluDeleteQuadric(ring);
glPopMatrix();
glPushMatrix();
glColor3f(0.0, 0.0, 0.0);
glBegin(GL_POLYGON);
for (int i = 0; i < 360; i++) {
float angle = i * RADIAN;
glVertex3f(cos(angle) * 3, sin(angle) * 3, 7.0f);
}
glEnd();
glPushMatrix();
glColor3f(1.0, 1.0, 1.0);
glBegin(GL_POLYGON);
for (int i = 0; i < 360; i++) {
float angle = i * RADIAN;
glVertex3f(cos(angle) * 2, sin(angle) * 2, 7.5f);
}
glEnd();
glPopMatrix();
glPopMatrix();
}
GLvoid KillGLWindow(GLvoid) // Properly Kill The Window
{
gluDeleteQuadric(quadratic); // Delete The Quadratic To Free System Resources
if (fullscreen) // Are We In Fullscreen Mode?
{
ChangeDisplaySettings(NULL,0); // If So Switch Back To The Desktop
ShowCursor(TRUE); // Show Mouse Pointer
}
if (hRC) // Do We Have A Rendering Context?
{
if (!wglMakeCurrent(NULL,NULL)) // Are We Able To Release The DC And RC Contexts?
{
MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
}
if (!wglDeleteContext(hRC)) // Are We Able To Delete The RC?
{
MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
}
hRC=NULL; // Set RC To NULL
}
if (hDC && !ReleaseDC(hWnd,hDC)) // Are We Able To Release The DC
{
MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hDC=NULL; // Set DC To NULL
}
if (hWnd && !DestroyWindow(hWnd)) // Are We Able To Destroy The Window?
{
MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hWnd=NULL; // Set hWnd To NULL
}
if (!UnregisterClass("OpenGL",hInstance)) // Are We Able To Unregister Class
{
MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hInstance=NULL; // Set hInstance To NULL
}
}
void render_cylinder(GLdouble diameter,const GLdouble p1[3],const GLdouble p2[3],const char *label)
{
GLdouble v[3],dist,ax,r[3];
GLUquadricObj *obj;
int is_z=0;
v[0]=p2[0]-p1[0];
v[1]=p2[1]-p1[1];
v[2]=p2[2]-p1[2];
dist=sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);
if (dist == 0.0)
return;
v[0] /= dist;
v[1] /= dist;
v[2] /= dist;
/* Compute angle and rotation axis */
ax=180.0/M_PI * acos(p5glove_dot(z_front,v));
p5glove_plane(z_front,zero,v,r);
obj=gluNewQuadric();
gluQuadricDrawStyle(obj,GLU_SMOOTH);
gluQuadricOrientation(obj,GLU_OUTSIDE);
/* Fun fun. Draw a cylinder between two points.
*/
glPushMatrix();
glPushMatrix();
glTranslated(p1[0],p1[1],p1[2]);
gluSphere(obj,diameter,10,10);
glRotated(ax, r[0], r[1], r[2]);
gluCylinder(obj,diameter,diameter,dist,10,1);
glPopMatrix();
glTranslated(p2[0],p2[1],p2[2]);
gluSphere(obj,diameter,10,10);
render_label(diameter,label);
glPopMatrix();
gluDeleteQuadric(obj);
}
void LunarModule::DrawCockpit()
{
glPushMatrix();
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texIds[2]);
GLUquadricObj *sphere=NULL;
sphere = gluNewQuadric();
gluQuadricDrawStyle(sphere, GLU_FILL);
gluQuadricTexture(sphere, true);
gluQuadricNormals(sphere, GLU_SMOOTH);
glEnable(GL_TEXTURE_2D);
glRotatef(90, 0, 1, 0);
gluSphere(sphere, 80, 200, 20);
gluDeleteQuadric(sphere);
glBindTexture(GL_TEXTURE_2D, NULL);
glDisable(GL_TEXTURE_2D);
glPopMatrix();
}
//////////////////////////////////////////////////////////////////////////////
//
// Un-initializes textures and quadric(s).
//
// RETURNS: true, Always.
//
//////////////////////////////////////////////////////////////////////////////
bool CComaLogo::unInit()
{
// Remove title image.
if (m_punTitle != NULL)
glDeleteTextures(1, m_punTitle), m_punTitle = NULL;
// Remove shadow image.
if (m_punBGShadow != NULL)
glDeleteTextures(1, m_punBGShadow), m_punBGShadow = NULL;
// Remove background image.
if (m_punBGTexture != NULL)
glDeleteTextures(1, m_punBGTexture), m_punBGTexture = NULL;
// Kill the OpenGL quadric sphere.
if (m_pQuadSphere != NULL)
gluDeleteQuadric(m_pQuadSphere), m_pQuadSphere = NULL;
return true;
}
static void drawPrism(GLdouble radius,V3d Base1Pos,V3d Base2Pos)
{
V3d Direction;
double lengt;
GLUquadricObj *obj;
glPushMatrix();
glTranslated(Base1Pos[0],Base1Pos[1],Base1Pos[2]);
Direction[0] = Base2Pos[0]-Base1Pos[0];
Direction[1] = Base2Pos[1]-Base1Pos[1];
Direction[2] = Base2Pos[2]-Base1Pos[2];
lengt = v3d_length(Direction);
rotatedVector(Direction);
obj = gluNewQuadric();
gluQuadricNormals(obj, GL_SMOOTH);
gluQuadricDrawStyle(obj, GLU_FILL);
gluCylinder (obj,radius,radius/5,lengt,10,10);
gluDeleteQuadric(obj);
glPopMatrix();
}
//------------------------------------------------------------------------------
void DrawSphere(GLdouble radius, GLint slices, GLint stacks,
GLenum style, GLenum orientation, GLenum normals,
GLenum textureCoords)
{
GLenum error = glGetError();
GLUquadricObj* qobj = gluNewQuadric();
error = glGetError();
gluQuadricDrawStyle(qobj, style);
error = glGetError();
gluQuadricNormals(qobj, normals);
error = glGetError();
gluQuadricTexture(qobj, textureCoords);
error = glGetError();
gluSphere(qobj, radius, slices, stacks);
error = glGetError();
gluQuadricOrientation(qobj, orientation);
error = glGetError();
gluDeleteQuadric(qobj);
error = glGetError();
}
Cylinder::Cylinder(int slices)
: slices(slices) {
GLUquadric* quadric = gluNewQuadric();
gluQuadricTexture(quadric, GL_TRUE);
idDisplayList = glGenLists(1);
glNewList(idDisplayList, GL_COMPILE);
// glRotatef(90.0, 1.0, 0.0, 0.0);
glTranslatef(0.0, 0.0, -1.0);
gluCylinder(quadric, 1.0, 1.0, 2.0, slices, 1);
glTranslatef(0.0, 0.0, 2.0);
gluDisk(quadric, 0.0, 1.0, slices, 1);
glTranslatef(0.0, 0.0, -2.0);
glRotatef(180.0, 1.0, 0.0, 0.0);
gluDisk(quadric, 0.0, 1.0, slices, 1);
glEndList();
gluDeleteQuadric(quadric);
}
bool CCubeZoom::unInit()
{
// Kill display list for single object
if (m_glDispObject != 0)
glDeleteLists(m_glDispObject,1);
// Kill display list(s) for recurssion
if (m_glDispStartIndex != 0)
glDeleteLists(m_glDispStartIndex, nMAX_CUBE_DEPTH);
// Remove node image.
if (m_punNodeTexture != NULL)
glDeleteTextures(1, m_punNodeTexture), m_punNodeTexture = NULL;
// Kill foreground sphere.
if (m_pQuadObject != NULL)
gluDeleteQuadric(m_pQuadObject), m_pQuadObject = NULL;
return true;
}
void Bird::draw() //render
{
//float angle = getAngle(velocity) + 1.57079633;
//QQuaternion thisQuat = QQuaternion(position.x(),position.y(),position.z(),0);
//QQuaternion zeroQuat = (0,0,0,0);
//QQuaternion = QQuaternion::slerp(thisQuat,zeroQuat);
glPushMatrix();
glTranslatef(position.x(),position.y(),position.z());
glColor3f(1.0,0,1.0);
//glRotatef();
//qDebug("drawing1");
GLUquadricObj *quadric;
quadric = gluNewQuadric();
gluQuadricDrawStyle(quadric, GLU_FILL );
gluSphere(quadric,1,100,100);
gluDeleteQuadric(quadric);
glPopMatrix();
//qDebug("drawing2");
}
