void PartialDisque::BuildAndDisplay()
{

	// Génération du cylindre partiel exterieur
	_cylExtPartiel->FastDisplay();

	// Génération du cylindre interieur
	if(_diametreInterieur != 0){
		GLUquadric* paramsCylInt = gluNewQuadric();
		gluCylinder(paramsCylInt, _diametreInterieur/2, _diametreInterieur/2,_height,_slices,1);
	}

	// Géréation des 2 disques
	GLUquadric* paramsDiscH = gluNewQuadric();
	gluPartialDisk(paramsDiscH,_diametreInterieur/2,_diametreExterieur/2,_slices,1, 0, _angle);
	gluDisk(paramsDiscH,0,_diametreInterieur/2,_slices,1);

	glPushMatrix();
		glTranslatef(0.0, 0.0, _height);
		GLUquadric* paramsDiscB = gluNewQuadric();
		gluPartialDisk(paramsDiscH,_diametreInterieur/2,_diametreExterieur/2,_slices,1, 0, _angle);
		gluDisk(paramsDiscH,0,_diametreInterieur/2,_slices,1);
	glPopMatrix();
	
	float angle = DEGREES_TO_RADIANS(15);
	// Pattern
	Point3D patternFlanc[2], flanc[4];
	patternFlanc[0] = Point3D(0, -_diametreExterieur/2, 0);
	patternFlanc[1] = Point3D(0, -_diametreExterieur/2, _height);

	for(int i=0; i<4; i++)
		flanc[i] = Point3D(patternFlanc[i%2]._x * cosf((i>1)?-angle:angle) - patternFlanc[i%2]._y * sinf((i>1)?-angle:angle), patternFlanc[i%2]._x * sinf((i>1)?-angle:angle) + patternFlanc[i%2]._y * cosf((i>1)?-angle:angle), patternFlanc[i%2]._z);

}
void PolarGridRenderer::render() {
    if(m_grid) {
        glPushMatrix();
        glTranslatef(0.f, 0.f, m_depth);
        if(m_position) {
            glTranslatef(m_position->x, m_position->y, 0.f);
            glRotatef(rad2deg(m_position->theta), 0.f, 0.f, 1.f);
        }
        double sweep = 2*M_PI/(m_phiEdges->size() - 1);
        for(unsigned int i = 0; i < m_grid->size(); i ++) {
            for(unsigned int j = 0; j < (*m_grid)[i].size(); j++) {
                glPushMatrix();
                m_color.lightness() = m_maxValue == 0.? 1. : 1. - 0.5*(*m_grid)[i][j]/m_maxValue;
                Color color(HSL2RGB(m_color));
                double inner = (*m_rhoEdges)[j];
                double outer = (*m_rhoEdges)[j+1];
                double start = -(*m_phiEdges)[i] + M_PI_2;
                glColor4f(color.red(), color.green(), color.blue(), color.alpha());
                gluQuadricDrawStyle(m_GLUSectors[i * (*m_grid)[i].size() + j], GLU_FILL);
                gluPartialDisk(m_GLUSectors[i * (*m_grid)[i].size() + j], inner, outer, m_subdivision[0], m_subdivision[1], rad2deg(start), rad2deg(-sweep));
                glColor4f(0.f, 0.f, 0.f, 1.f);
                gluQuadricDrawStyle(m_GLUGrids[i * (*m_grid)[i].size() + j], GLU_SILHOUETTE);
                gluPartialDisk(m_GLUGrids[i * (*m_grid)[i].size() + j], inner, outer, m_subdivision[0], m_subdivision[1], rad2deg(start), rad2deg(-sweep));
                glPopMatrix();
            }
        }
        glColor4f(0.f,0.f,0.f,1.f);
        glBegin(GL_LINES);
        glVertex3f(0.f, 0.f, 0.f);
        glVertex3f((*m_rhoEdges)[m_rhoEdges->size() - 1] + 0.1f, 0.f, 0.f);
        glEnd();
        glPopMatrix();
    }
}
示例#3
0
void ssr::QOpenGLPlotter::_draw_loudspeaker(bool muted, bool active)
{
  glColor3f(0.4f, 0.4f, 0.4f);

  if (muted)
  {
    // plot muted loudspeaker
    // TODO: Make lines wider?
    glBegin(GL_LINE_STRIP);
      glVertex3f( -0.02f,  0.017f, 0.0f); glVertex3f( -0.02f, -0.017f, 0.0f);
      glVertex3f( 0.002f, -0.017f, 0.0f);
      glVertex3f( 0.024f, -0.040f, 0.0f); glVertex3f(  0.024f,  0.040f, 0.0f);
      glVertex3f( 0.002f,  0.017f, 0.0f); glVertex3f( -0.02f, 0.017f, 0.0f);
    glEnd();
  }
  else
  {
    // plot loudspeaker

    glBegin(GL_TRIANGLE_FAN); // magnet
      glVertex3f( -0.02f,  0.017f, 0.0f); glVertex3f( -0.02f, -0.017f, 0.0f);
      glVertex3f( -0.002f, -0.017f, 0.0f); glVertex3f( -0.002f,  0.017f, 0.0f);
    glEnd();

    glBegin(GL_TRIANGLE_FAN); // cone
      glVertex3f( 0.002f,  0.017f, 0.0f); glVertex3f( 0.002f, -0.017f, 0.0f);
      glVertex3f( 0.024f, -0.040f, 0.0f); glVertex3f( 0.024f,  0.040f, 0.0f);
    glEnd();

    glColor3f(1.0f, 1.0f, 1.0f);

    glBegin(GL_TRIANGLE_FAN); // ring
      glVertex3f( -0.002f,  0.017f, 0.0f); glVertex3f( -0.002f, -0.017f, 0.0f);
      glVertex3f(  0.002f, -0.017f, 0.0f); glVertex3f(  0.002f,  0.017f, 0.0f);
    glEnd();

    if (active)
    {
      // plot sound waves

      // TODO: more elegant
      if (_active_source == -1) _active_source = 0;

      qglColor(_color_vector[_id_of_last_clicked_source%_color_vector.size()]);

      gluPartialDisk(_glu_quadric, 0.05f ,0.055f, LEVELOFDETAIL, 1, 50.0f, 80.0f);
      gluPartialDisk(_glu_quadric, 0.1f , 0.105f, LEVELOFDETAIL, 1, 50.0f, 80.0f);
      gluPartialDisk(_glu_quadric, 0.15f, 0.155f, LEVELOFDETAIL, 1, 50.0f, 80.0f);
    }
  }
}
示例#4
0
void drawRangeRing(GLfloat range, GLfloat fov, GLfloat range_width)
{
  glPushMatrix();
  glRotatef((fov/2.0f) - 90, 0.f, 0.f, 1.f);
  gluPartialDisk(GLUWrapper::getQuadradic(), range, range + range_width, 32, 1, 0.f, fov);
  glPopMatrix();
}
void __fastcall TFormMapper::Render() {
  CameraLookAt(0,-4,12,0,0,0,0,1,0);

  glClearColor(bgr,bgg,bgb,0.0);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glLoadIdentity();

  glPushMatrix();
  //Render all that stuff here
  //Quadrics
  //gluSphere, gluCylinder, gluDisk, gluPartialDisk
  glEnable(GL_TEXTURE_2D);
  textures.SetTexture(0);

  glRotatef(xrot,1,0,0);
  glRotatef(yrot,0,1,0);
  glRotatef(zrot,0,0,1);

  if (tool==0)gluSphere(obj,4,128,16);

  if (tool==1) {
    glTranslatef(0,0,-3);
    gluCylinder(obj,3,3,6,128,16);
  }

  if (tool==2)gluDisk(obj,1,4,128,16);
  if (tool==3)gluPartialDisk(obj,1,4,128,16,0,270);

  glDisable(GL_TEXTURE_2D);
  glPushMatrix();

  SwapBuffers(hDC);
  glFlush();
}
JNIEXPORT void JNICALL Java_OpenGL_GLUQuadric_partialDisk
(JNIEnv *env, jobject obj, jlong quadric,
 jdouble innerRadius, jdouble outerRadius,
 jint slices, jint loops, jdouble startAngle, jdouble sweepAngle)
{
    gluPartialDisk(TO_POINTER(quadric), innerRadius, outerRadius, slices, loops,
                   startAngle, sweepAngle);
}
示例#7
0
void GLThread::DrawArcBetweenMats(Vector3d& center, Vector3d& dir1, Vector3d& dir2, double inner_radius, double outer_radius, string& str)
{
	updateThreadPoints();
	GLUquadricObj *quadric=gluNewQuadric();
  gluQuadricNormals(quadric, GLU_SMOOTH);

	glDisable(GL_TEXTURE_2D);

	glPushMatrix();
	float pt_loc[3];
	for (int j=0; j < 3; j++)
	{
		pt_loc[j] = (float)center(j)-display_start_pos(j);
	}

	glTranslatef(pt_loc[0], pt_loc[1], pt_loc[2]);


	Matrix3d rot_mat;
	rot_mat.col(0) = dir1;
	Vector3d newy = dir2;
	make_vectors_perpendicular(rot_mat.col(0), newy);
	rot_mat.col(1) = newy.normalized();
	rot_mat.col(2) = rot_mat.col(0).cross(rot_mat.col(1)).normalized();
	//rot_mat = Eigen::AngleAxisd(M_PI/2.0, rot_mat.col(0))*rot_mat;


	double angx, angy, angz;
	euler_angles_from_rotation(rot_mat, angz, angy, angx);
	glRotatef(angz*180.0/M_PI, 0.0, 0.0, 1.0);
	glRotatef(angy*180.0/M_PI, 0.0, 1.0, 0.0);
	glRotatef(angx*180.0/M_PI, 1.0, 0.0, 0.0);


	double max_ang = abs(acos(dir1.dot(dir2)))*180.0/M_PI;

	gluPartialDisk(quadric, inner_radius, outer_radius, 20, 20, 90, max_ang);

	glRasterPos3f (0,-3.0,3.0);
	for (string::iterator s = str.begin(); s != str.end(); ++s)
	{
		char c = *s;
		glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, c);
	}




	glPopMatrix();


	glEnable(GL_TEXTURE_2D);



}
示例#8
0
void display_all(void) {

  GLUquadricObj *qobj = NULL;
  double innerRadiusOfRing;
  double outerRadiusOfRing;
  double start_angle;
  double angular_step;
  static int current_list = 0 ;
  int ring, spoke ;
  double scaleFactor;


  glClear(GL_COLOR_BUFFER_BIT);
  current_list = !current_list ;
  glNewList(current_list, GL_COMPILE) ;

  angular_step = 360.0/numSpokes;

  scaleFactor = pow( (maxEcc/minEcc),
                     (1.0/( (double) numRings) ) );

  innerRadiusOfRing = minEcc;
  outerRadiusOfRing = minEcc * scaleFactor;


  /* draw radial checkerboard */
  for (ring = 0; ring < numRings; ring++) {
    for (spoke = 0; spoke < numSpokes; spoke++) {
      start_angle = spoke * angular_step;

      glColor3f(redFrames[ring][spoke][currentFrame], greenFrames[ring][spoke][currentFrame],
                blueFrames[ring][spoke][currentFrame]) ;

      qobj = gluNewQuadric();
      gluPartialDisk(qobj,
                     (GLdouble) innerRadiusOfRing,  /* inner radius */
                     (GLdouble) outerRadiusOfRing,  /* outer radius */
                     (GLint) angular_step, /* #vert. on disk perimeter */
                     1,   /* # vertices on disk ray (minus 1) */
                     (GLdouble) start_angle,  /* start angle for wedge */
                     (GLdouble) angular_step); /* wedge width in degrees */

    }

    innerRadiusOfRing *= scaleFactor;
    outerRadiusOfRing *= scaleFactor;

  }

  /*  glTranslatef( -Width/2 , -Height/2 , 0 ); */

  glEndList() ;
  glCallList(current_list) ;
  /*  glFlush();*/
  glutSwapBuffers();
}
示例#9
0
static void init(void) 
{
   GLUquadricObj *qobj;
   GLfloat mat_ambient[] = { 0.5, 0.5, 0.5, 1.0 };
   GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
   GLfloat mat_shininess[] = { 50.0 };
   GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
   GLfloat model_ambient[] = { 0.5, 0.5, 0.5, 1.0 };

   glClearColor(0.0, 0.0, 0.0, 0.0);

   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
   glLightfv(GL_LIGHT0, GL_POSITION, light_position);
   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, model_ambient);

   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
   glEnable(GL_DEPTH_TEST);

