ref: 152882e1b5b6e382d6298c91144358d6867cedbf
dir: /SDL_Examples/model.c/
//#define PLAY_MUSIC
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../include/GL/gl.h"
#define STB_IMAGE_IMPLEMENTATION
#include "../include-demo/stb_image.h"
#define CHAD_MATH_IMPL
#include "../include-demo/3dMath.h"
#include "../include-demo/tobjparse.h"
#define CHAD_API_IMPL
#include "../include/zbuffer.h"
#ifdef PLAY_MUSIC
#include "../include-demo/api_audio.h"
#else
typedef unsigned char uchar;
#endif
#include <SDL/SDL.h>
#include <time.h>
int noSDL = 0;
int doblend = 0;
#ifndef M_PI
#define M_PI 3.14159265
#endif
vec3 campos = (vec3){.d[0] = 0, .d[1] = 0, .d[2] = -3};
vec3 camforw = (vec3){.d[0] = 0, .d[1] = 0, .d[2] = -1};
vec3 camup = (vec3){.d[0] = 0, .d[1] = 1, .d[2] = 0};
uint wasdstate[4] = {0, 0, 0, 0};
const float mouseratiox = 1.0 / 300.0f;
const float mouseratioy = 1.0 / 300.0f;
int mousex = 0, mousey = 0;
int ModelArrayLoaded = 0;
int testingModelArrays = 0;
int testingCopyImage2D = 0;
struct {
float* points;
uint npoints;
float* normals;
float* colors;
float* texcoords;
} ModelArray;
void FreeModelArray() {
if (!ModelArrayLoaded) {
ModelArray.points = NULL;
ModelArray.normals = NULL;
ModelArray.npoints = 0;
ModelArray.colors = NULL;
ModelArray.texcoords = NULL;
return;
}
ModelArrayLoaded = 0;
if (ModelArray.points)
free(ModelArray.points);
if (ModelArray.normals)
free(ModelArray.normals);
if (ModelArray.texcoords)
free(ModelArray.texcoords);
if (ModelArray.colors)
free(ModelArray.colors);
ModelArray.npoints = 0;
return;
}
void rotateCamera() {
vec3 a;
a.d[1] = (float)mousex * mouseratiox;
a.d[2] = (float)mousey * mouseratioy;
vec3 right = normalizev3(crossv3(camforw, camup));
right.d[1] = 0;
// vec3 forward = glm::vec3(glm::normalize(glm::rotate(angle, right) * glm::vec4(forward, 0.0)));
camforw = normalizev3(rotatev3(camforw, right, -a.d[2]));
// up = glm::normalize(glm::cross(forward, right));
camup = normalizev3(crossv3(right, camforw));
// Perform the rotation about the Y axis last.
static const vec3 UP = (vec3){{0, 1, 0}};
static const vec3 DOWN = (vec3){{0, -1, 0}};
if (dotv3(UP, camup) < 0) {
camforw = normalizev3(rotatev3(camforw, DOWN, -a.d[1]));
camup = normalizev3(rotatev3(camup, DOWN, -a.d[1]));
} else {
camforw = normalizev3(rotatev3(camforw, UP, -a.d[1]));
camup = normalizev3(rotatev3(camup, UP, -a.d[1]));
}
}
GLuint loadRGBTexture(unsigned char* buf, unsigned int w, unsigned int h) {
GLuint t = 0;
glGenTextures(1, &t);
glBindTexture(GL_TEXTURE_2D, t);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, 3, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, buf);
return t;
}
void LoadModelArrays(
// HUGE important note! these depend on the math library using
// f_ as float and not double!
// Remember that!
vec3* points, uint npoints, vec3* colors, vec3* normals, vec3* texcoords) {
if (!points)
return;
FreeModelArray();
ModelArrayLoaded = 1;
ModelArray.npoints = npoints;
ModelArray.points = malloc(sizeof(float) * npoints * 3);
if (normals)
ModelArray.normals = malloc(sizeof(float) * npoints * 3);
if (texcoords)
ModelArray.texcoords = malloc(sizeof(float) * npoints * 2);
if (colors)
ModelArray.colors = malloc(sizeof(float) * npoints * 3);
for (uint i = 0; i < npoints; i++) {
if (colors) { // Fix for TinyGL color interpolation.
ModelArray.colors[i * 3 + 0] = colors[i].d[0];
ModelArray.colors[i * 3 + 1] = colors[i].d[1];
ModelArray.colors[i * 3 + 2] = colors[i].d[2];
}
if (texcoords) {
ModelArray.texcoords[i * 2 + 0] = texcoords[i].d[0];
ModelArray.texcoords[i * 2 + 1] = texcoords[i].d[1];
}
if (normals) {
ModelArray.normals[i * 3 + 0] = normals[i].d[0];
ModelArray.normals[i * 3 + 1] = normals[i].d[1];
ModelArray.normals[i * 3 + 2] = normals[i].d[2];
}
ModelArray.points[i * 3 + 0] = points[i].d[0];
ModelArray.points[i * 3 + 1] = points[i].d[1];
ModelArray.points[i * 3 + 2] = points[i].d[2];
}
}
// Without display list
void drawModelArrays(
// HUGE important note! these depend on the math library using
// f_ as float and not double!
// Remember that!
vec3* points, uint npoints, vec3* colors, vec3* normals, vec3* texcoords) {
if (!points)
return;
glBegin(GL_TRIANGLES);
for (uint i = 0; i < npoints; i++) {
if (colors) { // Fix for TinyGL color interpolation.
glColor3f(colors[i].d[0], colors[i].d[1], colors[i].d[2]);
}
if (texcoords)
glTexCoord2f(texcoords[i].d[0], texcoords[i].d[1]);
if (normals)
glNormal3f(normals[i].d[0], normals[i].d[1], normals[i].d[2]);
glVertex3f(points[i].d[0], points[i].d[1], points[i].d[2]);
}
glEnd();
}
GLuint createModelDisplayList(
// HUGE important note! these depend on the math library using
// f_ as float and not double!
// Remember that!
vec3* points, uint npoints, vec3* colors, vec3* normals, vec3* texcoords) {
GLuint ret = 0;
if (!points)
return 0;
ret = glGenLists(1);
glNewList(ret, GL_COMPILE);
glBegin(GL_TRIANGLES);
for (uint i = 0; i < npoints; i++) {
if (colors) {
glColor3f(colors[i].d[0], colors[i].d[1], colors[i].d[2]);
}
if (texcoords)
glTexCoord2f(texcoords[i].d[0], texcoords[i].d[1]);
if (normals)
glNormal3f(normals[i].d[0], normals[i].d[1], normals[i].d[2]);
glVertex3f(points[i].d[0], points[i].d[1], points[i].d[2]);
}
// printf("\ncreateModelDisplayList is not the problem.\n");
glEnd();
glEndList();
return ret;
}
GLubyte stipplepattern[128] = {0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55};
#define BEGIN_EVENT_HANDLER \
void events(SDL_Event* e) { \
switch (e->type) {
#define E_KEYSYM e->key.keysym.sym
#define END_EVENT_HANDLER \
} \
}
#define EVENT_HANDLER events
#define E_MOTION e->motion
#define E_BUTTON e->button.button
#define E_WINEVENT e->window.event
#define E_WINW e->window.data1
#define E_WINH e->window.data2
int isRunning = 1;
/*
mousex = (kHeld & KEY_Y)?-30:0 + (kHeld & KEY_A)?30:0;
mousey = (kHeld & KEY_X)?-30:0 + (kHeld & KEY_B)?30:0;
*/
BEGIN_EVENT_HANDLER
case SDL_KEYDOWN:
switch (E_KEYSYM) {
case SDLK_w:
wasdstate[0] = 1;
break;
case SDLK_a:
wasdstate[1] = 1;
break;
case SDLK_s:
wasdstate[2] = 1;
break;
case SDLK_d:
wasdstate[3] = 1;
break;
case SDLK_UP:
mousey = -30;
break;
case SDLK_DOWN:
mousey = 30;
break;
case SDLK_LEFT:
mousex = -30;
break;
case SDLK_RIGHT:
mousex = 30;
break;
case SDLK_ESCAPE:
case SDLK_q:
isRunning = 0;
break;
default:
break;
}
break;
case SDL_KEYUP:
switch (E_KEYSYM) {
case SDLK_w:
wasdstate[0] = 0;
break;
case SDLK_a:
wasdstate[1] = 0;
break;
case SDLK_s:
wasdstate[2] = 0;
break;
case SDLK_d:
wasdstate[3] = 0;
break;
case SDLK_UP:
case SDLK_DOWN:
mousey = 0;
break;
case SDLK_LEFT:
case SDLK_RIGHT:
mousex = 0;
break;
default:
break;
}
break;
case SDL_QUIT:
isRunning = 0;
break;
END_EVENT_HANDLER
int main(int argc, char** argv) {
// initialize SDL video:
int winSizeX = 640;
int winSizeY = 480;
char needsRGBAFix = 0;
unsigned int count = 40;
GLuint modelDisplayList = 0;
GLuint buffers[4]; // pos,color,normal,texcoord
int dlExists = 0;
int doTextures = 1;
char* modelName = "extrude.obj";
#ifdef PLAY_MUSIC
track* myTrack = NULL;
#endif
unsigned int fps = 0;
if (argc > 1) {
char* larg = argv[0];
for (int i = 1; i < argc; i++) {
if (!strcmp(larg, "-w"))
winSizeX = atoi(argv[i]);
if (!strcmp(larg, "-h"))
winSizeY = atoi(argv[i]);
if (!strcmp(larg, "-fps"))
fps = strtoull(argv[i], 0, 10);
if (!strcmp(larg, "-count"))
count = strtoull(argv[i], 0, 10);
if (!strcmp(larg, "-m"))
modelName = argv[i];
if (!strcmp(argv[i], "-notexture") || !strcmp(larg, "-notexture"))
doTextures = 0;
if (!strcmp(argv[i], "-arrays"))
testingModelArrays = 1;
if (!strcmp(argv[i], "-copy"))
testingCopyImage2D = 1;
if (!strcmp(argv[i], "-blend"))
doblend = 1;
larg = argv[i];
}
}
#ifdef PLAY_MUSIC
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
#else
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
#endif
fprintf(stderr, "ERROR: cannot initialize SDL video.\n");
return 1;
}
#ifdef PLAY_MUSIC
ainit(0);
#endif
SDL_Surface* screen = NULL;
if ((screen = SDL_SetVideoMode(winSizeX, winSizeY, TGL_FEATURE_RENDER_BITS, SDL_SWSURFACE)) == 0) {
fprintf(stderr, "ERROR: Video mode set failed.\n");
return 1;
}
printf("\nRMASK IS %u", screen->format->Rmask);
printf("\nGMASK IS %u", screen->format->Gmask);
printf("\nBMASK IS %u", screen->format->Bmask);
printf("\nAMASK IS %u", screen->format->Amask);
#if TGL_FEATURE_RENDER_BITS == 32
if (screen->format->Rmask != 0x00FF0000 || screen->format->Gmask != 0x0000FF00 || screen->format->Bmask != 0x000000FF) {
needsRGBAFix = 1;
printf("\nYour screen is using an RGBA output different than this library expects.");
printf("\nYou should consider using the 16 bit version for optimal performance");
}
#endif
printf("\nRSHIFT IS %u", screen->format->Rshift);
printf("\nGSHIFT IS %u", screen->format->Gshift);
printf("\nBSHIFT IS %u", screen->format->Bshift);
printf("\nASHIFT IS %u\n", screen->format->Ashift);
fflush(stdout);
#ifdef PLAY_MUSIC
myTrack = lmus("WWGW.mp3");
mplay(myTrack, -1, 1000);
#endif
SDL_ShowCursor(SDL_DISABLE);
SDL_WM_SetCaption(argv[0], 0);
// initialize TinyGL:
int mode;
switch (screen->format->BitsPerPixel) {
case 8:
fprintf(stderr, "ERROR: Palettes are currently not supported.\n");
fprintf(stderr, "\nUnsupported by maintainer!!!");
return 1;
case 16:
// fprintf(stderr,"\nUnsupported by maintainer!!!");
mode = ZB_MODE_5R6G5B;
// return 1;
break;
case 24:
fprintf(stderr, "\nUnsupported by maintainer!!!");
mode = ZB_MODE_RGB24;
return 1;
break;
case 32:
mode = ZB_MODE_RGBA;
break;
default:
return 1;
break;
}
ZBuffer* frameBuffer = NULL;
if (TGL_FEATURE_RENDER_BITS == 32)
frameBuffer = ZB_open(winSizeX, winSizeY, ZB_MODE_RGBA, 0);
else
frameBuffer = ZB_open(winSizeX, winSizeY, ZB_MODE_5R6G5B, 0);
glInit(frameBuffer);
srand(time(NULL));
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glSetEnableSpecular(0);
static GLfloat white[4] = {1.0, 1.0, 1.0, 0.0};
static GLfloat pos[4] = {5, 5, 10, 0.0}; // Light at infinity.
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_DIFFUSE, white);
// glLightfv( GL_LIGHT0, GL_AMBIENT, white);
// glLightfv( GL_LIGHT0, GL_SPECULAR, white);
glEnable(GL_CULL_FACE);
// glDisable( GL_LIGHTING );
glEnable(GL_LIGHT0);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable(GL_COLOR_MATERIAL);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glClearColor(0, 0, 0, 0);
glClearDepth(1.0f);
glClearColor(0, 0, 0.3, 0);
glDisable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
// glDisable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
// glDisable(GL_DEPTH_TEST);
double t = 0;
glViewport(0, 0, winSizeX, winSizeY);
// glEnable(GL_POLYGON_STIPPLE);
glPolygonStipple(stipplepattern);
// initScene();
{
objraw omodel;
model m = initmodel();
omodel = tobj_load(modelName);
if (!omodel.positions) {
puts("\nERROR! No positions in model. Aborting...\n");
} else {
m = tobj_tomodel(&omodel);
printf("\nHas %ld points.\n", m.npoints);
if (!testingModelArrays) {
modelDisplayList = createModelDisplayList(m.d, m.npoints, m.c, m.n, m.t);
dlExists = 1;
} else {
LoadModelArrays(m.d, m.npoints, m.c, m.n, m.t);
/*
if(ModelArray.colors)glEnableClientState(GL_COLOR_ARRAY);
if(ModelArray.points)glEnableClientState(GL_VERTEX_ARRAY);
if(ModelArray.normals)glEnableClientState(GL_NORMAL_ARRAY);
if(ModelArray.texcoords)glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if(ModelArray.points)glVertexPointer(3,GL_FLOAT,0,ModelArray.points);
if(ModelArray.normals)glNormalPointer(GL_FLOAT,0,ModelArray.normals); //Must be 3!
if(ModelArray.colors)glColorPointer(3,GL_FLOAT,0,ModelArray.colors);
if(ModelArray.texcoords)glTexCoordPointer(2,GL_FLOAT,0,ModelArray.texcoords);
*/
glGenBuffers(4, buffers);
for (int i = 0; i < 4; i++) {
printf("\nBuffer %d is %d", i, buffers[i]);
if (buffers[i] == 0) {
printf("\nBuffer allocation failed for buffer %d!\n", i);
return 1;
}
}
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
/*Done multiple times to test and make sure that data isn't leaked*/
puts("\nTesting glBufferData data integrity\n");
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * ModelArray.npoints, ModelArray.points, GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * ModelArray.npoints, ModelArray.points, GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * ModelArray.npoints, ModelArray.points, GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * ModelArray.npoints, ModelArray.points, GL_STATIC_DRAW);
if (glMapBuffer(GL_ARRAY_BUFFER, 0) == NULL)
printf("\nglBufferData failed for buffer %d!\n", 0);
glBindBufferAsArray(GL_VERTEX_BUFFER, buffers[0], GL_FLOAT, 3, 0);
if (ModelArray.colors) {
glBindBuffer(GL_ARRAY_BUFFER, buffers[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * ModelArray.npoints, ModelArray.colors, GL_STATIC_DRAW);
glBindBufferAsArray(GL_COLOR_BUFFER, buffers[1], GL_FLOAT, 3, 0);
}
if (ModelArray.normals) {
glBindBuffer(GL_ARRAY_BUFFER, buffers[2]);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * ModelArray.npoints, ModelArray.normals, GL_STATIC_DRAW);
glBindBufferAsArray(GL_NORMAL_BUFFER, buffers[2], GL_FLOAT, 3, 0);
}
if (ModelArray.texcoords) {
glBindBuffer(GL_ARRAY_BUFFER, buffers[3]);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 2 * ModelArray.npoints, ModelArray.texcoords, GL_STATIC_DRAW);
glBindBufferAsArray(GL_TEXTURE_COORD_BUFFER, buffers[3], GL_FLOAT, 2, 0);
}
}
freemodel(&m);
}
freeobjraw(&omodel);
}
GLuint tex = 0;
if (doTextures) {
int sw = 0, sh = 0, sc = 0; // sc goes unused.
#if TGL_FEATURE_NO_DRAW_COLOR == 1
uchar* source_data = stbi_load("tex_hole.png", &sw, &sh, &sc, 3);
#else
uchar* source_data = stbi_load("tex.jpg", &sw, &sh, &sc, 3);
#endif
if (source_data) {
tex = loadRGBTexture(source_data, sw, sh);
free(source_data);
}
// tex =
}
// glDisable(GL_LIGHTING);
// glEnable( GL_NORMALIZE );
// variables for timing:
unsigned int frames = 0;
unsigned int tNow = SDL_GetTicks();
unsigned int tLastFps = tNow;
// main loop:
while (isRunning) {
++frames;
t += 0.016666f;
tNow = SDL_GetTicks();
// do event handling:
SDL_Event evt;
mousex = 0;
mousey = 0;
while (SDL_PollEvent(&evt))
EVENT_HANDLER(&evt);
/*
switch(evt.type) {
}
*/
// draw scene:
#define WIDTH winSizeX
#define HEIGHT winSizeY
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// gluPerspective(70,(float)WIDTH/(float)HEIGHT,1,512);
mat4 matrix = perspective(70, (float)WIDTH / (float)HEIGHT, 1, 512);
glLoadMatrixf(matrix.d);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix(); // Pushing on the LookAt Matrix.
vec3 right = normalizev3(crossv3(camforw, camup));
// right.d[1] = 0;
matrix = (lookAt(campos, addv3(campos, camforw), camup)); // Using right vector to correct for screen rotation.
glLoadMatrixf(matrix.d);
if (wasdstate[0])
campos = addv3(campos, scalev3(0.1, camforw));
if (wasdstate[2])
campos = addv3(campos, scalev3(-0.1, camforw));
if (wasdstate[1])
campos = addv3(campos, scalev3(-0.1, right));
if (wasdstate[3])
campos = addv3(campos, scalev3(0.1, right));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
if (doTextures)
glBindTexture(GL_TEXTURE_2D, tex);
// glDisable(GL_BLEND);
// Testing blending for textured triangles.
// glDisable(GL_DEPTH_TEST);
if (doblend) {
glEnable(GL_BLEND);
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
} else {
glDisable(GL_BLEND);
}
glBlendFunc(GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR);
glBlendEquation(GL_FUNC_ADD);
// glDisable(GL_TEXTURE_2D);
// printf("\nNew triangle!\n");
if (!dlExists) {
if (!testingModelArrays) {
glDisable(GL_TEXTURE_2D);
glBegin(GL_TRIANGLES);
// glColor3f(0,0,1);
glColor3f(1, 0, 0);
glTexCoord2f(0, 0);
glVertex3f(-1, -1, -10);
glColor3f(0, 1, 0);
glTexCoord2f(1, 0);
glVertex3f(1, -1, -10);
glColor3f(0, 0, 1);
glTexCoord2f(0.5, 1);
glVertex3f(0, 1, -10);
// glColor3f(0,1,0);
glEnd();
} else {
if (doTextures)
glEnable(GL_TEXTURE_2D);
// glDisable(GL_TEXTURE_2D);
glEnable(GL_POLYGON_STIPPLE);
// puts("\nUSING ARRAYS!");
// glDisable(GL_COLOR_MATERIAL);
for (unsigned int i = 0; i < count; i++) {
glPushMatrix();
mat4 horiz_translation = translate((vec3){{8.0 * (i % 10), 0.0, 0.0}});
mat4 vert_translation = translate((vec3){{0.0, 8.0 * (i / 10), 0.0}});
const mat4 ztranslation = translate((vec3){{0, 0, -10}});
mat4 total_translation = multm4(multm4(horiz_translation, vert_translation), ztranslation);
glMultMatrixf(total_translation.d);
// glTranslatef((float)(i % 10) * 8.0, (float)(i / 10) * 8.0, -10);
glBegin(GL_TRIANGLES);
for (uint j = 0; j < ModelArray.npoints; j++)
glArrayElement(j);
glEnd();
glPopMatrix();
}
glDisable(GL_POLYGON_STIPPLE);
glDisable(GL_TEXTURE_2D);
}
} else {
if (doTextures)
glEnable(GL_TEXTURE_2D);
// glDisable(GL_TEXTURE_2D);
glEnable(GL_POLYGON_STIPPLE);
// glDisable(GL_COLOR_MATERIAL);
for (unsigned int i = 0; i < count; i++) {
glPushMatrix();
mat4 horiz_translation = translate((vec3){{8.0 * (i % 10), 0.0, 0.0}});
mat4 vert_translation = translate((vec3){{0.0, 8.0 * (i / 10), 0.0}});
const mat4 ztranslation = translate((vec3){{0, 0, -10}});
mat4 total_translation = multm4(multm4(horiz_translation, vert_translation), ztranslation);
glMultMatrixf(total_translation.d);
// glTranslatef((float)(i % 10) * 8.0, (float)(i / 10) * 8.0, -10);
glCallList(modelDisplayList);
// drawModel(
// m.d, m.npoints,
// m.c,
// m.n,
// m.t
// );
glPopMatrix();
}
glDisable(GL_POLYGON_STIPPLE);
if (doTextures)
glDisable(GL_TEXTURE_2D);
}
// draw();
glPopMatrix(); // The view transform.
rotateCamera();
glTextSize(GL_TEXT_SIZE16x16);
glDrawText((unsigned char*)"\nModel Viewer Demo-\nTinyGL\nSDL 1.2\n", 0, 0, 0x000000FF);
// swap buffers:
if (SDL_MUSTLOCK(screen) && (SDL_LockSurface(screen) < 0)) {
fprintf(stderr, "SDL ERROR: Can't lock screen: %s\n", SDL_GetError());
return 1;
}
if (testingCopyImage2D && doTextures) {
glBindTexture(GL_TEXTURE_2D, tex);
glReadBuffer(GL_FRONT);
glCopyTexImage2D(GL_TEXTURE_2D, // 1
0, // 2
GL_RGBA, // 3
0, // 4
256, // 5
256, // 6
256, 0);
}
/*
printf("\nRMASK IS %u",screen->format->Rmask);
printf("\nGMASK IS %u",screen->format->Gmask);
printf("\nBMASK IS %u",screen->format->Bmask);
printf("\nAMASK IS %u",screen->format->Amask);
*/
// Quickly convert all pixels to the correct format
#if TGL_FEATURE_RENDER_BITS == 32
if (needsRGBAFix)
for (int i = 0; i < frameBuffer->xsize * frameBuffer->ysize; i++) {
#define DATONE (frameBuffer->pbuf[i])
DATONE = ((DATONE & 0x000000FF)) << screen->format->Rshift | ((DATONE & 0x0000FF00) >> 8) << screen->format->Gshift |
((DATONE & 0x00FF0000) >> 16) << screen->format->Bshift;
}
#endif
ZB_copyFrameBuffer(frameBuffer, screen->pixels, screen->pitch);
if (SDL_MUSTLOCK(screen))
SDL_UnlockSurface(screen);
SDL_Flip(screen);
if (fps > 0)
if ((1000 / fps) > (SDL_GetTicks() - tNow)) {
SDL_Delay((1000 / fps) - (SDL_GetTicks() - tNow)); // Yay stable framerate!
}
// check for error conditions:
char* sdl_error = SDL_GetError();
if (sdl_error[0] != '\0') {
fprintf(stderr, "SDL ERROR: \"%s\"\n", sdl_error);
SDL_ClearError();
}
// update fps:
if (tNow >= tLastFps + 5000) {
printf("%i frames in %f secs, %f frames per second.\n", frames, (float)(tNow - tLastFps) * 0.001f,
(float)frames * 1000.0f / (float)(tNow - tLastFps));
tLastFps = tNow;
frames = 0;
}
}
printf("%i frames in %f secs, %f frames per second.\n", frames, (float)(tNow - tLastFps) * 0.001f, (float)frames * 1000.0f / (float)(tNow - tLastFps));
// cleanup:
glDeleteTextures(1, &tex);
// glDeleteList(modelDisplayList);
if (dlExists)
glDeleteLists(modelDisplayList, 1);
FreeModelArray();
ZB_close(frameBuffer);
glClose();
if (SDL_WasInit(SDL_INIT_VIDEO))
SDL_QuitSubSystem(SDL_INIT_VIDEO);
#ifdef PLAY_MUSIC
mhalt();
Mix_FreeMusic(myTrack);
acleanup();
#endif
SDL_Quit();
return 0;
}