ref: 0aaced64e40dfdb26220d5f384ff68514aa6db4f
parent: 8ef11f40e6f394aa471d57a048737d8dca24eac8
author: David <gek@katherine>
date: Thu Feb 11 14:16:12 EST 2021
Update
--- a/src/SDL_Examples/Makefile
+++ b/src/SDL_Examples/Makefile
@@ -7,4 +7,4 @@
clean:
rm -f $(ALL_T)
gears:
- gcc gears.c ../libTinyGL.a -o gears $(GL_INCLUDES) $(GL_LIBS) $(CFLAGS) -lSDL -lm
\ No newline at end of file
+ gcc gears.c ../libTinyGL.a -o gears $(GL_INCLUDES) $(GL_LIBS) $(CFLAGS) -lSDL -lSDL_mixer -lmad -logg -lmikmod -logg -lm
binary files /dev/null b/src/SDL_Examples/WWGW.mp3 differ
--- a/src/SDL_Examples/gears.c
+++ b/src/SDL_Examples/gears.c
@@ -11,6 +11,8 @@
#include <string.h>
#include "../include/GL/gl.h"
+#define CHAD_API_IMPL
+#include "include/api_audio.h"
#include <SDL/SDL.h>
#include "../zbuffer.h"
@@ -188,7 +190,7 @@
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
glEnable( GL_DEPTH_TEST );
- glTextSize(GL_TEXT_SIZE16x16);
+ glTextSize(GL_TEXT_SIZE24x24);
/* make the gears */
gear1 = glGenLists(1);
glNewList(gear1, GL_COMPILE);
@@ -212,17 +214,21 @@
int main(int argc, char **argv) {// initialize SDL video:
- int winSizeX=320;
+ int winSizeX=640;
int winSizeY=480;
- if(SDL_Init(SDL_INIT_VIDEO)<0) {+ if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)<0) {fprintf(stderr,"ERROR: cannot initialize SDL video.\n");
return 1;
}
+ ainit(0);
SDL_Surface* screen = NULL;
if((screen=SDL_SetVideoMode( winSizeX, winSizeY, 32, SDL_SWSURFACE)) == 0 ) {fprintf(stderr,"ERROR: Video mode set failed.\n");
return 1;
}
+ track* myTrack = NULL;
+ myTrack = lmus("WWGW.mp3");+ mplay(myTrack, -1, 1000);
SDL_ShowCursor(SDL_DISABLE);
SDL_WM_SetCaption(argv[0],0);
@@ -339,6 +345,9 @@
ZB_close(frameBuffer);
if(SDL_WasInit(SDL_INIT_VIDEO))
SDL_QuitSubSystem(SDL_INIT_VIDEO);
+ mhalt();
+ Mix_FreeMusic(myTrack);
+ acleanup();
SDL_Quit();
return 0;
}
--- /dev/null
+++ b/src/SDL_Examples/include/3dMath.h
@@ -1,0 +1,591 @@
+#ifndef CHAD_MATH_H
+#define CHAD_MATH_H
+#include <math.h>
+#include <string.h>
+typedef float f_;
+typedef unsigned int uint;
+
+typedef struct {f_ d[3];} vec3;+typedef struct {int d[3];} ivec3;+typedef struct {f_ d[4];} vec4;+typedef struct {f_ d[16];} mat4;+mat4 swapRowColumnMajor(mat4 in);
+mat4 lookAt(vec3 eye, vec3 at, vec3 tmp);
+vec4 getrow(mat4 a, uint index);
+vec4 getcol(mat4 a, uint index);
+mat4 identitymat4();
+mat4 scalemat4(vec4 s);
+int invmat4(const mat4 m, mat4* invOut);
+mat4 perspective(f_ fov, f_ aspect, f_ near, f_ far);
+vec3 viewport(uint xdim, uint ydim, vec3 input);
+mat4 rotate(vec3 rotation);
+vec3 rotatev3(vec3 in,vec3 axis, f_ ang);
+mat4 translate(vec3 t);
+f_ clampf(f_ a, f_ min, f_ max);
+f_ lengthv3(vec3 a);
+f_ lengthv4(vec4 a);
+vec3 multvec3(vec3 a, vec3 b);
+vec4 multvec4(vec4 a, vec4 b);
+
+vec3 clampvec3(vec3 a, vec3 min, vec3 max);
+vec4 clampvec4(vec4 a, vec4 min, vec4 max);
+f_ dotv3(vec3 a, vec3 b);
+f_ dotv4(vec4 a, vec4 b);
+mat4 multm4(mat4 a, mat4 b);
+vec4 mat4xvec4(mat4 t, vec4 v);
+vec3 crossv3(vec3 a, vec3 b);
+vec3 scalev3(f_ s, vec3 i);
+
+vec4 scalev4(f_ s, vec4 i);
+vec3 normalizev3(vec3 a);
+vec4 normalizev4(vec4 a);
+vec3 addv3(vec3 a, vec3 b);
+vec4 addv4(vec4 a, vec4 b);
+vec3 subv3(vec3 a, vec3 b);
+vec4 subv4(vec4 a, vec4 b);
+vec3 reflect(vec3 in, vec3 norm);
+vec4 upv3(vec3 in, f_ w);
+vec3 downv4(vec4 in);
+
+//Collision detection
+//These Algorithms return the penetration vector into
+//the shape in the first argument
+//With depth of penetration in element 4
+//if depth of penetration is zero or lower then there is no penetration.
+typedef struct{+ vec4 c;
+ vec3 e;
+}aabb;
+typedef aabb colshape; //c.d[3] determines if it's a sphere or box. 0 or less = box, greater than 0 = sphere
+vec4 spherevsphere(vec4 s1, vec4 s2);
+vec4 boxvbox(aabb b1, aabb b2);
+vec3 closestpointAABB(aabb b, vec3 p);
+vec4 aabbvsphere(aabb box,vec4 sph);
+
+
+#ifdef CHAD_MATH_IMPL
+mat4 swapRowColumnMajor(mat4 in){+ mat4 result;
+ vec4 t;
+ int i = 0;
+ t = getrow(in,i);
+ memcpy(result.d+i*4, t.d, 4*4);i++;
+ t = getrow(in,i);
+ memcpy(result.d+i*4, t.d, 4*4);i++;
+ t = getrow(in,i);
+ memcpy(result.d+i*4, t.d, 4*4);i++;
+ t = getrow(in,i);
+ memcpy(result.d+i*4, t.d, 4*4);
+ return result;
+}
+mat4 lookAt(vec3 eye, vec3 at, vec3 tmp){+ mat4 cw = identitymat4();
+ vec3 zaxis = normalizev3(subv3(at,eye));
+ vec3 xaxis = normalizev3(crossv3(zaxis,tmp));
+ vec3 yaxis = crossv3(xaxis, zaxis);
+ zaxis = scalev3(-1,zaxis);
+ cw.d[0*4+0] = xaxis.d[0];
+ cw.d[1*4+0] = xaxis.d[1];
+ cw.d[2*4+0] = xaxis.d[2];
+ cw.d[3*4+0] = -dotv3(xaxis,eye);
+
+ cw.d[0*4+1] = yaxis.d[0];
+ cw.d[1*4+1] = yaxis.d[1];
+ cw.d[2*4+1] = yaxis.d[2];
+ cw.d[3*4+1] = -dotv3(yaxis,eye);
+
+ cw.d[0*4+2] = zaxis.d[0];
+ cw.d[1*4+2] = zaxis.d[1];
+ cw.d[2*4+2] = zaxis.d[2];
+ cw.d[3*4+2] = -dotv3(zaxis,eye);
+ cw.d[0*4+3] = 0;
+ cw.d[1*4+3] = 0;
+ cw.d[2*4+3] = 0;
+ cw.d[3*4+3] = 1;
+ return cw;
+}
+
+/*
+mat4 lookAt(vec3 eye, vec3 at, vec3 tmp){+ vec3 forw = normalizev3(subv3(eye,at));
+
+ vec3 right = crossv3(normalizev3(tmp),forw);
+ vec3 tup = crossv3(forw,right);
+ mat4 cw = identitymat4();
+ cw.d[0*4+0*1] = right.d[0];
+ cw.d[0*4+1*1] = right.d[1];
+ cw.d[0*4+2*1] = right.d[2];
+
+ cw.d[1*4+0*1] = tup.d[0];
+ cw.d[1*4+1*1] = tup.d[1];
+ cw.d[1*4+2*1] = tup.d[2];
+
+ cw.d[2*4+0*1] = forw.d[0];
+ cw.d[2*4+1*1] = forw.d[1];
+ cw.d[2*4+2*1] = forw.d[2];
+
+ cw.d[3*4+0*1] = eye.d[0];
+ cw.d[3*4+1*1] = eye.d[1];
+ cw.d[3*4+2*1] = eye.d[2];
+ cw.d[3*4+3*1] = 1.0;
+ return cw;
+}
+*/
+vec4 getrow(mat4 a, uint index){+ return (vec4){+ .d[0]=a.d[0*4+index],
+ .d[1]=a.d[1*4+index],
+ .d[2]=a.d[2*4+index],
+ .d[3]=a.d[3*4+index]
+ };
+}
+vec3 rotatev3(vec3 in, vec3 axis, f_ ang){+ vec3 t1 = scalev3(cosf(ang),in);
+ vec3 t2 = scalev3(sinf(ang),crossv3(axis,in));
+ vec3 t3 = scalev3((1-cosf(ang))*dotv3(axis,in),axis);
+ return addv3(t1,addv3(t2,t3));
+}
+vec4 getcol(mat4 a, uint index){+ return (vec4){+ .d[0]=a.d[index*4+0],
+ .d[1]=a.d[index*4+1],
+ .d[2]=a.d[index*4+2],
+ .d[3]=a.d[index*4+3]
+ };
+}
+mat4 scalemat4(vec4 s){+ mat4 ret;
+ for(int i = 1; i < 16; i++)
+ ret.d[i]= 0.0;
+ ret.d[0*4 + 0] = s.d[0]; //x scale
+ ret.d[1*4 + 1] = s.d[1]; //y scale
+ ret.d[2*4 + 2] = s.d[2]; //z scale
+ ret.d[3*4 + 3] = s.d[3]; //w scale
+ return ret;
+}
+mat4 identitymat4(){+ return scalemat4(
+ (vec4){.d[0]=1.0,.d[1]=1.0,.d[2]=1.0,.d[3]=1.0}+ );
+}
+int invmat4(const mat4 m, mat4* invOut) //returns 1 if successful
+{+ mat4 inv;
+ f_ det;
+ int i;
+
+ inv.d[0] = m.d[5] * m.d[10] * m.d[15] -
+ m.d[5] * m.d[11] * m.d[14] -
+ m.d[9] * m.d[6] * m.d[15] +
+ m.d[9] * m.d[7] * m.d[14] +
+ m.d[13] * m.d[6] * m.d[11] -
+ m.d[13] * m.d[7] * m.d[10];
+
+ inv.d[4] = -m.d[4] * m.d[10] * m.d[15] +
+ m.d[4] * m.d[11] * m.d[14] +
+ m.d[8] * m.d[6] * m.d[15] -
+ m.d[8] * m.d[7] * m.d[14] -
+ m.d[12] * m.d[6] * m.d[11] +
+ m.d[12] * m.d[7] * m.d[10];
+
+ inv.d[8] = m.d[4] * m.d[9] * m.d[15] -
+ m.d[4] * m.d[11] * m.d[13] -
+ m.d[8] * m.d[5] * m.d[15] +
+ m.d[8] * m.d[7] * m.d[13] +
+ m.d[12] * m.d[5] * m.d[11] -
+ m.d[12] * m.d[7] * m.d[9];
+
+ inv.d[12] = -m.d[4] * m.d[9] * m.d[14] +
+ m.d[4] * m.d[10] * m.d[13] +
+ m.d[8] * m.d[5] * m.d[14] -
+ m.d[8] * m.d[6] * m.d[13] -
+ m.d[12] * m.d[5] * m.d[10] +
+ m.d[12] * m.d[6] * m.d[9];
+
+ inv.d[1] = -m.d[1] * m.d[10] * m.d[15] +
+ m.d[1] * m.d[11] * m.d[14] +
+ m.d[9] * m.d[2] * m.d[15] -
+ m.d[9] * m.d[3] * m.d[14] -
+ m.d[13] * m.d[2] * m.d[11] +
+ m.d[13] * m.d[3] * m.d[10];
+
+ inv.d[5] = m.d[0] * m.d[10] * m.d[15] -
+ m.d[0] * m.d[11] * m.d[14] -
+ m.d[8] * m.d[2] * m.d[15] +
+ m.d[8] * m.d[3] * m.d[14] +
+ m.d[12] * m.d[2] * m.d[11] -
+ m.d[12] * m.d[3] * m.d[10];
+
+ inv.d[9] = -m.d[0] * m.d[9] * m.d[15] +
+ m.d[0] * m.d[11] * m.d[13] +
+ m.d[8] * m.d[1] * m.d[15] -
+ m.d[8] * m.d[3] * m.d[13] -
+ m.d[12] * m.d[1] * m.d[11] +
+ m.d[12] * m.d[3] * m.d[9];
+
+ inv.d[13] = m.d[0] * m.d[9] * m.d[14] -
+ m.d[0] * m.d[10] * m.d[13] -
+ m.d[8] * m.d[1] * m.d[14] +
+ m.d[8] * m.d[2] * m.d[13] +
+ m.d[12] * m.d[1] * m.d[10] -
+ m.d[12] * m.d[2] * m.d[9];
+
+ inv.d[2] = m.d[1] * m.d[6] * m.d[15] -
+ m.d[1] * m.d[7] * m.d[14] -
+ m.d[5] * m.d[2] * m.d[15] +
+ m.d[5] * m.d[3] * m.d[14] +
+ m.d[13] * m.d[2] * m.d[7] -
+ m.d[13] * m.d[3] * m.d[6];
+
+ inv.d[6] = -m.d[0] * m.d[6] * m.d[15] +
+ m.d[0] * m.d[7] * m.d[14] +
+ m.d[4] * m.d[2] * m.d[15] -
+ m.d[4] * m.d[3] * m.d[14] -
+ m.d[12] * m.d[2] * m.d[7] +
+ m.d[12] * m.d[3] * m.d[6];
+
+ inv.d[10] = m.d[0] * m.d[5] * m.d[15] -
+ m.d[0] * m.d[7] * m.d[13] -
+ m.d[4] * m.d[1] * m.d[15] +
+ m.d[4] * m.d[3] * m.d[13] +
+ m.d[12] * m.d[1] * m.d[7] -
+ m.d[12] * m.d[3] * m.d[5];
+
+ inv.d[14] = -m.d[0] * m.d[5] * m.d[14] +
+ m.d[0] * m.d[6] * m.d[13] +
+ m.d[4] * m.d[1] * m.d[14] -
+ m.d[4] * m.d[2] * m.d[13] -
+ m.d[12] * m.d[1] * m.d[6] +
+ m.d[12] * m.d[2] * m.d[5];
+
+ inv.d[3] = -m.d[1] * m.d[6] * m.d[11] +
+ m.d[1] * m.d[7] * m.d[10] +
+ m.d[5] * m.d[2] * m.d[11] -
+ m.d[5] * m.d[3] * m.d[10] -
+ m.d[9] * m.d[2] * m.d[7] +
+ m.d[9] * m.d[3] * m.d[6];
+
+ inv.d[7] = m.d[0] * m.d[6] * m.d[11] -
+ m.d[0] * m.d[7] * m.d[10] -
+ m.d[4] * m.d[2] * m.d[11] +
+ m.d[4] * m.d[3] * m.d[10] +
+ m.d[8] * m.d[2] * m.d[7] -
+ m.d[8] * m.d[3] * m.d[6];
+
+ inv.d[11] = -m.d[0] * m.d[5] * m.d[11] +
+ m.d[0] * m.d[7] * m.d[9] +
+ m.d[4] * m.d[1] * m.d[11] -
+ m.d[4] * m.d[3] * m.d[9] -
+ m.d[8] * m.d[1] * m.d[7] +
+ m.d[8] * m.d[3] * m.d[5];
+
+ inv.d[15] = m.d[0] * m.d[5] * m.d[10] -
+ m.d[0] * m.d[6] * m.d[9] -
+ m.d[4] * m.d[1] * m.d[10] +
+ m.d[4] * m.d[2] * m.d[9] +
+ m.d[8] * m.d[1] * m.d[6] -
+ m.d[8] * m.d[2] * m.d[5];
+
+ det = m.d[0] * inv.d[0] + m.d[1] * inv.d[4] + m.d[2] * inv.d[8] + m.d[3] * inv.d[12];
+ if (det == 0)
+ return 0;
+ det = 1.0 / det;
+ for (i = 0; i < 16; i++)
+ invOut->d[i] = inv.d[i] * det;
+ return 1;
+}
+mat4 perspective(f_ fov, f_ aspect, f_ near, f_ far){+ mat4 ret;
+ f_ D2R = 3.14159265358979323 / 180.0;
+ f_ yScale = 1.0/tanf(D2R * fov/2);
+ f_ xScale = yScale/aspect;
+ f_ nearmfar = near-far;
+
+ ret.d[0*4+0] = xScale; ret.d[0*4+1]=0; ret.d[0*4+2]=0; ret.d[0*4+3]=0;
+ ret.d[1*4+0]=0; ret.d[1*4+1]=yScale;ret.d[1*4+2]=0; ret.d[1*4+3]=0;
+ ret.d[2*4+0]=0; ret.d[2*4+1]=0; ret.d[2*4+2]=(far+near)/nearmfar;ret.d[2*4+3]=-1;
+ ret.d[3*4+0]=0; ret.d[3*4+1]=0; ret.d[3*4+2]=2*far*near/nearmfar;ret.d[3*4+3]=0;
+
+ /*
+ ret.d[0*4+0] = xScale; ret.d[0*4+1]=0; ret.d[0*4+2]=0; ret.d[0*4+3]=0;
+ ret.d[1*4+0]=0; ret.d[1*4+1]=yScale;ret.d[1*4+2]=0; ret.d[1*4+3]=0;
+ ret.d[2*4+0]=0; ret.d[2*4+1]=0; ret.d[2*4+2]=(far+near)/nearmfar; ret.d[2*4+3]=2*far*near/nearmfar;
+ ret.d[3*4+0]=0; ret.d[3*4+1]=0; ret.d[3*4+2]=-1; ret.d[3*4+3]=0;
+ */
+ return ret;
+}
+vec3 viewport(uint xdim, uint ydim, vec3 input){+ input.d[0] += 1;
+ input.d[1] += 1;
+ input.d[0] *= (f_)xdim / 2.0;
+ input.d[1] *= (f_)ydim / 2.0;
+ input.d[2] = (input.d[2])/2.0;
+ return input;
+}
+mat4 rotate(vec3 rotation){+ f_ a = rotation.d[0];
+ f_ b = rotation.d[1];
+ f_ c = rotation.d[2];
+ mat4 rm;
+ rm.d[0*4 + 0] = cosf(a)*cosf(b);
+ rm.d[1*4 + 0] = sinf(a)*cosf(b);
+ rm.d[2*4 + 0] = -sinf(b);
+ rm.d[0*4 + 1] = cosf(a)*sinf(b)*sinf(c)-sinf(a)*cosf(c);
+ rm.d[1*4 + 1] = sinf(a)*sinf(b)*sinf(c)+cosf(a)*cosf(c);
+ rm.d[2*4 + 1] = cosf(b)*sinf(c);
+ rm.d[0*4 + 2] = cosf(a)*sinf(b)*cosf(c)+sinf(a)*sinf(c);
+ rm.d[1*4 + 2] = sinf(a)*sinf(b)*cosf(c)-cosf(a)*sinf(c);
+ rm.d[2*4 + 2] = cosf(b)*cosf(c);
+ //the other parts
+ rm.d[0*4 + 3] = 0;
+ rm.d[1*4 + 3] = 0;
+ rm.d[2*4 + 3] = 0;
+ rm.d[3*4 + 3] = 1; //the bottom right corner of the matrix.
+ rm.d[3*4 + 0] = 0;
+ rm.d[3*4 + 1] = 0;
+ rm.d[3*4 + 2] = 0;
+ return rm;
+}
+mat4 translate(vec3 t){+ mat4 tm = identitymat4();
+ tm.d[3*4+0] = t.d[0];
+ tm.d[3*4+1] = t.d[1];
+ tm.d[3*4+2] = t.d[2];
+ return tm;
+}
+
+f_ clampf(f_ a, f_ min, f_ max){+ if(a<min) return min;
+ if(a>max) return max;
+ return a;
+}
+f_ lengthv3(vec3 a){+ return sqrtf(a.d[0] * a.d[0] + a.d[1] * a.d[1] + a.d[2] * a.d[2]);
+}
+f_ lengthv4(vec4 a){+ return sqrtf(a.d[0] * a.d[0] + a.d[1] * a.d[1] + a.d[2] * a.d[2] + a.d[3] * a.d[3]);
+}
+vec3 multvec3(vec3 a, vec3 b){+ return (vec3){+ .d[0]=a.d[0]*b.d[0],
+ .d[1]=a.d[1]*b.d[1],
+ .d[2]=a.d[2]*b.d[2]
+ };
+}
+vec4 multvec4(vec4 a, vec4 b){+ return (vec4){+ .d[0]=a.d[0]*b.d[0],
+ .d[1]=a.d[1]*b.d[1],
+ .d[2]=a.d[2]*b.d[2],
+ .d[3]=a.d[3]*b.d[3]
+ };
+}
+vec3 clampvec3(vec3 a, vec3 min, vec3 max){+ vec3 ret;
+ ret.d[0] = clampf(a.d[0],min.d[0],max.d[0]);
+ ret.d[1] = clampf(a.d[1],min.d[1],max.d[1]);
+ ret.d[2] = clampf(a.d[2],min.d[2],max.d[2]);
+ return ret;
+}
+vec4 clampvec4(vec4 a, vec4 min, vec4 max){+ vec4 ret;
+ ret.d[0] = clampf(a.d[0],min.d[0],max.d[0]);
+ ret.d[1] = clampf(a.d[1],min.d[1],max.d[1]);
+ ret.d[2] = clampf(a.d[2],min.d[2],max.d[2]);
+ ret.d[3] = clampf(a.d[3],min.d[3],max.d[3]);
+ return ret;
+}
+f_ dotv3(vec3 a, vec3 b){+ return a.d[0] * b.d[0] + a.d[1] * b.d[1] + a.d[2] * b.d[2];
+}
+f_ dotv4(vec4 a, vec4 b){+ return a.d[0] * b.d[0] + a.d[1] * b.d[1] + a.d[2] * b.d[2] + a.d[3] * b.d[3];
+}
+mat4 multm4(mat4 a, mat4 b){+ mat4 ret;
+ for(int i = 0; i < 4; i++)
+ for(int j = 0; j < 4; j++)
+ ret.d[i*4 + j] = dotv4(
+ getrow(a, j),
+ getcol(b, i)
+ );
+ return ret;
+}
+vec4 mat4xvec4(mat4 t, vec4 v){+ uint i = 0;
+ vec4 vr;
+ vr.d[0] = t.d[0*4+i] * v.d[0] +
+ t.d[1*4+i] * v.d[1] +
+ t.d[2*4+i] * v.d[2] +
+ t.d[3*4+i] * v.d[3];
+ i++;
+ vr.d[1] = t.d[0*4+i] * v.d[0] +
+ t.d[1*4+i] * v.d[1] +
+ t.d[2*4+i] * v.d[2] +
+ t.d[3*4+i] * v.d[3];
+ i++;
+ vr.d[2] = t.d[0*4+i] * v.d[0] +
+ t.d[1*4+i] * v.d[1] +
+ t.d[2*4+i] * v.d[2] +
+ t.d[3*4+i] * v.d[3];
+ i++;
+ vr.d[3] = t.d[0*4+i] * v.d[0] +
+ t.d[1*4+i] * v.d[1] +
+ t.d[2*4+i] * v.d[2] +
+ t.d[3*4+i] * v.d[3];
+ return vr;
+}
+vec3 crossv3(vec3 a, vec3 b){+ vec3 retval;
+ retval.d[0] = a.d[1] * b.d[2] - a.d[2] * b.d[1];
+ retval.d[1] = a.d[2] * b.d[0] - a.d[0] * b.d[2];
+ retval.d[2] = a.d[0] * b.d[1] - a.d[1] * b.d[0];
+ return retval;
+}
+vec3 scalev3(f_ s, vec3 i){i.d[0] *= s; i.d[1] *= s; i.d[2] *= s; return i;}+
+vec4 scalev4(f_ s, vec4 i){i.d[0] *= s; i.d[1] *= s; i.d[2] *= s;i.d[3] *= s; return i;}+vec3 normalizev3(vec3 a){+ if(lengthv3(a)==0) return (vec3){.d[0]=0.0,.d[1]=0.0,.d[2]=1.0};+ return scalev3(1.0/lengthv3(a), a);
+}
+vec4 normalizev4(vec4 a){+ if(lengthv4(a)==0) return (vec4){.d[0]=0.0,.d[1]=0.0,.d[2]=1.0,.d[3]=0.0};+ return scalev4(1.0/lengthv4(a), a);
+}
+vec3 addv3(vec3 a, vec3 b){+ a.d[0] += b.d[0]; a.d[1] += b.d[1]; a.d[2] += b.d[2]; return a;
+}
+vec4 addv4(vec4 a, vec4 b){+ a.d[0] += b.d[0]; a.d[1] += b.d[1]; a.d[2] += b.d[2]; a.d[3] += b.d[3]; return a;
+}
+vec3 subv3(vec3 a, vec3 b){+ return addv3(a,scalev3(-1,b));
+}
+vec4 subv4(vec4 a, vec4 b){+ return addv4(a,scalev4(-1,b));
+}
+vec3 reflect(vec3 in, vec3 norm){+ return
+ addv3(in, //I +
+ scalev3(-2.0*dotv3(norm, in), //-2.0 * dotv3(norm,in) *
+ norm //N
+ )
+ );
+}
+vec4 upv3(vec3 in, f_ w){+ return (vec4){+ .d[0]=in.d[0],
+ .d[1]=in.d[1],
+ .d[2]=in.d[2],
+ .d[3]=w
+ };
+}
+vec3 downv4(vec4 in){+ return (vec3){+ .d[0]=in.d[0],
+ .d[1]=in.d[1],
+ .d[2]=in.d[2]
+ };
+}
+
+//Collision detection
+//These Algorithms return the penetration vector into
+//the shape in the first argument
+//With depth of penetration in element 4
+//if depth of penetration is zero or lower then there is no penetration.
+vec4 spherevsphere(vec4 s1, vec4 s2){ //x,y,z,radius+ vec4 ret;
+ ret = upv3(
+ subv3(
+ downv4(s1),
+ downv4(s2)
+ )
+ ,0.0
+ );
+ ret.d[3]= -1 * sqrtf(
+ (s1.d[0]-s2.d[0])*(s1.d[0]-s2.d[0])+
+ (s1.d[1]-s2.d[1])*(s1.d[1]-s2.d[1])+
+ (s1.d[2]-s2.d[2])*(s1.d[2]-s2.d[2])
+ ) + s1.d[3] + s2.d[3];
+ return ret;
+}
+vec4 boxvbox(aabb b1, aabb b2){ //Just points along the minimum separating axis, Nothing fancy.+ vec4 ret = (vec4){+ .d[0]=0,
+ .d[1]=0,
+ .d[2]=0,
+ .d[3]=0
+ };
+ //vec3 sumextents = addv3(b1.e,b2.e);
+ vec3 b1min = subv3(downv4(b1.c),b1.e);
+ vec3 b2min = subv3(downv4(b2.c),b2.e);
+ vec3 b1max = addv3(downv4(b1.c),b1.e);
+ vec3 b2max = addv3(downv4(b2.c),b2.e);
+ vec3 axispen[2];
+ //For any overlap, these are negative.
+ //These ones point toward b2 in an intersection, so they need to be inverted.
+ axispen[0].d[0] = b1min.d[0] - b2max.d[0];
+ axispen[0].d[1] = b1min.d[1] - b2max.d[1];
+ axispen[0].d[2] = b1min.d[2] - b2max.d[2];
+ //These ones point toward b1 in an intersection. They can be left alone.
+ axispen[1].d[0] = b2min.d[0] - b1max.d[0];
+ axispen[1].d[1] = b2min.d[1] - b1max.d[1];
+ axispen[1].d[2] = b2min.d[2] - b1max.d[2];
+ //if they are not intersecting...
+ if(!(
+ (axispen[0].d[0] < 0 && axispen[1].d[0] < 0) &&
+ (axispen[0].d[1] < 0 && axispen[1].d[1] < 0) &&
+ (axispen[0].d[2] < 0 && axispen[1].d[2] < 0)
+ )){+ return ret;
+ }
+ axispen[0] = scalev3(-1,axispen[0]); //invert these to point toward b1
+ int minimum = 0;
+ f_ mindist = fabsf(axispen[0].d[0]);
+ for(int i = 1; i < 6;i++){+ f_ d = fabsf(axispen[i/3].d[i%3]);
+ if(d < mindist){+ minimum = i;
+ mindist = d;
+ }
+ }
+ ret =
+ (vec4){+ .d[0]=(minimum%3==0)?axispen[minimum/3].d[minimum%3]:0,
+ .d[1]=(minimum%3==1)?axispen[minimum/3].d[minimum%3]:0,
+ .d[2]=(minimum%3==2)?axispen[minimum/3].d[minimum%3]:0,
+ .d[3]=mindist
+ };
+ return ret;
+}
+vec3 closestpointAABB(aabb b, vec3 p){+ vec3 b1min = subv3(downv4(b.c),b.e);
+ vec3 b1max = addv3(downv4(b.c),b.e);
+ return clampvec3(p,b1min,b1max);
+}
+vec4 aabbvsphere(aabb box,vec4 sph){+ vec4 ret;
+ vec3 p = closestpointAABB(box,downv4(sph));
+ vec3 v = subv3(p,downv4(sph));
+ f_ d2 = dotv3(v,v);
+
+ if(d2 <= sph.d[3] * sph.d[3]){+ f_ len = lengthv3(v);
+ ret = upv3(v,len);
+ return ret;
+ }
+ else
+ return (vec4){+ .d[0]=0,
+ .d[1]=0,
+ .d[2]=0,
+ .d[3]=0
+ };
+
+}
+//end of chad math impl
+#endif
+//END Math_Library.h~~~~~~~~~~~~~~~~~~~~
+
+#endif
--- /dev/null
+++ b/src/SDL_Examples/include/api_audio.h
@@ -1,0 +1,97 @@
+/*
+ *
+Licensed under CC0, public domain software rendering toolkit.
+ *
+ * */
+
+/*
+HOW TO BUILD THINGS USING THIS LIBRARY
+You gotta use a makefile
+
+Make sure to #include "api.h" into your code. You can only include it in one file.
+
+If you aren't using mixer, I recommend disabling USE_MIXER at the top, and then you don't need to link to it.
+
+
+*/
+#define USE_MIXER
+#define USE_MP3
+//#ifdef __TINYC__
+//#define STBI_NO_SIMD
+//#define SDL_DISABLE_IMMINTRIN_H
+//#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#define SDL_MAIN_HANDLED
+#include <SDL/SDL.h>
+
+//NOTE: you might need to change these depending on your project structure.
+
+#ifdef CHAD_API_IMPL
+#define CHAD_MATH_IMPL
+#endif //
+#include "3dMath.h"
+//#include "../../include/fixedmath.h"
+typedef unsigned char uchar;
+
+extern uint R_;
+extern uint G_;
+extern uint B_;
+extern uint A_;
+
+
+#ifdef USE_MIXER
+#include<SDL/SDL_mixer.h>
+void ainit(int needsSDLINIT);
+void acleanup();
+
+typedef Mix_Chunk samp;
+typedef Mix_Music track;
+samp* lwav(const char* t);
+track* lmus(const char* t);
+samp* qlwav(Uint8* w);
+int aplay(samp* samp, int loops);
+void aPos(int chan, int angle, unsigned char dist);
+void aHalt(int chan);
+int mplay(track* mus,int loops, int ms);
+void mhalt();
+#ifdef CHAD_API_IMPL
+void ainit(int needsSDLINIT){+ if(needsSDLINIT)
+ if (SDL_Init(SDL_INIT_AUDIO)!=0) //We only use SDL for mixer...
+ { + fprintf(stderr, "SDL_Init Error: %s\n", SDL_GetError());
+ exit(0);
+ }
+ Mix_Init(MIX_INIT_OGG | MIX_INIT_MP3);
+ if(-1 == Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 1024)) {printf("\nAudio can't init :(");exit(2);}+}
+void acleanup(){+ Mix_CloseAudio();
+ Mix_Quit();
+ SDL_Quit();
+}
+void mhalt(){Mix_HaltMusic();}+void aHalt(int chan){Mix_HaltChannel(chan);}+samp* lwav(const char* t){return Mix_LoadWAV(t);}+track* lmus(const char* t){return Mix_LoadMUS(t);}+samp* qlwav(Uint8* w){return Mix_QuickLoad_WAV(w);}+int aplay(samp* samp, int loops){return Mix_PlayChannel(-1, samp, loops);}+void aPos(int chan, int angle, unsigned char dist){Mix_SetPosition(chan,angle,dist);}+int mplay(track* mus,int loops, int ms){return Mix_FadeInMusic(mus,loops,ms);}+//end of chad api impl
+#endif
+//end of USE_MIXER
+#endif
+
+
+
+#define MAX(x,y) (x>y?x:y)
+#define MIN(x,y) (x<y?x:y)
+#define CHAD_API_NEAR 0.0
+
+
+
+
--- a/src/ztext.c
+++ b/src/ztext.c
@@ -6,7 +6,7 @@
#include "include/GL/gl.h"
#include "zgl.h"
#include "font8x8_basic.h"
-GLTEXTSIZE textsize;
+GLTEXTSIZE textsize = 1;
void glTextSize(GLTEXTSIZE mode){textsize = mode;}//Set text size void renderchar(char *bitmap, int _x, int _y, PIXEL p) {