added a bunch of features, preparing to read from obj files for display

.clang-format

@@ -1 +1,2 @@
 IndentWidth: 4
+ColumnLimit: 80

Makefile

@@ -1,12 +1,12 @@
-CC = gcc
+CC = clang #Set compiler
-CFLAGS = -pg -g -Wall 
+CFLAGS = -pg -g -Wall -O2 -pg #set compiler flags
-LDFLAGS = -pg -g 
+LDFLAGS = -pg -g #set linker flags
-LDLIBS = -lraylib -lm
+LDLIBS = -lraylib -lm #set libraries to use
-objects  = c3d.o
+objects  = c3d.o reader.o arrayfuncs.o vecfunc.c #list all object files
 
-c3d: $(objects)
+c3d: $(objects) #State that to make the c3d executeable, we need all objects
 
-$(objects): %.o: %.c
+$(objects): %.o: %.c #State that to make each object, we use its respective c file
 
-clean:
+clean: #to clean remove all object files and the executable
 	rm -f *.o c3d 

arrayfuncs.c

@@ -0,0 +1,11 @@
+#include "c3dtypes.h"
+
+void TriArrayAppend(TriArray *tarr, Tri t) {
+    tarr->arr[tarr->length] = t;
+    tarr->length = tarr->length + 1;
+}
+
+void Tri2DArrayAppend(Tri2DArray *tarr, Tri2D t) {
+    tarr->arr[tarr->length] = t;
+    tarr->length = tarr->length + 1;
+}

arrayfuncs.h

@@ -0,0 +1,8 @@
+#ifndef ARRAYFUNCS_HEADER
+#define ARRAYFUNCS_HEADER
+
+void TriArrayAppend(TriArray *tarr, Tri t);
+
+void Tri2DArrayAppend(Tri2DArray *tarr, Tri2D t);
+
+#endif

c3d.c

@@ -1,8 +1,13 @@
+#include "raylib.h"
+#include "reader.h"
 #include <math.h>
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
-#include "raylib.h"
+#include <string.h>
+
+#include "c3dtypes.h"
+#include "arrayfuncs.h"
+#include "vecfunc.h"
 
 
 const int RENDERWIDTH = 1920;
@@ -11,67 +16,18 @@ const int RENDERHEIGHT = 1080;
 const int HALFWIDTH = RENDERWIDTH / 2;
 const int HALFHEIGHT = RENDERHEIGHT / 2;
 
-
 const int SCREENWIDTH = 1280;
 const int SCREENHEIGHT = 720;
 
 const float WIDTHSCALE = (float)RENDERWIDTH / SCREENWIDTH;
 const float HEIGHTSCALE = (float)RENDERHEIGHT / SCREENHEIGHT;
 
-
 const float fov = 70.0 / 180.0 * 3.14159265369;
 const float half_fov = fov / 2;
 
 float proj; // HALFWIDTH / tan(half_fov) Inited later
 
 
