| /* San Angeles Observation OpenGL ES version example |
| * Copyright 2004-2005 Jetro Lauha |
| * All rights reserved. |
| * Web: http://iki.fi/jetro/ |
| * |
| * This source is free software; you can redistribute it and/or |
| * modify it under the terms of EITHER: |
| * (1) The GNU Lesser General Public License as published by the Free |
| * Software Foundation; either version 2.1 of the License, or (at |
| * your option) any later version. The text of the GNU Lesser |
| * General Public License is included with this source in the |
| * file LICENSE-LGPL.txt. |
| * (2) The BSD-style license that is included with this source in |
| * the file LICENSE-BSD.txt. |
| * |
| * This source 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 files |
| * LICENSE-LGPL.txt and LICENSE-BSD.txt for more details. |
| * |
| * $Id: demo.c,v 1.10 2005/02/08 20:54:39 tonic Exp $ |
| * $Revision: 1.10 $ |
| */ |
| |
| // The GLES2 implementation is adapted from the javascript implementation |
| // upon WebGL by kwaters@. |
| |
| // The OpenGL implementation uses VBO extensions instead. |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <math.h> |
| #include <float.h> |
| #include <assert.h> |
| |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| #undef IMPORTGL_API |
| #undef IMPORTGL_FNPTRINIT |
| #include "importgl.h" |
| #include "matrixop.h" |
| #include "shader.h" |
| #else // SAN_ANGELES_OBSERVATION_GLES |
| #undef IMPORTVBO_API |
| #undef IMPORTVBO_FNPTRINIT |
| #include "importvbo.h" |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| |
| #include "app.h" |
| #include "shapes.h" |
| #include "cams.h" |
| |
| |
| // Total run length is 20 * camera track base unit length (see cams.h). |
| #define RUN_LENGTH (20 * CAMTRACK_LEN) |
| #undef PI |
| #define PI 3.1415926535897932f |
| #define RANDOM_UINT_MAX 65535 |
| |
| |
| static unsigned long sRandomSeed = 0; |
| |
| static void seedRandom(unsigned long seed) |
| { |
| sRandomSeed = seed; |
| } |
| |
| static unsigned long randomUInt() |
| { |
| sRandomSeed = sRandomSeed * 0x343fd + 0x269ec3; |
| return sRandomSeed >> 16; |
| } |
| |
| |
| // Definition of one GL object in this demo. |
| typedef struct { |
| /* Vertex array and color array are enabled for all objects, so their |
| * pointers must always be valid and non-NULL. Normal array is not |
| * used by the ground plane, so when its pointer is NULL then normal |
| * array usage is disabled. |
| * |
| * Vertex array is supposed to use GL_FIXED datatype and stride 0 |
| * (i.e. tightly packed array). Color array is supposed to have 4 |
| * components per color with GL_UNSIGNED_BYTE datatype and stride 0. |
| * Normal array is supposed to use GL_FIXED datatype and stride 0. |
| */ |
| GLfloat *vertexArray; |
| GLint vertexArraySize; |
| GLintptr vertexArrayOffset; |
| GLubyte *colorArray; |
| GLint colorArraySize; |
| GLintptr colorArrayOffset; |
| GLfloat *normalArray; |
| GLint normalArraySize; |
| GLintptr normalArrayOffset; |
| GLint vertexComponents; |
| GLsizei count; |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| GLuint shaderProgram; |
| #endif // SAN_ANGELES_OBSERVATION_GLES |
| } GLOBJECT; |
| |
| |
| static long sStartTick = 0; |
| static long sTick = 0; |
| |
| static int sCurrentCamTrack = 0; |
| static long sCurrentCamTrackStartTick = 0; |
| static long sNextCamTrackStartTick = 0x7fffffff; |
| |
| static GLOBJECT *sSuperShapeObjects[SUPERSHAPE_COUNT] = { NULL }; |
| static GLOBJECT *sGroundPlane = NULL; |
| static GLOBJECT *sFadeQuad = NULL; |
| |
| static GLuint sVBO = 0; |
| |
| typedef struct { |
| float x, y, z; |
| } VECTOR3; |
| |
| |
| static void freeGLObject(GLOBJECT *object) |
| { |
| if (object == NULL) |
| return; |
| |
| free(object->normalArray); |
| free(object->colorArray); |
| free(object->vertexArray); |
| |
| free(object); |
| } |
| |
| |
| static GLOBJECT * newGLObject(long vertices, int vertexComponents, |
| int useColorArray, int useNormalArray) |
| { |
| GLOBJECT *result; |
| result = malloc(sizeof(GLOBJECT)); |
| if (result == NULL) |
| return NULL; |
| result->count = vertices; |
| result->vertexComponents = vertexComponents; |
| result->vertexArraySize = vertices * vertexComponents * sizeof(GLfloat); |
| result->vertexArray = malloc(result->vertexArraySize); |
| result->vertexArrayOffset = 0; |
| if (useColorArray) |
| { |
| result->colorArraySize = vertices * 4 * sizeof(GLubyte); |
| result->colorArray = malloc(result->colorArraySize); |
| } |
| else |
| { |
| result->colorArraySize = 0; |
| result->colorArray = NULL; |
| } |
| result->colorArrayOffset = result->vertexArrayOffset + |
| result->vertexArraySize; |
| if (useNormalArray) |
| { |
| result->normalArraySize = vertices * 3 * sizeof(GLfloat); |
| result->normalArray = malloc(result->normalArraySize); |
| } |
| else |
| { |
| result->normalArraySize = 0; |
| result->normalArray = NULL; |
| } |
| result->normalArrayOffset = result->colorArrayOffset + |
| result->colorArraySize; |
| if (result->vertexArray == NULL || |
| (useColorArray && result->colorArray == NULL) || |
| (useNormalArray && result->normalArray == NULL)) |
| { |
| freeGLObject(result); |
| return NULL; |
| } |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| result->shaderProgram = 0; |
| #endif // SAN_ANGELES_OBSERVATION_GLES |
| return result; |
| } |
| |
| |
| static void appendObjectVBO(GLOBJECT *object, GLint *offset) |
| { |
| assert(object != NULL); |
| |
| object->vertexArrayOffset += *offset; |
| object->colorArrayOffset += *offset; |
| object->normalArrayOffset += *offset; |
| *offset += object->vertexArraySize + object->colorArraySize + |
| object->normalArraySize; |
| |
| glBufferSubData(GL_ARRAY_BUFFER, object->vertexArrayOffset, |
| object->vertexArraySize, object->vertexArray); |
| if (object->colorArray) |
| glBufferSubData(GL_ARRAY_BUFFER, object->colorArrayOffset, |
| object->colorArraySize, object->colorArray); |
| if (object->normalArray) |
| glBufferSubData(GL_ARRAY_BUFFER, object->normalArrayOffset, |
| object->normalArraySize, object->normalArray); |
| |
| free(object->normalArray); |
| object->normalArray = NULL; |
| free(object->colorArray); |
| object->colorArray = NULL; |
| free(object->vertexArray); |
| object->vertexArray = NULL; |
| } |
| |
| |
| static GLuint createVBO(GLOBJECT **superShapes, int superShapeCount, |
| GLOBJECT *groundPlane, GLOBJECT *fadeQuad) |
| { |
| GLuint vbo; |
| GLint totalSize = 0; |
| int a; |
| for (a = 0; a < superShapeCount; ++a) |
| { |
| assert(superShapes[a] != NULL); |
| totalSize += superShapes[a]->vertexArraySize + |
| superShapes[a]->colorArraySize + |
| superShapes[a]->normalArraySize; |
| } |
| totalSize += groundPlane->vertexArraySize + |
| groundPlane->colorArraySize + |
| groundPlane->normalArraySize; |
| totalSize += fadeQuad->vertexArraySize + |
| fadeQuad->colorArraySize + |
| fadeQuad->normalArraySize; |
| glGenBuffers(1, &vbo); |
| glBindBuffer(GL_ARRAY_BUFFER, vbo); |
| glBufferData(GL_ARRAY_BUFFER, totalSize, 0, GL_STATIC_DRAW); |
| GLint offset = 0; |
| for (a = 0; a < superShapeCount; ++a) |
| appendObjectVBO(superShapes[a], &offset); |
| appendObjectVBO(groundPlane, &offset); |
| appendObjectVBO(fadeQuad, &offset); |
| assert(offset == totalSize); |
| return vbo; |
| } |
| |
| |
| static void drawGLObject(GLOBJECT *object) |
| { |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| int loc_pos = -1; |
| int loc_colorIn = -1; |
| int loc_normal = -1; |
| #endif // SAN_ANGELES_OBSERVATION_GLES |
| |
| assert(object != NULL); |
| |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| bindShaderProgram(object->shaderProgram); |
| if (object->shaderProgram == sShaderLit.program) |
| { |
| loc_pos = sShaderLit.pos; |
| loc_colorIn = sShaderLit.colorIn; |
| loc_normal = sShaderLit.normal; |
| } |
| else if (object->shaderProgram == sShaderFlat.program) |
| { |
| loc_pos = sShaderFlat.pos; |
| loc_colorIn = sShaderFlat.colorIn; |
| } |
| else |
| { |
| assert(0); |
| } |
| glVertexAttribPointer(loc_pos, object->vertexComponents, GL_FLOAT, |
| GL_FALSE, 0, (GLvoid *)object->vertexArrayOffset); |
| glEnableVertexAttribArray(loc_pos); |
| glVertexAttribPointer(loc_colorIn, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, |
| (GLvoid *)object->colorArrayOffset); |
| glEnableVertexAttribArray(loc_colorIn); |
| if (object->normalArraySize > 0) |
| { |
| glVertexAttribPointer(loc_normal, 3, GL_FLOAT, GL_FALSE, 0, |
| (GLvoid *)object->normalArrayOffset); |
| glEnableVertexAttribArray(loc_normal); |
| } |
| glDrawArrays(GL_TRIANGLES, 0, object->count); |
| |
| if (object->normalArraySize > 0) |
| glDisableVertexAttribArray(loc_normal); |
| glDisableVertexAttribArray(loc_colorIn); |
| glDisableVertexAttribArray(loc_pos); |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| glVertexPointer(object->vertexComponents, GL_FLOAT, 0, |
| (GLvoid *)object->vertexArrayOffset); |
| glColorPointer(4, GL_UNSIGNED_BYTE, 0, (GLvoid *)object->colorArrayOffset); |
| if (object->normalArraySize > 0) |
| { |
| glNormalPointer(GL_FLOAT, 0, (GLvoid *)object->normalArrayOffset); |
| glEnableClientState(GL_NORMAL_ARRAY); |
| } |
| else |
| glDisableClientState(GL_NORMAL_ARRAY); |
| glDrawArrays(GL_TRIANGLES, 0, object->count); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| } |
| |
| |
| static void vector3Sub(VECTOR3 *dest, VECTOR3 *v1, VECTOR3 *v2) |
| { |
| dest->x = v1->x - v2->x; |
| dest->y = v1->y - v2->y; |
| dest->z = v1->z - v2->z; |
| } |
| |
| |
| static void superShapeMap(VECTOR3 *point, float r1, float r2, float t, float p) |
| { |
| // sphere-mapping of supershape parameters |
| point->x = (float)(cos(t) * cos(p) / r1 / r2); |
| point->y = (float)(sin(t) * cos(p) / r1 / r2); |
| point->z = (float)(sin(p) / r2); |
| } |
| |
| |
| static float ssFunc(const float t, const float *p) |
| { |
| return (float)(pow(pow(fabs(cos(p[0] * t / 4)) / p[1], p[4]) + |
| pow(fabs(sin(p[0] * t / 4)) / p[2], p[5]), 1 / p[3])); |
| } |
| |
| |
| // Creates and returns a supershape object. |
| // Based on Paul Bourke's POV-Ray implementation. |
| // http://astronomy.swin.edu.au/~pbourke/povray/supershape/ |
| static GLOBJECT * createSuperShape(const float *params) |
| { |
| const int resol1 = (int)params[SUPERSHAPE_PARAMS - 3]; |
| const int resol2 = (int)params[SUPERSHAPE_PARAMS - 2]; |
| // latitude 0 to pi/2 for no mirrored bottom |
| // (latitudeBegin==0 for -pi/2 to pi/2 originally) |
| const int latitudeBegin = resol2 / 4; |
| const int latitudeEnd = resol2 / 2; // non-inclusive |
| const int longitudeCount = resol1; |
| const int latitudeCount = latitudeEnd - latitudeBegin; |
| const long triangleCount = longitudeCount * latitudeCount * 2; |
| const long vertices = triangleCount * 3; |
| GLOBJECT *result; |
| float baseColor[3]; |
| int a, longitude, latitude; |
| long currentVertex, currentQuad; |
| |
| result = newGLObject(vertices, 3, 1, 1); |
| if (result == NULL) |
| return NULL; |
| |
| for (a = 0; a < 3; ++a) |
| baseColor[a] = ((randomUInt() % 155) + 100) / 255.f; |
| |
| currentQuad = 0; |
| currentVertex = 0; |
| |
| // longitude -pi to pi |
| for (longitude = 0; longitude < longitudeCount; ++longitude) |
| { |
| |
| // latitude 0 to pi/2 |
| for (latitude = latitudeBegin; latitude < latitudeEnd; ++latitude) |
| { |
| float t1 = -PI + longitude * 2 * PI / resol1; |
| float t2 = -PI + (longitude + 1) * 2 * PI / resol1; |
| float p1 = -PI / 2 + latitude * 2 * PI / resol2; |
| float p2 = -PI / 2 + (latitude + 1) * 2 * PI / resol2; |
| float r0, r1, r2, r3; |
| |
| r0 = ssFunc(t1, params); |
| r1 = ssFunc(p1, ¶ms[6]); |
| r2 = ssFunc(t2, params); |
| r3 = ssFunc(p2, ¶ms[6]); |
| |
| if (r0 != 0 && r1 != 0 && r2 != 0 && r3 != 0) |
| { |
| VECTOR3 pa, pb, pc, pd; |
| VECTOR3 v1, v2, n; |
| float ca; |
| int i; |
| //float lenSq, invLenSq; |
| |
| superShapeMap(&pa, r0, r1, t1, p1); |
| superShapeMap(&pb, r2, r1, t2, p1); |
| superShapeMap(&pc, r2, r3, t2, p2); |
| superShapeMap(&pd, r0, r3, t1, p2); |
| |
| // kludge to set lower edge of the object to fixed level |
| if (latitude == latitudeBegin + 1) |
| pa.z = pb.z = 0; |
| |
| vector3Sub(&v1, &pb, &pa); |
| vector3Sub(&v2, &pd, &pa); |
| |
| // Calculate normal with cross product. |
| /* i j k i j |
| * v1.x v1.y v1.z | v1.x v1.y |
| * v2.x v2.y v2.z | v2.x v2.y |
| */ |
| |
| n.x = v1.y * v2.z - v1.z * v2.y; |
| n.y = v1.z * v2.x - v1.x * v2.z; |
| n.z = v1.x * v2.y - v1.y * v2.x; |
| |
| /* Pre-normalization of the normals is disabled here because |
| * they will be normalized anyway later due to automatic |
| * normalization (GL_NORMALIZE). It is enabled because the |
| * objects are scaled with glScale. |
| */ |
| /* |
| lenSq = n.x * n.x + n.y * n.y + n.z * n.z; |
| invLenSq = (float)(1 / sqrt(lenSq)); |
| n.x *= invLenSq; |
| n.y *= invLenSq; |
| n.z *= invLenSq; |
| */ |
| |
| ca = pa.z + 0.5f; |
| |
| for (i = currentVertex * 3; |
| i < (currentVertex + 6) * 3; |
| i += 3) |
| { |
| result->normalArray[i] = n.x; |
| result->normalArray[i + 1] = n.y; |
| result->normalArray[i + 2] = n.z; |
| } |
| for (i = currentVertex * 4; |
| i < (currentVertex + 6) * 4; |
| i += 4) |
| { |
| int a, color[3]; |
| for (a = 0; a < 3; ++a) |
| { |
| color[a] = (int)(ca * baseColor[a] * 255); |
| if (color[a] > 255) color[a] = 255; |
| } |
| result->colorArray[i] = (GLubyte)color[0]; |
| result->colorArray[i + 1] = (GLubyte)color[1]; |
| result->colorArray[i + 2] = (GLubyte)color[2]; |
| result->colorArray[i + 3] = 0; |
| } |
| result->vertexArray[currentVertex * 3] = pa.x; |
| result->vertexArray[currentVertex * 3 + 1] = pa.y; |
| result->vertexArray[currentVertex * 3 + 2] = pa.z; |
| ++currentVertex; |
| result->vertexArray[currentVertex * 3] = pb.x; |
| result->vertexArray[currentVertex * 3 + 1] = pb.y; |
| result->vertexArray[currentVertex * 3 + 2] = pb.z; |
| ++currentVertex; |
| result->vertexArray[currentVertex * 3] = pd.x; |
| result->vertexArray[currentVertex * 3 + 1] = pd.y; |
| result->vertexArray[currentVertex * 3 + 2] = pd.z; |
| ++currentVertex; |
| result->vertexArray[currentVertex * 3] = pb.x; |
| result->vertexArray[currentVertex * 3 + 1] = pb.y; |
| result->vertexArray[currentVertex * 3 + 2] = pb.z; |
| ++currentVertex; |
| result->vertexArray[currentVertex * 3] = pc.x; |
| result->vertexArray[currentVertex * 3 + 1] = pc.y; |
| result->vertexArray[currentVertex * 3 + 2] = pc.z; |
| ++currentVertex; |
| result->vertexArray[currentVertex * 3] = pd.x; |
| result->vertexArray[currentVertex * 3 + 1] = pd.y; |
| result->vertexArray[currentVertex * 3 + 2] = pd.z; |
| ++currentVertex; |
| } // r0 && r1 && r2 && r3 |
| ++currentQuad; |
| } // latitude |
| } // longitude |
| |
| // Set number of vertices in object to the actual amount created. |
| result->count = currentVertex; |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| result->shaderProgram = sShaderLit.program; |
| #endif // SAN_ANGELES_OBSERVATION_GLES |
| return result; |
| } |
| |
| |
| static GLOBJECT * createGroundPlane() |
| { |
| const int scale = 4; |
| const int yBegin = -15, yEnd = 15; // ends are non-inclusive |
| const int xBegin = -15, xEnd = 15; |
| const long triangleCount = (yEnd - yBegin) * (xEnd - xBegin) * 2; |
| const long vertices = triangleCount * 3; |
| GLOBJECT *result; |
| int x, y; |
| long currentVertex, currentQuad; |
| |
| result = newGLObject(vertices, 2, 1, 0); |
| if (result == NULL) |
| return NULL; |
| |
| currentQuad = 0; |
| currentVertex = 0; |
| |
| for (y = yBegin; y < yEnd; ++y) |
| { |
| for (x = xBegin; x < xEnd; ++x) |
| { |
| GLubyte color; |
| int i, a; |
| color = (GLubyte)((randomUInt() & 0x5f) + 81); // 101 1111 |
| for (i = currentVertex * 4; i < (currentVertex + 6) * 4; i += 4) |
| { |
| result->colorArray[i] = color; |
| result->colorArray[i + 1] = color; |
| result->colorArray[i + 2] = color; |
| result->colorArray[i + 3] = 0; |
| } |
| |
| // Axis bits for quad triangles: |
| // x: 011100 (0x1c), y: 110001 (0x31) (clockwise) |
| // x: 001110 (0x0e), y: 100011 (0x23) (counter-clockwise) |
| for (a = 0; a < 6; ++a) |
| { |
| const int xm = x + ((0x1c >> a) & 1); |
| const int ym = y + ((0x31 >> a) & 1); |
| const float m = (float)(cos(xm * 2) * sin(ym * 4) * 0.75f); |
| result->vertexArray[currentVertex * 2] = xm * scale + m; |
| result->vertexArray[currentVertex * 2 + 1] = ym * scale + m; |
| ++currentVertex; |
| } |
| ++currentQuad; |
| } |
| } |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| result->shaderProgram = sShaderFlat.program; |
| #endif // SAN_ANGELES_OBSERVATION_GLES |
| return result; |
| } |
| |
| |
| static void drawGroundPlane() |
| { |
| glDisable(GL_CULL_FACE); |
| glDisable(GL_DEPTH_TEST); |
| glEnable(GL_BLEND); |
| glBlendFunc(GL_ZERO, GL_SRC_COLOR); |
| #ifndef SAN_ANGELES_OBSERVATION_GLES |
| glDisable(GL_LIGHTING); |
| #endif // !SAN_ANGELES_OBSERVATION_GLES |
| |
| drawGLObject(sGroundPlane); |
| |
| #ifndef SAN_ANGELES_OBSERVATION_GLES |
| glEnable(GL_LIGHTING); |
| #endif // !SAN_ANGELES_OBSERVATION_GLES |
| glDisable(GL_BLEND); |
| glEnable(GL_DEPTH_TEST); |
| } |
| |
| |
| static GLOBJECT * createFadeQuad() |
| { |
| static const GLfloat quadVertices[] = { |
| -1, -1, |
| 1, -1, |
| -1, 1, |
| 1, -1, |
| 1, 1, |
| -1, 1 |
| }; |
| |
| GLOBJECT *result; |
| int i; |
| |
| result = newGLObject(6, 2, 0, 0); |
| if (result == NULL) |
| return NULL; |
| |
| for (i = 0; i < 12; ++i) |
| result->vertexArray[i] = quadVertices[i]; |
| |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| result->shaderProgram = sShaderFade.program; |
| #endif // SAN_ANGELES_OBSERVATION_GLES |
| return result; |
| } |
| |
| |
| static void drawFadeQuad() |
| { |
| const int beginFade = sTick - sCurrentCamTrackStartTick; |
| const int endFade = sNextCamTrackStartTick - sTick; |
| const int minFade = beginFade < endFade ? beginFade : endFade; |
| |
| if (minFade < 1024) |
| { |
| const GLfloat fadeColor = minFade / 1024.f; |
| glDisable(GL_DEPTH_TEST); |
| glEnable(GL_BLEND); |
| glBlendFunc(GL_ZERO, GL_SRC_COLOR); |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| bindShaderProgram(sShaderFade.program); |
| glUniform1f(sShaderFade.minFade, fadeColor); |
| glVertexAttribPointer(sShaderFade.pos, 2, GL_FLOAT, GL_FALSE, 0, |
| (GLvoid *)sFadeQuad->vertexArrayOffset); |
| glEnableVertexAttribArray(sShaderFade.pos); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| glDisableVertexAttribArray(sShaderFade.pos); |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| glColor4f(fadeColor, fadeColor, fadeColor, 0); |
| |
| glDisable(GL_LIGHTING); |
| |
| glMatrixMode(GL_MODELVIEW); |
| glLoadIdentity(); |
| |
| glMatrixMode(GL_PROJECTION); |
| glLoadIdentity(); |
| |
| glDisableClientState(GL_COLOR_ARRAY); |
| glDisableClientState(GL_NORMAL_ARRAY); |
| glVertexPointer(2, GL_FLOAT, 0, (GLvoid *)sFadeQuad->vertexArrayOffset); |
| |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| |
| glEnableClientState(GL_COLOR_ARRAY); |
| |
| glMatrixMode(GL_MODELVIEW); |
| |
| glEnable(GL_LIGHTING); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| glDisable(GL_BLEND); |
| glEnable(GL_DEPTH_TEST); |
| } |
| } |
| |
| |
| // Called from the app framework. |
| int appInit() |
| { |
| int a; |
| static GLfloat light0Diffuse[] = { 1.f, 0.4f, 0, 1.f }; |
| static GLfloat light1Diffuse[] = { 0.07f, 0.14f, 0.35f, 1.f }; |
| static GLfloat light2Diffuse[] = { 0.07f, 0.17f, 0.14f, 1.f }; |
| static GLfloat materialSpecular[] = { 1.f, 1.f, 1.f, 1.f }; |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| static GLfloat lightAmbient[] = { 0.2f, 0.2f, 0.2f, 1.f }; |
| #endif // SAN_ANGELES_OBSERVATION_GLES |
| |
| glDisable(GL_CULL_FACE); |
| glEnable(GL_DEPTH_TEST); |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| if (initShaderPrograms() == 0) |
| { |
| fprintf(stderr, "Error: initShaderPrograms failed\n"); |
| return 0; |
| } |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| glShadeModel(GL_FLAT); |
| glEnable(GL_NORMALIZE); |
| |
| glEnable(GL_LIGHTING); |
| glEnable(GL_LIGHT0); |
| glEnable(GL_LIGHT1); |
| glEnable(GL_LIGHT2); |
| |
| glEnableClientState(GL_VERTEX_ARRAY); |
| glEnableClientState(GL_COLOR_ARRAY); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| seedRandom(15); |
| |
| for (a = 0; a < SUPERSHAPE_COUNT; ++a) |
| { |
| sSuperShapeObjects[a] = createSuperShape(sSuperShapeParams[a]); |
| assert(sSuperShapeObjects[a] != NULL); |
| } |
| sGroundPlane = createGroundPlane(); |
| assert(sGroundPlane != NULL); |
| sFadeQuad = createFadeQuad(); |
| assert(sFadeQuad != NULL); |
| sVBO = createVBO(sSuperShapeObjects, SUPERSHAPE_COUNT, |
| sGroundPlane, sFadeQuad); |
| |
| // setup non-changing lighting parameters |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| bindShaderProgram(sShaderLit.program); |
| glUniform4fv(sShaderLit.ambient, 1, lightAmbient); |
| glUniform4fv(sShaderLit.light_0_diffuse, 1, light0Diffuse); |
| glUniform4fv(sShaderLit.light_1_diffuse, 1, light1Diffuse); |
| glUniform4fv(sShaderLit.light_2_diffuse, 1, light2Diffuse); |
| glUniform4fv(sShaderLit.light_0_specular, 1, materialSpecular); |
| glUniform1f(sShaderLit.shininess, 60.f); |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| glLightfv(GL_LIGHT0, GL_DIFFUSE, light0Diffuse); |
| glLightfv(GL_LIGHT1, GL_DIFFUSE, light1Diffuse); |
| glLightfv(GL_LIGHT2, GL_DIFFUSE, light2Diffuse); |
| glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, materialSpecular); |
| glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| return 1; |
| } |
| |
| |
| // Called from the app framework. |
| void appDeinit() |
| { |
| int a; |
| for (a = 0; a < SUPERSHAPE_COUNT; ++a) |
| freeGLObject(sSuperShapeObjects[a]); |
| freeGLObject(sGroundPlane); |
| freeGLObject(sFadeQuad); |
| glDeleteBuffers(1, &sVBO); |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| deInitShaderPrograms(); |
| #endif // SAN_ANGELES_OBSERVATION_GLES |
| } |
| |
| #ifndef SAN_ANGELES_OBSERVATION_GLES |
| static void gluPerspective(GLfloat fovy, GLfloat aspect, |
| GLfloat zNear, GLfloat zFar) |
| { |
| GLfloat xmin, xmax, ymin, ymax; |
| |
| ymax = zNear * (GLfloat)tan(fovy * PI / 360); |
| ymin = -ymax; |
| xmin = ymin * aspect; |
| xmax = ymax * aspect; |
| |
| glFrustum(xmin, xmax, ymin, ymax, zNear, zFar); |
| } |
| #endif // !SAN_ANGELES_OBSERVATION_GLES |
| |
| static void prepareFrame(int width, int height) |
| { |
| glViewport(0, 0, width, height); |
| |
| glClearColor(0.1f, 0.2f, 0.3f, 1.f); |
| glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); |
| |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| Matrix4x4_LoadIdentity(sProjection); |
| Matrix4x4_Perspective(sProjection, |
| 45.f, (float)width / height, 0.5f, 150); |
| |
| Matrix4x4_LoadIdentity(sModelView); |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| glMatrixMode(GL_PROJECTION); |
| glLoadIdentity(); |
| gluPerspective(45, (float)width / height, 0.5f, 150); |
| |
| glMatrixMode(GL_MODELVIEW); |
| glLoadIdentity(); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| } |
| |
| |
| static void configureLightAndMaterial() |
| { |
| GLfloat light0Position[] = { -4.f, 1.f, 1.f, 0 }; |
| GLfloat light1Position[] = { 1.f, -2.f, -1.f, 0 }; |
| GLfloat light2Position[] = { -1.f, 0, -4.f, 0 }; |
| |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| Matrix4x4_Transform(sModelView, |
| light0Position, light0Position + 1, light0Position + 2); |
| Matrix4x4_Transform(sModelView, |
| light1Position, light1Position + 1, light1Position + 2); |
| Matrix4x4_Transform(sModelView, |
| light2Position, light2Position + 1, light2Position + 2); |
| |
| bindShaderProgram(sShaderLit.program); |
| glUniform3fv(sShaderLit.light_0_direction, 1, light0Position); |
| glUniform3fv(sShaderLit.light_1_direction, 1, light1Position); |
| glUniform3fv(sShaderLit.light_2_direction, 1, light2Position); |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| glLightfv(GL_LIGHT0, GL_POSITION, light0Position); |
| glLightfv(GL_LIGHT1, GL_POSITION, light1Position); |
| glLightfv(GL_LIGHT2, GL_POSITION, light2Position); |
| |
| glEnable(GL_COLOR_MATERIAL); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| } |
| |
| |
| static void drawModels(float zScale) |
| { |
| const int translationScale = 9; |
| int x, y; |
| |
| seedRandom(9); |
| |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| Matrix4x4_Scale(sModelView, 1.f, 1.f, zScale); |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| glScalef(1.f, 1.f, zScale); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| |
| for (y = -5; y <= 5; ++y) |
| { |
| for (x = -5; x <= 5; ++x) |
| { |
| float buildingScale; |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| Matrix4x4 tmp; |
| #endif // SAN_ANGELES_OBSERVATION_GLES |
| |
| int curShape = randomUInt() % SUPERSHAPE_COUNT; |
| buildingScale = sSuperShapeParams[curShape][SUPERSHAPE_PARAMS - 1]; |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| Matrix4x4_Copy(tmp, sModelView); |
| Matrix4x4_Translate(sModelView, x * translationScale, |
| y * translationScale, 0); |
| Matrix4x4_Rotate(sModelView, randomUInt() % 360, 0, 0, 1.f); |
| Matrix4x4_Scale(sModelView, |
| buildingScale, buildingScale, buildingScale); |
| |
| drawGLObject(sSuperShapeObjects[curShape]); |
| Matrix4x4_Copy(sModelView, tmp); |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| glPushMatrix(); |
| glTranslatef(x * translationScale, y * translationScale, 0); |
| glRotatef(randomUInt() % 360, 0, 0, 1.f); |
| glScalef(buildingScale, buildingScale, buildingScale); |
| |
| drawGLObject(sSuperShapeObjects[curShape]); |
| glPopMatrix(); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| } |
| } |
| |
| for (x = -2; x <= 2; ++x) |
| { |
| const int shipScale100 = translationScale * 500; |
| const int offs100 = x * shipScale100 + (sTick % shipScale100); |
| float offs = offs100 * 0.01f; |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| Matrix4x4 tmp; |
| Matrix4x4_Copy(tmp, sModelView); |
| Matrix4x4_Translate(sModelView, offs, -4.f, 2.f); |
| drawGLObject(sSuperShapeObjects[SUPERSHAPE_COUNT - 1]); |
| Matrix4x4_Copy(sModelView, tmp); |
| Matrix4x4_Translate(sModelView, -4.f, offs, 4.f); |
| Matrix4x4_Rotate(sModelView, 90.f, 0, 0, 1.f); |
| drawGLObject(sSuperShapeObjects[SUPERSHAPE_COUNT - 1]); |
| Matrix4x4_Copy(sModelView, tmp); |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| glPushMatrix(); |
| glTranslatef(offs, -4.f, 2.f); |
| drawGLObject(sSuperShapeObjects[SUPERSHAPE_COUNT - 1]); |
| glPopMatrix(); |
| glPushMatrix(); |
| glTranslatef(-4.f, offs, 4.f); |
| glRotatef(90.f, 0, 0, 1.f); |
| drawGLObject(sSuperShapeObjects[SUPERSHAPE_COUNT - 1]); |
| glPopMatrix(); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| } |
| } |
| |
| /* Following gluLookAt implementation is adapted from the |
| * Mesa 3D Graphics library. http://www.mesa3d.org |
| */ |
| static void gluLookAt(GLfloat eyex, GLfloat eyey, GLfloat eyez, |
| GLfloat centerx, GLfloat centery, GLfloat centerz, |
| GLfloat upx, GLfloat upy, GLfloat upz) |
| { |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| Matrix4x4 m; |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| GLfloat m[16]; |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| GLfloat x[3], y[3], z[3]; |
| GLfloat mag; |
| |
| /* Make rotation matrix */ |
| |
| /* Z vector */ |
| z[0] = eyex - centerx; |
| z[1] = eyey - centery; |
| z[2] = eyez - centerz; |
| mag = (float)sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]); |
| if (mag) { /* mpichler, 19950515 */ |
| z[0] /= mag; |
| z[1] /= mag; |
| z[2] /= mag; |
| } |
| |
| /* Y vector */ |
| y[0] = upx; |
| y[1] = upy; |
| y[2] = upz; |
| |
| /* X vector = Y cross Z */ |
| x[0] = y[1] * z[2] - y[2] * z[1]; |
| x[1] = -y[0] * z[2] + y[2] * z[0]; |
| x[2] = y[0] * z[1] - y[1] * z[0]; |
| |
| /* Recompute Y = Z cross X */ |
| y[0] = z[1] * x[2] - z[2] * x[1]; |
| y[1] = -z[0] * x[2] + z[2] * x[0]; |
| y[2] = z[0] * x[1] - z[1] * x[0]; |
| |
| /* mpichler, 19950515 */ |
| /* cross product gives area of parallelogram, which is < 1.0 for |
| * non-perpendicular unit-length vectors; so normalize x, y here |
| */ |
| |
| mag = (float)sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]); |
| if (mag) { |
| x[0] /= mag; |
| x[1] /= mag; |
| x[2] /= mag; |
| } |
| |
| mag = (float)sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]); |
| if (mag) { |
| y[0] /= mag; |
| y[1] /= mag; |
| y[2] /= mag; |
| } |
| |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| #define M(row, col) m[col*4 + row] |
| M(0, 0) = x[0]; |
| M(0, 1) = x[1]; |
| M(0, 2) = x[2]; |
| M(0, 3) = 0.0; |
| M(1, 0) = y[0]; |
| M(1, 1) = y[1]; |
| M(1, 2) = y[2]; |
| M(1, 3) = 0.0; |
| M(2, 0) = z[0]; |
| M(2, 1) = z[1]; |
| M(2, 2) = z[2]; |
| M(2, 3) = 0.0; |
| M(3, 0) = 0.0; |
| M(3, 1) = 0.0; |
| M(3, 2) = 0.0; |
| M(3, 3) = 1.0; |
| #undef M |
| |
| Matrix4x4_Multiply(sModelView, m, sModelView); |
| |
| Matrix4x4_Translate(sModelView, -eyex, -eyey, -eyez); |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| #define M(row, col) m[col*4 + row] |
| M(0, 0) = x[0]; |
| M(0, 1) = x[1]; |
| M(0, 2) = x[2]; |
| M(0, 3) = 0.0; |
| M(1, 0) = y[0]; |
| M(1, 1) = y[1]; |
| M(1, 2) = y[2]; |
| M(1, 3) = 0.0; |
| M(2, 0) = z[0]; |
| M(2, 1) = z[1]; |
| M(2, 2) = z[2]; |
| M(2, 3) = 0.0; |
| M(3, 0) = 0.0; |
| M(3, 1) = 0.0; |
| M(3, 2) = 0.0; |
| M(3, 3) = 1.0; |
| #undef M |
| |
| glMultMatrixf(m); |
| |
| /* Translate Eye to Origin */ |
| glTranslatef(-eyex, -eyey, -eyez); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| } |
| |
| static void camTrack() |
| { |
| float lerp[5]; |
| float eX, eY, eZ, cX, cY, cZ; |
| float trackPos; |
| CAMTRACK *cam; |
| long currentCamTick; |
| int a; |
| |
| if (sNextCamTrackStartTick <= sTick) |
| { |
| ++sCurrentCamTrack; |
| sCurrentCamTrackStartTick = sNextCamTrackStartTick; |
| } |
| sNextCamTrackStartTick = sCurrentCamTrackStartTick + |
| sCamTracks[sCurrentCamTrack].len * CAMTRACK_LEN; |
| |
| cam = &sCamTracks[sCurrentCamTrack]; |
| currentCamTick = sTick - sCurrentCamTrackStartTick; |
| trackPos = (float)currentCamTick / (CAMTRACK_LEN * cam->len); |
| |
| for (a = 0; a < 5; ++a) |
| lerp[a] = (cam->src[a] + cam->dest[a] * trackPos) * 0.01f; |
| |
| if (cam->dist) |
| { |
| float dist = cam->dist * 0.1f; |
| cX = lerp[0]; |
| cY = lerp[1]; |
| cZ = lerp[2]; |
| eX = cX - (float)cos(lerp[3]) * dist; |
| eY = cY - (float)sin(lerp[3]) * dist; |
| eZ = cZ - lerp[4]; |
| } |
| else |
| { |
| eX = lerp[0]; |
| eY = lerp[1]; |
| eZ = lerp[2]; |
| cX = eX + (float)cos(lerp[3]); |
| cY = eY + (float)sin(lerp[3]); |
| cZ = eZ + lerp[4]; |
| } |
| gluLookAt(eX, eY, eZ, cX, cY, cZ, 0, 0, 1); |
| } |
| |
| |
| // Called from the app framework. |
| /* The tick is current time in milliseconds, width and height |
| * are the image dimensions to be rendered. |
| */ |
| void appRender(long tick, int width, int height) |
| { |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| Matrix4x4 tmp; |
| #endif // SAN_ANGELES_OBSERVATION_GLES |
| |
| if (sStartTick == 0) |
| sStartTick = tick; |
| if (!gAppAlive) |
| return; |
| |
| // Actual tick value is "blurred" a little bit. |
| sTick = (sTick + tick - sStartTick) >> 1; |
| |
| // Terminate application after running through the demonstration once. |
| if (sTick >= RUN_LENGTH) |
| { |
| gAppAlive = 0; |
| return; |
| } |
| |
| // Prepare OpenGL ES for rendering of the frame. |
| prepareFrame(width, height); |
| |
| // Update the camera position and set the lookat. |
| camTrack(); |
| |
| // Configure environment. |
| configureLightAndMaterial(); |
| |
| // Draw the reflection by drawing models with negated Z-axis. |
| #ifdef SAN_ANGELES_OBSERVATION_GLES |
| Matrix4x4_Copy(tmp, sModelView); |
| drawModels(-1); |
| Matrix4x4_Copy(sModelView, tmp); |
| #else // !SAN_ANGELES_OBSERVATION_GLES |
| glPushMatrix(); |
| drawModels(-1); |
| glPopMatrix(); |
| #endif // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES |
| |
| // Blend the ground plane to the window. |
| drawGroundPlane(); |
| |
| // Draw all the models normally. |
| drawModels(1); |
| |
| // Draw fade quad over whole window (when changing cameras). |
| drawFadeQuad(); |
| } |
| |
