void displayObjects(void)
{
GLfloat torus_diffuse[] = { 0.7, 0.7, 0.0, 1.0 };
GLfloat cube_diffuse[] = { 0.0, 0.7, 0.7, 1.0 };
GLfloat sphere_diffuse[] = { 0.7, 0.0, 0.7, 1.0 };
GLfloat octa_diffuse[] = { 0.7, 0.4, 0.4, 1.0 };
glPushMatrix();
glRotatef(30.0, 1.0, 0.0, 0.0);
glPushMatrix();
glTranslatef(-0.80, 0.35, 0.0);
glRotatef(100.0, 1.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, torus_diffuse);
glutSolidTorus(0.275, 0.85, 16, 16);
glPopMatrix();
glPushMatrix();
glTranslatef(-0.75, -0.50, 0.0);
glRotatef(45.0, 0.0, 0.0, 1.0);
glRotatef(45.0, 1.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, cube_diffuse);
glutSolidCube(1.5);
glPopMatrix();
glPushMatrix();
glTranslatef(0.75, 0.60, 0.0);
glRotatef(30.0, 1.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, sphere_diffuse);
glutSolidSphere(1.0, 16, 16);
glPopMatrix();
glPushMatrix();
glTranslatef(0.70, -0.90, 0.25);
glMaterialfv(GL_FRONT, GL_DIFFUSE, octa_diffuse);
glutSolidOctahedron();
glPopMatrix();
glPopMatrix();
}
void displayFcn(void) {
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(x0, yO, z0, 0, 0, 0, 0, 1, 0);
glColor3f(color[0], color[1], color[2]);
if (toggle)
glRotatef(rotTheta += 3, 0.0, 1.0, 0.0);
glScalef(scale, scale, scale);
if (solid) {
switch (poly) {
case 1:
glutSolidCube(1.0);
break;
case 2:
glutSolidDodecahedron();
break;
case 3:
glutSolidTetrahedron();
break;
case 4:
glutSolidOctahedron();
break;
case 5:
glutSolidIcosahedron();
break;
case 6:
glutSolidIcosahedron();
break;
}
}
else {
switch (poly) {
case 1:
glutWireCube(1.0);
break;
case 2:
glutWireDodecahedron();
break;
case 3:
glutWireTetrahedron();
break;
case 4:
glutWireOctahedron();
break;
case 5:
glutWireIcosahedron();
break;
case 6:
glutWireIcosahedron();
break;
}
}
glPopMatrix();
glutSwapBuffers();
glFlush();
}
void cene_octa(){
glPushMatrix();
glColor3d(1,1,0.5);
glTranslated(-4,-2,-4);
glRotated(-20, 0, 5, 0);
glutSolidOctahedron();
glPopMatrix();
}
void drawFossil(float x,float y,float z,float angle,float color[3])
{
glPushMatrix();
glColor3f(color[0],color[1],color[2]);
glTranslatef(x,y,z);
glRotatef(angle,0.0,1.0,0.0);
glutSolidOctahedron();
glPopMatrix();
}
// Called to draw scene objects
void DrawModels(GLboolean drawBasePlane)
{
if (drawBasePlane)
{
// Draw plane that the objects rest on
glColor3f(0.0f, 0.0f, 0.90f); // Blue
glNormal3f(0.0f, 1.0f, 0.0f);
glBegin(GL_QUADS);
glVertex3f(-100.0f, -25.0f, -100.0f);
glVertex3f(-100.0f, -25.0f, 100.0f);
glVertex3f(100.0f, -25.0f, 100.0f);
glVertex3f(100.0f, -25.0f, -100.0f);
glEnd();
}
// Draw red cube
glColor3f(1.0f, 0.0f, 0.0f);
glutSolidCube(48.0f);
// Draw green sphere
glColor3f(0.0f, 1.0f, 0.0f);
glPushMatrix();
glTranslatef(-60.0f, 0.0f, 0.0f);
glutSolidSphere(25.0f, 50, 50);
glPopMatrix();
// Draw yellow cone
glColor3f(1.0f, 1.0f, 0.0f);
glPushMatrix();
glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
glTranslatef(60.0f, 0.0f, -24.0f);
glutSolidCone(25.0f, 50.0f, 50, 50);
glPopMatrix();
// Draw magenta torus
glColor3f(1.0f, 0.0f, 1.0f);
glPushMatrix();
glTranslatef(0.0f, 0.0f, 60.0f);
glutSolidTorus(8.0f, 16.0f, 50, 50);
glPopMatrix();
// Draw cyan octahedron
glColor3f(0.0f, 1.0f, 1.0f);
glPushMatrix();
glTranslatef(0.0f, 0.0f, -60.0f);
glScalef(25.0f, 25.0f, 25.0f);
glutSolidOctahedron();
glPopMatrix();
}
//------------------------------------------------------------------------------
void npGlutPrimitive (int primitive)
{
switch (primitive)
{
case kNPgeoCubeWire :
glScalef (0.6f, 0.6f, 0.6f);
glutWireCube(2.0f);
glScalef (1.666667f, 1.666667f, 1.666667f);
break;
case kNPgeoCube :
glScalef (0.6f, 0.6f, 0.6f);
glutSolidCube(2.0f);
glScalef (1.666667f, 1.666667f, 1.666667f);
break;
case kNPgeoSphereWire : glutWireSphere( 1.0f, 24, 12); break;//15, 15 ); break;
case kNPgeoSphere : glutSolidSphere( 1.0f, 24, 12 ); break;
case kNPgeoConeWire : glutWireCone( 1.0f, 2.0f, 24, 1 ); break;
case kNPgeoCone : glutSolidCone( 1.0f, 2.0f, 24, 1 ); break;
case kNPgeoTorusWire : glutWireTorus(kNPtorusRadius * 0.1f, kNPtorusRadius, 7, 16); break;
case kNPgeoTorus : glutSolidTorus(kNPtorusRadius * 0.1f, kNPtorusRadius, 7, 16); break;
case kNPgeoDodecahedronWire :
glScalef (0.6f, 0.6f, 0.6f);
glutWireDodecahedron();
glScalef (1.666667f, 1.666667f, 1.666667f);
break;
case kNPgeoDodecahedron :
glScalef (0.6f, 0.6f, 0.6f);
glutSolidDodecahedron();
glScalef (1.666667f, 1.666667f, 1.666667f);
break;
case kNPgeoOctahedronWire : glutWireOctahedron(); break;
case kNPgeoOctahedron : glutSolidOctahedron(); break;
case kNPgeoTetrahedronWire : glutWireTetrahedron(); break;
case kNPgeoTetrahedron : glutSolidTetrahedron(); break;
case kNPgeoIcosahedronWire : glutWireIcosahedron(); break;
case kNPgeoIcosahedron : glutSolidIcosahedron(); break;
// case kNPglutWireTeapot : glutWireTeapot( 2.0f ); break;
// case kNPglutSolidTeapot : glutSolidTeapot( 2.0f ); break;
default : glutWireTetrahedron(); break;
}
}
void C3D::displayObjects ()
{
//## begin C3D::displayObjects%40E215A503B4.body preserve=yes
GLfloat torus_diffuse[] = { 0.7f, 0.7f, 0.0f, 1.0f };
GLfloat cube_diffuse[] = { 0.0f, 0.7f, 0.7f, 1.0f };
GLfloat sphere_diffuse[] = { 0.7f, 0.0f, 0.7f, 1.0f };
GLfloat octa_diffuse[] = { 0.7f, 0.4f, 0.4f, 1.0f };
glPushMatrix ();
glTranslatef (0.0, 0.0, -5.0);
glRotatef (30.0, 1.0, 0.0, 0.0);
glPushMatrix ();
glTranslatef (-0.80f, 0.35f, 0.0f);
glRotatef (100.0f, 1.0f, 0.0f, 0.0f);
glMaterialfv(GL_FRONT, GL_DIFFUSE, torus_diffuse);
glutSolidTorus (0.275f, 0.85f, 16, 16);
glPopMatrix ();
glPushMatrix ();
glTranslatef (-0.75, -0.50, 0.0);
glRotatef (45.0, 0.0, 0.0, 1.0);
glRotatef (45.0, 1.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, cube_diffuse);
glutSolidCube (1.5);
glPopMatrix ();
glPushMatrix ();
glTranslatef (0.75f, 0.60f, 0.0f);
glRotatef (30.0, 1.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, sphere_diffuse);
glutSolidSphere (1.0, 16, 16);
glPopMatrix ();
glPushMatrix ();
glTranslatef (0.70f, -0.90f, 0.25f);
glMaterialfv(GL_FRONT, GL_DIFFUSE, octa_diffuse);
glutSolidOctahedron ();
glPopMatrix ();
glPopMatrix ();
//## end C3D::displayObjects%40E215A503B4.body
}
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;
}
}
void Diamond::draw() {
glPushMatrix();
float mat_ambient[] = {0.17, 0.01, 0.01, 0.55};
float mat_diffuse[] = {0.61, 0.04, 0.04, 0.55};
float mat_specular[] = {0.72, 0.62, 0.62, 0.55};
float high_shininess[] = {0.55};
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
glColor3f(0, 0, 1);
glTranslatef(0, 1, 0);
glutSolidOctahedron();
glPopMatrix();
glFlush();
}
void DrawObjects()
{
glPushMatrix();
glColor3f(1.0f, 0.0f, 0.0f);
glutSolidCube(3.0);
glColor3f(0.0f, 0.0f, 1.0f);
glTranslatef(-10.0f, 0.0f, 0.0f);
glutSolidTorus(1.0, 3.0, 20, 20);
glColor3f(1.0f, 1.0f, 0.0f);
glTranslatef(20.0f, 0.0f, 0.0f);
glutSolidTeapot(3.0);
glColor3f(1.0f, 0.0f, 1.0f);
glTranslatef(-10.0f, 0.0f, -10.0f);
glutSolidSphere(3.0, 20, 20);
glColor3f(0.0f, 1.0f, 1.0f);
glTranslatef(0.0f, 0.0f, 20.0f);
glScalef(3.0f, 3.0f, 3.0f);
glutSolidOctahedron();
glPopMatrix();
}
// Draw our world
void display_1(void)
{
char *p;
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //Clear the screen
glMatrixMode (GL_PROJECTION); // Tell opengl that we are doing project matrix work
glLoadIdentity(); // Clear the matrix
glOrtho(-8.0, 8.0, -8.0, 8.0, 0.0, 30.0); // Setup an Ortho view
glMatrixMode(GL_MODELVIEW); // Tell opengl that we are doing model matrix work. (drawing)
glLoadIdentity(); // Clear the model matrix
glColor3f(1.0, 1.0, 1.0);
if (shape == 0) Sprint(-3, -7 ,"Solid Cube");
if (shape == 1) Sprint(-3, -7 ,"Solid Cone");
if (shape == 2) Sprint(-3, -7 ,"Solid Sphere");
if (shape == 3) Sprint(-3, -7 ,"Solid Torus");
if (shape == 4) Sprint(-3, -7 ,"Solid Dodecahedron");
if (shape == 5) Sprint(-3, -7 ,"Solid Octahedron");
if (shape == 6) Sprint(-3, -7 ,"Solid Tetrahedron");
if (shape == 7) Sprint(-3, -7 ,"Solid Icosahedron");
if (shape == 8) Sprint(-3, -7 ,"Solid Teapot");
// Setup view, and print view state on screen
if (view_state == 1)
{
glColor3f( 1.0, 1.0, 1.0);
Sprint(-2, 4, "Perspective view");
glMatrixMode (GL_PROJECTION);
glLoadIdentity();
gluPerspective(60, 1, 1, 30);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}else
{
glColor3f( 1.0, 1.0, 1.0);
Sprint(-2, 4, "Ortho view");
}
glColor3f( 0.0, 0.0, 1.0); // Cube color
// Lighting on/off
if (light_state == 1)
{
glDisable(GL_LIGHTING); // Turn off lighting
glDisable(GL_COLOR_MATERIAL); // Turn off material, which needs lighting to work
}else
{
glEnable(GL_LIGHTING); // Turn on lighting
glEnable(GL_COLOR_MATERIAL); // Turn on material settings
glColorMaterial(GL_FRONT, GL_AMBIENT);
glColor4f(0.65, 0.65, 0.65, 0.4);
glColorMaterial(GL_FRONT, GL_EMISSION);
glColor4f(0.10, 0.10, 0.10, 0.0);
glColorMaterial(GL_FRONT, GL_SPECULAR);
glColor4f(0.5, 0.5, 0.5, 0.4);
glColorMaterial(GL_FRONT, GL_DIFFUSE);
glColor4f(0.85, 0.85, 0.85, 0.4);
}
gluLookAt( 0, 0, 20, 0, 0, 0, 0, 1, 0);
//glRotatef( 45, 1.0, 1.0, 0.0); // rotate cube
glRotatef( spin++, 1.0, 1.0, 1.0); // spin cube
if (shape == 0) glutSolidCube(10); // Draw a cube
if (shape == 1) glutSolidCone(5,10, 16,16); // Draw a Cone
if (shape == 2) glutSolidSphere(5, 16,16 ); // Draw a Sphere
if (shape == 3) glutSolidTorus( 2.5, 5, 16, 16);
if (shape == 4)
{
glScalef( 3.5, 3.5, 3.5);
glutSolidDodecahedron();
}
if (shape == 5)
{
glScalef( 5.0, 5.0, 5.0);
glutSolidOctahedron();
}
if (shape == 6)
{
glScalef( 5.0, 5.0, 5.0);
glutSolidTetrahedron();
}
if (shape == 7)
{
glScalef( 5.0, 5.0, 5.0);
glutSolidIcosahedron();
}
if (shape == 8) glutSolidTeapot( 5 );
glutSwapBuffers();
}
// Called to draw scene
void RenderScene(void)
{
// Clear the window
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Save matrix state and do the rotation
glPushMatrix();
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
glRotatef(yRot, 0.0f, 1.0f, 0.0f);
switch(iShape)
{
case 1:
glutWireSphere(1.0f, 25, 25);
break;
case 2:
glutWireCube(1.0f);
break;
case 3:
glutWireCone(0.30f, 1.1f, 20, 20);
break;
case 4:
glutWireTorus(0.3f, 1.0f, 10, 25);
break;
case 5:
glutWireDodecahedron();
break;
case 6:
glutWireOctahedron();
break;
case 7:
glutWireTetrahedron();
break;
case 8:
glutWireIcosahedron();
break;
case 9:
glutWireTeapot(1.0f);
break;
case 11:
glutSolidSphere(1.0f, 25, 25);
break;
case 12:
glutSolidCube(1.0f);
break;
case 13:
glutSolidCone(0.30, 1.1f, 20, 20);
break;
case 14:
glutSolidTorus(0.3f, 1.0f, 10, 25);
break;
case 15:
glutSolidDodecahedron();
break;
case 16:
glutSolidOctahedron();
break;
case 17:
glutSolidTetrahedron();
break;
case 18:
glutSolidIcosahedron();
break;
default:
glutSolidTeapot(1.0f);
break;
}
// Restore transformations
glPopMatrix();
// Flush drawing commands
glutSwapBuffers();
}
static void hugsprim_glutSolidOctahedron_6(HugsStackPtr hugs_root)
{
glutSolidOctahedron();
hugs->returnIO(hugs_root,0);
}
/*
* These one-liners draw particular objects, fetching appropriate
* information from the above globals. They are just thin wrappers
* for the FreeGLUT objects.
*/
static void drawSolidTetrahedron(void) { glutSolidTetrahedron (); }
static void drawWireTetrahedron(void) { glutWireTetrahedron (); }
static void drawSolidCube(void) { glutSolidCube(orad); } /* orad doubles as size input */
static void drawWireCube(void) { glutWireCube(orad); } /* orad doubles as size input */
static void drawSolidOctahedron(void) { glutSolidOctahedron (); }
/** SolidOctahedron () -> None
*/
static int glut_solid_octahedron(lua_State *L) {
glutSolidOctahedron();
}
void drawWindHouse(void){
DiskObj = gluNewQuadric(); //New an object
DiskObj1 = gluNewQuadric(); //New an object
glColor4f(0.9, 0.8, 1, 1); //rice white
glTranslatef(0, 50, 0);
gluCylinder(DiskObj, 9, 7, 40, 8, 20);
glTranslatef(0, 0, 40);
gluDisk(DiskObj1, 0, 7, 8, 20 );
glColor4f(0.2, 0.1, 0, 1); //dark grey
glutSolidSphere(6, 20, 20);
glTranslatef(0, -7, 0);
glutSolidSphere(2, 20, 20);
glPushMatrix();
if (fanAngle >= 360){ //rotate the fan
fanAngle = 0;
}
else{
fanAngle = fanAngle + fanSpeed;
}
glRotated(fanAngle, 0, 1, 0);
glTranslatef(12, -1, 0); //draw the fan
glPushMatrix();
glScalef(20, 1, 5);
glutSolidCube(1);
glPopMatrix();
glTranslatef(-24, 0, 0);
glPushMatrix();
glScalef(20, 1, 5);
glutSolidCube(1);
glPopMatrix();
glTranslatef(12, 0, 12);
glPushMatrix();
glScalef(5, 1, 20);
glutSolidCube(1);
glPopMatrix();
glTranslatef(0, 0, -24);
glPushMatrix();
glScalef(5, 1, 20);
glutSolidCube(1);
glPopMatrix();
glTranslatef(0, 0, 12);
glPopMatrix();
glTranslatef(0, -42, -40);// after draw the fan, back to center point
glPushMatrix();
glTranslatef(20, 10, 0); //begin to draw the house
glRotated(45, 0, 0, -1);
glPushMatrix();
glColor4f(0.9, 0.8, 1, 1);
glScalef(20, 40, 20);
glutSolidCube(1);
glPopMatrix();
glPushMatrix(); // draw the door
glColor4f(0.2, 0.1, 0, 1);
glTranslatef(0, -16, 3);
glutSolidCube(10);
glPopMatrix();
glPushMatrix(); // draw the window
glColor4f(0.22, 0.22, 0.22, 1);
glTranslatef(10, -10, 5);
glPushMatrix();
glScalef(2, 10, 5);
glutSolidCube(1);
glPopMatrix();
glTranslatef(0, 20, 0);
glScalef(2, 10, 5);
glutSolidCube(1);
glPopMatrix();
glTranslatef(0, 0, 10); //draw the roof
glColor4f(0.2, 0.1, 0, 1);
glScalef(15, 29, 15);
glRotated(45, 0, 0, -1);
glutSolidOctahedron();
glPopMatrix();
}
void Display(void)
{
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(X,Y,Z, 0,0,0, 0,1,0);
float verticies[300];
int i, j, k;
float x=0,y=0,z=0;
for(i=0; i<10; i++)
{
for (j=0; j<10; j++)
{
k = ( i*10 + j ) * 3;
z= sqrt(x) + sqrt(y);
verticies[k]= x;
verticies[k + 1] = z;
verticies[k + 2] = y;
x+=1;
}
x = 0;
y+=1;
}
//индексы вершин для построения прямоугольников
int index = 0;
int quards[324];
for(i=0; i<10; i++)
{
for (j=0; j<9; j++)
{
k = i*9 + j;
if (k%10 == 9) continue;
quards[index] = k;
quards[index + 1] = k+1;
quards[index + 2] = k+11;
quards[index + 3] = k+10;
index += 4;
}
}
glNewList(1,GL_COMPILE);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glutWireDodecahedron();
glTranslated(6,0,0);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glutSolidOctahedron();
glColor3ub(0,0,100);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glutSolidOctahedron();
glEndList();
glNewList(2,GL_COMPILE);
glTranslated(4,0,0);
//оси
glBegin(GL_LINES);
glVertex3f(0,0,0);
glVertex3f(10,0,0);
glVertex3f(0,0,0);
glVertex3f(0,2,0);
glVertex3f(0,0,0);
glVertex3f(0,0,10);
glEnd();
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, verticies);
//сначала сплошного заданного цвета
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDrawElements(GL_QUADS, 324, GL_UNSIGNED_INT, quards);
//затем грани
glColor3ub(0,0,100);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDrawElements(GL_QUADS, 324, GL_UNSIGNED_INT, quards);
//завершение построения
glDisableClientState(GL_VERTEX_ARRAY);
glEndList();
glPushMatrix();
glTranslated(-10,10,0);
glColor3ub(242,178,103);
glCallList(1);
glColor3ub(242,178,103);
glCallList(2);
glPopMatrix();
glPushMatrix();
glTranslated(-10,3,0);
glScalef(1.2,1.2,1.2);
glColor3ub(242,178,103);
glCallList(1);
glColor3ub(242,178,103);
glCallList(2);
glPopMatrix();
glPushMatrix();
glTranslated(-10,-5,0);
glScalef(1.5,1.5,1.5);
glColor3ub(242,178,103);
glCallList(1);
glColor3ub(242,178,103);
glCallList(2);
glPopMatrix();
glFlush();
}
void
displayFunc(void)
{
static int shape = 1;
fprintf(stderr, " %d", shape);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
switch (shape) {
case 1:
glutWireSphere(1.0, 20, 20);
break;
case 2:
glutSolidSphere(1.0, 20, 20);
break;
case 3:
glutWireCone(1.0, 1.0, 20, 20);
break;
case 4:
glutSolidCone(1.0, 1.0, 20, 20);
break;
case 5:
glutWireCube(1.0);
break;
case 6:
glutSolidCube(1.0);
break;
case 7:
glutWireTorus(0.5, 1.0, 15, 15);
break;
case 8:
glutSolidTorus(0.5, 1.0, 15, 15);
break;
case 9:
glutWireDodecahedron();
break;
case 10:
glutSolidDodecahedron();
break;
case 11:
glutWireTeapot(1.0);
break;
case 12:
glutSolidTeapot(1.0);
break;
case 13:
glutWireOctahedron();
break;
case 14:
glutSolidOctahedron();
break;
case 15:
glutWireTetrahedron();
break;
case 16:
glutSolidTetrahedron();
break;
case 17:
glutWireIcosahedron();
break;
case 18:
glutSolidIcosahedron();
break;
default:
printf("\nPASS: test16\n");
exit(0);
}
glutSwapBuffers();
shape += 1;
sleep(1);
glutPostRedisplay();
}
void duduk(){
GLUquadric *quadric = gluNewQuadric();
glPushMatrix();
glColor3f(1.0,1.0,1.0);
//tempat duduk
glPushMatrix();
glColor3f(1.0,0.3,2.0);
glTranslatef(5,0,0);
glRotatef(angl,0,0,1);
glRotatef(270,1,0,0);
gluCylinder(quadric, 0.5, 0.5, 1, 20, 20);
glTranslatef(0,0,0.75);
glutSolidOctahedron();
glPopMatrix();
glPushMatrix();
glColor3f(0.3,1.0,0.5);
glTranslatef(-5,0,0);
glRotatef(angl,0,0,1);
glRotatef(270,1,0,0);
gluCylinder(quadric, 0.5, 0.5, 1, 20, 20);
glTranslatef(0,0,0.75);
glutSolidOctahedron();
glPopMatrix();
glPushMatrix();
glColor3f(0.1,1.0,0.4);
glTranslatef(0,5,0);
glRotatef(angl,0,0,1);
glRotatef(270,1,0,0);
gluCylinder(quadric, 0.5, 0.5, 1, 20, 20);
glTranslatef(0,0,0.75);
glutSolidOctahedron();
glPopMatrix();
glPushMatrix();
glColor3f(1.0,0.5,1.0);
glTranslatef(0,-5,0);
glRotatef(angl,0,0,1);
glRotatef(270,1,0,0);
gluCylinder(quadric, 0.5, 0.5, 1, 20, 20);
glTranslatef(0,0,0.75);
glutSolidOctahedron();
glPopMatrix();
glPushMatrix();
glColor3f(1.0,0.0,0.0);
glTranslatef(3.5,3.5,0);
glRotatef(angl,0,0,1);
glRotatef(270,1,0,0);
gluCylinder(quadric, 0.5, 0.5, 1, 20, 20);
glTranslatef(0,0,0.75);
glutSolidOctahedron();
glPopMatrix();
glPushMatrix();
glColor3f(0.8,0.5,0.0);
glTranslatef(-3.5,3.5,0);
glRotatef(angl,0,0,1);
glRotatef(270,1,0,0);
gluCylinder(quadric, 0.5, 0.5, 1, 20, 20);
glTranslatef(0,0,0.75);
glutSolidOctahedron();
glPopMatrix();
glPushMatrix();
glColor3f(6.0,0.5,0.0);
glTranslatef(3.5,-3.5,0);
glRotatef(angl,0,0,1);
glRotatef(270,1,0,0);
gluCylinder(quadric, 0.5, 0.5, 1, 20, 20);
glTranslatef(0,0,0.75);
glutSolidOctahedron();
glPopMatrix();
glPushMatrix();
glColor3f(0.5,0.7,1.0);
glTranslatef(-3.5,-3.5,0);
glRotatef(angl,0,0,1);
glRotatef(270,1,0,0);
gluCylinder(quadric, 0.5, 0.5, 1, 20, 20);
glTranslatef(0,0,0.75);
glutSolidOctahedron();
glPopMatrix();
glPopMatrix();
angl-=1;
}
//-------------------------------------------------------------------------
// Draws our object.
//-------------------------------------------------------------------------
void drawObject ()
{
// Draw the object only if the Draw check box is selected
if (draw)
{
// Push the current matrix into the model view stack
glPushMatrix ();
// Apply the translation
glTranslatef (translate_xy[0], translate_xy[1], -translate_z);
// Apply the rotation matrix
glMultMatrixf (rotation_matrix);
// Apply the scaling
glScalef (scale, scale, scale);
// Get the id of the selected object
int selected_object = (radiogroup_item_id * 2) + 1 - wireframe;
switch (selected_object)
{
// draw glut wire cube
case GLUT_WIRE_CUBE:
glutWireCube (0.5);
break;
// draw glut solid cube
case GLUT_SOLID_CUBE:
glutSolidCube (0.5);
break;
// draw glut wire sphere
case GLUT_WIRE_SPHERE:
glutWireSphere (0.5, 50, 50);
break;
// draw glut solid sphere
case GLUT_SOLID_SPHERE:
glutSolidSphere (0.5, 50, 50);
break;
// draw glut wire Cone
case GLUT_WIRE_CONE:
glutWireCone (0.5, 0.5, 50, 50);
break;
// draw glut solid cone
case GLUT_SOLID_CONE:
glutSolidCone (0.5, 0.5, 50, 50);
break;
// draw glut wire Torus
case GLUT_WIRE_TORUS:
glutWireTorus (0.15, 0.25, 20, 20);
break;
/// draw glut solid Torus
case GLUT_SOLID_TORUS:
glutSolidTorus (0.15, 0.25, 20, 20);
break;
// draw a wire dodecahedron.. The reason why I'm dividing
// by 2 * radical (3) when I'm scaling it because I want to fit
// the dodecahedron which is centered at the modeling
// coordinates origin with a radius of radical (3).
case GLUT_WIRE_DODECAHEDRON:
glScalef (1 / sqrt (12), 1 / sqrt (12), 1 / sqrt (12));
glutWireDodecahedron ();
break;
// draw a solid dodecahedron
case GLUT_SOLID_DODECAHEDRON:
glScalef (1 / sqrt (12), 1 / sqrt (12), 1 / sqrt (12));
glutSolidDodecahedron ();
break;
// draw a wire octahedron.. The reason why I'm dividing
// by 2 when I'm scaling is because I want to fit
// the octahedron which is centered at the modeling
// coordinates origin with a radius of 1.
case GLUT_WIRE_OCTAHEDRON:
glScalef (0.5, 0.5, 0.5);
glutWireOctahedron ();
break;
// draw a solid tetrahedron
case GLUT_SOLID_OCTAHEDRON:
glScalef (0.5, 0.5, 0.5);
glutSolidOctahedron ();
break;
// draw a wire tetrahedron..
case GLUT_WIRE_TETRAHEDRON:
glScalef (1 / sqrt(6), 1 / sqrt(6), 1 / sqrt(6));
glutWireTetrahedron ();
break;
// draw a solid tetrahedron
case GLUT_SOLID_TETRAHEDRON:
glScalef (1 / sqrt(6), 1 / sqrt(6), 1 / sqrt(6));
glutSolidTetrahedron ();
break;
// draw a wire icosahedron.. The reason why I'm dividing
// by 2 when I'm scaling is because I want to fit
// the icosahedron which is centered at the modeling
// coordinates origin with a radius of 1.
case GLUT_WIRE_ICOSAHEDRON:
glScalef (0.5, 0.5, 0.5);
glutWireIcosahedron ();
break;
// draw a solid icosahedron
case GLUT_SOLID_ICOSAHEDRON:
glScalef (0.5, 0.5, 0.5);
glutSolidIcosahedron ();
break;
// draw Wire Teapot
case GLUT_WIRE_TEAPOT:
glutWireTeapot (0.5);
break;
// draw a solid Teapot
case GLUT_SOLID_TEAPOT:
glutSolidTeapot (0.5);
break;
// Do Nothing
default:
break;
}
// Pop our matrix from the model view stack after we finish drawing
glPopMatrix ();
}
}
/*
* Class: gruenewa_opengl_GLUT__
* Method: glutSolidOctahedron
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_gruenewa_opengl_GLUT_00024_glutSolidOctahedron
(JNIEnv * jenv, jobject jobj) {
glutSolidOctahedron();
}
//显示回调函数
void renderScreen(void){
//将窗口颜色清理为黑色
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
//将模板缓冲区值全部清理为1
glClearStencil(1);
//使能模板缓冲区
glEnable(GL_STENCIL_TEST);
//把整个窗口清理为当前清理颜色：黑色。清除深度缓冲区、模板缓冲区
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
//将当前Matrix状态入栈
glPushMatrix();
//坐标系绕x轴旋转xRotAngle
glRotatef(xRotAngle, 1.0f, 0.0f, 0.0f);
//坐标系绕y轴旋转yRotAngle
glRotatef(yRotAngle, 0.0f, 1.0f, 0.0f);
//进行平滑处理
glEnable(GL_POINT_SMOOTH);
glHint(GL_POINT_SMOOTH, GL_NICEST);
glEnable(GL_LINE_SMOOTH);
glHint(GL_LINE_SMOOTH, GL_NICEST);
glEnable(GL_POLYGON_SMOOTH);
glHint(GL_POLYGON_SMOOTH, GL_NICEST);
//白色绘制坐标系
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_LINES);
glVertex3f(-9.0f, 0.0f, 0.0f);
glVertex3f(9.0f, 0.0f, 0.0f);
glVertex3f(0.0f, -9.0f, 0.0f);
glVertex3f(0.0f, 9.0f, 0.0f);
glVertex3f(0.0f, 0.0f, -9.0f);
glVertex3f(0.0f, 0.0f, 9.0f);
glEnd();
glPushMatrix();
glTranslatef(9.0f, 0.0f, 0.0f);
glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
glutSolidCone(0.3, 0.6, 10, 10);
glPopMatrix();
glPushMatrix();
glTranslatef(0.0f, 9.0f, 0.0f);
glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
glutSolidCone(0.3, 0.6, 10, 10);
glPopMatrix();
glPushMatrix();
glTranslatef(0.0f, 0.0f, 9.0f);
glRotatef(90.0f, 0.0f, 0.0f, 1.0f);
glutSolidCone(0.3, 0.6, 10, 10);
glPopMatrix();
//设置绘画颜色为金色
glColor3f(0.0f, 1.0f, 0.0f);
switch (iModel){
//球
case SPHERE:
if (bWire){
glutWireSphere(8.0f, 20, 20);
}
else{
glutSolidSphere(8.0f, 20, 20);
}
break;
//锥体
case CONE:
if (bWire){
glutWireCone(4.0f, 8.0f, 20, 20);
}
else{
glutSolidCone(4.0f, 8.0f, 20, 20);
}
break;
//立体
case CUBE:
if (bWire){
glutWireCube(8.0f);
}
else{
glutSolidCube(8.0f);
}
break;
//甜圈
case TORUS:
if (bWire){
glutWireTorus(3.0f, 6.0f, 20, 20);
}
else{
glutSolidTorus(3.0f, 6.0f, 20, 20);
}
break;
//十六面体，默认半径1.0
case DODECAHEDRON:
glScalef(6.0f, 6.0f, 6.0f);//x,y,z轴均放大6倍
if (bWire){
glutWireDodecahedron();
}
else{
glutSolidDodecahedron();
}
break;
//茶壶
case TEAPOT:
if (bWire){
glutWireTeapot(8.0f);
}
else{
glutSolidTeapot(8.0f);
}
break;
//八面体，默认半径1.0
case OCTAHEDRON:
glScalef(6.0f, 6.0f, 6.0f);//x,y,z轴均放大6倍
if (bWire){
glutWireOctahedron();
}
else{
glutSolidOctahedron();
}
break;
//四面体，默认半径1.0
case TETRAHEDRON:
glScalef(6.0f, 6.0f, 6.0f);//x,y,z轴均放大6倍
if (bWire){
glutWireTetrahedron();
}
else{
glutSolidTetrahedron();
}
break;
//二十面体，默认半径1.0
case ICOSAHEDRON:
glScalef(6.0f, 6.0f, 6.0f);//x,y,z轴均放大6倍
if (bWire){
glutWireIcosahedron();
}
else{
glutSolidIcosahedron();
}
break;
default:
break;
}
//恢复压入栈的Matrix
glPopMatrix();
//交换两个缓冲区的指针
glutSwapBuffers();
}
