cleaned up a bunch of warnings
[freeglut] / progs / demos / Fractals / fractals.c
1 /* fractals.c */
2 /*
3  * Program to draw a fractal by Michael Barnsley's deterministic algorithm.
4  * Algorithm:
5  *  (1) Define the affine transformations (of the form r(i+1) = A r(i) + b )
6  *  (2) Find the stationary point for each transformation
7  *  (3) To draw:
8  *        - If you are at the lowest level, draw lines connecting all the stationary points
9  *        - If not, call the draw function recursively with each affine transformation applied
10  */
11
12 /*
13  * User Commands:
14  *  +,- - increment/decrement number of levels
15  *  PgUp, PgDn - increase/decrease scaling
16  *  Arrow keys - translate viewing section
17  *  r - reset view
18  *  Escape - quit
19  */
20
21 #include <GL/freeglut.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <math.h>
26 #define FGH_PI       3.14159265358979323846
27
28 typedef struct
29 {
30   double a00, a01, a10, a11 ;   /* Transformation matrix */
31   double b0, b1 ;               /* Constant vector added on */
32   double statx, staty ;         /* Coordinates of the stationary point */
33 }
34 AffineTrans ;
35
36 /* Number of levels to draw the fractal */
37 static int num_levels = 4 ;
38
39 /* The definition of the fractal */
40 static int num_trans ;
41 static AffineTrans *affine ;
42
43 /* Flag telling us to keep executing the main loop */
44 static int continue_in_main_loop = 1;
45
46 /* the window title */
47 char window_title [ 80 ] ;
48
49 /* The amount the view is translated and scaled */
50 double xwin = 0.0, ywin = 0.0 ;
51 double scale_factor = 1.0 ;
52
53 static void draw_level ( int num, double m00, double m01, double m10, double m11, double n0, double n1 )
54 {
55   /* Draw a fractal transformed by "M", "N" as passed in */
56   int i ;
57
58   if ( num == 0 )
59   {
60     double x0 = m00 * affine[0].statx + m01 * affine[0].staty + n0 ;
61     double y0 = m10 * affine[0].statx + m11 * affine[0].staty + n1 ;
62
63     for ( i = 1; i < num_trans; i++ )
64     {
65       double x1 = m00 * affine[i].statx + m01 * affine[i].staty + n0 ;
66       double y1 = m10 * affine[i].statx + m11 * affine[i].staty + n1 ;
67
68       glVertex2d ( x0, y0 ) ;
69       glVertex2d ( x1, y1 ) ;
70
71       x0 = x1 ;
72       y0 = y1 ;
73     }
74   }
75   else
76   {
77     /* Map each affine transformation in the fractal through the one passed in and call "draw_level" */
78
79     for ( i = 0; i < num_trans; i++ )
80     {
81       draw_level ( num-1, m00*affine[i].a00+m01*affine[i].a10,     m00*affine[i].a01+m01*affine[i].a11,
82                           m10*affine[i].a00+m11*affine[i].a10,     m10*affine[i].a01+m11*affine[i].a11,
83                           m00*affine[i].b0 +m01*affine[i].b1 + n0, m10*affine[i].b0 +m11*affine[i].b1  + n1 ) ;
84     }
85   }
86 }
87
88 static void 
89 Display(void)
90 {
91   glClear( GL_COLOR_BUFFER_BIT );
92
93   /* the curve */
94   glPushMatrix();
95   glScalef(2.5, 2.5, 2.5);
96
97   glColor4f(0.0, 0.0, 0.0, 1.0);
98   glBegin ( GL_LINES ) ;
99   draw_level ( num_levels, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0 );
100   glEnd () ;
101
102   glPopMatrix();
103   glutSwapBuffers();
104 }
105
106 static void 
107 Reshape(int width, int height)
108 {
109   float ar;
110   glViewport ( 0, 0, width, height ) ;
111   glMatrixMode ( GL_PROJECTION ) ;
112   glLoadIdentity();
113   ar = (float) width / (float) height ;
114   if( ar > 1 )
115       glFrustum ( -ar, ar, -1.0, 1.0, 2.0, 100.0 ) ;
116   else
117       glFrustum ( -1.0, 1.0, -1/ar, 1/ar, 2.0, 100.0 );
118   glMatrixMode ( GL_MODELVIEW ) ;
119   glLoadIdentity () ;
120   xwin = -1.0 ;
121   ywin =  0.0 ;
122   glTranslated ( xwin, ywin, -5.0 ) ;
123 }
124
125 static void 
126 Key(unsigned char key, int x, int y)
127 {
128   int need_redisplay = 1;
129   
130   switch (key) {
131   case 27:  /* Escape key */
132     continue_in_main_loop = 0 ;
133     break;
134
135   case '+' :
136     ++num_levels ;
137     break ;
138
139   case '-' :
140     if ( num_levels > 0 )
141       --num_levels ;
142     break ;
143
144   case 'r' :  case 'R' :
145     glMatrixMode ( GL_MODELVIEW ) ;
146     glLoadIdentity();
147     xwin = -1.0 ;
148     ywin = 0.0 ;
149     glTranslated ( xwin, ywin, -5.0 ) ;
150     break ;
151
152   default:
153     need_redisplay = 0;
154     break;
155   }
156   if (need_redisplay)
157     glutPostRedisplay();
158 }
159
160 static void 
161 Special(int key, int x, int y)
162 {
163   int need_redisplay = 1;
164
165   switch (key) {
166   case GLUT_KEY_UP :
167     glMatrixMode ( GL_MODELVIEW ) ;
168     ywin += 0.1 * scale_factor ;
169     glTranslated ( 0.0, 0.1 * scale_factor, 0.0 ) ;
170     break ;
171
172   case GLUT_KEY_DOWN :
173     glMatrixMode ( GL_MODELVIEW ) ;
174     ywin -= 0.1 * scale_factor ;
175     glTranslated ( 0.0, -0.1 * scale_factor, 0.0 ) ;
176     break ;
177
178   case GLUT_KEY_LEFT :
179     glMatrixMode ( GL_MODELVIEW ) ;
180     xwin -= 0.1 * scale_factor ;
181     glTranslated ( -0.1 * scale_factor, 0.0, 0.0 ) ;
182     break ;
183
184   case GLUT_KEY_RIGHT :
185     glMatrixMode ( GL_MODELVIEW ) ;
186     xwin += 0.1 * scale_factor ;
187     glTranslated ( 0.1 * scale_factor, 0.0, 0.0 ) ;
188     break ;
189
190   case GLUT_KEY_PAGE_UP :
191     glMatrixMode ( GL_MODELVIEW ) ;
192     glTranslated ( -xwin, -ywin, 0.0 ) ;
193     glScaled ( 1.25, 1.25, 1.25 ) ;
194     glTranslated ( xwin, ywin, 0.0 ) ;
195     scale_factor *= 0.8 ;
196     break ;
197
198   case GLUT_KEY_PAGE_DOWN :
199     glMatrixMode ( GL_MODELVIEW ) ;
200     glTranslated ( -xwin, -ywin, 0.0 ) ;
201     glScaled ( 0.8, 0.8, 0.8 ) ;
202     glTranslated ( xwin, ywin, 0.0 ) ;
203     scale_factor *= 1.25 ;
204     break ;
205
206   default:
207     need_redisplay = 0;
208     break;
209   }
210   if (need_redisplay)
211     glutPostRedisplay();
212 }
213
214
215 static void
216 checkedFGets ( char *s, int size, FILE *stream )
217 {
218   if ( fgets ( s, size, stream ) == NULL ) {
219     fprintf ( stderr, "fgets failed\n");
220     exit ( EXIT_FAILURE );
221   }
222 }
223
224
225 void readConfigFile ( char *fnme )
226 {
227   FILE *fptr = fopen ( fnme, "rt" ) ;
228   int i ;
229   char inputline [ 256 ] ;
230
231   if ( fptr )
232   {
233     /* Read a header line */
234     checkedFGets ( inputline, sizeof ( inputline ), fptr ) ;
235
236     /* Read a comment line */
237     checkedFGets ( inputline, sizeof ( inputline ), fptr ) ;
238
239     /* Read the window title */
240     checkedFGets ( inputline, sizeof ( inputline ), fptr ) ;
241     /* We assume here that this line will not exceed 79 characters plus a 
242        newline (window_title is 80 characters long). That'll cause a buffer 
243        overflow. For a simple program like  this, though, we're letting it 
244        slide! 
245     */
246     sscanf ( inputline, "%[a-zA-Z0-9!@#$%^&*()+=/\\_-\" ]", window_title ) ; 
247
248     /* Read a comment line */
249     checkedFGets ( inputline, sizeof ( inputline ), fptr ) ;
250
251     /* Read the number of affine transformations */
252     checkedFGets ( inputline, sizeof ( inputline ), fptr ) ;
253     sscanf ( inputline, "%d", &num_trans ) ;
254
255     affine = (AffineTrans *)malloc ( num_trans * sizeof(AffineTrans) ) ;
256
257     /* Read a comment line */
258     checkedFGets ( inputline, sizeof ( inputline ), fptr ) ;
259
260     for ( i = 0; i < num_trans; i++ )
261     {
262       /* Read an affine transformation definition */
263       checkedFGets ( inputline, sizeof ( inputline ), fptr ) ;
264       sscanf ( inputline, "%lf %lf %lf %lf %lf %lf", &affine[i].a00, &affine[i].a01,
265                        &affine[i].a10, &affine[i].a11, &affine[i].b0, &affine[i].b1 ) ;
266     }
267   }
268   else  /* No data file, set a default */
269   {
270     printf ( "ERROR opening file <%s>\n", fnme ) ;
271     strcpy ( window_title, "Koch Snowflake" ) ;
272     num_trans = 4 ;
273     affine = (AffineTrans *)malloc ( num_trans * sizeof(AffineTrans) ) ;
274     affine[0].a00 = 1/3. ;  affine[0].a01 = 0.00 ;  affine[0].a10 = 0.00 ;  affine[0].a11 = 1/3. ;
275     affine[0].b0 = 0.0 ;    affine[0].b1 = 0.0 ;
276
277     affine[1].a00 = 1/6. ;  affine[1].a01 = -1/3.*sin(FGH_PI/3.) ;   affine[1].a10 = 1/3.*sin(FGH_PI/3.) ;   affine[1].a11 = 1/6. ;
278     affine[1].b0 = 1/3. ;   affine[1].b1 = 0.0 ;
279
280     affine[2].a00 = 1/6. ;  affine[2].a01 = -1/3.*sin(-FGH_PI/3.) ;  affine[2].a10 = 1/3.*sin(-FGH_PI/3.) ;  affine[2].a11 = 1/6. ;
281     affine[2].b0 = 0.5 ;    affine[2].b1 = sqrt(3)/6. ;
282
283     affine[3].a00 = 1/3. ;  affine[3].a01 = 0.00 ;  affine[3].a10 = 0.00 ;  affine[3].a11 = 1/3. ;
284     affine[3].b0 = 2/3. ;   affine[3].b1 = 0.0 ;
285   }
286
287   for ( i = 0; i < num_trans; i++ )
288   {
289     double m00, m01, m10, m11 ;  /* Matrix "I" minus "A" */
290     double determ ;              /* Determinant of this matrix */
291
292     /* Calculate the stationary point */
293
294     m00 = 1.0 - affine[i].a00 ;
295     m01 =     - affine[i].a01 ;
296     m10 =     - affine[i].a10 ;
297     m11 = 1.0 - affine[i].a11 ;
298
299     determ = m00 * m11 - m01 * m10 ;
300
301     if ( fabs ( determ ) > 1.e-6 )
302     {
303       affine[i].statx = (  m11 * affine[i].b0 - m01 * affine[i].b1 ) / determ ;
304       affine[i].staty = ( -m10 * affine[i].b0 + m00 * affine[i].b1 ) / determ ;
305     }
306     else
307       affine[i].statx = affine[i].staty = 0.0 ;
308   }
309 }
310
311 int 
312 main(int argc, char *argv[])
313 {
314   glutInitWindowSize(500, 250);
315   glutInitWindowPosition ( 140, 140 );
316   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE );
317   glutInit(&argc, argv);
318
319   if ( argc > 1 )
320     readConfigFile ( argv[1] ) ;
321   else
322     readConfigFile ( "fractals.dat" ) ;
323
324   glutCreateWindow( window_title );
325
326   glClearColor(1.0, 1.0, 1.0, 1.0);
327
328   glutReshapeFunc(Reshape);
329   glutKeyboardFunc(Key);
330   glutSpecialFunc(Special);
331   glutDisplayFunc(Display);
332
333 #ifdef WIN32
334 #endif
335
336   while ( continue_in_main_loop )
337     glutMainLoopEvent();
338
339   printf ( "Back from the 'freeglut' main loop\n" ) ;
340
341   return 0;             /* ANSI C requires main to return int. */
342 }