[go: nahoru, domu]

1/* San Angeles Observation OpenGL ES version example
2 * Copyright 2004-2005 Jetro Lauha
3 * All rights reserved.
4 * Web: http://iki.fi/jetro/
5 *
6 * This source is free software; you can redistribute it and/or
7 * modify it under the terms of EITHER:
8 *   (1) The GNU Lesser General Public License as published by the Free
9 *       Software Foundation; either version 2.1 of the License, or (at
10 *       your option) any later version. The text of the GNU Lesser
11 *       General Public License is included with this source in the
12 *       file LICENSE-LGPL.txt.
13 *   (2) The BSD-style license that is included with this source in
14 *       the file LICENSE-BSD.txt.
15 *
16 * This source is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
19 * LICENSE-LGPL.txt and LICENSE-BSD.txt for more details.
20 *
21 * $Id: demo.c,v 1.10 2005/02/08 20:54:39 tonic Exp $
22 * $Revision: 1.10 $
23 */
24
25#include <stdlib.h>
26#include <math.h>
27#include <float.h>
28#include <assert.h>
29
30#include <GLES/gl.h>
31
32#include "app.h"
33#include "shapes.h"
34#include "cams.h"
35
36
37// Total run length is 20 * camera track base unit length (see cams.h).
38#define RUN_LENGTH  (20 * CAMTRACK_LEN)
39#undef PI
40#define PI 3.1415926535897932f
41#define RANDOM_UINT_MAX 65535
42
43
44static unsigned long sRandomSeed = 0;
45
46static void seedRandom(unsigned long seed)
47{
48    sRandomSeed = seed;
49}
50
51static unsigned long randomUInt()
52{
53    sRandomSeed = sRandomSeed * 0x343fd + 0x269ec3;
54    return sRandomSeed >> 16;
55}
56
57
58// Capped conversion from float to fixed.
59static long floatToFixed(float value)
60{
61    if (value < -32768) value = -32768;
62    if (value > 32767) value = 32767;
63    return (long)(value * 65536);
64}
65
66#define FIXED(value) floatToFixed(value)
67
68
69// Definition of one GL object in this demo.
70typedef struct {
71    /* Vertex array and color array are enabled for all objects, so their
72     * pointers must always be valid and non-NULL. Normal array is not
73     * used by the ground plane, so when its pointer is NULL then normal
74     * array usage is disabled.
75     *
76     * Vertex array is supposed to use GL_FIXED datatype and stride 0
77     * (i.e. tightly packed array). Color array is supposed to have 4
78     * components per color with GL_UNSIGNED_BYTE datatype and stride 0.
79     * Normal array is supposed to use GL_FIXED datatype and stride 0.
80     */
81    GLfixed *vertexArray;
82    GLubyte *colorArray;
83    GLfixed *normalArray;
84    GLint vertexComponents;
85    GLsizei count;
86} GLOBJECT;
87
88
89static long sStartTick = 0;
90static long sTick = 0;
91
92static int sCurrentCamTrack = 0;
93static long sCurrentCamTrackStartTick = 0;
94static long sNextCamTrackStartTick = 0x7fffffff;
95
96static GLOBJECT *sSuperShapeObjects[SUPERSHAPE_COUNT] = { NULL };
97static GLOBJECT *sGroundPlane = NULL;
98
99
100typedef struct {
101    float x, y, z;
102} VECTOR3;
103
104
105static void freeGLObject(GLOBJECT *object)
106{
107    if (object == NULL)
108        return;
109    free(object->normalArray);
110    free(object->colorArray);
111    free(object->vertexArray);
112    free(object);
113}
114
115
116static GLOBJECT * newGLObject(long vertices, int vertexComponents,
117                              int useNormalArray)
118{
119    GLOBJECT *result;
120    result = (GLOBJECT *)malloc(sizeof(GLOBJECT));
121    if (result == NULL)
122        return NULL;
123    result->count = vertices;
124    result->vertexComponents = vertexComponents;
125    result->vertexArray = (GLfixed *)malloc(vertices * vertexComponents *
126                                            sizeof(GLfixed));
127    result->colorArray = (GLubyte *)malloc(vertices * 4 * sizeof(GLubyte));
128    if (useNormalArray)
129    {
130        result->normalArray = (GLfixed *)malloc(vertices * 3 *
131                                                sizeof(GLfixed));
132    }
133    else
134        result->normalArray = NULL;
135    if (result->vertexArray == NULL ||
136        result->colorArray == NULL ||
137        (useNormalArray && result->normalArray == NULL))
138    {
139        freeGLObject(result);
140        return NULL;
141    }
142    return result;
143}
144
145
146static void drawGLObject(GLOBJECT *object)
147{
148    assert(object != NULL);
149
150    glVertexPointer(object->vertexComponents, GL_FIXED,
151                    0, object->vertexArray);
152    glColorPointer(4, GL_UNSIGNED_BYTE, 0, object->colorArray);
153
154    // Already done in initialization:
155    //glEnableClientState(GL_VERTEX_ARRAY);
156    //glEnableClientState(GL_COLOR_ARRAY);
157
158    if (object->normalArray)
159    {
160        glNormalPointer(GL_FIXED, 0, object->normalArray);
161        glEnableClientState(GL_NORMAL_ARRAY);
162    }
163    else
164        glDisableClientState(GL_NORMAL_ARRAY);
165    glDrawArrays(GL_TRIANGLES, 0, object->count);
166}
167
168
169static void vector3Sub(VECTOR3 *dest, VECTOR3 *v1, VECTOR3 *v2)
170{
171    dest->x = v1->x - v2->x;
172    dest->y = v1->y - v2->y;
173    dest->z = v1->z - v2->z;
174}
175
176
177static void superShapeMap(VECTOR3 *point, float r1, float r2, float t, float p)
178{
179    // sphere-mapping of supershape parameters
180    point->x = (float)(cos(t) * cos(p) / r1 / r2);
181    point->y = (float)(sin(t) * cos(p) / r1 / r2);
182    point->z = (float)(sin(p) / r2);
183}
184
185
186static float ssFunc(const float t, const float *p)
187{
188    return (float)(pow(pow(fabs(cos(p[0] * t / 4)) / p[1], p[4]) +
189                       pow(fabs(sin(p[0] * t / 4)) / p[2], p[5]), 1 / p[3]));
190}
191
192
193// Creates and returns a supershape object.
194// Based on Paul Bourke's POV-Ray implementation.
195// http://astronomy.swin.edu.au/~pbourke/povray/supershape/
196static GLOBJECT * createSuperShape(const float *params)
197{
198    const int resol1 = (int)params[SUPERSHAPE_PARAMS - 3];
199    const int resol2 = (int)params[SUPERSHAPE_PARAMS - 2];
200    // latitude 0 to pi/2 for no mirrored bottom
201    // (latitudeBegin==0 for -pi/2 to pi/2 originally)
202    const int latitudeBegin = resol2 / 4;
203    const int latitudeEnd = resol2 / 2;    // non-inclusive
204    const int longitudeCount = resol1;
205    const int latitudeCount = latitudeEnd - latitudeBegin;
206    const long triangleCount = longitudeCount * latitudeCount * 2;
207    const long vertices = triangleCount * 3;
208    GLOBJECT *result;
209    float baseColor[3];
210    int a, longitude, latitude;
211    long currentVertex, currentQuad;
212
213    result = newGLObject(vertices, 3, 1);
214    if (result == NULL)
215        return NULL;
216
217    for (a = 0; a < 3; ++a)
218        baseColor[a] = ((randomUInt() % 155) + 100) / 255.f;
219
220    currentQuad = 0;
221    currentVertex = 0;
222
223    // longitude -pi to pi
224    for (longitude = 0; longitude < longitudeCount; ++longitude)
225    {
226
227        // latitude 0 to pi/2
228        for (latitude = latitudeBegin; latitude < latitudeEnd; ++latitude)
229        {
230            float t1 = -PI + longitude * 2 * PI / resol1;
231            float t2 = -PI + (longitude + 1) * 2 * PI / resol1;
232            float p1 = -PI / 2 + latitude * 2 * PI / resol2;
233            float p2 = -PI / 2 + (latitude + 1) * 2 * PI / resol2;
234            float r0, r1, r2, r3;
235
236            r0 = ssFunc(t1, params);
237            r1 = ssFunc(p1, &params[6]);
238            r2 = ssFunc(t2, params);
239            r3 = ssFunc(p2, &params[6]);
240
241            if (r0 != 0 && r1 != 0 && r2 != 0 && r3 != 0)
242            {
243                VECTOR3 pa, pb, pc, pd;
244                VECTOR3 v1, v2, n;
245                float ca;
246                int i;
247                //float lenSq, invLenSq;
248
249                superShapeMap(&pa, r0, r1, t1, p1);
250                superShapeMap(&pb, r2, r1, t2, p1);
251                superShapeMap(&pc, r2, r3, t2, p2);
252                superShapeMap(&pd, r0, r3, t1, p2);
253
254                // kludge to set lower edge of the object to fixed level
255                if (latitude == latitudeBegin + 1)
256                    pa.z = pb.z = 0;
257
258                vector3Sub(&v1, &pb, &pa);
259                vector3Sub(&v2, &pd, &pa);
260
261                // Calculate normal with cross product.
262                /*   i    j    k      i    j
263                 * v1.x v1.y v1.z | v1.x v1.y
264                 * v2.x v2.y v2.z | v2.x v2.y
265                 */
266
267                n.x = v1.y * v2.z - v1.z * v2.y;
268                n.y = v1.z * v2.x - v1.x * v2.z;
269                n.z = v1.x * v2.y - v1.y * v2.x;
270
271                /* Pre-normalization of the normals is disabled here because
272                 * they will be normalized anyway later due to automatic
273                 * normalization (GL_NORMALIZE). It is enabled because the
274                 * objects are scaled with glScale.
275                 */
276                /*
277                lenSq = n.x * n.x + n.y * n.y + n.z * n.z;
278                invLenSq = (float)(1 / sqrt(lenSq));
279                n.x *= invLenSq;
280                n.y *= invLenSq;
281                n.z *= invLenSq;
282                */
283
284                ca = pa.z + 0.5f;
285
286                for (i = currentVertex * 3;
287                     i < (currentVertex + 6) * 3;
288                     i += 3)
289                {
290                    result->normalArray[i] = FIXED(n.x);
291                    result->normalArray[i + 1] = FIXED(n.y);
292                    result->normalArray[i + 2] = FIXED(n.z);
293                }
294                for (i = currentVertex * 4;
295                     i < (currentVertex + 6) * 4;
296                     i += 4)
297                {
298                    int a, color[3];
299                    for (a = 0; a < 3; ++a)
300                    {
301                        color[a] = (int)(ca * baseColor[a] * 255);
302                        if (color[a] > 255) color[a] = 255;
303                    }
304                    result->colorArray[i] = (GLubyte)color[0];
305                    result->colorArray[i + 1] = (GLubyte)color[1];
306                    result->colorArray[i + 2] = (GLubyte)color[2];
307                    result->colorArray[i + 3] = 0;
308                }
309                result->vertexArray[currentVertex * 3] = FIXED(pa.x);
310                result->vertexArray[currentVertex * 3 + 1] = FIXED(pa.y);
311                result->vertexArray[currentVertex * 3 + 2] = FIXED(pa.z);
312                ++currentVertex;
313                result->vertexArray[currentVertex * 3] = FIXED(pb.x);
314                result->vertexArray[currentVertex * 3 + 1] = FIXED(pb.y);
315                result->vertexArray[currentVertex * 3 + 2] = FIXED(pb.z);
316                ++currentVertex;
317                result->vertexArray[currentVertex * 3] = FIXED(pd.x);
318                result->vertexArray[currentVertex * 3 + 1] = FIXED(pd.y);
319                result->vertexArray[currentVertex * 3 + 2] = FIXED(pd.z);
320                ++currentVertex;
321                result->vertexArray[currentVertex * 3] = FIXED(pb.x);
322                result->vertexArray[currentVertex * 3 + 1] = FIXED(pb.y);
323                result->vertexArray[currentVertex * 3 + 2] = FIXED(pb.z);
324                ++currentVertex;
325                result->vertexArray[currentVertex * 3] = FIXED(pc.x);
326                result->vertexArray[currentVertex * 3 + 1] = FIXED(pc.y);
327                result->vertexArray[currentVertex * 3 + 2] = FIXED(pc.z);
328                ++currentVertex;
329                result->vertexArray[currentVertex * 3] = FIXED(pd.x);
330                result->vertexArray[currentVertex * 3 + 1] = FIXED(pd.y);
331                result->vertexArray[currentVertex * 3 + 2] = FIXED(pd.z);
332                ++currentVertex;
333            } // r0 && r1 && r2 && r3
334            ++currentQuad;
335        } // latitude
336    } // longitude
337
338    // Set number of vertices in object to the actual amount created.
339    result->count = currentVertex;
340
341    return result;
342}
343
344
345static GLOBJECT * createGroundPlane()
346{
347    const int scale = 4;
348    const int yBegin = -15, yEnd = 15;    // ends are non-inclusive
349    const int xBegin = -15, xEnd = 15;
350    const long triangleCount = (yEnd - yBegin) * (xEnd - xBegin) * 2;
351    const long vertices = triangleCount * 3;
352    GLOBJECT *result;
353    int x, y;
354    long currentVertex, currentQuad;
355
356    result = newGLObject(vertices, 2, 0);
357    if (result == NULL)
358        return NULL;
359
360    currentQuad = 0;
361    currentVertex = 0;
362
363    for (y = yBegin; y < yEnd; ++y)
364    {
365        for (x = xBegin; x < xEnd; ++x)
366        {
367            GLubyte color;
368            int i, a;
369            color = (GLubyte)((randomUInt() & 0x5f) + 81);  // 101 1111
370            for (i = currentVertex * 4; i < (currentVertex + 6) * 4; i += 4)
371            {
372                result->colorArray[i] = color;
373                result->colorArray[i + 1] = color;
374                result->colorArray[i + 2] = color;
375                result->colorArray[i + 3] = 0;
376            }
377
378            // Axis bits for quad triangles:
379            // x: 011100 (0x1c), y: 110001 (0x31)  (clockwise)
380            // x: 001110 (0x0e), y: 100011 (0x23)  (counter-clockwise)
381            for (a = 0; a < 6; ++a)
382            {
383                const int xm = x + ((0x1c >> a) & 1);
384                const int ym = y + ((0x31 >> a) & 1);
385                const float m = (float)(cos(xm * 2) * sin(ym * 4) * 0.75f);
386                result->vertexArray[currentVertex * 2] =
387                    FIXED(xm * scale + m);
388                result->vertexArray[currentVertex * 2 + 1] =
389                    FIXED(ym * scale + m);
390                ++currentVertex;
391            }
392            ++currentQuad;
393        }
394    }
395    return result;
396}
397
398
399static void drawGroundPlane()
400{
401    glDisable(GL_CULL_FACE);
402    glDisable(GL_DEPTH_TEST);
403    glEnable(GL_BLEND);
404    glBlendFunc(GL_ZERO, GL_SRC_COLOR);
405    glDisable(GL_LIGHTING);
406
407    drawGLObject(sGroundPlane);
408
409    glEnable(GL_LIGHTING);
410    glDisable(GL_BLEND);
411    glEnable(GL_DEPTH_TEST);
412}
413
414
415static void drawFadeQuad()
416{
417    static const GLfixed quadVertices[] = {
418        -0x10000, -0x10000,
419         0x10000, -0x10000,
420        -0x10000,  0x10000,
421         0x10000, -0x10000,
422         0x10000,  0x10000,
423        -0x10000,  0x10000
424    };
425
426    const int beginFade = sTick - sCurrentCamTrackStartTick;
427    const int endFade = sNextCamTrackStartTick - sTick;
428    const int minFade = beginFade < endFade ? beginFade : endFade;
429
430    if (minFade < 1024)
431    {
432        const GLfixed fadeColor = minFade << 6;
433        glColor4x(fadeColor, fadeColor, fadeColor, 0);
434
435        glDisable(GL_DEPTH_TEST);
436        glEnable(GL_BLEND);
437        glBlendFunc(GL_ZERO, GL_SRC_COLOR);
438        glDisable(GL_LIGHTING);
439
440        glMatrixMode(GL_MODELVIEW);
441        glLoadIdentity();
442
443        glMatrixMode(GL_PROJECTION);
444        glLoadIdentity();
445
446        glDisableClientState(GL_COLOR_ARRAY);
447        glDisableClientState(GL_NORMAL_ARRAY);
448        glVertexPointer(2, GL_FIXED, 0, quadVertices);
449        glDrawArrays(GL_TRIANGLES, 0, 6);
450
451        glEnableClientState(GL_COLOR_ARRAY);
452
453        glMatrixMode(GL_MODELVIEW);
454
455        glEnable(GL_LIGHTING);
456        glDisable(GL_BLEND);
457        glEnable(GL_DEPTH_TEST);
458    }
459}
460
461
462// Called from the app framework.
463void appInit()
464{
465    int a;
466
467    glEnable(GL_NORMALIZE);
468    glEnable(GL_DEPTH_TEST);
469    glDisable(GL_CULL_FACE);
470    glShadeModel(GL_FLAT);
471
472    glEnable(GL_LIGHTING);
473    glEnable(GL_LIGHT0);
474    glEnable(GL_LIGHT1);
475    glEnable(GL_LIGHT2);
476
477    glEnableClientState(GL_VERTEX_ARRAY);
478    glEnableClientState(GL_COLOR_ARRAY);
479
480    seedRandom(15);
481
482    for (a = 0; a < SUPERSHAPE_COUNT; ++a)
483    {
484        sSuperShapeObjects[a] = createSuperShape(sSuperShapeParams[a]);
485        assert(sSuperShapeObjects[a] != NULL);
486    }
487    sGroundPlane = createGroundPlane();
488    assert(sGroundPlane != NULL);
489}
490
491
492// Called from the app framework.
493void appDeinit()
494{
495    int a;
496    for (a = 0; a < SUPERSHAPE_COUNT; ++a)
497        freeGLObject(sSuperShapeObjects[a]);
498    freeGLObject(sGroundPlane);
499}
500
501
502static void gluPerspective(GLfloat fovy, GLfloat aspect,
503                           GLfloat zNear, GLfloat zFar)
504{
505    GLfloat xmin, xmax, ymin, ymax;
506
507    ymax = zNear * (GLfloat)tan(fovy * PI / 360);
508    ymin = -ymax;
509    xmin = ymin * aspect;
510    xmax = ymax * aspect;
511
512    glFrustumx((GLfixed)(xmin * 65536), (GLfixed)(xmax * 65536),
513               (GLfixed)(ymin * 65536), (GLfixed)(ymax * 65536),
514               (GLfixed)(zNear * 65536), (GLfixed)(zFar * 65536));
515}
516
517
518static void prepareFrame(int width, int height)
519{
520    glViewport(0, 0, width, height);
521
522    glClearColorx((GLfixed)(0.1f * 65536),
523                  (GLfixed)(0.2f * 65536),
524                  (GLfixed)(0.3f * 65536), 0x10000);
525    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
526
527    glMatrixMode(GL_PROJECTION);
528    glLoadIdentity();
529    gluPerspective(45, (float)width / height, 0.5f, 150);
530
531    glMatrixMode(GL_MODELVIEW);
532
533    glLoadIdentity();
534}
535
536
537static void configureLightAndMaterial()
538{
539    static GLfixed light0Position[] = { -0x40000, 0x10000, 0x10000, 0 };
540    static GLfixed light0Diffuse[] = { 0x10000, 0x6666, 0, 0x10000 };
541    static GLfixed light1Position[] = { 0x10000, -0x20000, -0x10000, 0 };
542    static GLfixed light1Diffuse[] = { 0x11eb, 0x23d7, 0x5999, 0x10000 };
543    static GLfixed light2Position[] = { -0x10000, 0, -0x40000, 0 };
544    static GLfixed light2Diffuse[] = { 0x11eb, 0x2b85, 0x23d7, 0x10000 };
545    static GLfixed materialSpecular[] = { 0x10000, 0x10000, 0x10000, 0x10000 };
546
547    glLightxv(GL_LIGHT0, GL_POSITION, light0Position);
548    glLightxv(GL_LIGHT0, GL_DIFFUSE, light0Diffuse);
549    glLightxv(GL_LIGHT1, GL_POSITION, light1Position);
550    glLightxv(GL_LIGHT1, GL_DIFFUSE, light1Diffuse);
551    glLightxv(GL_LIGHT2, GL_POSITION, light2Position);
552    glLightxv(GL_LIGHT2, GL_DIFFUSE, light2Diffuse);
553    glMaterialxv(GL_FRONT_AND_BACK, GL_SPECULAR, materialSpecular);
554
555    glMaterialx(GL_FRONT_AND_BACK, GL_SHININESS, 60 << 16);
556    glEnable(GL_COLOR_MATERIAL);
557}
558
559
560static void drawModels(float zScale)
561{
562    const int translationScale = 9;
563    int x, y;
564
565    seedRandom(9);
566
567    glScalex(1 << 16, 1 << 16, (GLfixed)(zScale * 65536));
568
569    for (y = -5; y <= 5; ++y)
570    {
571        for (x = -5; x <= 5; ++x)
572        {
573            float buildingScale;
574            GLfixed fixedScale;
575
576            int curShape = randomUInt() % SUPERSHAPE_COUNT;
577            buildingScale = sSuperShapeParams[curShape][SUPERSHAPE_PARAMS - 1];
578            fixedScale = (GLfixed)(buildingScale * 65536);
579
580            glPushMatrix();
581            glTranslatex((x * translationScale) * 65536,
582                         (y * translationScale) * 65536,
583                         0);
584            glRotatex((GLfixed)((randomUInt() % 360) << 16), 0, 0, 1 << 16);
585            glScalex(fixedScale, fixedScale, fixedScale);
586
587            drawGLObject(sSuperShapeObjects[curShape]);
588            glPopMatrix();
589        }
590    }
591
592    for (x = -2; x <= 2; ++x)
593    {
594        const int shipScale100 = translationScale * 500;
595        const int offs100 = x * shipScale100 + (sTick % shipScale100);
596        float offs = offs100 * 0.01f;
597        GLfixed fixedOffs = (GLfixed)(offs * 65536);
598        glPushMatrix();
599        glTranslatex(fixedOffs, -4 * 65536, 2 << 16);
600        drawGLObject(sSuperShapeObjects[SUPERSHAPE_COUNT - 1]);
601        glPopMatrix();
602        glPushMatrix();
603        glTranslatex(-4 * 65536, fixedOffs, 4 << 16);
604        glRotatex(90 << 16, 0, 0, 1 << 16);
605        drawGLObject(sSuperShapeObjects[SUPERSHAPE_COUNT - 1]);
606        glPopMatrix();
607    }
608}
609
610
611/* Following gluLookAt implementation is adapted from the
612 * Mesa 3D Graphics library. http://www.mesa3d.org
613 */
614static void gluLookAt(GLfloat eyex, GLfloat eyey, GLfloat eyez,
615	              GLfloat centerx, GLfloat centery, GLfloat centerz,
616	              GLfloat upx, GLfloat upy, GLfloat upz)
617{
618    GLfloat m[16];
619    GLfloat x[3], y[3], z[3];
620    GLfloat mag;
621
622    /* Make rotation matrix */
623
624    /* Z vector */
625    z[0] = eyex - centerx;
626    z[1] = eyey - centery;
627    z[2] = eyez - centerz;
628    mag = (float)sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
629    if (mag) {			/* mpichler, 19950515 */
630        z[0] /= mag;
631        z[1] /= mag;
632        z[2] /= mag;
633    }
634
635    /* Y vector */
636    y[0] = upx;
637    y[1] = upy;
638    y[2] = upz;
639
640    /* X vector = Y cross Z */
641    x[0] = y[1] * z[2] - y[2] * z[1];
642    x[1] = -y[0] * z[2] + y[2] * z[0];
643    x[2] = y[0] * z[1] - y[1] * z[0];
644
645    /* Recompute Y = Z cross X */
646    y[0] = z[1] * x[2] - z[2] * x[1];
647    y[1] = -z[0] * x[2] + z[2] * x[0];
648    y[2] = z[0] * x[1] - z[1] * x[0];
649
650    /* mpichler, 19950515 */
651    /* cross product gives area of parallelogram, which is < 1.0 for
652     * non-perpendicular unit-length vectors; so normalize x, y here
653     */
654
655    mag = (float)sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
656    if (mag) {
657        x[0] /= mag;
658        x[1] /= mag;
659        x[2] /= mag;
660    }
661
662    mag = (float)sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
663    if (mag) {
664        y[0] /= mag;
665        y[1] /= mag;
666        y[2] /= mag;
667    }
668
669#define M(row,col)  m[col*4+row]
670    M(0, 0) = x[0];
671    M(0, 1) = x[1];
672    M(0, 2) = x[2];
673    M(0, 3) = 0.0;
674    M(1, 0) = y[0];
675    M(1, 1) = y[1];
676    M(1, 2) = y[2];
677    M(1, 3) = 0.0;
678    M(2, 0) = z[0];
679    M(2, 1) = z[1];
680    M(2, 2) = z[2];
681    M(2, 3) = 0.0;
682    M(3, 0) = 0.0;
683    M(3, 1) = 0.0;
684    M(3, 2) = 0.0;
685    M(3, 3) = 1.0;
686#undef M
687    {
688        int a;
689        GLfixed fixedM[16];
690        for (a = 0; a < 16; ++a)
691            fixedM[a] = (GLfixed)(m[a] * 65536);
692        glMultMatrixx(fixedM);
693    }
694
695    /* Translate Eye to Origin */
696    glTranslatex((GLfixed)(-eyex * 65536),
697                 (GLfixed)(-eyey * 65536),
698                 (GLfixed)(-eyez * 65536));
699}
700
701
702static void camTrack()
703{
704    float lerp[5];
705    float eX, eY, eZ, cX, cY, cZ;
706    float trackPos;
707    CAMTRACK *cam;
708    long currentCamTick;
709    int a;
710
711    if (sNextCamTrackStartTick <= sTick)
712    {
713        ++sCurrentCamTrack;
714        sCurrentCamTrackStartTick = sNextCamTrackStartTick;
715    }
716    sNextCamTrackStartTick = sCurrentCamTrackStartTick +
717                             sCamTracks[sCurrentCamTrack].len * CAMTRACK_LEN;
718
719    cam = &sCamTracks[sCurrentCamTrack];
720    currentCamTick = sTick - sCurrentCamTrackStartTick;
721    trackPos = (float)currentCamTick / (CAMTRACK_LEN * cam->len);
722
723    for (a = 0; a < 5; ++a)
724        lerp[a] = (cam->src[a] + cam->dest[a] * trackPos) * 0.01f;
725
726    if (cam->dist)
727    {
728        float dist = cam->dist * 0.1f;
729        cX = lerp[0];
730        cY = lerp[1];
731        cZ = lerp[2];
732        eX = cX - (float)cos(lerp[3]) * dist;
733        eY = cY - (float)sin(lerp[3]) * dist;
734        eZ = cZ - lerp[4];
735    }
736    else
737    {
738        eX = lerp[0];
739        eY = lerp[1];
740        eZ = lerp[2];
741        cX = eX + (float)cos(lerp[3]);
742        cY = eY + (float)sin(lerp[3]);
743        cZ = eZ + lerp[4];
744    }
745    gluLookAt(eX, eY, eZ, cX, cY, cZ, 0, 0, 1);
746}
747
748
749// Called from the app framework.
750/* The tick is current time in milliseconds, width and height
751 * are the image dimensions to be rendered.
752 */
753void appRender(long tick, int width, int height)
754{
755    if (sStartTick == 0)
756        sStartTick = tick;
757    if (!gAppAlive)
758        return;
759
760    // Actual tick value is "blurred" a little bit.
761    sTick = (sTick + tick - sStartTick) >> 1;
762
763    // Terminate application after running through the demonstration once.
764    if (sTick >= RUN_LENGTH)
765    {
766        gAppAlive = 0;
767        return;
768    }
769
770    // Prepare OpenGL ES for rendering of the frame.
771    prepareFrame(width, height);
772
773    // Update the camera position and set the lookat.
774    camTrack();
775
776    // Configure environment.
777    configureLightAndMaterial();
778
779    // Draw the reflection by drawing models with negated Z-axis.
780    glPushMatrix();
781    drawModels(-1);
782    glPopMatrix();
783
784    // Blend the ground plane to the window.
785    drawGroundPlane();
786
787    // Draw all the models normally.
788    drawModels(1);
789
790    // Draw fade quad over whole window (when changing cameras).
791    drawFadeQuad();
792}
793