/*  Create 4 display lists, each with a different quadric object.
 *  Different drawing styles and surface normal specifications
 *  are demonstrated.
 */
   startList = glGenLists(4);
   qobj = gluNewQuadric();
   gluQuadricCallback(qobj, GLU_ERROR, 
                      (GLvoid (CALLBACK*) ()) errorCallback);

   gluQuadricDrawStyle(qobj, GLU_FILL); /* smooth shaded */
   gluQuadricNormals(qobj, GLU_SMOOTH);
   glNewList(startList, GL_COMPILE);
      gluSphere(qobj, 0.75, 15, 10);
   glEndList();

   gluQuadricDrawStyle(qobj, GLU_FILL); /* flat shaded */
   gluQuadricNormals(qobj, GLU_FLAT);
   glNewList(startList+1, GL_COMPILE);
      gluCylinder(qobj, 0.5, 0.3, 1.0, 15, 5);
   glEndList();

   gluQuadricDrawStyle(qobj, GLU_LINE); /* all polygons wireframe */
   gluQuadricNormals(qobj, GLU_NONE);
   glNewList(startList+2, GL_COMPILE);
      gluDisk(qobj, 0.25, 1.0, 20, 4);
   glEndList();

   gluQuadricDrawStyle(qobj, GLU_SILHOUETTE); /* boundary only  */
   gluQuadricNormals(qobj, GLU_NONE);
   glNewList(startList+3, GL_COMPILE);
      gluPartialDisk(qobj, 0.0, 1.0, 20, 4, 0.0, 225.0);
   glEndList();

   gluDeleteQuadric(qobj);
}
示例#10
0
// 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
}
示例#11
0
文件: View.cpp 项目: ggobbe/pacman-3d
void View::initDlPacMan2D() {
	// création de la liste pour le dessin du PacMan 2D
	idList_PacMan_2D = idList_SuperPill + 1;
	glNewList(idList_PacMan_2D, GL_COMPILE);
	GLUquadricObj *disque = gluNewQuadric();
	gluQuadricDrawStyle(disque, GLU_FILL);
	gluPartialDisk(disque, 0, 10, 100, 1, 135, 270);
	gluDeleteQuadric(disque);
	glEndList();
}
int DrawGLScene(GLvoid)									// Here's Where We Do All The Drawing
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Clear The Screen And The Depth Buffer
	glLoadIdentity();									// Reset The View
	glTranslatef(0.0f,0.0f,z);

	glRotatef(xrot,1.0f,0.0f,0.0f);
	glRotatef(yrot,0.0f,1.0f,0.0f);

	glBindTexture(GL_TEXTURE_2D, texture[filter]);

	switch(object)
	{
	case 0:
		glDrawCube();
		break;
	case 1:
		glTranslatef(0.0f,0.0f,-1.5f);					// Center The Cylinder
		gluCylinder(quadratic,1.0f,1.0f,3.0f,32,32);	// A Cylinder With A Radius Of 0.5 And A Height Of 2
		break;
	case 2:
		gluDisk(quadratic,0.5f,1.5f,32,32);				// Draw A Disc (CD Shape) With An Inner Radius Of 0.5, And An Outer Radius Of 2.  Plus A Lot Of Segments ;)
		break;
	case 3:
		gluSphere(quadratic,1.3f,32,32);				// Draw A Sphere With A Radius Of 1 And 16 Longitude And 16 Latitude Segments
		break;
	case 4:
		glTranslatef(0.0f,0.0f,-1.5f);					// Center The Cone
		gluCylinder(quadratic,1.0f,0.0f,3.0f,32,32);	// A Cone With A Bottom Radius Of .5 And A Height Of 2
		break;
	case 5:
		part1+=p1;
		part2+=p2;

		if(part1>359)									// 360 Degrees
		{
			p1=0;
			part1=0;
			p2=1;
			part2=0;
		}
		if(part2>359)									// 360 Degrees
		{
			p1=1;
			p2=0;
		}
		gluPartialDisk(quadratic,0.5f,1.5f,32,32,part1,part2-part1);	// A Disk Like The One Before
		break;
	};

	xrot+=xspeed;
	yrot+=yspeed;
	return TRUE;										// Keep Going
}
示例#13
0
void Sample_18::draw()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer

	glLoadIdentity();                   // Reset The View
	glTranslatef(0.0f,0.0f,m_z);              // Translate Into The Screen

	glRotatef(m_xrot,1.0f,0.0f,0.0f);             // Rotate On The X Axis
	glRotatef(m_yrot,0.0f,1.0f,0.0f);             // Rotate On The Y Axis

	glBindTexture(GL_TEXTURE_2D, m_texture[m_filter]);      // Select A Filtered Texture

	switch(m_object)                      // Check object To Find Out What To Draw
	{
	case 0:                         // Drawing Object 1
		glDrawCube();                   // Draw Our Cube
		break;                      // Done
	case 1:                         // Drawing Object 2
		glTranslatef(0.0f,0.0f,-1.5f);          // Center The Cylinder
		gluCylinder(m_quadratic,1.0f,1.0f,3.0f,32,32);    // Draw Our Cylinder
		break;                      // Done
	case 2:                         // Drawing Object 3
		gluDisk(m_quadratic,0.5f,1.5f,32,32);     // Draw A Disc (CD Shape)
		break;                      // Done
	case 3:                         // Drawing Object 4
		gluSphere(m_quadratic,1.3f,32,32);        // Draw A Sphere
		break;                      // Done
	case 4:                         // Drawing Object 5
		glTranslatef(0.0f,0.0f,-1.5f);          // Center The Cone
		gluCylinder(m_quadratic,1.0f,0.0f,3.0f,32,32);    // A Cone With A Bottom Radius Of .5 And A Height Of 2
		break;                      // Done
	case 5:                         // Drawing Object 6
		m_part1+=m_p1;                  // Increase Start Angle
		m_part2+=m_p2;                  // Increase Sweep Angle

		if(m_part1>359)                    // 360 Degrees
		{
			m_p1=0;                   // Stop Increasing Start Angle
			m_part1=0;                // Set Start Angle To Zero
			m_p2=1;                   // Start Increasing Sweep Angle
			m_part2=0;                // Start Sweep Angle At Zero
		}
		if(m_part2>359)                    // 360 Degrees
		{
			m_p1=1;                   // Start Increasing Start Angle
			m_p2=0;                   // Stop Increasing Sweep Angle
		}
		gluPartialDisk(m_quadratic,0.5f,1.5f,32,32,m_part1,m_part2-m_part1);    // A Disk Like The One Before
		break;                      // Done
	};

	m_xrot+=m_xspeed;                       // Increase Rotation On X Axis
	m_yrot+=m_yspeed;                       // Increase Rotation On Y Axis
}
示例#14
0
/* quad:PartialDisk (inner, outer, slices, loops, start, sweep) -> quad */
static int luaglu_partial_disk(lua_State *L)
{
  LuaGLUquadric *lquad=luaglu_checkquadric(L,1);

  gluPartialDisk(lquad->quad,luaL_checknumber(L, 2), luaL_checknumber(L, 3), 
		             luaL_checkinteger(L, 4),luaL_checkinteger(L, 5), 
		             luaL_checknumber(L, 6),luaL_checknumber(L, 7));

  lua_pushvalue(L,1);
  return 1;

}
示例#15
0
void gst_opengl_gluPartialDisk (GLenum draw, GLenum normals, GLenum orient,
			        GLboolean texture, GLdouble inner, GLdouble outer,
			        GLint slices, GLint loops,
				GLdouble start, GLdouble sweep)
{
  GLUquadric *q = gluNewQuadric ();
  gluQuadricDrawStyle (q, draw);
  gluQuadricNormals (q, normals);
  gluQuadricOrientation (q, orient);
  gluQuadricTexture (q, texture);
  gluPartialDisk (q, inner, outer, slices, loops, start, sweep);
  gluDeleteQuadric (q);
}
示例#16
0
// Draw function
void OcclusionArc::drawFunc()
{
   BEGIN_DLIST
   GLUquadricObj* qobj = gluNewQuadric();
   if (isFilled()) {
      gluQuadricDrawStyle(qobj, GLU_FILL);
   }
   else {
      gluQuadricDrawStyle(qobj, GLU_SILHOUETTE);
   }

   gluPartialDisk(qobj, getRadius(), outerRadius, getSlices(), 2, getStartAngle(), getArcLength());

   gluDeleteQuadric(qobj);
   END_DLIST
}
void RobotDrawComponent::drawObject()
{
	//drawCircle(getXDisplay(rPos.x), getYDisplay(rPos.y), 0.1, 10);	

	//GLUquadric* test = gluNewQuadric();
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glTranslatef(getXDisplay(rPos.x), getYDisplay(rPos.y), 0.0f);

	for (int i = 0; i < NUM_OF_CONES; i++)
		cones[i]->drawObject();


	glColor4f(1.0, 0.0, 0.0, 0.8f);
	gluPartialDisk(gluNewQuadric(), 0, 0.1, 100, 10, -orientationAngle+100, 340);

	
	glTranslatef(-getXDisplay(rPos.x), -getYDisplay(rPos.y), 0.0f);
}
示例#18
0
文件: g.c 项目: Svtter/workspace
void Display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);  //用当前背景色填充窗口
    glMatrixMode(GL_MODELVIEW);  //制定设置模型视图变换参数
    glLoadIdentity();   //消除以前的变换
    glRotatef(xRot,1.0f,0.0f,0.0f);   //绕X轴旋转图形
    glRotatef(yRot,0.0f,1.0f,0.0f);  //绕y轴旋转图形
    switch(iMode)
    {
        case 1:
            glutWireTetrahedron();break;   //绘制线框正四面体
        case 2:
            glutSolidTetrahedron();break;  //绘制实体正四面体

        case 3:
            glutWireOctahedron();break; //绘制线框正八面体
        case 4:
            glutSolidOctahedron();break;//绘制实体正八面体

        case 5:
            glutWireSphere(1.0f,15,15);break;  //绘制线框球
        case 6:
            glutSolidSphere(1.0f,15,15);break;//绘制实体球

        case 7:
            glutWireTeapot(1.0f);break;   //绘制线框茶壶
        case 8:
            glutSolidTeapot(1.0f);break;//绘制实体茶壶

        case 9:
            gluSphere(obj,1.0f,15,15);break;  //绘制二次曲面(球)

        case 10:
            gluCylinder(obj,1.0f,0.0f,1.0f,15,15);break;//绘制二次曲面(圆锥)

        case 11:
            gluPartialDisk(obj,0.3f,0.8f,15,15,30.0f,260.0f);break;  //绘制二次曲面(圆环)

        default: 
            break;
    }

}
示例#19
0
Pacman::Pacman(void)
{
	lives =  3;
	dir = 0;
	x = 0;
	y = 0;
	z = 0;
	step = 1.00;
	material = 6;
	ang = 0;
	inc_ang = -1;
	list_ptr = glGenLists(1);
	GLUquadricObj *qobj = gluNewQuadric();   
	gluQuadricDrawStyle(qobj, GLU_FILL);
	gluQuadricNormals(qobj, GLU_NONE);
	glNewList(list_ptr, GL_COMPILE);
    glPushMatrix(); //dibuja el tope
      gluPartialDisk(qobj, 0.0, 0.5, 20, 4, 0.0, 270.0);
    glPopMatrix();
	glEndList();
}
示例#20
0
//------------------------------------------------------------------------------
// drawFunc() -- draws the object(s)
//------------------------------------------------------------------------------
void DialArcSegment::drawFunc()
{
    // get our data from our base class
    double startAngle = getStartAngle();
    double radius = getRadius();
    double sweepAngle = getSweepAngle();

    GLint curSlices = getSlices();
    // our slice amount should go up as we get more of a sweep, if not, it will
    // look funny.  Pretty much one slice per degree sweep
    double y = std::fabs(static_cast<double>(sweepAngle));
    curSlices = curSlices + static_cast<GLint>(y * 0.05f);

    // draw our arc
    glPushMatrix();
        GLUquadric* qobj = gluNewQuadric();
        if (filled) gluQuadricDrawStyle(qobj, GL_FILL);
        else gluQuadricDrawStyle(qobj, GLU_SILHOUETTE);
        gluPartialDisk(qobj, radius, outerRadius, curSlices, 1, startAngle, sweepAngle);
        gluDeleteQuadric(qobj);
    glPopMatrix();
}
示例#21
0
static int tolua_glu_gluPartialDisk00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GLUquadricObj",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GLUquadricObj* qobj = ((GLUquadricObj*)  tolua_tousertype(tolua_S,1,0));
   double innerRadius = ((  double)  tolua_tonumber(tolua_S,2,0));
   double outerRadius = ((  double)  tolua_tonumber(tolua_S,3,0));
   int slices = ((  int)  tolua_tonumber(tolua_S,4,0));
   int loops = ((  int)  tolua_tonumber(tolua_S,5,0));
   double startAngle = ((  double)  tolua_tonumber(tolua_S,6,0));
   double sweepAngle = ((  double)  tolua_tonumber(tolua_S,7,0));
  {
   gluPartialDisk(qobj,innerRadius,outerRadius,slices,loops,startAngle,sweepAngle);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'gluPartialDisk'.",&tolua_err);
 return 0;
#endif
}
示例#22
0
void display_expanding_rings(void) {

  GLUquadricObj *qobj = NULL;
  double innerRadiusOfRing;
  double outerRadiusOfRing;
  double start_angle;
  double angular_step;
  static int current_list = 0 ;

  int ring, spoke, bit;
  double scaleFactor;

  double t, T, eccRange;
  double innerRadiusOfAnnulus;
  double outerRadiusOfAnnulus;

  putenv("__GL_SYNC_TO_VBLANK=23") ;  /* will force syncing with vertical retrace */
  glClear(GL_COLOR_BUFFER_BIT);
  current_list = !current_list ;
  glNewList(current_list, GL_COMPILE) ;

  angular_step = 360.0/numSpokes;

  scaleFactor = pow( (maxEcc/minEcc),
                     (1.0/( (double) numRings) ) );

  innerRadiusOfRing = minEcc;
  outerRadiusOfRing = minEcc * scaleFactor;

  /* draw radial checkerboard */
  for (ring = 0; ring < numRings; ring++) {
    if ( ring % 2 )
      bit = 0;
    else
      bit = 1;

    for (spoke = 0; spoke < numSpokes; spoke++) {

      start_angle = spoke * angular_step;

      if ( (spoke + bit) % 2 )
        glColor3f(On, On, On);
      else
        glColor3f(1-On, 1-On, 1-On);

      qobj = gluNewQuadric();
      gluPartialDisk(qobj,
                     (GLdouble) innerRadiusOfRing,  /* inner radius */
                     (GLdouble) outerRadiusOfRing,  /* outer radius */
                     (GLint) angular_step, /* #vert. on disk perimeter */
                     1,   /* # vertices on disk ray (minus 1) */
                     (GLdouble) start_angle,  /* start angle for wedge */
                     (GLdouble) angular_step); /* wedge width in degrees */

    }

    innerRadiusOfRing *= scaleFactor;
    outerRadiusOfRing *= scaleFactor;

  }


  T = stimPeriod;
  t = timePoint - counter*T;
  if (t > T) {
    outerRadiusOfAnnulus = maxEcc;
    innerRadiusOfAnnulus = minEcc;
    counter++;
  }

  eccRange = log(maxEcc) - log(minEcc);

  if (OUTWARD == 1) { /*** --------- EXP. OUTWARD ---------- ***/
    if ( t < T/2 ) {
      outerRadiusOfAnnulus = maxEcc;
      innerRadiusOfAnnulus = (log(minEcc) + log(maxEcc))/2 +
                             eccRange * (1/T) * t;
      innerRadiusOfAnnulus = exp(innerRadiusOfAnnulus);

      /* Threshold, and add 1 (pixel?) so that mask overcovers stim */
      if ( outerRadiusOfAnnulus >= maxEcc)
        outerRadiusOfAnnulus = maxEcc + 1;

      /* Threshold, and subtract 1 so that mask overcovers stim */
      if ( innerRadiusOfAnnulus <= minEcc)
        innerRadiusOfAnnulus = minEcc - 1;

      /*** GL calls to draw annulus ***/
      glColor3f(0.5, 0.5, 0.5);
      gluDisk(qobj,
              (GLdouble) innerRadiusOfAnnulus,
              (GLdouble) outerRadiusOfAnnulus,
              360,
              1);

      outerRadiusOfAnnulus = log(minEcc) +
                             eccRange * (1/T) * t;
      outerRadiusOfAnnulus = exp(outerRadiusOfAnnulus);
      innerRadiusOfAnnulus = minEcc;

      /* Threshold, and add 1 (pixel?) so that mask overcovers stim */
      if ( outerRadiusOfAnnulus >= maxEcc)
        outerRadiusOfAnnulus = maxEcc + 1;

      /* Threshold, and subtract 1 so that mask overcovers stim */
      if ( innerRadiusOfAnnulus <= minEcc)
        innerRadiusOfAnnulus = minEcc - 1;

      /*** GL calls to draw annulus ***/
      glColor3f(0.5, 0.5, 0.5);
      gluDisk(qobj,
              (GLdouble) innerRadiusOfAnnulus,
              (GLdouble) outerRadiusOfAnnulus,
              360,
              1);

    } else {
      innerRadiusOfAnnulus = log(minEcc) +
                             eccRange * (1/T) * (t - T/2);
      innerRadiusOfAnnulus = exp(innerRadiusOfAnnulus);

      outerRadiusOfAnnulus = (log(minEcc) + log(maxEcc))/2 +
                             eccRange * (1/T) * (t - T/2);
      outerRadiusOfAnnulus = exp(outerRadiusOfAnnulus);

      /* Threshold, and add 1 (pixel?) so that mask overcovers stim */
      if ( outerRadiusOfAnnulus >= maxEcc)
        outerRadiusOfAnnulus = maxEcc + 1;

      /* Threshold, and subtract 1 so that mask overcovers stim */
      if ( innerRadiusOfAnnulus <= minEcc)
        innerRadiusOfAnnulus = minEcc - 1;

      /*** GL calls to draw annulus ***/
      glColor3f(0.5, 0.5, 0.5);
      gluDisk(qobj,
              (GLdouble) innerRadiusOfAnnulus,
              (GLdouble) outerRadiusOfAnnulus,
              360,
              1);


    }
  } else { /*** --------- EXP. INWARD ---------- ***/
    if ( t < T/2 ) {
      outerRadiusOfAnnulus = (log(minEcc) + log(maxEcc))/2 -
                             eccRange * (1/T) * t;
      outerRadiusOfAnnulus = exp(outerRadiusOfAnnulus);
      innerRadiusOfAnnulus = minEcc;

      /* Threshold, and add 1 (pixel?) so that mask overcovers stim */
      if ( outerRadiusOfAnnulus >= maxEcc)
        outerRadiusOfAnnulus = maxEcc + 1;

      /* Threshold, and subtract 1 so that mask overcovers stim */
      if ( innerRadiusOfAnnulus <= minEcc)
        innerRadiusOfAnnulus = minEcc - 1;

      /*** GL calls to draw annulus ***/
      glColor3f(0.5, 0.5, 0.5);
      gluDisk(qobj,
              (GLdouble) innerRadiusOfAnnulus,
              (GLdouble) outerRadiusOfAnnulus,
              360,
              1);

      outerRadiusOfAnnulus = maxEcc;
      innerRadiusOfAnnulus = log(maxEcc) -
                             eccRange * (1/T) * t;
      innerRadiusOfAnnulus = exp(innerRadiusOfAnnulus);

      /* Threshold, and add 1 (pixel?) so that mask overcovers stim */
      if ( outerRadiusOfAnnulus >= maxEcc)
        outerRadiusOfAnnulus = maxEcc + 1;

      /* Threshold, and subtract 1 so that mask overcovers stim */
      if ( innerRadiusOfAnnulus <= minEcc)
        innerRadiusOfAnnulus = minEcc - 1;

      /*** GL calls to draw annulus ***/
      glColor3f(0.5, 0.5, 0.5);
      gluDisk(qobj,
              (GLdouble) innerRadiusOfAnnulus,
              (GLdouble) outerRadiusOfAnnulus,
              360,
              1);

    } else {
      innerRadiusOfAnnulus = (log(minEcc) + log(maxEcc))/2 -
                             eccRange * (1/T) * (t - T/2);
      innerRadiusOfAnnulus = exp(innerRadiusOfAnnulus);

      outerRadiusOfAnnulus = log(maxEcc) -
                             eccRange * (1/T) * (t - T/2);
      outerRadiusOfAnnulus = exp(outerRadiusOfAnnulus);

      /* Threshold, and add 1 (pixel?) so that mask overcovers stim */
      if ( outerRadiusOfAnnulus >= maxEcc)
        outerRadiusOfAnnulus = maxEcc + 1;

      /* Threshold, and subtract 1 so that mask overcovers stim */
      if ( innerRadiusOfAnnulus <= minEcc)
        innerRadiusOfAnnulus = minEcc - 1;

      /*** GL calls to draw annulus ***/
      glColor3f(0.5, 0.5, 0.5);
      gluDisk(qobj,
              (GLdouble) innerRadiusOfAnnulus,
              (GLdouble) outerRadiusOfAnnulus,
              360,
              1);


    }
  }

  /*  glTranslatef( -Width/2 , -Height/2 , 0 ); */

  glEndList() ;
  glCallList(current_list) ;
  /*  glFlush();*/
  glutSwapBuffers();
}
示例#23
0
void Graphics::render(TrackData_t *track)
{
    if (!initialized) {
        error->log(GRAPHICS, IMPORTANT, "Render function called without graphics initialization\n");
        return;
    }

    if (track) {
        int i, j;
        /* load in the vertices */

        Vec3f_t vert;

        GLUquadricObj *quadobj = gluNewQuadric();
        Vec3f_t v;
        Segment_t *seg;
        int len;
        float ang;

        glColor3f(1,1,0);
        glBegin(GL_LINES);
        for (i = 0; i < track->nLanes; i++)
        {
            for (j = 0; j < track->lanes[i].nSegs; j++)
            {
                seg = &track->lanes[i].segs[j];
                switch (track->lanes[i].segs[j].kind) {
                    case LINE_SEGMENT:
                        CopyV3f(track->verts[seg->start], vert);
                        glVertex3f(vert[0], vert[1] + .01, vert[2]);
                        CopyV3f(track->verts[seg->end], vert);
                        glVertex3f(vert[0], vert[1] + .01, vert[2]);
                        break;
                    case ARC_SEGMENT:
                        glEnd();
                        CopyV3f(track->verts[seg->center],v);
                        glPushMatrix();
                        glTranslatef(v[0], v[1] + .01, v[2]);
                        glRotatef(-90,1,0,0);
                        SubV3f(v, track->verts[seg->start], v);
                        len = LengthV3f(v);
                        ang = seg->end > seg->start ? seg->angle : -seg->angle;
                        gluPartialDisk(quadobj, len-.05, len, 40, 5,
                                        0, ang);
                        gluPartialDisk(quadobj, len-.05, len, 40, 5,
                                    0, ang);

                        glPopMatrix();
                        glBegin(GL_LINES);
                        break;
                }
            }
        }
        glEnd();
        gluDeleteQuadric(quadobj);

        /* draw finish line */
        glDisable(GL_LIGHTING);
        glColor3f(1,0,1);
        glLineStipple(1, 0x0C0F);
        glLineWidth(4);
        glBegin(GL_LINES);
        glVertex3fv(track->verts[track->sects[0].edges[0].start]);
        glVertex3fv(track->verts[track->sects[0].edges[1].start]);
        glEnd();
        glLineWidth(1);
        glDisable(GL_LINE_STIPPLE);
        glEnable(GL_LIGHTING);

    }
}
示例#24
0
void PsychRenderArc(unsigned int mode)
{
        PsychColorType			color;
        PsychRectType                   rect;
        double				*startAngle, *arcAngle, *penWidth, *penHeight;
	PsychWindowRecordType           *windowRecord;
	int				depthValue, whiteValue, colorPlaneSize, numColorPlanes;
	double                          dotSize;
        boolean				isArgThere;
	GLUquadric                      *diskQuadric = NULL;


	//get the window record from the window record argument and get info from the window record
	PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord);
	
	//Get the depth from the window, we need this to interpret the color argument.
	depthValue=PsychGetWindowDepthValueFromWindowRecord(windowRecord);
	numColorPlanes=PsychGetNumPlanesFromDepthValue(depthValue);
	colorPlaneSize=PsychGetColorSizeFromDepthValue(depthValue);

	//Get the color argument or use the default, then coerce to the form determened by the window depth.  
	isArgThere=PsychCopyInColorArg(kPsychUseDefaultArgPosition, FALSE, &color);
        if(!isArgThere){
                whiteValue=PsychGetWhiteValueFromDepthValue(depthValue);
                PsychLoadColorStruct(&color, kPsychIndexColor, whiteValue ); //index mode will coerce to any other.
        }
 	PsychCoerceColorModeFromSizes(numColorPlanes, colorPlaneSize, &color);
        
        // Get the rect to which the object should be inscribed: Default is "full screen"
        PsychMakeRect(rect, 0, 0, PsychGetWidthFromRect(windowRecord->rect), PsychGetHeightFromRect(windowRecord->rect));
        PsychCopyInRectArg(3, FALSE, rect);
        double w=PsychGetWidthFromRect(rect);
        double h=PsychGetHeightFromRect(rect);
        double cx, cy, aspect;
        PsychGetCenterFromRectAbsolute(rect, &cx, &cy);
        if (w==0 || h==0) PsychErrorExitMsg(PsychError_user, "Invalid rect (width or height equals zero) provided!");
        
	// Get start angle: 
	PsychAllocInDoubleArg(4, TRUE,  &startAngle);
	PsychAllocInDoubleArg(5, TRUE,  &arcAngle);

        if (mode==2) {
            // Get pen width and height:
            penWidth=NULL;
            penHeight=NULL;
            PsychAllocInDoubleArg(6, FALSE,  &penWidth);
            PsychAllocInDoubleArg(7, FALSE,  &penHeight);
            // Check if penWidth and penHeight spec'd. If so, they
            // need to be equal:
            if (penWidth && penHeight && (*penWidth!=*penHeight)) {
                PsychErrorExitMsg(PsychError_user, "penWidth and penHeight must be equal on OS-X if both are specified!");
            }
            dotSize=1;
            if (penWidth) dotSize = *penWidth;
            if (penHeight) dotSize = *penHeight;
        }
        
        // Setup OpenGL context:
	PsychSetGLContext(windowRecord);
	PsychUpdateAlphaBlendingFactorLazily(windowRecord);
	PsychSetGLColor(&color, depthValue);
        
        // Backup our modelview matrix:
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();

	// Position disk at center of rect:
        glTranslated(cx, cy, 0);
        
        // Scale in order to fit to rect in case w!=h:
        glScaled(1.0, -h/w, 1.0);
        
        // Draw filled partial disk:
        diskQuadric=gluNewQuadric();
        
        switch (mode) {
            case 1: // One pixel thin arc: InnerRadius = OuterRadius - 1
                gluPartialDisk(diskQuadric, (w/2) - 1.0, w/2, w, 2, *startAngle, *arcAngle);
                break;
            case 2: // dotSize thick arc:  InnerRadius = OuterRadius - dotsize
                gluPartialDisk(diskQuadric, (dotSize < (w/2)) ? (w/2) - dotSize : 0, w/2, w, 2, *startAngle, *arcAngle);
                break;
            case 3: // Filled arc:
                gluPartialDisk(diskQuadric, 0, w/2, w, 1, *startAngle, *arcAngle);
                break;
        }

	gluDeleteQuadric(diskQuadric);
	
        // Restore old matrix:
        glPopMatrix();

	return;
}
示例#25
0
// Funciones a definir desde Effect.h
void FXmanga::perFrame(float time) {
	float z_depth=-0.0120f,y_desp;
	static float pulso=0;
	int i;

	fxradialblur->prepareFrame();	
	
	glClearColor(0.8,0,0.8,1);
	glClear(GL_COLOR_BUFFER_BIT);
	
	
	//------------ matriz de objetos/whatever
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glColor3f(1,1,1);
	float z=0;
	
	cam.toOGL();
	glDisable(GL_DEPTH_TEST);
	glEnable(GL_SMOOTH);
	glLineWidth(1.5);
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glScalef(3,3,3);
	glRotatef(time * 0.15,0,1,0);
	glTranslatef(-1,0,0);
	// una k , q se me ha ocurrido
	for(i=1; i < 9;i++)
	{
		glMatrixMode(GL_MODELVIEW);
		glPushMatrix();
		glTranslatef(0.1*i,0,0);
		glBegin(GL_LINE_STRIP);
			glVertex3f(0,2,z);
			glVertex3f(0,-2,z);
			glVertex3f(0.2,-2,z);
			glVertex3f(1.7,2,z);
			glVertex3f(1.9,2,z);
			glVertex3f(1.1,0.1,z);
			glVertex3f(2,-2,z);
		glEnd();
		glMatrixMode(GL_MODELVIEW);
		glPopMatrix();
	}
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();
	glEnable(GL_DEPTH_TEST);
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();

	
	//------------ fin de matriz de objetos

	fxradialblur->postprepareFrame();
	fxradialblur->perFrame(time);
	
	miDemo->ponOrtopedico(1,1);//(miDemo->getWidth(),miDemo->getHeight()); // el q debe ser es 2,2
	glEnable(GL_BLEND);
	
	// ahora algunos adornos technoish

	//glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
	//glBlendFunc(GL_DST_COLOR,  GL_SRC_ALPHA);
	glEnable(GL_LINE_SMOOTH);
	glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);
	glBlendFunc(GL_SRC_ALPHA,  GL_ONE_MINUS_SRC_ALPHA);

	float c=1 ; // componente de color , es para hacer un grisaceo
	int slices = 64;
	float part1, part2;
	float d1; // estas distancias las usare para cambiar el radio de los discos
	glColor4f(c,c,c,0.3);

	d1=0.25*sin(time*0.005);
	// Varios círculos (algunos fijos y otros no)
	gluDisk(quad,0.02f,0.025f,slices,slices);
	gluDisk(quad,0.08f,0.1f,slices,slices);
	gluDisk(quad,0.36f+d1,0.362f+d1,slices/2,slices/2);
	gluDisk(quad,0.36f+d1+d1,0.362f+d1+d1,slices/2,slices/2);
	gluDisk(quad,0.4f,0.41f,slices,slices);
	
	// Trocitos de pizza pero en disco
	part1=0;

	// Trozos del centro
	part2=20;
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	for(i=1;i<4;i++) {
		glRotatef(time*.1,0,0,-1);
		gluPartialDisk(quad,0.06f,0.08f,slices,slices,part1,part2-part1);	
	}
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();

	
	// Trozos intermedios
	part2=20;
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	for(i=1;i<6;i++) {
		glRotatef(time*.05,0,0,1);
		gluPartialDisk(quad,0.2f,0.30f,slices,slices,part1,part2-part1);	
	}
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();
	// Trozos mas gordos
	part2=30;
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	for(i=1;i<4;i++) {
		glRotatef(time*.0200,0,0,-1);
		gluPartialDisk(quad,0.5f,1.5f,slices,slices,part1,part2-part1);	
	}
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();
	// ---------fin adornos technoish
	
	//------------ Trozo de muñeco/oso cabron
	glColor4f(1,1,1,1);
	glEnable(GL_TEXTURE_2D);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	if((this->_row%8)==0) {
		pulso=1;
		fxradialblur->setTimes(16);
	} else {
		fxradialblur->setTimes(10);
	}
	if(pulso>0) {
		pulso=pulso - pulso*pulso*0.9;
	}
	y_desp=pulso;
	
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();
	glTranslatef(0.0,-0.7,0);
	glBindTexture(GL_TEXTURE_2D, this->text_oso.texID);
	float lado=0.7;
	glBegin(GL_QUADS);
		glNormal3f( 0.0f, 0.0f, 1.0f);
		glTexCoord2f(0,0); 
		glVertex3f(0,0+y_desp,z_depth);
		
		glTexCoord2f(1, 0);
		glVertex3f(lado,0+y_desp, z_depth);

		glTexCoord2f(1,1);
		glVertex3f(lado,lado+y_desp,  z_depth);

		glTexCoord2f(0,1);
		glVertex3f(0,lado+y_desp,z_depth);
	glEnd();
	
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();
	y_desp=-y_desp;
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();
	//z_depth-=0.1;
	glTranslatef(-0.5,.1,0);
	glBindTexture(GL_TEXTURE_2D, this->text_k.texID);
	glBegin(GL_QUADS);
		glNormal3f( 0.0f, 0.0f, 1.0f);
		glTexCoord2f(0,0); 
		glVertex3f(0,0+y_desp,z_depth);
		
		glTexCoord2f(1, 0);
		glVertex3f(0.35,0+y_desp, z_depth);

		glTexCoord2f(1,1);
		glVertex3f(0.35,0.5+y_desp,  z_depth);

		glTexCoord2f(0,1);
		glVertex3f(0,0.35+y_desp,z_depth);

		//glVertex3f(0,0,0);

	glEnd();
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();

	glDisable(GL_TEXTURE_2D);
	// fin osocabron

	
	miDemo->quitaOrtopedico();
	glDisable(GL_SMOOTH);	
	glDisable(GL_BLEND);

	// fade
	float alfa;
	if((_row<=16)&&(_pattern==5)) {
		alfa=float(16-_row)/16.0;
		glDisable(GL_DEPTH_TEST);
		fxfade->setFadeColor(1,1,1,alfa);
		fxfade->perFrame(_time);
		glEnable(GL_DEPTH_TEST);
	}
	else if((_row>=112)&&(_pattern==6)) {
		alfa=float(_row%16)/16.0;
		glDisable(GL_DEPTH_TEST);
		fxfade->setFadeColor(1,1,1,alfa);
		fxfade->perFrame(_time);
		glEnable(GL_DEPTH_TEST);
	} else if((_row%8)==0){
		alfa=0.15;
		glDisable(GL_DEPTH_TEST);
		fxfade->setFadeColor(1,1,1,alfa);
		fxfade->perFrame(_time);
		glEnable(GL_DEPTH_TEST);
	}

	
}
示例#26
0
文件: quad.c 项目: JamesLinus/nui3
void GLAPIENTRY
gluDisk(GLUquadric *qobj, GLdouble innerRadius, GLdouble outerRadius,
	    GLint slices, GLint loops)
{
    gluPartialDisk(qobj, innerRadius, outerRadius, slices, loops, 0.0, 360.0);
}
void drawFish()
{
	quad=gluNewQuadric();
	gluQuadricNormals(quad, GLU_SMOOTH);
	gluQuadricTexture(quad, GL_TRUE);
	glDisable(GL_BLEND);


	//body
	glPushMatrix();

   // set the material
   GLfloat material_diffuse[] = {.80, .80, .80};

   glMaterialfv(GL_FRONT, GL_DIFFUSE, material_diffuse);
	
	glTranslatef(translate[0], translate[1], translate[2]);


	glScalef(3.0, 1, 1);
	glutSolidSphere(1.0, 30, 30); 
	// recover the transform state
   glPopMatrix();


	//eye
	glPushMatrix();

   GLfloat material_ambient1[] = {.80, .80, .80};
	GLfloat material_diffuse1[] = {.80, .80, .80};
	GLfloat material_specular1[] = {.80, .80, .80};
	GLfloat material_shininess1 = 25.0f;

	glMaterialfv(GL_FRONT, GL_AMBIENT, material_ambient1);
	glMaterialfv(GL_FRONT, GL_DIFFUSE, material_diffuse1);
	glMaterialfv(GL_FRONT, GL_SPECULAR, material_specular1);
	glMaterialf(GL_FRONT, GL_SHININESS, material_shininess1);
	
	//quad, base radius, top radius, height, slices, stacks
	glTranslatef(translate[0] + 2, translate[1] + .2, translate[2]+.8);
	gluDisk(quad, 0, .3, 20, 20);
	glPopMatrix();

	glPushMatrix();

	GLfloat material_diffuse2[] = {0, 0, 0};

	glMaterialfv(GL_FRONT, GL_DIFFUSE, material_diffuse2);

	
	//quad, base radius, top radius, height, slices, stacks
	glTranslatef(translate[0] + 2, translate[1] + .2, translate[2]+.9);
	gluDisk(quad, 0, .15, 10, 10);
	glPopMatrix();


	//fins
	glPushMatrix();
	GLfloat material_diffuse3[] = {.4, .4, .4};
	glMaterialfv(GL_FRONT, GL_DIFFUSE, material_diffuse3);	
	//quad, base radius, top radius, height, slices, stacks
	glTranslatef(translate[0]-3.0, translate[1]+.1, translate[2]+.3);
	gluPartialDisk(quad, 0, 1.3, 20, 20, 0, 180);
	glPopMatrix();

	glPushMatrix();
	glMaterialfv(GL_FRONT, GL_DIFFUSE, material_diffuse3);
	//quad, base radius, top radius, height, slices, stacks
	glTranslatef(translate[0]-.8, translate[1]+.4, translate[2]+.25);
	gluPartialDisk(quad, 0, 1.3, 20, 20, 0, 90);
	glPopMatrix();

	glPushMatrix();
	glMaterialfv(GL_FRONT, GL_DIFFUSE, material_diffuse3);
	//quad, base radius, top radius, height, slices, stacks
	glTranslatef(translate[0]-.1, translate[1]-.3, translate[2]+.9);
	gluPartialDisk(quad, 0, 1, 20, 20, 90, 100);
	glPopMatrix();



	glEnable(GL_BLEND);
   return;
}
示例#28
0
//------------------------------------------------------------------------------
// drawFunc()
//------------------------------------------------------------------------------
void AoAIndexer::drawFunc()
{
    // if we have components, we are going to check for a ROTARY
    base::PairStream* subcomponents = getComponents();
    if (subcomponents != nullptr) {
      subcomponents->unref();
      subcomponents = nullptr;
      return;
    }

    GLfloat currentColor[4];
    GLfloat lw = 0;
    glGetFloatv(GL_CURRENT_COLOR, &currentColor[0]);
    glGetFloatv(GL_LINE_WIDTH, &lw);

    // check our state and draw accordingly
    if (aoaState == 1) {
        glPushMatrix();
            glColor3f(1, 0, 0);
            glTranslatef(0, 1.0, 0);
            glLineWidth(3.0);
            glBegin(GL_LINES);
                glVertex2f(-0.05f, 0.0);
                glVertex2f(-0.2f, 0.4f);
                glVertex2f(0.05f, 0.0);
                glVertex2f(0.2f, 0.4f);
            glEnd();
        glPopMatrix();
    }
    if (aoaState == -1) {
        glPushMatrix();
            glColor3f(1, 1, 0);
            glLineWidth(3.0);
            glTranslatef(0, -1.0, 0);
            glBegin(GL_LINES);
                glVertex2f(-0.05f, 0.0);
                glVertex2f(-0.2f, -0.4f);
                glVertex2f(0.05f, 0.0);
                glVertex2f(0.2f, -0.4f);
            glEnd();
        glPopMatrix();
    }
    if (aoaState == 0) {
        // now draw the lines to blend out the semi-circle
        glLineWidth(3.0);
        glPushMatrix();
            glColor3f(0,0,0);
            glBegin(GL_LINES);
                glVertex2f(-0.25f, 0.025f);
                glVertex2f(0.25f, 0.025f);
                glVertex2f(-0.25f, -0.025f);
                glVertex2f(0.25f, -0.025f);
            glEnd();
        glPopMatrix();

        // we draw two semicircles that are almost touching
        glPushMatrix();
            glColor3f(0, 1, 0);
            glTranslatef(0, 0.025f, 0);
            GLUquadricObj * qobj = gluNewQuadric();
            gluQuadricDrawStyle(qobj, GLU_SILHOUETTE);
            gluPartialDisk(qobj, 0, 0.2, 1000, 1, 270, 180);
            gluDeleteQuadric(qobj);
        glPopMatrix();
        glPushMatrix();
            glColor3f(0, 1, 0);
            glTranslatef(0, -0.025f, 0);
            glRotatef(180, 0, 0, 1);
            GLUquadricObj * qobj2 = gluNewQuadric();
            gluQuadricDrawStyle(qobj2, GLU_SILHOUETTE);
            gluPartialDisk(qobj2, 0, 0.2, 1000, 1, 270, 180);
            gluDeleteQuadric(qobj2);
        glPopMatrix();
    }

    // if we haven't created our display list, do it now
    if (!isDlist) {
        displayList = glGenLists(1);
        glNewList(displayList,GL_COMPILE);
        // finally draw our outlines
        // top outline
        glPushMatrix();
            glColor3f(0.3f, 0.3f, 0.3f);
            glTranslatef(0, 1.0, 0);
            glLineWidth(3.0);
            glBegin(GL_LINES);
                glVertex2f(-0.05f, 0.0);
                glVertex2f(-0.2f, 0.4f);
                glVertex2f(0.05f, 0.0);
                glVertex2f(0.2f, 0.4f);
            glEnd();
        glPopMatrix();
        // circle outlines
        // now draw the lines to blend out the semi-circle
        glLineWidth(3.0);
        glPushMatrix();
            glColor3f(0,0,0);
            glBegin(GL_LINES);
                glVertex2f(-0.25f, 0.025f);
                glVertex2f(0.25f, 0.025f);
                glVertex2f(-0.25f, -0.025f);
                glVertex2f(0.25f, -0.025f);
            glEnd();
        glPopMatrix();

        // we draw two semicircles that are almost touching
        glPushMatrix();
            glColor3f(0.3f, 0.3f, 0.3f);
            glTranslatef(0, 0.025f, 0);
            GLUquadricObj * qobj3 = gluNewQuadric();
            gluQuadricDrawStyle(qobj3, GLU_SILHOUETTE);
            gluPartialDisk(qobj3, 0, 0.2, 1000, 1, 270, 180);
            gluDeleteQuadric(qobj3);
        glPopMatrix();
        glPushMatrix();
            glColor3f(0.3f, 0.3f, 0.3f);
            glTranslatef(0, -0.025f, 0);
            glRotatef(180, 0, 0, 1);
            GLUquadricObj * qobj4 = gluNewQuadric();
            gluQuadricDrawStyle(qobj4, GLU_SILHOUETTE);
            gluPartialDisk(qobj4, 0, 0.2, 1000, 1, 270, 180);
            gluDeleteQuadric(qobj4);
        glPopMatrix();

        // draw the bottom outline
        glPushMatrix();
            glColor3f(0.3f, 0.3f, 0.3f);
            glLineWidth(3.0);
            glTranslatef(0, -1.0, 0);
            glBegin(GL_LINES);
                glVertex2f(-0.05f, 0.0);
                glVertex2f(-0.2f, -0.4f);
                glVertex2f(0.05f, 0.0);
                glVertex2f(0.2f, -0.4f);
            glEnd();
            glPopMatrix();
            // end our display list
            glEndList();
            // set our flag
            isDlist = true;
        }
        // if we already have the display list, then call it
    else if (displayList > 0) glCallList(displayList);

    glColor4fv(currentColor);
    glLineWidth(lw);
}
示例#29
0
void 
ssr::QOpenGLPlotter::_draw_source(source_buffer_list_t::const_iterator& source,
			     unsigned int index)
{
  float scale = 1.0f;

  bool selected = false;
  bool soloed = false;

  if (_selected_sources_map.find(index) != _selected_sources_map.end()) 
  {
    selected = true;
  }

  if (_soloed_sources.find(source->id) != _soloed_sources.end())
  {
    soloed = true;
  }
  
  // check if source is selected
  if (selected) scale = 2.0f;

  // dummy id to prevend mouse action
  glLoadName(DUMMYINDEX);

  // draw shadow texture
  glEnable(GL_TEXTURE_2D);
  //glEnable(GL_ALPHA_TEST);
  glEnable(GL_BLEND);

  glBindTexture(GL_TEXTURE_2D, _source_shadow_texture);

  glPushMatrix();
  glTranslatef(0.015f, -0.015f, 0.01f);
  gluQuadricTexture(_glu_quadric, GL_TRUE );
  gluDisk(_glu_quadric, 0.0f, 0.163f * scale,LEVELOFDETAIL,1);
  glPopMatrix();

  glDisable(GL_TEXTURE_2D);
  //glDisable(GL_ALPHA_TEST);
  glDisable(GL_BLEND);

  // make sure that source is drawn on top
  //if (selected) glTranslatef(0.0f, 0.0f, 0.2f);
  //else          
  glTranslatef(0.0f, 0.0f, 0.1f);
  // TODO: make it more elegant

  // source id
  glLoadName(NAMESTACKOFFSET + index * NAMESTACKSTEP + 1);

  // draw source
  glColor3f(1.0f, 1.0f, 1.0f); // white

  gluDisk(_glu_quadric, 0.0f, 0.15f * scale, LEVELOFDETAIL, 1);

  // fill source
  qglColor(_color_vector[source->id%_color_vector.size()]);

  gluPartialDisk(_glu_quadric, 0.0f, 0.125f * scale,
                 LEVELOFDETAIL, 1, 0.0f, 360.0f);

  // draw solo indication
  if (soloed)
  {
    gluPartialDisk(_glu_quadric, 0.2f * scale, 0.22f * scale,
		   LEVELOFDETAIL, 1, 55.0f, 70.0f);  
    gluPartialDisk(_glu_quadric, 0.2f * scale, 0.22f * scale,
		   LEVELOFDETAIL, 1, 235.0f, 70.0f);
  }

  // choose color
  if (source->mute) glColor3f(0.5f, 0.5f, 0.5f);
  else qglColor(_color_vector[source->id%_color_vector.size()]);
    
  // draw ring around source
  gluDisk(_glu_quadric, 0.14f * scale, 0.15f * scale, LEVELOFDETAIL, 1);

  // volume slider id; It is accessible only when source selected
  if (selected) glLoadName(NAMESTACKOFFSET + index * NAMESTACKSTEP + 2);

  // plot level meter frame in black
  glBegin(GL_TRIANGLE_FAN);
    glVertex3f( -0.1f * scale, -0.2f * scale, 0.0f);
    glVertex3f( -0.1f * scale, -0.25f * scale, 0.0f);
    glVertex3f(  0.1f * scale, -0.25f * scale, 0.0f);
    glVertex3f(  0.1f * scale, -0.2f * scale, 0.0f);
  glEnd();

  if (selected)
  {
    // plot volume slider
    glBegin(GL_TRIANGLES);
      glVertex3f((-0.09f * scale + (20.0f*log10(source->gain)+50.0f)/62.0f
                  * 0.18f * scale ) - 0.015f * scale, -0.29f * scale, 0.0f);
      glVertex3f((-0.09f * scale + (20.0f*log10(source->gain)+50.0f)/62.0f
                  * 0.18f * scale ) + 0.015f * scale, -0.29f * scale, 0.0f);
      glVertex3f((-0.09f * scale + (20.0f*log10(source->gain)+50.0f)/62.0f
                  * 0.18f * scale ), -0.26f * scale, 0.0f);
    glEnd();
  }

  if (source->fixed_position)
  {
    // draw cross
    glBegin(GL_TRIANGLES);
      glVertex3f( -0.02f * scale,  0.005f * scale, 0.0f);
      glVertex3f( -0.02f * scale, -0.005f * scale, 0.0f);
      glVertex3f(  0.02f * scale,  0.005f * scale, 0.0f);

      glVertex3f(  0.02f * scale,  0.005f * scale, 0.0f);
      glVertex3f( -0.02f * scale, -0.005f * scale, 0.0f);
      glVertex3f(  0.02f * scale, -0.005f * scale, 0.0f);

      glVertex3f( -0.005f * scale, -0.02f * scale, 0.0f);
      glVertex3f(  0.005f * scale, -0.02f * scale, 0.0f);
      glVertex3f(  0.005f * scale,  0.02f * scale, 0.0f);

      glVertex3f(  0.005f * scale,  0.02f * scale, 0.0f);
      glVertex3f( -0.005f * scale,  0.02f * scale, 0.0f);
      glVertex3f( -0.005f * scale, -0.02f * scale, 0.0f);
    glEnd();
  }

  // plot level meter background white
  glColor3f(1.0f, 1.0f, 1.0f);

  glBegin(GL_TRIANGLE_FAN);
    glVertex3f( -0.09f * scale, -0.21f * scale, 0.0f);
    glVertex3f( -0.09f * scale, -0.24f * scale, 0.0f);
    glVertex3f(  0.09f * scale, -0.24f * scale, 0.0f);
    glVertex3f(  0.09f * scale, -0.21f * scale, 0.0f);
  glEnd();

  // plot audio level in green
  glColor3f(0.2275f, 0.9373f, 0.2275f);

  // signal_level in dB
  float signal_level = 20.0f
    * log10(source->signal_level + 0.00001f); // min -100 dB

  // only values up to 0 dB can be shown
  signal_level = std::min(signal_level, 0.0f);

  // TODO: color
  glBegin(GL_TRIANGLE_FAN);
    glVertex3f( -0.09f * scale, -0.21f * scale, 0.0f);
    glVertex3f( -0.09f * scale, -0.24f * scale, 0.0f);
    glVertex3f( -0.09f * scale + (signal_level + 50.0f)/50.0f
                * 0.18f * scale, -0.24f * scale, 0.0f);
    glVertex3f( -0.09f * scale + (signal_level + 50.0f)/50.0f
                * 0.18f * scale, -0.21f * scale, 0.0f);
  glEnd();

  // display source name
  if (_allow_displaying_text)
  {
    qglColor(_color_vector[source->id%_color_vector.size()]);
    QFont f = font();
    f.setPointSize(static_cast<int>(_zoom_factor/STDZOOMFACTOR*font().pointSize() + 0.5f));
    renderText(0.18f * scale, 0.13f * scale, 0.0f, source->name.c_str(), f);
  }

  // dummy id to prevend mouse action
  glLoadName(DUMMYINDEX);

  // plot orientation of plane wave
  if (source->model == Source::plane)
  {
    // rotate
    glRotatef(static_cast<GLfloat>(source->orientation.azimuth), 0.0f, 0.0f, 1.0f);

    if (source->mute) glColor3f(0.5f, 0.5f, 0.5f);
      else qglColor(_color_vector[source->id%_color_vector.size()]);
      
    // plot ring segments
    gluPartialDisk(_glu_quadric, 0.18f * scale, 0.19f * scale, LEVELOFDETAIL, 1, 105.0f, 75.0f);
    gluPartialDisk(_glu_quadric, 0.18f * scale, 0.19f * scale, LEVELOFDETAIL, 1,   0.0f, 90.0f);

    // plot bars
    glBegin(GL_TRIANGLE_FAN);
      glVertex3f(-0.005f * scale, -0.36f * scale, 0.0f); glVertex3f( 0.005f * scale, -0.36f * scale, 0.0f);
      glVertex3f( 0.005f * scale, -0.18f * scale, 0.0f); glVertex3f(-0.005f * scale, -0.18f * scale,  0.0f);
    glEnd();
    glBegin(GL_TRIANGLE_FAN);
      glVertex3f( 0.005f * scale, 0.36f * scale, 0.0f); glVertex3f(-0.005f * scale, 0.36f * scale, 0.0f);
      glVertex3f(-0.005f * scale, 0.18f * scale, 0.0f); glVertex3f( 0.005f * scale, 0.18f * scale, 0.0f);
    glEnd();

    // plot arrow
    glBegin(GL_TRIANGLE_FAN); // lower branch
      glVertex3f( 0.277f * scale, 0.0f, 0.0f); glVertex3f( 0.25f * scale, -0.028f * scale, 0.0f);
      glVertex3f( 0.25f * scale, -0.04f * scale, 0.0f); glVertex3f( 0.29f * scale,  0.0f, 0.0f);
    glEnd();

    glBegin(GL_TRIANGLE_FAN); // upper branch
      glVertex3f( 0.29f * scale, 0.0f, 0.0f); glVertex3f( 0.25f * scale,  0.04f * scale, 0.0f);
      glVertex3f( 0.25f * scale, 0.028f * scale, 0.0f); glVertex3f( 0.277f * scale, 0.0f, 0.0f);
    glEnd();

    glBegin(GL_TRIANGLE_FAN); // root
      glVertex3f( 0.18f * scale,  0.005f * scale, 0.0f); glVertex3f( 0.18f * scale, -0.005f * scale, 0.0f);
      glVertex3f( 0.285f * scale, -0.005f * scale, 0.0f); glVertex3f( 0.285f * scale,  0.005f * scale, 0.0f);
    glEnd();
  }
  else if (source->model == Source::directional)
  {
    // rotate
    glRotatef((GLfloat)(source->orientation.azimuth), 0.0f, 0.0f, 1.0f);

    qglColor(_color_vector[source->id%_color_vector.size()]);

    // plot ring
    gluPartialDisk(_glu_quadric, 0.18f * scale, 0.19f * scale, LEVELOFDETAIL, 1, 105.0f, 346.0f);

    // id of direction handle
    glLoadName(NAMESTACKOFFSET + index * NAMESTACKSTEP + 3);

    // plot arrow
    glBegin(GL_TRIANGLE_FAN); // lower branch
      glVertex3f( 0.277f * scale, 0.0f, 0.0f); glVertex3f( 0.25f * scale, -0.028f * scale, 0.0f);
      glVertex3f( 0.25f * scale, -0.04f * scale, 0.0f); glVertex3f( 0.29f * scale,  0.0f, 0.0f);
    glEnd();

    glBegin(GL_TRIANGLE_FAN); // upper branch
      glVertex3f( 0.29f * scale, 0.0f, 0.0f); glVertex3f( 0.25f * scale,  0.04f * scale, 0.0f);
      glVertex3f( 0.25f * scale, 0.028f * scale, 0.0f); glVertex3f( 0.277f * scale, 0.0f, 0.0f);
    glEnd();

    glBegin(GL_TRIANGLE_FAN); // root
      glVertex3f( 0.18f * scale,  0.005f * scale, 0.0f); glVertex3f( 0.18f * scale, -0.005f * scale, 0.0f);
      glVertex3f( 0.285f * scale, -0.005f * scale, 0.0f); glVertex3f( 0.285f * scale,  0.005f * scale, 0.0f);
    glEnd();
  }

}
/* The main drawing function. */
void DrawGLScene(void)
{
    glMatrixMode(GL_MODELVIEW);
    
    // clear all the buffers - gives OpenGL full control
    // OpenSG doesn't clear the background because of the PassiveBackground object
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    // set the model transformation
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    
    // set camera position from mouse movement
    glTranslatef(0.0f, 0.0f, -m_distance);
    glRotatef(m_tiltAngle, 1.0f, 0.0f, 0.0f);
    glRotatef(m_twistAngle, 0.0f, 0.0f, 1.0f);
    //glTranslatef(0.0f, 0.0f, -90.0f);
    
    glPushMatrix(); // OpenSG will overwrite
    
    OSG::Real32 proj_matrix[16], model_matrix[16];
    glGetFloatv(GL_PROJECTION_MATRIX, proj_matrix);
    glGetFloatv(GL_MODELVIEW_MATRIX, model_matrix);
    
    // retrieve OpenGL's matrices
    OSG::Matrix proj, model;
    proj.setValue(proj_matrix);
    model.setValue(model_matrix);
    
    newcam->setProjectionMatrix(proj);
    
    // transform the world just like the OpenGL content
    // necessary since OpenSG's modelview transforms start from the unity matrix. 
    newcam->setModelviewMatrix(model);
    
    // setup an initial transformation
    OSG::Matrix m1;
    OSG::Quaternion q1;
  
    // mind that the VRML base coordinate system has different meanings for X, Y, Z, hence the rotation for 90 degrees.
    // this, together with the MatrixCamera code above hooks OpenSG to OpenGL ! 
    m1.setIdentity();
    q1.setValueAsAxisDeg(1, 0, 0., 90); // rotation 
    m1.setRotate(q1);
    trans->setMatrix(m1);

    OSG::commitChanges();
    
    // redraw the OpenSG window content - the calls are a bit after one's own taste 
    pwin->render(mgr->getRenderAction());
    //pwin->frameInit();
    //pwin->frameExit();
    //mgr->redraw();
    
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
    //################ START FOR OPENGL STUFF
    
    // light attributes
    const GLfloat light_ambient[]  = { 0.3f, 0.3f, 0.3f, 1.0f };
    const GLfloat light_diffuse[]  = { 0.52f, 0.5f, 0.5f, 1.0f };
    const GLfloat light_specular[] = { 0.1f, 0.1f, 0.1f, 1.0f };
    
    // setup the light attributes
    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    
    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHTING);
    
    // set the light position
    GLfloat lightPosition[] = { 0.0f, -10.0f, 10.0f, 0.0f };
    glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
    
    glEnable(GL_NORMALIZE);
    
    glDisable(GL_NORMALIZE);
    //glDisable(GL_BLEND);
    
    glEnable(GL_LIGHTING);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture[0]);   // choose the texture to use.
    
    GLfloat TableDiffuse[] = { 0.3f, 0.0f, 1.0f, 0.5f };
    GLfloat TableSpecular[] = { 0.6f, 0.0f, 0.8f, 0.5f };
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, TableDiffuse);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, TableSpecular);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.4f);
    glEnable(GL_BLEND);
    
    gluPartialDisk(quadric,0,12.0f,32,16, 0, 360);    // A Disk Like The One Before  
#if 1 
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_LIGHTING);
    
    // X axis on table    
    glColor3f(1,0,0);
    glBegin(GL_LINES);
    glVertex3f(0,0,0.1f);
    glVertex3f(120,0,0.1f);
    glEnd();
    
    // Y axis on table 
    glColor3f(0,1,0);
    glBegin(GL_LINES);
    glVertex3f(0,0,0.1f);
    glVertex3f(0,120,0.1f);
    glEnd();
    
    glEnable(GL_LIGHTING);
#endif

    glDisable(GL_TEXTURE_2D);
    glDisable(GL_BLEND);
    
    glDisable(GL_LIGHTING);
    
    // render the cursor
    renderCursor();
    
    // swap the front- and back-buffer
    glutSwapBuffers();
}