-
-struct LocalCam {
-    Vector3 position;
-    Vector3 velocity;
-    Vector3 acceleration;
-    Vector3 angles;
-    Vector3 angleVelocity;
-    Vector3 angleAcceleration;
-};
-typedef struct LocalCam LocalCam;
-
-struct Tri {
-    Vector3 a;
-    Vector3 b;
-    Vector3 c;
-
-    Color color;
-};
-typedef struct Tri Tri;
-
-struct Tri2D{
-    Vector2 a;
-    Vector2 b;
-    Vector2 c;
-
-    Color color;
-};
-typedef struct Tri2D Tri2D;
-
-struct Zee {
-    int depth;
-    Tri2D * triangle;
-};
-typedef struct Zee Zee;
-
-struct TriArray {
-    int length;
-    Tri* arr;
-};
-typedef struct TriArray TriArray;
-
-struct Tri2DArray {
-    int length;
-    Tri2D* arr;
-};
-typedef struct Tri2DArray Tri2DArray;
-
 double Min(double a, double b) {
     if (a > b) {
         return b;
@@ -86,13 +42,12 @@ double Max(double a, double b){
     return a;
 }
 
-
 static inline int IndexOfZBuff(int row, int col) {
     return row + RENDERWIDTH * col;
 }
 
-
+// sort triangle verts so that point A is the "highest" point (lowest y val) and
-//sort triangle verts so that point A is the "highest" point (lowest y val) and point C is the "lowest" pont (highest y val)
+// point C is the "lowest" pont (highest y val)
 void Tri2DSortByY(Tri2D *t) {
     Vector2 temp;
     if (t->a.y > t->b.y) {
@@ -112,18 +67,25 @@ void Tri2DSortByY(Tri2D * t){
     }
 }
 
-//Draws triangle with a flat top. Note A and B must be the top points with C being the bottom "spike"
+// Draws triangle with a flat top. Note A and B must be the top points with C
+// being the bottom "spike"
 void FillTopFlatZbuffer(Zee *zee, Tri2D *t, Tri2D *tp) {
     if (t->b.x < t->a.x) {
         Vector2 e = t->b;
         t->b = t->a;
         t->a = e;
     }
-    //Becasue we are trying to get the x values in terms of the y values, we need inverse slope
+    // Becasue we are trying to get the x values in terms of the y values, we
-    float atocslopeinv = (t->c.x - t->a.x) / (t->c.y - t->a.y); //dif in x from start to end with a and c
+    // need inverse slope
-    float btocslopinv = (t->c.x - t->b.x) / (t->c.y - t->b.y); //dif in x from start to end with b and c 
+    float atocslopeinv =
+        (t->c.x - t->a.x) /
+        (t->c.y - t->a.y); // dif in x from start to end with a and c
+    float btocslopinv =
+        (t->c.x - t->b.x) /
+        (t->c.y - t->b.y); // dif in x from start to end with b and c
 
-    //start at bottom of triangle (point c) so that we do not need to determine which vertex is on which side and increment it with its proper slope
+    // start at bottom of triangle (point c) so that we do not need to determine
+    // which vertex is on which side and increment it with its proper slope
     double curx1 = t->c.x;
     double curx2 = t->c.x;
 
@@ -133,26 +95,36 @@ void FillTopFlatZbuffer(Zee * zee , Tri2D* t, Tri2D * tp) {
                 zee[IndexOfZBuff(i, scanline)].triangle = tp;
             }
         }
-	curx1 -= atocslopeinv; //subtract because we are working backwards (reason why we start with point c in slope equtn)
+        curx1 -=
+            atocslopeinv; // subtract because we are working backwards (reason
+                          // why we start with point c in slope equtn)
         curx2 -= btocslopinv;
     }
 }
 void PrintTri2D(Tri2D t) {
-    printf("{(TRI2D) A: (%f, %f), B: (%f, %f), C:(%f,%f) }\n ",t.a.x,t.a.y,t.b.x, t.b.y, t.c.x, t.c.y); 
+    printf("{(TRI2D) A: (%f, %f), B: (%f, %f), C:(%f,%f) }\n ", t.a.x, t.a.y,
+           t.b.x, t.b.y, t.c.x, t.c.y);
 }
 
-//Draws triangle with a flat bottomp. Note B and C must be the bottom points with A being the top "spike"
+// Draws triangle with a flat bottomp. Note B and C must be the bottom points
+// with A being the top "spike"
 void FillBottomFlatZbuffer(Zee *zee, Tri2D *t, Tri2D *tp) {
     if (t->c.x < t->b.x) {
         Vector2 e = t->c;
         t->c = t->b;
         t->b = e;
     }
-    //Becasue we are trying to get the x values in terms of the y values, we need inverse slope
+    // Becasue we are trying to get the x values in terms of the y values, we
-    float atobslopeinv = (t->b.x - t->a.x) / (t->b.y - t->a.y); //dif in x from start to end with a and c
+    // need inverse slope
-    float atocslopeinv = (t->c.x - t->a.x) / (t->c.y - t->a.y); //dif in x from start to end with b and c 
+    float atobslopeinv =
+        (t->b.x - t->a.x) /
+        (t->b.y - t->a.y); // dif in x from start to end with a and c
+    float atocslopeinv =
+        (t->c.x - t->a.x) /
+        (t->c.y - t->a.y); // dif in x from start to end with b and c
 
-    //start at top of triangle (point c) so that we do not need to determine which vertex is on which side and increment it with its proper slope
+    // start at top of triangle (point c) so that we do not need to determine
+    // which vertex is on which side and increment it with its proper slope
     double curx1 = t->a.x;
     double curx2 = t->a.x;
 
@@ -165,25 +137,24 @@ void FillBottomFlatZbuffer(Zee * zee, Tri2D* t, Tri2D * tp) {
         curx1 += atobslopeinv;
         curx2 += atocslopeinv;
     }
-
 }
 
-
-
 void DrawTriZuff(Zee *zbuf, Tri2D *t) {
     Tri2DSortByY(t);
 
     if (t->b.y == t->c.y) { // if bottom of triangle is flat
         FillBottomFlatZbuffer(zbuf, t, t);
-    }
+    } else if (t->a.y == t->b.y) { // if top of triangle is flat
-    else if (t->a.y == t->b.y) { //if top of triangle is flat
 
         FillTopFlatZbuffer(zbuf, t, t);
 
     } else {        // funny split tri
-	Vector2 v4; //v4 is the vertex on the line between a and c. It is used to split the triangle into a top and bottom
+        Vector2 v4; // v4 is the vertex on the line between a and c. It is used
+                    // to split the triangle into a top and bottom
         v4.y = t->b.y;
-	float slope = (float)((t->c.x) - (t->a.x)) /((float)(t->c.y - t->a.y)); //get slope in run over rise becasue we need to find x
+        float slope = (float)((t->c.x) - (t->a.x)) /
+                      ((float)(t->c.y - t->a.y)); // get slope in run over rise
+                                                  // becasue we need to find x
         float changeiny = (float)(t->b.y - t->a.y);
         float officalxpos = t->a.x + (slope * changeiny);
         v4.x = officalxpos;
@@ -201,16 +172,14 @@ void DrawTriZuff(Zee * zbuf, Tri2D * t){
         FillBottomFlatZbuffer(zbuf, &bottomflattrires, t);
         FillTopFlatZbuffer(zbuf, &topflattrires, t);
     }
-
-    
-    
 }
 
 float Sign(Vector2 *v1, Vector2 *v2, Vector2 *v3) {
-    return (v1->x - v3->x) * (v2->y - v3->y) - (v2->x - v3->x) * (v1->y - v3->y);
+    return (v1->x - v3->x) * (v2->y - v3->y) -
+           (v2->x - v3->x) * (v1->y - v3->y);
 }
 
-bool IsInTri(Tri2D tri, Vector2 p) {
+static inline bool IsInTri(Tri2D tri, Vector2 p) {
     float d1, d2, d3;
     bool has_neg, has_pos;
 
@@ -224,58 +193,7 @@ bool IsInTri(Tri2D tri, Vector2 p) {
     return !(has_neg && has_pos);
 }
 
-void TriArrayAppend(TriArray * tarr, Tri  t) {
-    tarr->arr[tarr->length] = t;
-    tarr->length = tarr->length + 1;
-}
 
-void Tri2DArrayAppend(Tri2DArray * tarr, Tri2D  t) {
-    tarr->arr[tarr->length] = t;
-    tarr->length = tarr->length + 1;
-}
-
-Vector3 Vector3Sum(Vector3 v1, Vector3 v2) {
-    Vector3 retvec;
-    retvec.x = v1.x + v2.x;
-    retvec.y = v1.y + v2.y;
-    retvec.z = v1.z + v2.z;
-    return retvec;
-}
-
-void Vector3Print(Vector3 v) {
-    printf("VX: %f, VY: %f, FZ: %f\n",v.x,v.y,v.z);
-}
-
-Vector3 Vector3Scale(Vector3 v1, float scale) {
-    Vector3 retvec;
-    retvec.x = v1.x * scale;
-    retvec.y = v1.y * scale;
-    retvec.z = v1.z * scale;
-    return retvec;
-}
-
-Vector3 RotateAboutX(Vector3 v, double radians){
-    Vector3 rotatedvector;
-    rotatedvector.x = 1*v.x + (0) + (0);
-    rotatedvector.y = (0) + cos(radians)*v.y + (-sin(radians)*v.z);
-    rotatedvector.z = 0 + sin(radians)*v.y + cos(radians)*v.z;
-    return rotatedvector;
-}
-Vector3 RotateAboutY(Vector3 v, double radians){
-    Vector3 rotatedvector;
-    rotatedvector.x = cos(radians)*v.x + (0) + sin(radians)*v.z;
-    rotatedvector.y = (0) + 1*v.y + (0);
-    rotatedvector.z = -sin(radians)*v.x + 0 + cos(radians)*v.z;
-    return rotatedvector;
-}
-
-Vector3 RotateAboutZ(Vector3 v, double radians){
-    Vector3 rotatedvector;
-    rotatedvector.x = cos(radians)*v.x + (-sin(radians)*v.y) + (0);
-    rotatedvector.y = sin(radians)*v.x + cos(radians)*v.y + (0);
-    rotatedvector.z = 0 + 0 + 1*v.z;
-    return rotatedvector;
-}
 
 void CtrlLocalCam(LocalCam *cam, float time) {
     cam->velocity.x = 0;
@@ -288,8 +206,8 @@ void CtrlLocalCam(LocalCam *cam, float time) {
     if (IsKeyDown(KEY_W)) {
         Vector3 forceForward = (Vector3){0, 0, -500};
         Vector3 rotatedforce = RotateAboutY(forceForward, cam->angles.y);
-	printf("%f", cam->angles.y);
+        // printf("%f", cam->angles.y);
-	Vector3Print(rotatedforce);
+        // Vector3Print(rotatedforce);
         cam->velocity = Vector3Sum(cam->velocity, rotatedforce);
 
         // cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
@@ -337,8 +255,10 @@ void CtrlLocalCam(LocalCam *cam, float time) {
     }
 
     if (IsKeyDown(KEY_G)) {
-	printf("PosX: %f PosY: %f PosZ: %f\n",cam->position.x,cam->position.y,cam->position.z);
+        printf("PosX: %f PosY: %f PosZ: %f\n", cam->position.x, cam->position.y,
-	printf("RotX; %f RotY: %f RotZ: %f\n",cam->angles.x,cam->angles.y,cam->angles.z);
+               cam->position.z);
+        printf("RotX; %f RotY: %f RotZ: %f\n", cam->angles.x, cam->angles.y,
+               cam->angles.z);
     }
 }
 
@@ -353,10 +273,6 @@ void LocalCamApplyVelo(LocalCam *cam,float time){
     // printf("%f %f %f\n",cam->angles.x, cam->angles.y, cam->angles.z);
 }
 
-
-
-
-
 Vector2 Conv3Dto2D(Vector3 v) {
     Vector2 returnvector;
     returnvector.x = proj * v.x / (-v.z);
@@ -371,7 +287,7 @@ Vector2 Conv2DCenteredToScreen(Vector2 v) {
     return returnvector;
 }
 
-Vector3 TransformWithCam(Vector3 v, LocalCam * cam) {
+static inline Vector3 TransformWithCam(Vector3 v, LocalCam *cam) {
     Vector3 returnvector;
     returnvector.x = v.x - cam->position.x;
     returnvector.y = v.y - cam->position.y;
@@ -381,7 +297,8 @@ Vector3 TransformWithCam(Vector3 v, LocalCam * cam) {
     returnvector = RotateAboutY(returnvector, -cam->angles.y);
     returnvector = RotateAboutX(returnvector, -cam->angles.x);
 
-    //printf("Before: %f %f %f, After: %f %f %f\n", v.x, v.y, v.z, returnvector.x, returnvector.y, returnvector.z);
+    // printf("Before: %f %f %f, After: %f %f %f\n", v.x, v.y, v.z,
+    // returnvector.x, returnvector.y, returnvector.z);
     return returnvector;
 }
 
@@ -392,6 +309,7 @@ Tri TriTransformWithCam(Tri *t, LocalCam * cam) {
     rettri.c = TransformWithCam(t->c, cam);
 
     rettri.color = t->color;
+
     return rettri;
 }
 
@@ -409,14 +327,13 @@ Tri2D ConvertTriToTri2D(Tri* t){
     return rettri2d;
 }
 
-
-
 int main() {
+    printf("%d\n", TestFunc(5));
     proj = HALFWIDTH / tan(half_fov);
 
     SetConfigFlags(FLAG_WINDOW_UNDECORATED);
-    InitWindow(SCREENWIDTH, SCREENHEIGHT, "raylib [core] example - basic window");
+    InitWindow(SCREENWIDTH, SCREENHEIGHT,
-    
+               "raylib [core] example - basic window");
 
     // SetWindowPosition(0,1080);
     Vector2 a = GetMonitorPosition(0);
@@ -427,14 +344,14 @@ int main() {
     printf("mh:%d mw:%d w:%d h:%d\n", mh, mw, w, h);
     SetWindowPosition(a.x + (0.5 * mw) - (w / 2), a.y + (0.5 * mh) - (0.5 * h));
 
-    RenderTexture2D uiraylibtexture = LoadRenderTexture(RENDERWIDTH,RENDERHEIGHT);
+    RenderTexture2D uiraylibtexture =
-
+        LoadRenderTexture(RENDERWIDTH, RENDERHEIGHT);
-    RenderTexture2D render3dtexture = LoadRenderTexture(RENDERWIDTH,RENDERHEIGHT);
 
+    RenderTexture2D render3dtexture =
+        LoadRenderTexture(RENDERWIDTH, RENDERHEIGHT);
 
     Texture2D directaccesstex;
 
-    
     // Init cube model
     // TODO: Load from obj
 
@@ -452,7 +369,9 @@ int main() {
     TriArray tarr;
     tarr.arr = internaltriarray;
     tarr.length = 0;
-    TriArrayAppend(&tarr,(Tri){(Vector3){0,0,-1000},(Vector3){0,800,-1000},(Vector3){800,800,-1000},WHITE});
+    TriArrayAppend(&tarr,
+                   (Tri){(Vector3){0, 0, -1000}, (Vector3){0, 800, -1000},
+                         (Vector3){800, 800, -1000}, WHITE});
 
     Tri internaltransformedtriarray[50];
     TriArray TransformedTris;
@@ -464,23 +383,33 @@ int main() {
     Tri2Darr.length = 0;
     Tri2Darr.arr = internaltri2darray;
 
-    //static Zee ZBuff[1920][1080] = {{(Zee){10000,NULL}}}; //FIXME: Stupid static makes the file 32 Megs because pog
+    // static Zee ZBuff[1920][1080] = {{(Zee){10000,NULL}}}; //FIXME: Stupid
+    // static makes the file 32 Megs because pog
     Zee *ZBuff = malloc(RENDERHEIGHT * RENDERWIDTH * sizeof(Zee));
     static Color display[1920 * 1080 * 4];
     memset(display, 0, sizeof(display));
 
-    Tri2D funners = (Tri2D){ (Vector2){50,50},(Vector2){500,50},(Vector2){500,500},GREEN};
+    Tri2D funners = (Tri2D){(Vector2){50, 50}, (Vector2){500, 50},
-    Tri2D funners2 = (Tri2D){ (Vector2){600,0},(Vector2){600,500},(Vector2){1000,500},RED};
+                            (Vector2){500, 500}, GREEN};
+    Tri2D funners2 = (Tri2D){(Vector2){600, 0}, (Vector2){600, 500},
+                             (Vector2){1000, 500}, RED};
 
-    Tri2D fullscreentritop = (Tri2D){ (Vector2){0,0}, (Vector2){1920,0}, (Vector2){1920,1080}, BLUE};
+    Tri2D fullscreentritop = (Tri2D){(Vector2){0, 0}, (Vector2){1920, 0},
-    Tri2D fullscreentribottom = (Tri2D){ (Vector2){0,0}, (Vector2){0,1080}, (Vector2){1920,1080}, RED};
+                                     (Vector2){1920, 1080}, BLUE};
+    Tri2D fullscreentribottom = (Tri2D){(Vector2){0, 0}, (Vector2){0, 1080},
+                                        (Vector2){1920, 1080}, RED};
+
+    Tri2D blank =
+        (Tri2D){(Vector2){-10, -10}, (Vector2){-10, -10}, (Vector2){-10, -10}};
+
+    Tri2D norm = (Tri2D){(Vector2){500, 50}, (Vector2){0, 0},
+                         (Vector2){250, 500}, GREEN};
 
 
-    Tri2D blank = (Tri2D) { (Vector2){-10,-10},(Vector2){-10,-10}, (Vector2){-10,-10}};
 
-    Tri2D norm =  (Tri2D){ (Vector2){500,50},(Vector2){0,0},(Vector2){250,500},GREEN};
 	
-    while (!WindowShouldClose()) {
+	bool run3d = false;
+    while (!WindowShouldClose() && run3d) {
         float frametime = GetFrameTime();
         CtrlLocalCam(&camera, frametime);
         LocalCamApplyVelo(&camera, frametime);
@@ -498,38 +427,39 @@ int main() {
         Tri2Darr.length = 0;
 
         for (int i = 0; i < tarr.length; i++) {
-	    TriArrayAppend(&TransformedTris,TriTransformWithCam(&tarr.arr[i],&camera));
+            TriArrayAppend(&TransformedTris,
+                           TriTransformWithCam(&tarr.arr[i], &camera));
         }
 
         for (int i = 0; i < TransformedTris.length; i++) {
-	    Tri2DArrayAppend(&Tri2Darr,ConvertTriToTri2D(&TransformedTris.arr[i]));
+            if ((TransformedTris.arr[i].a.z < 0) &&
+                (TransformedTris.arr[i].b.z < 0) &&
+                (TransformedTris.arr[i].c.z < 0)) {
+                Tri2DArrayAppend(&Tri2Darr,
+                                 ConvertTriToTri2D(&TransformedTris.arr[i]));
+            }
         }
 
-        //memset(ZBuff,NULL ,sizeof(Zee) * RENDERHEIGHT*RENDERWIDTH  );
+        /* for (int i = 0; i < RENDERHEIGHT*RENDERWIDTH; i ++) { */
-	// for (int i = 0; i < RENDERHEIGHT*RENDERWIDTH; i ++) {
+        /*     ZBuff[i] = (Zee){10000,NULL}; */
-	//     ZBuff[i] = (Zee){10000,NULL};
+        /* } */
-	// }
         memset(display, 0, sizeof(display));
-
+        memset(ZBuff, 0, sizeof(Zee) * 1920 * 1080);
-
-
         /* for (int y = 0; y < RENDERHEIGHT; y++){ */
         /*     for (int x = 0; x<RENDERWIDTH; x++){ */
         /* 	ZBuff[x][y].triangle = &blank; */
         /*     } */
         /* } */
 
-	/* for(int i = 0; i < Tri2Darr.length; i++) { */
+        for (int i = 0; i < Tri2Darr.length; i++) {
-	/*     for(int y = 0; y < RENDERHEIGHT; y++){ */
+            for (int y = 0; y < RENDERHEIGHT; y++) {
-	/* 	for(int x = 0; x< RENDERWIDTH; x++) { */
+                for (int x = 0; x < RENDERWIDTH; x++) {
-	/* 	    if (IsInTri(Tri2Darr.arr[i],(Vector2){x,y})) { */
+                    if (IsInTri(Tri2Darr.arr[i], (Vector2){x, y})) {
-	/* 		ZBuff[x][y].triangle = &Tri2Darr.arr[i]; */
+                        ZBuff[IndexOfZBuff(x, y)].triangle = &Tri2Darr.arr[i];
-	/* 	    } */
+                    }
-	/* 	} */
+                }
-	/*     } */
+            }
-	/* } */
+        }
-
-	
 
         // FillTopFlatZbuffer(ZBuff, &funners);
         // FillBottomFlatZbuffer(ZBuff,&funners2);
@@ -537,9 +467,8 @@ int main() {
         // FillTopFlatZbuffer(ZBuff, &fullscreentritop);
         // FillBottomFlatZbuffer(ZBuff, &fullscreentribottom);
 
-	DrawTriZuff(ZBuff, &norm);
+        // DrawTriZuff(ZBuff, &norm);
-
+        // DrawTriZuff(ZBuff, TriTransformWithCam(&norm, &camera));
-
 
         int index = 0;
         for (int y = 0; y < RENDERHEIGHT; y++) {
@@ -552,26 +481,22 @@ int main() {
                 display[index+3] = c->a;
                 */
 
-		
+                if (ZBuff[IndexOfZBuff(x, y)].triangle !=
-		if (ZBuff[IndexOfZBuff(x,y)].triangle != NULL) {
+                    0) { // memset sets this to 0
                     // DrawPixel(x,y,ZBuff[x][y].triangle->color);
 
                     display[index] = ZBuff[IndexOfZBuff(x, y)].triangle->color;
                     // Zee test = ZBuff[IndexOfZBuff(x,y)];
                     // display[index] = test.triangle->color;
-
                 }
                 index = index + 1;
-		
             }
-
         }
 
         BeginTextureMode(uiraylibtexture);
         // gui stuff
         EndTextureMode();
 
-	
         // Copytexture to main display :0
 
         BeginDrawing();
@@ -579,17 +504,25 @@ int main() {
         UpdateTexture(render3dtexture.texture, display);
 
         // Copies render3dtexture to screen
-	DrawTexturePro(render3dtexture.texture, (Rectangle){0,0,render3dtexture.texture.width, render3dtexture.texture.height}, (Rectangle){0,0,SCREENWIDTH,SCREENHEIGHT},(Vector2){0,0},0,WHITE);
+        DrawTexturePro(render3dtexture.texture,
+                       (Rectangle){0, 0, render3dtexture.texture.width,
+                                   render3dtexture.texture.height},
+                       (Rectangle){0, 0, SCREENWIDTH, SCREENHEIGHT},
+                       (Vector2){0, 0}, 0, WHITE);
 
-	//Copies uiraylibtexture to screen (not this is not the texture used for 3d stuff
+        // Copies uiraylibtexture to screen (not this is not the texture used
-	DrawTexturePro(uiraylibtexture.texture, (Rectangle){0,0,uiraylibtexture.texture.width,-uiraylibtexture.texture.height},(Rectangle){0,0,SCREENWIDTH,SCREENHEIGHT},(Vector2){0,0},0,WHITE);
+        // for 3d stuff
+        DrawTexturePro(uiraylibtexture.texture,
+                       (Rectangle){0, 0, uiraylibtexture.texture.width,
+                                   -uiraylibtexture.texture.height},
+                       (Rectangle){0, 0, SCREENWIDTH, SCREENHEIGHT},
+                       (Vector2){0, 0}, 0, WHITE);
 
         char fpstext[40];
         sprintf(fpstext, "%d", GetFPS());
         DrawText(fpstext, 0, 0, 20, WHITE);
 
         EndDrawing();
-	
     }
 
     CloseWindow();

c3dtypes.h

@@ -0,0 +1,64 @@
+#include "raylib.h"
+
+#ifndef C3DTYPES_HEADER
+#define C3DTYPES_HEADER
+
+
+
+struct LocalCam {
+    Vector3 position;
+    Vector3 velocity;
+    Vector3 acceleration;
+    Vector3 angles;
+    Vector3 angleVelocity;
+    Vector3 angleAcceleration;
+};
+typedef struct LocalCam LocalCam;
+
+struct Tri {
+    Vector3 a;
+    Vector3 b;
+    Vector3 c;
+
+    Color color;
+};
+typedef struct Tri Tri;
+
+struct Tri2D {
+    Vector2 a;
+    Vector2 b;
+    Vector2 c;
+
+    Color color;
+};
+typedef struct Tri2D Tri2D;
+
+struct Zee {
+    int depth;
+    Tri2D *triangle;
+};
+typedef struct Zee Zee;
+
+struct TriArray {
+    int length;
+    Tri *arr;
+};
+typedef struct TriArray TriArray;
+
+struct Tri2DArray {
+    int length;
+    Tri2D *arr;
+};
+typedef struct Tri2DArray Tri2DArray;
+
+
+
+struct Object {
+	char name[100];
+	Vector3 *VertexArray;
+	int VertexArrayLength;
+	TriArray  * triangles;
+};
+typedef struct Object Object;
+
+#endif

cube.obj

@@ -0,0 +1,46 @@
+# Blender v2.76 (sub 0) OBJ File: ''
+# www.blender.org
+mtllib cube.mtl
+o Cube
+v 1.000000 -1.000000 -1.000000
+v 1.000000 -1.000000 1.000000
+v -1.000000 -1.000000 1.000000
+v -1.000000 -1.000000 -1.000000
+v 1.000000 1.000000 -0.999999
+v 0.999999 1.000000 1.000001
+v -1.000000 1.000000 1.000000
+v -1.000000 1.000000 -1.000000
+vt 1.000000 0.333333
+vt 1.000000 0.666667
+vt 0.666667 0.666667
+vt 0.666667 0.333333
+vt 0.666667 0.000000
+vt 0.000000 0.333333
+vt 0.000000 0.000000
+vt 0.333333 0.000000
+vt 0.333333 1.000000
+vt 0.000000 1.000000
+vt 0.000000 0.666667
+vt 0.333333 0.333333
+vt 0.333333 0.666667
+vt 1.000000 0.000000
+vn 0.000000 -1.000000 0.000000
+vn 0.000000 1.000000 0.000000
+vn 1.000000 0.000000 0.000000
+vn -0.000000 0.000000 1.000000
+vn -1.000000 -0.000000 -0.000000
+vn 0.000000 0.000000 -1.000000
+usemtl Material
+s off
+f 2/1/1 3/2/1 4/3/1
+f 8/1/2 7/4/2 6/5/2
+f 5/6/3 6/7/3 2/8/3
+f 6/8/4 7/5/4 3/4/4
+f 3/9/5 7/10/5 8/11/5
+f 1/12/6 4/13/6 8/11/6
+f 1/4/1 2/1/1 4/3/1
+f 5/14/2 8/1/2 6/5/2
+f 1/12/3 5/6/3 2/8/3
+f 2/12/4 6/8/4 3/4/4
+f 4/13/5 3/9/5 8/11/5
+f 5/6/6 1/12/6 8/11/6

reader.c

@@ -0,0 +1,60 @@
+#include "c3dtypes.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+int TestFunc(int x) {
+    x = x + 1;
+    return x;
+}
+
+
+Object ReadObjectFromFile() {
+	Object out;
+	out.VertexArray = malloc(10000*sizeof(Vector3));
+	out.VertexArrayLength = 0;
+
+	TriArray tarr;
+	tarr.arr = malloc(10000*sizeof(Tri));
+	tarr.length = 0;
+
+
+	out.triangles = &tarr;
+
+	strncpy(out.name, "cube.obj", 100);
+
+
+	FILE * f = fopen("cube.obj", "r");
+
+	while (true) {
+		char t[500];
+		char * fgetres = fgets(t, 500, f);
+		if (fgetres == NULL) {
+			break;
+		}
+
+		char objtype[10];
+		double v1;
+		double v2;
+		double v3;
+		sscanf(t, "%s %lf %lf %lf", objtype, &v1,&v2,&v3);
+		if ( strcmp(t, "v")) {
+			out.VertexArray[out.VertexArrayLength].x = v1;
+			out.VertexArray[out.VertexArrayLength].x = v2;
+			out.VertexArray[out.VertexArrayLength].x = v3;
+			out.VertexArrayLength = out.VertexArrayLength + 1;
+		}
+		if ( strcmp(t, "f")) {
+			//TODO: append face to triarry
+		}
+		//need to bring in triarray functions into their own file 
+
+		
+		
+	}
+	
+	//TODO: use file object and read each line
+	// add verticies to the vertex list, +1 ing the length value each time
+	// just fucking parse the obj file its not that hard
+
+}

reader.h

@@ -0,0 +1,6 @@
+#ifndef READER_HEADER
+#define READER_HEADER
+
+int TestFunc(int x);
+
+#endif

vecfunc.c

@@ -0,0 +1,46 @@
+#include "raylib.h"
+#include <stdio.h>
+#include <math.h>
+
+Vector3 Vector3Sum(Vector3 v1, Vector3 v2) {
+    Vector3 retvec;
+    retvec.x = v1.x + v2.x;
+    retvec.y = v1.y + v2.y;
+    retvec.z = v1.z + v2.z;
+    return retvec;
+}
+
+void Vector3Print(Vector3 v) {
+    printf("VX: %f, VY: %f, FZ: %f\n", v.x, v.y, v.z);
+}
+
+Vector3 Vector3Scale(Vector3 v1, float scale) {
+    Vector3 retvec;
+    retvec.x = v1.x * scale;
+    retvec.y = v1.y * scale;
+    retvec.z = v1.z * scale;
+    return retvec;
+}
+
+Vector3 RotateAboutX(Vector3 v, double radians) {
+    Vector3 rotatedvector;
+    rotatedvector.x = 1 * v.x + (0) + (0);
+    rotatedvector.y = (0) + cos(radians) * v.y + (-sin(radians) * v.z);
+    rotatedvector.z = 0 + sin(radians) * v.y + cos(radians) * v.z;
+    return rotatedvector;
+}
+Vector3 RotateAboutY(Vector3 v, double radians) {
+    Vector3 rotatedvector;
+    rotatedvector.x = cos(radians) * v.x + (0) + sin(radians) * v.z;
+    rotatedvector.y = (0) + 1 * v.y + (0);
+    rotatedvector.z = -sin(radians) * v.x + 0 + cos(radians) * v.z;
+    return rotatedvector;
+}
+
+Vector3 RotateAboutZ(Vector3 v, double radians) {
+    Vector3 rotatedvector;
+    rotatedvector.x = cos(radians) * v.x + (-sin(radians) * v.y) + (0);
+    rotatedvector.y = sin(radians) * v.x + cos(radians) * v.y + (0);
+    rotatedvector.z = 0 + 0 + 1 * v.z;
+    return rotatedvector;
+}

vecfunc.h

@@ -0,0 +1,15 @@
+#ifndef VECFUNC_HEADER
+#define VECFUNC_HEADER
+
+Vector3 Vector3Sum(Vector3 v1, Vector3 v2);
+
+void Vector3Print(Vector3 v);
+
+Vector3 Vector3Scale(Vector3 v1, float scale);
+
+Vector3 RotateAboutX(Vector3 V, double radians);
+Vector3 RotateAboutY(Vector3 V, double radians);
+Vector3 RotateAboutZ(Vector3 V, double radians);
+
+
+#endif