diff options
Diffstat (limited to 'progs/directfb/df_morph3d.c')
| -rw-r--r-- | progs/directfb/df_morph3d.c | 1013 |
1 files changed, 1013 insertions, 0 deletions
diff --git a/progs/directfb/df_morph3d.c b/progs/directfb/df_morph3d.c new file mode 100644 index 00000000000..f7f143447f4 --- /dev/null +++ b/progs/directfb/df_morph3d.c @@ -0,0 +1,1013 @@ +/* + (c) Copyright 2001 convergence integrated media GmbH. + All rights reserved. + + Written by Denis Oliver Kropp <[email protected]> and + Andreas Hundt <[email protected]>. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/*- + * morph3d.c - Shows 3D morphing objects + * + * Converted to GLUT by brianp on 1/1/98 + * + * This program was inspired on a WindowsNT(R)'s screen saver. It was written + * from scratch and it was not based on any other source code. + * + * Porting it to xlock (the final objective of this code since the moment I + * decided to create it) was possible by comparing the original Mesa's gear + * demo with it's ported version, so thanks for Danny Sung for his indirect + * help (look at gear.c in xlock source tree). NOTE: At the moment this code + * was sent to Brian Paul for package inclusion, the XLock Version was not + * available. In fact, I'll wait it to appear on the next Mesa release (If you + * are reading this, it means THIS release) to send it for xlock package + * inclusion). It will probably there be a GLUT version too. + * + * Thanks goes also to Brian Paul for making it possible and inexpensive + * to use OpenGL at home. + * + * Since I'm not a native english speaker, my apologies for any gramatical + * mistake. + * + * My e-mail addresses are + * + * and + * + * Marcelo F. Vianna (Feb-13-1997) + */ + +/* +This document is VERY incomplete, but tries to describe the mathematics used +in the program. At this moment it just describes how the polyhedra are +generated. On futhurer versions, this document will be probabbly improved. + +Since I'm not a native english speaker, my apologies for any gramatical +mistake. + +Marcelo Fernandes Vianna +- Undergraduate in Computer Engeneering at Catholic Pontifical University +- of Rio de Janeiro (PUC-Rio) Brasil. +- e-mail: [email protected] or [email protected] +- Feb-13-1997 + +POLYHEDRA GENERATION + +For the purpose of this program it's not sufficient to know the polyhedra +vertexes coordinates. Since the morphing algorithm applies a nonlinear +transformation over the surfaces (faces) of the polyhedron, each face has +to be divided into smaller ones. The morphing algorithm needs to transform +each vertex of these smaller faces individually. It's a very time consoming +task. + +In order to reduce calculation overload, and since all the macro faces of +the polyhedron are transformed by the same way, the generation is made by +creating only one face of the polyhedron, morphing it and then rotating it +around the polyhedron center. + +What we need to know is the face radius of the polyhedron (the radius of +the inscribed sphere) and the angle between the center of two adjacent +faces using the center of the sphere as the angle's vertex. + +The face radius of the regular polyhedra are known values which I decided +to not waste my time calculating. Following is a table of face radius for +the regular polyhedra with edge length = 1: + + TETRAHEDRON : 1/(2*sqrt(2))/sqrt(3) + CUBE : 1/2 + OCTAHEDRON : 1/sqrt(6) + DODECAHEDRON : T^2 * sqrt((T+2)/5) / 2 -> where T=(sqrt(5)+1)/2 + ICOSAHEDRON : (3*sqrt(3)+sqrt(15))/12 + +I've not found any reference about the mentioned angles, so I needed to +calculate them, not a trivial task until I figured out how :) +Curiously these angles are the same for the tetrahedron and octahedron. +A way to obtain this value is inscribing the tetrahedron inside the cube +by matching their vertexes. So you'll notice that the remaining unmatched +vertexes are in the same straight line starting in the cube/tetrahedron +center and crossing the center of each tetrahedron's face. At this point +it's easy to obtain the bigger angle of the isosceles triangle formed by +the center of the cube and two opposite vertexes on the same cube face. +The edges of this triangle have the following lenghts: sqrt(2) for the base +and sqrt(3)/2 for the other two other edges. So the angle we want is: + +-----------------------------------------------------------+ + | 2*ARCSIN(sqrt(2)/sqrt(3)) = 109.47122063449069174 degrees | + +-----------------------------------------------------------+ +For the cube this angle is obvious, but just for formality it can be +easily obtained because we also know it's isosceles edge lenghts: +sqrt(2)/2 for the base and 1/2 for the other two edges. So the angle we +want is: + +-----------------------------------------------------------+ + | 2*ARCSIN((sqrt(2)/2)/1) = 90.000000000000000000 degrees | + +-----------------------------------------------------------+ +For the octahedron we use the same idea used for the tetrahedron, but now +we inscribe the cube inside the octahedron so that all cubes's vertexes +matches excatly the center of each octahedron's face. It's now clear that +this angle is the same of the thetrahedron one: + +-----------------------------------------------------------+ + | 2*ARCSIN(sqrt(2)/sqrt(3)) = 109.47122063449069174 degrees | + +-----------------------------------------------------------+ +For the dodecahedron it's a little bit harder because it's only relationship +with the cube is useless to us. So we need to solve the problem by another +way. The concept of Face radius also exists on 2D polygons with the name +Edge radius: + Edge Radius For Pentagon (ERp) + ERp = (1/2)/TAN(36 degrees) * VRp = 0.6881909602355867905 + (VRp is the pentagon's vertex radio). + Face Radius For Dodecahedron + FRd = T^2 * sqrt((T+2)/5) / 2 = 1.1135163644116068404 +Why we need ERp? Well, ERp and FRd segments forms a 90 degrees angle, +completing this triangle, the lesser angle is a half of the angle we are +looking for, so this angle is: + +-----------------------------------------------------------+ + | 2*ARCTAN(ERp/FRd) = 63.434948822922009981 degrees | + +-----------------------------------------------------------+ +For the icosahedron we can use the same method used for dodecahedron (well +the method used for dodecahedron may be used for all regular polyhedra) + Edge Radius For Triangle (this one is well known: 1/3 of the triangle height) + ERt = sin(60)/3 = sqrt(3)/6 = 0.2886751345948128655 + Face Radius For Icosahedron + FRi= (3*sqrt(3)+sqrt(15))/12 = 0.7557613140761707538 +So the angle is: + +-----------------------------------------------------------+ + | 2*ARCTAN(ERt/FRi) = 41.810314895778596167 degrees | + +-----------------------------------------------------------+ + +*/ + + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <math.h> +#include <unistd.h> + +#include <directfb.h> + +#include <GL/gl.h> +#include <GL/directfbgl.h> + + +/* the super interface */ +IDirectFB *dfb; + +/* the primary surface (surface of primary layer) */ +IDirectFBSurface *primary; + +/* the GL context */ +IDirectFBGL *primary_gl; + +/* our font */ +IDirectFBFont *font; + +/* event buffer */ +IDirectFBEventBuffer *events; + +/* macro for a safe call to DirectFB functions */ +#define DFBCHECK(x...) \ + { \ + err = x; \ + if (err != DFB_OK) { \ + fprintf( stderr, "%s <%d>:\n\t", __FILE__, __LINE__ ); \ + DirectFBErrorFatal( #x, err ); \ + } \ + } + +static int screen_width, screen_height; + +static unsigned long T0 = 0; +static GLint Frames = 0; +static GLfloat fps = 0; + +static inline unsigned long get_millis() +{ + struct timeval tv; + + gettimeofday (&tv, NULL); + return (tv.tv_sec * 1000 + tv.tv_usec / 1000); +} + + + +#define Scale 0.3 + +#define VectMul(X1,Y1,Z1,X2,Y2,Z2) (Y1)*(Z2)-(Z1)*(Y2),(Z1)*(X2)-(X1)*(Z2),(X1)*(Y2)-(Y1)*(X2) +#define sqr(A) ((A)*(A)) + +/* Increasing this values produces better image quality, the price is speed. */ +/* Very low values produces erroneous/incorrect plotting */ +#define tetradivisions 23 +#define cubedivisions 20 +#define octadivisions 21 +#define dodecadivisions 10 +#define icodivisions 15 + +#define tetraangle 109.47122063449069174 +#define cubeangle 90.000000000000000000 +#define octaangle 109.47122063449069174 +#define dodecaangle 63.434948822922009981 +#define icoangle 41.810314895778596167 + +#ifndef Pi +#define Pi 3.1415926535897932385 +#endif +#define SQRT2 1.4142135623730951455 +#define SQRT3 1.7320508075688771932 +#define SQRT5 2.2360679774997898051 +#define SQRT6 2.4494897427831778813 +#define SQRT15 3.8729833462074170214 +#define cossec36_2 0.8506508083520399322 +#define cos72 0.3090169943749474241 +#define sin72 0.9510565162951535721 +#define cos36 0.8090169943749474241 +#define sin36 0.5877852522924731292 + +/*************************************************************************/ + +static int mono=0; +static int smooth=1; +static GLint WindH, WindW; +static GLfloat step=0; +static GLfloat seno; +static int object; +static int edgedivisions; +static void (*draw_object)( void ); +static float Magnitude; +static float *MaterialColor[20]; + +static float front_shininess[] = {60.0}; +static float front_specular[] = { 0.7, 0.7, 0.7, 1.0 }; +static float ambient[] = { 0.0, 0.0, 0.0, 1.0 }; +static float diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; +static float position0[] = { 1.0, 1.0, 1.0, 0.0 }; +static float position1[] = {-1.0,-1.0, 1.0, 0.0 }; +static float lmodel_ambient[] = { 0.5, 0.5, 0.5, 1.0 }; +static float lmodel_twoside[] = {GL_TRUE}; + +static float MaterialRed[] = { 0.7, 0.0, 0.0, 1.0 }; +static float MaterialGreen[] = { 0.1, 0.5, 0.2, 1.0 }; +static float MaterialBlue[] = { 0.0, 0.0, 0.7, 1.0 }; +static float MaterialCyan[] = { 0.2, 0.5, 0.7, 1.0 }; +static float MaterialYellow[] = { 0.7, 0.7, 0.0, 1.0 }; +static float MaterialMagenta[] = { 0.6, 0.2, 0.5, 1.0 }; +static float MaterialWhite[] = { 0.7, 0.7, 0.7, 1.0 }; +static float MaterialGray[] = { 0.2, 0.2, 0.2, 1.0 }; + +#define TRIANGLE(Edge, Amp, Divisions, Z) \ +{ \ + GLfloat Xf,Yf,Xa,Yb,Xf2,Yf2; \ + GLfloat Factor,Factor1,Factor2; \ + GLfloat VertX,VertY,VertZ,NeiAX,NeiAY,NeiAZ,NeiBX,NeiBY,NeiBZ; \ + GLfloat Ax,Ay,Bx; \ + int Ri,Ti; \ + GLfloat Vr=(Edge)*SQRT3/3; \ + GLfloat AmpVr2=(Amp)/sqr(Vr); \ + GLfloat Zf=(Edge)*(Z); \ + \ + Ax=(Edge)*(+0.5/(Divisions)), Ay=(Edge)*(-SQRT3/(2*Divisions)); \ + Bx=(Edge)*(-0.5/(Divisions)); \ + \ + for (Ri=1; Ri<=(Divisions); Ri++) { \ + glBegin(GL_TRIANGLE_STRIP); \ + for (Ti=0; Ti<Ri; Ti++) { \ + Xf=(float)(Ri-Ti)*Ax + (float)Ti*Bx; \ + Yf=Vr+(float)(Ri-Ti)*Ay + (float)Ti*Ay; \ + Xa=Xf+0.001; Yb=Yf+0.001; \ + Factor=1-(((Xf2=sqr(Xf))+(Yf2=sqr(Yf)))*AmpVr2); \ + Factor1=1-((sqr(Xa)+Yf2)*AmpVr2); \ + Factor2=1-((Xf2+sqr(Yb))*AmpVr2); \ + VertX=Factor*Xf; VertY=Factor*Yf; VertZ=Factor*Zf; \ + NeiAX=Factor1*Xa-VertX; NeiAY=Factor1*Yf-VertY; NeiAZ=Factor1*Zf-VertZ; \ + NeiBX=Factor2*Xf-VertX; NeiBY=Factor2*Yb-VertY; NeiBZ=Factor2*Zf-VertZ; \ + glNormal3f(VectMul(NeiAX, NeiAY, NeiAZ, NeiBX, NeiBY, NeiBZ)); \ + glVertex3f(VertX, VertY, VertZ); \ + \ + Xf=(float)(Ri-Ti-1)*Ax + (float)Ti*Bx; \ + Yf=Vr+(float)(Ri-Ti-1)*Ay + (float)Ti*Ay; \ + Xa=Xf+0.001; Yb=Yf+0.001; \ + Factor=1-(((Xf2=sqr(Xf))+(Yf2=sqr(Yf)))*AmpVr2); \ + Factor1=1-((sqr(Xa)+Yf2)*AmpVr2); \ + Factor2=1-((Xf2+sqr(Yb))*AmpVr2); \ + VertX=Factor*Xf; VertY=Factor*Yf; VertZ=Factor*Zf; \ + NeiAX=Factor1*Xa-VertX; NeiAY=Factor1*Yf-VertY; NeiAZ=Factor1*Zf-VertZ; \ + NeiBX=Factor2*Xf-VertX; NeiBY=Factor2*Yb-VertY; NeiBZ=Factor2*Zf-VertZ; \ + glNormal3f(VectMul(NeiAX, NeiAY, NeiAZ, NeiBX, NeiBY, NeiBZ)); \ + glVertex3f(VertX, VertY, VertZ); \ + \ + } \ + Xf=(float)Ri*Bx; \ + Yf=Vr+(float)Ri*Ay; \ + Xa=Xf+0.001; Yb=Yf+0.001; \ + Factor=1-(((Xf2=sqr(Xf))+(Yf2=sqr(Yf)))*AmpVr2); \ + Factor1=1-((sqr(Xa)+Yf2)*AmpVr2); \ + Factor2=1-((Xf2+sqr(Yb))*AmpVr2); \ + VertX=Factor*Xf; VertY=Factor*Yf; VertZ=Factor*Zf; \ + NeiAX=Factor1*Xa-VertX; NeiAY=Factor1*Yf-VertY; NeiAZ=Factor1*Zf-VertZ; \ + NeiBX=Factor2*Xf-VertX; NeiBY=Factor2*Yb-VertY; NeiBZ=Factor2*Zf-VertZ; \ + glNormal3f(VectMul(NeiAX, NeiAY, NeiAZ, NeiBX, NeiBY, NeiBZ)); \ + glVertex3f(VertX, VertY, VertZ); \ + glEnd(); \ + } \ +} + +#define SQUARE(Edge, Amp, Divisions, Z) \ +{ \ + int Xi,Yi; \ + GLfloat Xf,Yf,Y,Xf2,Yf2,Y2,Xa,Yb; \ + GLfloat Factor,Factor1,Factor2; \ + GLfloat VertX,VertY,VertZ,NeiAX,NeiAY,NeiAZ,NeiBX,NeiBY,NeiBZ; \ + GLfloat Zf=(Edge)*(Z); \ + GLfloat AmpVr2=(Amp)/sqr((Edge)*SQRT2/2); \ + \ + for (Yi=0; Yi<(Divisions); Yi++) { \ + Yf=-((Edge)/2.0) + ((float)Yi)/(Divisions)*(Edge); \ + Yf2=sqr(Yf); \ + Y=Yf+1.0/(Divisions)*(Edge); \ + Y2=sqr(Y); \ + glBegin(GL_QUAD_STRIP); \ + for (Xi=0; Xi<=(Divisions); Xi++) { \ + Xf=-((Edge)/2.0) + ((float)Xi)/(Divisions)*(Edge); \ + Xf2=sqr(Xf); \ + \ + Xa=Xf+0.001; Yb=Y+0.001; \ + Factor=1-((Xf2+Y2)*AmpVr2); \ + Factor1=1-((sqr(Xa)+Y2)*AmpVr2); \ + Factor2=1-((Xf2+sqr(Yb))*AmpVr2); \ + VertX=Factor*Xf; VertY=Factor*Y; VertZ=Factor*Zf; \ + NeiAX=Factor1*Xa-VertX; NeiAY=Factor1*Y-VertY; NeiAZ=Factor1*Zf-VertZ; \ + NeiBX=Factor2*Xf-VertX; NeiBY=Factor2*Yb-VertY; NeiBZ=Factor2*Zf-VertZ; \ + glNormal3f(VectMul(NeiAX, NeiAY, NeiAZ, NeiBX, NeiBY, NeiBZ)); \ + glVertex3f(VertX, VertY, VertZ); \ + \ + Xa=Xf+0.001; Yb=Yf+0.001; \ + Factor=1-((Xf2+Yf2)*AmpVr2); \ + Factor1=1-((sqr(Xa)+Yf2)*AmpVr2); \ + Factor2=1-((Xf2+sqr(Yb))*AmpVr2); \ + VertX=Factor*Xf; VertY=Factor*Yf; VertZ=Factor*Zf; \ + NeiAX=Factor1*Xa-VertX; NeiAY=Factor1*Yf-VertY; NeiAZ=Factor1*Zf-VertZ; \ + NeiBX=Factor2*Xf-VertX; NeiBY=Factor2*Yb-VertY; NeiBZ=Factor2*Zf-VertZ; \ + glNormal3f(VectMul(NeiAX, NeiAY, NeiAZ, NeiBX, NeiBY, NeiBZ)); \ + glVertex3f(VertX, VertY, VertZ); \ + } \ + glEnd(); \ + } \ +} + +#define PENTAGON(Edge, Amp, Divisions, Z) \ +{ \ + int Ri,Ti,Fi; \ + GLfloat Xf,Yf,Xa,Yb,Xf2,Yf2; \ + GLfloat x[6],y[6]; \ + GLfloat Factor,Factor1,Factor2; \ + GLfloat VertX,VertY,VertZ,NeiAX,NeiAY,NeiAZ,NeiBX,NeiBY,NeiBZ; \ + GLfloat Zf=(Edge)*(Z); \ + GLfloat AmpVr2=(Amp)/sqr((Edge)*cossec36_2); \ + \ + for(Fi=0;Fi<6;Fi++) { \ + x[Fi]=-cos( Fi*2*Pi/5 + Pi/10 )/(Divisions)*cossec36_2*(Edge); \ + y[Fi]=sin( Fi*2*Pi/5 + Pi/10 )/(Divisions)*cossec36_2*(Edge); \ + } \ + \ + for (Ri=1; Ri<=(Divisions); Ri++) { \ + for (Fi=0; Fi<5; Fi++) { \ + glBegin(GL_TRIANGLE_STRIP); \ + for (Ti=0; Ti<Ri; Ti++) { \ + Xf=(float)(Ri-Ti)*x[Fi] + (float)Ti*x[Fi+1]; \ + Yf=(float)(Ri-Ti)*y[Fi] + (float)Ti*y[Fi+1]; \ + Xa=Xf+0.001; Yb=Yf+0.001; \ + Factor=1-(((Xf2=sqr(Xf))+(Yf2=sqr(Yf)))*AmpVr2); \ + Factor1=1-((sqr(Xa)+Yf2)*AmpVr2); \ + Factor2=1-((Xf2+sqr(Yb))*AmpVr2); \ + VertX=Factor*Xf; VertY=Factor*Yf; VertZ=Factor*Zf; \ + NeiAX=Factor1*Xa-VertX; NeiAY=Factor1*Yf-VertY; NeiAZ=Factor1*Zf-VertZ; \ + NeiBX=Factor2*Xf-VertX; NeiBY=Factor2*Yb-VertY; NeiBZ=Factor2*Zf-VertZ; \ + glNormal3f(VectMul(NeiAX, NeiAY, NeiAZ, NeiBX, NeiBY, NeiBZ)); \ + glVertex3f(VertX, VertY, VertZ); \ + \ + Xf=(float)(Ri-Ti-1)*x[Fi] + (float)Ti*x[Fi+1]; \ + Yf=(float)(Ri-Ti-1)*y[Fi] + (float)Ti*y[Fi+1]; \ + Xa=Xf+0.001; Yb=Yf+0.001; \ + Factor=1-(((Xf2=sqr(Xf))+(Yf2=sqr(Yf)))*AmpVr2); \ + Factor1=1-((sqr(Xa)+Yf2)*AmpVr2); \ + Factor2=1-((Xf2+sqr(Yb))*AmpVr2); \ + VertX=Factor*Xf; VertY=Factor*Yf; VertZ=Factor*Zf; \ + NeiAX=Factor1*Xa-VertX; NeiAY=Factor1*Yf-VertY; NeiAZ=Factor1*Zf-VertZ; \ + NeiBX=Factor2*Xf-VertX; NeiBY=Factor2*Yb-VertY; NeiBZ=Factor2*Zf-VertZ; \ + glNormal3f(VectMul(NeiAX, NeiAY, NeiAZ, NeiBX, NeiBY, NeiBZ)); \ + glVertex3f(VertX, VertY, VertZ); \ + \ + } \ + Xf=(float)Ri*x[Fi+1]; \ + Yf=(float)Ri*y[Fi+1]; \ + Xa=Xf+0.001; Yb=Yf+0.001; \ + Factor=1-(((Xf2=sqr(Xf))+(Yf2=sqr(Yf)))*AmpVr2); \ + Factor1=1-((sqr(Xa)+Yf2)*AmpVr2); \ + Factor2=1-((Xf2+sqr(Yb))*AmpVr2); \ + VertX=Factor*Xf; VertY=Factor*Yf; VertZ=Factor*Zf; \ + NeiAX=Factor1*Xa-VertX; NeiAY=Factor1*Yf-VertY; NeiAZ=Factor1*Zf-VertZ; \ + NeiBX=Factor2*Xf-VertX; NeiBY=Factor2*Yb-VertY; NeiBZ=Factor2*Zf-VertZ; \ + glNormal3f(VectMul(NeiAX, NeiAY, NeiAZ, NeiBX, NeiBY, NeiBZ)); \ + glVertex3f(VertX, VertY, VertZ); \ + glEnd(); \ + } \ + } \ +} + +static void draw_tetra( void ) +{ + GLuint list; + + list = glGenLists( 1 ); + glNewList( list, GL_COMPILE ); + TRIANGLE(2,seno,edgedivisions,0.5/SQRT6); + glEndList(); + + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[0]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,0,1); + glRotatef(-tetraangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[1]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+tetraangle,0.5,SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[2]); + glCallList(list); + glPopMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+tetraangle,0.5,-SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[3]); + glCallList(list); + + glDeleteLists(list,1); +} + +static void draw_cube( void ) +{ + GLuint list; + + list = glGenLists( 1 ); + glNewList( list, GL_COMPILE ); + SQUARE(2, seno, edgedivisions, 0.5) + glEndList(); + + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[0]); + glCallList(list); + glRotatef(cubeangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[1]); + glCallList(list); + glRotatef(cubeangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[2]); + glCallList(list); + glRotatef(cubeangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[3]); + glCallList(list); + glRotatef(cubeangle,0,1,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[4]); + glCallList(list); + glRotatef(2*cubeangle,0,1,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[5]); + glCallList(list); + + glDeleteLists(list,1); +} + +static void draw_octa( void ) +{ + GLuint list; + + list = glGenLists( 1 ); + glNewList( list, GL_COMPILE ); + TRIANGLE(2,seno,edgedivisions,1/SQRT6); + glEndList(); + + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[0]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,0,1); + glRotatef(-180+octaangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[1]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-octaangle,0.5,SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[2]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-octaangle,0.5,-SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[3]); + glCallList(list); + glPopMatrix(); + glRotatef(180,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[4]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,0,1); + glRotatef(-180+octaangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[5]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-octaangle,0.5,SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[6]); + glCallList(list); + glPopMatrix(); + glRotatef(180,0,1,0); + glRotatef(-octaangle,0.5,-SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[7]); + glCallList(list); + + glDeleteLists(list,1); +} + +static void draw_dodeca( void ) +{ + GLuint list; + +#define TAU ((SQRT5+1)/2) + + list = glGenLists( 1 ); + glNewList( list, GL_COMPILE ); + PENTAGON(1,seno,edgedivisions,sqr(TAU) * sqrt((TAU+2)/5) / 2); + glEndList(); + + glPushMatrix(); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[0]); + glCallList(list); + glRotatef(180,0,0,1); + glPushMatrix(); + glRotatef(-dodecaangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[1]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(-dodecaangle,cos72,sin72,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[2]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(-dodecaangle,cos72,-sin72,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[3]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(dodecaangle,cos36,-sin36,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[4]); + glCallList(list); + glPopMatrix(); + glRotatef(dodecaangle,cos36,sin36,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[5]); + glCallList(list); + glPopMatrix(); + glRotatef(180,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[6]); + glCallList(list); + glRotatef(180,0,0,1); + glPushMatrix(); + glRotatef(-dodecaangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[7]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(-dodecaangle,cos72,sin72,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[8]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(-dodecaangle,cos72,-sin72,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[9]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(dodecaangle,cos36,-sin36,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[10]); + glCallList(list); + glPopMatrix(); + glRotatef(dodecaangle,cos36,sin36,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[11]); + glCallList(list); + + glDeleteLists(list,1); +} + +static void draw_ico( void ) +{ + GLuint list; + + list = glGenLists( 1 ); + glNewList( list, GL_COMPILE ); + TRIANGLE(1.5,seno,edgedivisions,(3*SQRT3+SQRT15)/12); + glEndList(); + + glPushMatrix(); + + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[0]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,0,1); + glRotatef(-icoangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[1]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[2]); + glCallList(list); + glPopMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,-SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[3]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[4]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[5]); + glCallList(list); + glPopMatrix(); + glRotatef(180,0,0,1); + glRotatef(-icoangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[6]); + glCallList(list); + glPopMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,-SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[7]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,-SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[8]); + glCallList(list); + glPopMatrix(); + glRotatef(180,0,0,1); + glRotatef(-icoangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[9]); + glCallList(list); + glPopMatrix(); + glRotatef(180,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[10]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,0,1); + glRotatef(-icoangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[11]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[12]); + glCallList(list); + glPopMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,-SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[13]); + glCallList(list); + glPopMatrix(); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[14]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[15]); + glCallList(list); + glPopMatrix(); + glRotatef(180,0,0,1); + glRotatef(-icoangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[16]); + glCallList(list); + glPopMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,-SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[17]); + glCallList(list); + glPushMatrix(); + glRotatef(180,0,1,0); + glRotatef(-180+icoangle,0.5,-SQRT3/2,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[18]); + glCallList(list); + glPopMatrix(); + glRotatef(180,0,0,1); + glRotatef(-icoangle,1,0,0); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[19]); + glCallList(list); + + glDeleteLists(list,1); +} + +static void draw ( void ) { + glClear( /*GL_COLOR_BUFFER_BIT |*/ GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + + glTranslatef( 0.0, 0.0, -10.0 ); + glScalef( Scale*WindH/WindW, Scale, Scale ); + glTranslatef(2.5*WindW/WindH*sin(step*1.11),2.5*cos(step*1.25*1.11),0); + glRotatef(step*100,1,0,0); + glRotatef(step*95,0,1,0); + glRotatef(step*90,0,0,1); + + seno=(sin(step)+1.0/3.0)*(4.0/5.0)*Magnitude; + + draw_object(); + + glPopMatrix(); + + glFlush(); + + step+=0.05; +} + +static void reshape( int width, int height ) +{ + glViewport(0, 0, WindW=(GLint)width, WindH=(GLint)height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 ); + glMatrixMode(GL_MODELVIEW); +} + +static void pinit(void) +{ + switch(object) { + case 1: + draw_object=draw_tetra; + MaterialColor[0]=MaterialRed; + MaterialColor[1]=MaterialGreen; + MaterialColor[2]=MaterialBlue; + MaterialColor[3]=MaterialWhite; + edgedivisions=tetradivisions; + Magnitude=2.5; + break; + case 2: + draw_object=draw_cube; + MaterialColor[0]=MaterialRed; + MaterialColor[1]=MaterialGreen; + MaterialColor[2]=MaterialCyan; + MaterialColor[3]=MaterialMagenta; + MaterialColor[4]=MaterialYellow; + MaterialColor[5]=MaterialBlue; + edgedivisions=cubedivisions; + Magnitude=2.0; + break; + case 3: + draw_object=draw_octa; + MaterialColor[0]=MaterialRed; + MaterialColor[1]=MaterialGreen; + MaterialColor[2]=MaterialBlue; + MaterialColor[3]=MaterialWhite; + MaterialColor[4]=MaterialCyan; + MaterialColor[5]=MaterialMagenta; + MaterialColor[6]=MaterialGray; + MaterialColor[7]=MaterialYellow; + edgedivisions=octadivisions; + Magnitude=2.5; + break; + case 4: + draw_object=draw_dodeca; + MaterialColor[ 0]=MaterialRed; + MaterialColor[ 1]=MaterialGreen; + MaterialColor[ 2]=MaterialCyan; + MaterialColor[ 3]=MaterialBlue; + MaterialColor[ 4]=MaterialMagenta; + MaterialColor[ 5]=MaterialYellow; + MaterialColor[ 6]=MaterialGreen; + MaterialColor[ 7]=MaterialCyan; + MaterialColor[ 8]=MaterialRed; + MaterialColor[ 9]=MaterialMagenta; + MaterialColor[10]=MaterialBlue; + MaterialColor[11]=MaterialYellow; + edgedivisions=dodecadivisions; + Magnitude=2.0; + break; + case 5: + draw_object=draw_ico; + MaterialColor[ 0]=MaterialRed; + MaterialColor[ 1]=MaterialGreen; + MaterialColor[ 2]=MaterialBlue; + MaterialColor[ 3]=MaterialCyan; + MaterialColor[ 4]=MaterialYellow; + MaterialColor[ 5]=MaterialMagenta; + MaterialColor[ 6]=MaterialRed; + MaterialColor[ 7]=MaterialGreen; + MaterialColor[ 8]=MaterialBlue; + MaterialColor[ 9]=MaterialWhite; + MaterialColor[10]=MaterialCyan; + MaterialColor[11]=MaterialYellow; + MaterialColor[12]=MaterialMagenta; + MaterialColor[13]=MaterialRed; + MaterialColor[14]=MaterialGreen; + MaterialColor[15]=MaterialBlue; + MaterialColor[16]=MaterialCyan; + MaterialColor[17]=MaterialYellow; + MaterialColor[18]=MaterialMagenta; + MaterialColor[19]=MaterialGray; + edgedivisions=icodivisions; + Magnitude=2.5; + break; + } + if (mono) { + int loop; + for (loop=0; loop<20; loop++) MaterialColor[loop]=MaterialGray; + } + if (smooth) { + glShadeModel( GL_SMOOTH ); + } else { + glShadeModel( GL_FLAT ); + } + +} + +static void init(void) +{ + printf("Morph 3D - Shows morphing platonic polyhedra\n"); + printf("Author: Marcelo Fernandes Vianna ([email protected])\n\n"); + printf(" [1] - Tetrahedron\n"); + printf(" [2] - Hexahedron (Cube)\n"); + printf(" [3] - Octahedron\n"); + printf(" [4] - Dodecahedron\n"); + printf(" [5] - Icosahedron\n"); + printf("[SPACE] - Toggle colored faces\n"); + printf("[RETURN] - Toggle smooth/flat shading\n"); + printf(" [ESC] - Quit\n"); + + object=1; + + glClearDepth(1.0); + glClearColor( 0.0, 0.0, 0.0, 0.0 ); + glColor3f( 1.0, 1.0, 1.0 ); + + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + glFlush(); + primary->Flip( primary, NULL, 0 ); + + glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); + glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); + glLightfv(GL_LIGHT0, GL_POSITION, position0); + glLightfv(GL_LIGHT1, GL_AMBIENT, ambient); + glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse); + glLightfv(GL_LIGHT1, GL_POSITION, position1); + glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); + glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_LIGHT1); + glEnable(GL_DEPTH_TEST); + glEnable(GL_NORMALIZE); + + glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_shininess); + glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_specular); + + glHint(GL_FOG_HINT, GL_FASTEST); + glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); + glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST); + + pinit(); +} + +int main( int argc, char *argv[] ) +{ + int quit = 0; + DFBResult err; + DFBSurfaceDescription dsc; + + DFBCHECK(DirectFBInit( &argc, &argv )); + + /* create the super interface */ + DFBCHECK(DirectFBCreate( &dfb )); + + /* create an event buffer for all devices with these caps */ + DFBCHECK(dfb->CreateInputEventBuffer( dfb, DICAPS_KEYS, DFB_FALSE, &events )); + + /* set our cooperative level to DFSCL_FULLSCREEN + for exclusive access to the primary layer */ + dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN ); + + /* get the primary surface, i.e. the surface of the + primary layer we have exclusive access to */ + dsc.flags = DSDESC_CAPS; + dsc.caps = DSCAPS_PRIMARY | DSCAPS_DOUBLE; + + DFBCHECK(dfb->CreateSurface( dfb, &dsc, &primary )); + + /* get the size of the surface and fill it */ + DFBCHECK(primary->GetSize( primary, &screen_width, &screen_height )); + DFBCHECK(primary->FillRectangle( primary, 0, 0, + screen_width, screen_height )); + + /* create the default font and set it */ + DFBCHECK(dfb->CreateFont( dfb, NULL, NULL, &font )); + DFBCHECK(primary->SetFont( primary, font )); + + /* get the GL context */ + DFBCHECK(primary->GetGL( primary, &primary_gl )); + + DFBCHECK(primary_gl->Lock( primary_gl )); + + init(); + reshape(screen_width, screen_height); + + DFBCHECK(primary_gl->Unlock( primary_gl )); + + T0 = get_millis(); + + while (!quit) { + DFBInputEvent evt; + unsigned long t; + + primary->Clear( primary, 0, 0, 0, 0 ); + + DFBCHECK(primary_gl->Lock( primary_gl )); + + draw(); + + DFBCHECK(primary_gl->Unlock( primary_gl )); + + if (fps) { + char buf[64]; + + sprintf(buf, "%4.1f FPS\n", fps); + primary->SetColor( primary, 0xff, 0, 0, 0xff ); + primary->DrawString( primary, buf, -1, screen_width - 5, 5, DSTF_TOPRIGHT ); + } + + primary->Flip( primary, NULL, 0 ); + Frames++; + + + t = get_millis(); + if (t - T0 >= 1000) { + GLfloat seconds = (t - T0) / 1000.0; + + fps = Frames / seconds; + + T0 = t; + Frames = 0; + } + + + while (events->GetEvent( events, DFB_EVENT(&evt) ) == DFB_OK) { + switch (evt.type) { + case DIET_KEYPRESS: + switch (evt.key_symbol) { + case DIKS_ESCAPE: + quit = 1; + break; + case DIKS_1: object=1; break; + case DIKS_2: object=2; break; + case DIKS_3: object=3; break; + case DIKS_4: object=4; break; + case DIKS_5: object=5; break; + case DIKS_SPACE: mono^=1; break; + case DIKS_ENTER: smooth^=1; break; + default: + ; + } + pinit(); + break; + default: + ; + } + } + } + + /* release our interfaces to shutdown DirectFB */ + primary_gl->Release( primary_gl ); + primary->Release( primary ); + font->Release( font ); + events->Release( events ); + dfb->Release( dfb ); + + return 0; +} + |