diff --git a/.clang-format b/.clang-format
index e1f1075..e5ab5c1 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1 +1,2 @@
-IndentWidth: 4
\ No newline at end of file
+IndentWidth: 4
+ColumnLimit: 80
diff --git a/Makefile b/Makefile
index 6ab857a..50b5ef8 100644
--- a/Makefile
+++ b/Makefile
@@ -1,12 +1,12 @@
-CC = gcc
-CFLAGS = -pg -g -Wall 
-LDFLAGS = -pg -g 
-LDLIBS = -lraylib -lm
-objects  = c3d.o
+CC = clang #Set compiler
+CFLAGS = -pg -g -Wall -O2 -pg #set compiler flags
+LDFLAGS = -pg -g #set linker flags
+LDLIBS = -lraylib -lm #set libraries to use
+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:
-	rm -f *.o c3d
+clean: #to clean remove all object files and the executable
+	rm -f *.o c3d 
diff --git a/arrayfuncs.c b/arrayfuncs.c
new file mode 100644
index 0000000..0488fc6
--- /dev/null
+++ b/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;
+}
diff --git a/arrayfuncs.h b/arrayfuncs.h
new file mode 100644
index 0000000..4e92079
--- /dev/null
+++ b/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
diff --git a/c3d.c b/c3d.c
index e9d5988..5c857a6 100644
--- a/c3d.c
+++ b/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,206 +16,170 @@ 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 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
+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;
+double Min(double a, double b) {
+    if (a > b) {
+        return b;
     }
     return a;
 }
 
-double Max(double a, double b){
-    if (a<b){
-	return b;
+double Max(double a, double b) {
+    if (a < b) {
+        return b;
     }
     return a;
 }
 
-
 static inline int IndexOfZBuff(int row, int col) {
-    return row + RENDERWIDTH*col;
+    return row + RENDERWIDTH * col;
 }
 
-
-//sort triangle verts so that point A is the "highest" point (lowest y val) and point C is the "lowest" pont (highest y val)
-void Tri2DSortByY(Tri2D * t){
+// sort triangle verts so that point A is the "highest" point (lowest y val) and
+// point C is the "lowest" pont (highest y val)
+void Tri2DSortByY(Tri2D *t) {
     Vector2 temp;
     if (t->a.y > t->b.y) {
-	temp = t->a;
-	t->a = t->b;
-	t->b = temp;
+        temp = t->a;
+        t->a = t->b;
+        t->b = temp;
     }
-    if (t->b.y > t->c.y){
-	temp = t->b;
-	t->b = t->c;
-	t->c = temp;
+    if (t->b.y > t->c.y) {
+        temp = t->b;
+        t->b = t->c;
+        t->c = temp;
     }
     if (t->a.y > t->b.y) {
-	temp = t->a;
-	t->a = t->b;
-	t->b = temp;
+        temp = t->a;
+        t->a = t->b;
+        t->b = temp;
     }
 }
 
-//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) {
+// 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;
+        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
-    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 
+    // Becasue we are trying to get the x values in terms of the y values, we
+    // 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 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;
 
-    for(int scanline=t->c.y; scanline >= t->a.y; scanline--){
-	if (0 <= scanline && scanline < RENDERHEIGHT){
-	    for (int i = Max(curx1,0); i < Min(curx2,RENDERWIDTH); i++) {
-		zee[IndexOfZBuff(i,scanline) ].triangle = tp;
-	    }
-	}
-	curx1 -= atocslopeinv; //subtract because we are working backwards (reason why we start with point c in slope equtn)
-	curx2 -= btocslopinv;
+    for (int scanline = t->c.y; scanline >= t->a.y; scanline--) {
+        if (0 <= scanline && scanline < RENDERHEIGHT) {
+            for (int i = Max(curx1, 0); i < Min(curx2, RENDERWIDTH); i++) {
+                zee[IndexOfZBuff(i, scanline)].triangle = tp;
+            }
+        }
+        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"
-void FillBottomFlatZbuffer(Zee * zee, Tri2D* t, Tri2D * tp) {
+// 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;
+        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
-    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 
+    // Becasue we are trying to get the x values in terms of the y values, we
+    // need inverse slope
+    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;
 
-    for(int scanline=t->a.y; scanline < t->c.y; scanline++){
-	if (0 <= scanline && scanline < RENDERHEIGHT){
-	    for (int i = Max(curx1,0); i < Min(curx2,RENDERWIDTH); i++) {
-		zee[ IndexOfZBuff(i,scanline) ].triangle = tp;
-	    }
-	}
-	curx1 += atobslopeinv;
-	curx2 += atocslopeinv;
+    for (int scanline = t->a.y; scanline < t->c.y; scanline++) {
+        if (0 <= scanline && scanline < RENDERHEIGHT) {
+            for (int i = Max(curx1, 0); i < Min(curx2, RENDERWIDTH); i++) {
+                zee[IndexOfZBuff(i, scanline)].triangle = tp;
+            }
+        }
+        curx1 += atobslopeinv;
+        curx2 += atocslopeinv;
     }
-
 }
 
-
-
-void DrawTriZuff(Zee * zbuf, Tri2D * t){
+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);
+        FillBottomFlatZbuffer(zbuf, t, t);
+    } 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
+        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 changeiny = (float)(t->b.y - t->a.y);
+        float officalxpos = t->a.x + (slope * changeiny);
+        v4.x = officalxpos;
+        Tri2D bottomflattrires;
+        bottomflattrires.a = t->a;
+        bottomflattrires.b = t->b;
+        bottomflattrires.c = v4;
+        bottomflattrires.color = t->color;
+        Tri2D topflattrires;
+        topflattrires.a = t->b;
+        topflattrires.b = v4;
+        topflattrires.c = t->c;
+        topflattrires.color = t->color;
+
+        FillBottomFlatZbuffer(zbuf, &bottomflattrires, t);
+        FillTopFlatZbuffer(zbuf, &topflattrires, t);
     }
-    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
-	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 changeiny = (float) (t->b.y - t->a.y);
-	float officalxpos = t->a.x + (slope*changeiny);
-	v4.x = officalxpos;
-	Tri2D bottomflattrires;
-	bottomflattrires.a = t->a;
-	bottomflattrires.b = t->b;
-	bottomflattrires.c = v4;
-	bottomflattrires.color = t->color;
-	Tri2D topflattrires;
-	topflattrires.a = t->b;
-	topflattrires.b = v4;
-	topflattrires.c = t->c;
-	topflattrires.color = t->color;
-
-	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);
+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);
 }
 
-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;
@@ -286,63 +204,65 @@ void CtrlLocalCam(LocalCam *cam, float time) {
     cam->angleVelocity.z = 0;
 
     if (IsKeyDown(KEY_W)) {
-	Vector3 forceForward = (Vector3){0,0,-500};
-	Vector3 rotatedforce = RotateAboutY(forceForward,cam->angles.y);
-	printf("%f", cam->angles.y);
-	Vector3Print(rotatedforce);
-	cam->velocity = Vector3Sum(cam->velocity,rotatedforce);
+        Vector3 forceForward = (Vector3){0, 0, -500};
+        Vector3 rotatedforce = RotateAboutY(forceForward, cam->angles.y);
+        // printf("%f", cam->angles.y);
+        // Vector3Print(rotatedforce);
+        cam->velocity = Vector3Sum(cam->velocity, rotatedforce);
 
-	//cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
-	//cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
+        // cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
+        // cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
     }
     if (IsKeyDown(KEY_S)) {
-	Vector3 forceForward = (Vector3){0,0,500};
-	Vector3 rotatedforce = RotateAboutY(forceForward,cam->angles.y);
-	cam->velocity = Vector3Sum(cam->velocity,rotatedforce);
+        Vector3 forceForward = (Vector3){0, 0, 500};
+        Vector3 rotatedforce = RotateAboutY(forceForward, cam->angles.y);
+        cam->velocity = Vector3Sum(cam->velocity, rotatedforce);
 
-	//cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
-	//cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
+        // cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
+        // cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
     }
 
     if (IsKeyDown(KEY_A)) {
-	Vector3 forceForward = (Vector3){-500,0,0};
-	Vector3 rotatedforce = RotateAboutY(forceForward,cam->angles.y);
-	cam->velocity = Vector3Sum(cam->velocity,rotatedforce);
+        Vector3 forceForward = (Vector3){-500, 0, 0};
+        Vector3 rotatedforce = RotateAboutY(forceForward, cam->angles.y);
+        cam->velocity = Vector3Sum(cam->velocity, rotatedforce);
 
-	//cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
-	//cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
+        // cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
+        // cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
     }
     if (IsKeyDown(KEY_D)) {
-	Vector3 forceForward = (Vector3){500,0,0};
-	Vector3 rotatedforce = RotateAboutY(forceForward,cam->angles.y);
-	cam->velocity = Vector3Sum(cam->velocity,rotatedforce);
+        Vector3 forceForward = (Vector3){500, 0, 0};
+        Vector3 rotatedforce = RotateAboutY(forceForward, cam->angles.y);
+        cam->velocity = Vector3Sum(cam->velocity, rotatedforce);
 
-	//cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
-	//cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
+        // cam->velocity.z = cam->velocity.z + 50000*time*sin(cam->angles.y);
+        // cam->velocity.x = cam->velocity.x + 500*time*cos(cam->angles.y);
     }
 
-    if(IsKeyDown(KEY_SPACE)) {
-	cam->velocity.y = cam->velocity.y - 50;
+    if (IsKeyDown(KEY_SPACE)) {
+        cam->velocity.y = cam->velocity.y - 50;
     }
 
-    if(IsKeyDown(KEY_LEFT_SHIFT)) {
-	cam->velocity.y = cam->velocity.y + 50;
+    if (IsKeyDown(KEY_LEFT_SHIFT)) {
+        cam->velocity.y = cam->velocity.y + 50;
     }
 
-    if (IsKeyDown(KEY_Q)){
-	cam->angleVelocity.y = cam->angleVelocity.y + time*10;
+    if (IsKeyDown(KEY_Q)) {
+        cam->angleVelocity.y = cam->angleVelocity.y + time * 10;
     }
-    if (IsKeyDown(KEY_E)){
-	cam->angleVelocity.y = cam->angleVelocity.y - time*10;
+    if (IsKeyDown(KEY_E)) {
+        cam->angleVelocity.y = cam->angleVelocity.y - time * 10;
     }
 
     if (IsKeyDown(KEY_G)) {
-	printf("PosX: %f PosY: %f PosZ: %f\n",cam->position.x,cam->position.y,cam->position.z);
-	printf("RotX; %f RotY: %f RotZ: %f\n",cam->angles.x,cam->angles.y,cam->angles.z);
+        printf("PosX: %f PosY: %f PosZ: %f\n", cam->position.x, cam->position.y,
+               cam->position.z);
+        printf("RotX; %f RotY: %f RotZ: %f\n", cam->angles.x, cam->angles.y,
+               cam->angles.z);
     }
 }
 
-void LocalCamApplyVelo(LocalCam *cam,float time){
+void LocalCamApplyVelo(LocalCam *cam, float time) {
     cam->position.x = cam->position.x + cam->velocity.x * time;
     cam->position.y = cam->position.y + cam->velocity.y * time;
     cam->position.z = cam->position.z + cam->velocity.z * time;
@@ -350,13 +270,9 @@ void LocalCamApplyVelo(LocalCam *cam,float time){
     cam->angles.x = cam->angles.x + cam->angleVelocity.x * time;
     cam->angles.y = cam->angles.y + cam->angleVelocity.y * time;
     cam->angles.z = cam->angles.z + cam->angleVelocity.z * time;
-    //printf("%f %f %f\n",cam->angles.x, cam->angles.y, cam->angles.z);
+    // 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,31 +287,33 @@ 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;
     returnvector.z = v.z - cam->position.z;
 
-    returnvector = RotateAboutZ(returnvector,cam->angles.z);
-    returnvector = RotateAboutY(returnvector,-cam->angles.y);
-    returnvector = RotateAboutX(returnvector,-cam->angles.x);
+    returnvector = RotateAboutZ(returnvector, cam->angles.z);
+    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;
 }
 
-Tri TriTransformWithCam(Tri *t, LocalCam * cam) {
+Tri TriTransformWithCam(Tri *t, LocalCam *cam) {
     Tri rettri;
-    rettri.a = TransformWithCam(t->a,cam);
-    rettri.b = TransformWithCam(t->b,cam);
-    rettri.c = TransformWithCam(t->c,cam);
-    
+    rettri.a = TransformWithCam(t->a, cam);
+    rettri.b = TransformWithCam(t->b, cam);
+    rettri.c = TransformWithCam(t->c, cam);
+
     rettri.color = t->color;
+
     return rettri;
 }
 
-Tri2D ConvertTriToTri2D(Tri* t){
+Tri2D ConvertTriToTri2D(Tri *t) {
     Tri2D rettri2d;
     rettri2d.a = Conv3Dto2D(t->a);
     rettri2d.b = Conv3Dto2D(t->b);
@@ -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,32 +344,34 @@ 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
 
     LocalCam camera;
-    camera.position = (Vector3){0,0,0};
-    camera.acceleration = (Vector3){0,0,0};
-    camera.angleAcceleration = (Vector3){0,0,0};
-    camera.angles = (Vector3){0,0,0};
-    camera.velocity = (Vector3){0,0,0};
-    camera.angleVelocity = (Vector3){0,0,0};
-    
-    Vector3 point = (Vector3){0,0,-10};
+    camera.position = (Vector3){0, 0, 0};
+    camera.acceleration = (Vector3){0, 0, 0};
+    camera.angleAcceleration = (Vector3){0, 0, 0};
+    camera.angles = (Vector3){0, 0, 0};
+    camera.velocity = (Vector3){0, 0, 0};
+    camera.angleVelocity = (Vector3){0, 0, 0};
+
+    Vector3 point = (Vector3){0, 0, -10};
 
     Tri internaltriarray[50];
     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;
@@ -461,135 +380,149 @@ int main() {
 
     Tri2D internaltri2darray[50];
     Tri2DArray Tri2Darr;
-    Tri2Darr.length=0;
+    Tri2Darr.length = 0;
     Tri2Darr.arr = internaltri2darray;
 
-    //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));
+    // 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 funners2 = (Tri2D){ (Vector2){600,0},(Vector2){600,500},(Vector2){1000,500},RED};
+    Tri2D funners = (Tri2D){(Vector2){50, 50}, (Vector2){500, 50},
+                            (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 fullscreentribottom = (Tri2D){ (Vector2){0,0}, (Vector2){0,1080}, (Vector2){1920,1080}, RED};
+    Tri2D fullscreentritop = (Tri2D){(Vector2){0, 0}, (Vector2){1920, 0},
+                                     (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 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()) {
-	float frametime = GetFrameTime();
-	CtrlLocalCam(&camera,frametime);
-	LocalCamApplyVelo(&camera,frametime);
-        //ClearBackground(BLACK);
-        
-	/* Vector3 TransVector = TransformWithCam(point,&camera); */
-	/* if (TransVector.z < 0) { */
-	/* Vector2 MPos = Conv3Dto2D(TransVector); */
-	/* Vector2 FinPos = Conv2DCenteredToScreen(MPos); */
-	/* DrawCircleV(FinPos,100,BLACK); */
-	/* } */
+    Tri2D norm = (Tri2D){(Vector2){500, 50}, (Vector2){0, 0},
+                         (Vector2){250, 500}, GREEN};
+
+
+
+	
+	bool run3d = false;
+    while (!WindowShouldClose() && run3d) {
+        float frametime = GetFrameTime();
+        CtrlLocalCam(&camera, frametime);
+        LocalCamApplyVelo(&camera, frametime);
+        // ClearBackground(BLACK);
+
+        /* Vector3 TransVector = TransformWithCam(point,&camera); */
+        /* if (TransVector.z < 0) { */
+        /* Vector2 MPos = Conv3Dto2D(TransVector); */
+        /* Vector2 FinPos = Conv2DCenteredToScreen(MPos); */
+        /* DrawCircleV(FinPos,100,BLACK); */
+        /* } */
         /* EndTextureMode(); */
 
-	TransformedTris.length = 0;
-	Tri2Darr.length = 0;
+        TransformedTris.length = 0;
+        Tri2Darr.length = 0;
 
-	for (int i = 0; i < tarr.length; i++) {
-	    TriArrayAppend(&TransformedTris,TriTransformWithCam(&tarr.arr[i],&camera));
-	}
+        for (int i = 0; i < tarr.length; i++) {
+            TriArrayAppend(&TransformedTris,
+                           TriTransformWithCam(&tarr.arr[i], &camera));
+        }
 
-	for(int i = 0; i < TransformedTris.length; i++) {
-	    Tri2DArrayAppend(&Tri2Darr,ConvertTriToTri2D(&TransformedTris.arr[i]));
-	}
-	
-        //memset(ZBuff,NULL ,sizeof(Zee) * RENDERHEIGHT*RENDERWIDTH  );
-	// for (int i = 0; i < RENDERHEIGHT*RENDERWIDTH; i ++) {
-	//     ZBuff[i] = (Zee){10000,NULL};
-	// }
-	memset(display,0,sizeof(display));
+        for (int i = 0; i < TransformedTris.length; 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]));
+            }
+        }
 
+        /* for (int i = 0; i < RENDERHEIGHT*RENDERWIDTH; i ++) { */
+        /*     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 y = 0; y < RENDERHEIGHT; y++) {
+                for (int x = 0; x < RENDERWIDTH; x++) {
+                    if (IsInTri(Tri2Darr.arr[i], (Vector2){x, y})) {
+                        ZBuff[IndexOfZBuff(x, y)].triangle = &Tri2Darr.arr[i];
+                    }
+                }
+            }
+        }
 
-	/* 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 y = 0; y < RENDERHEIGHT; y++){ */
-	/* 	for(int x = 0; x< RENDERWIDTH; x++) { */
-	/* 	    if (IsInTri(Tri2Darr.arr[i],(Vector2){x,y})) { */
-	/* 		ZBuff[x][y].triangle = &Tri2Darr.arr[i]; */
-	/* 	    } */
-	/* 	} */
-	/*     } */
-	/* } */
+        // FillTopFlatZbuffer(ZBuff, &funners);
+        // FillBottomFlatZbuffer(ZBuff,&funners2);
 
-	
+        // FillTopFlatZbuffer(ZBuff, &fullscreentritop);
+        // FillBottomFlatZbuffer(ZBuff, &fullscreentribottom);
 
-	//FillTopFlatZbuffer(ZBuff, &funners);
-	//FillBottomFlatZbuffer(ZBuff,&funners2);
+        // DrawTriZuff(ZBuff, &norm);
+        // DrawTriZuff(ZBuff, TriTransformWithCam(&norm, &camera));
 
-	//FillTopFlatZbuffer(ZBuff, &fullscreentritop);
-	//FillBottomFlatZbuffer(ZBuff, &fullscreentribottom);
+        int index = 0;
+        for (int y = 0; y < RENDERHEIGHT; y++) {
+            for (int x = 0; x < RENDERWIDTH; x++) {
+                // int index  = (x+y*RENDERWIDTH);
+                /* Color * c = &ZBuff[x][y].triangle->color;
+                display[index] = c->r;
+                display[index+1] = c->g;
+                display[index+2] = c->b;
+                display[index+3] = c->a;
+                */
 
-	DrawTriZuff(ZBuff, &norm);
+                if (ZBuff[IndexOfZBuff(x, y)].triangle !=
+                    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();
 
-	int index = 0;
-	for(int y = 0; y < RENDERHEIGHT; y++) {
-	    for(int x = 0; x < RENDERWIDTH; x++) {
-		//int index  = (x+y*RENDERWIDTH);
-		/* Color * c = &ZBuff[x][y].triangle->color;
-		display[index] = c->r;
-		display[index+1] = c->g;
-		display[index+2] = c->b;
-		display[index+3] = c->a;
-		*/
+        // Copytexture to main display :0
 
-		
-		if (ZBuff[IndexOfZBuff(x,y)].triangle != NULL) {
-		    //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;
+        BeginDrawing();
+        ClearBackground(BLACK);
+        UpdateTexture(render3dtexture.texture, display);
 
-		}
-		index = index+1;
-		
-	    }
+        // 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);
 
-	}
+        // Copies uiraylibtexture to screen (not this is not the texture used
+        // 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);
 
-	BeginTextureMode(uiraylibtexture);
-	//gui stuff
-	EndTextureMode();
+        char fpstext[40];
+        sprintf(fpstext, "%d", GetFPS());
+        DrawText(fpstext, 0, 0, 20, WHITE);
 
-	
-	//Copytexture to main display :0
-	
-	BeginDrawing();
-	ClearBackground(BLACK);
-	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);
-	
-	//Copies uiraylibtexture to screen (not this is not the texture used 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();
-	
+        EndDrawing();
     }
 
     CloseWindow();
diff --git a/c3dtypes.h b/c3dtypes.h
new file mode 100644
index 0000000..0211d84
--- /dev/null
+++ b/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
diff --git a/cube.obj b/cube.obj
new file mode 100644
index 0000000..c786c1e
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/reader.c b/reader.c
new file mode 100644
index 0000000..a702405
--- /dev/null
+++ b/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
+
+}
diff --git a/reader.h b/reader.h
new file mode 100644
index 0000000..505d8f3
--- /dev/null
+++ b/reader.h
@@ -0,0 +1,6 @@
+#ifndef READER_HEADER
+#define READER_HEADER
+
+int TestFunc(int x);
+
+#endif
diff --git a/vecfunc.c b/vecfunc.c
new file mode 100644
index 0000000..95f36ab
--- /dev/null
+++ b/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;
+}
diff --git a/vecfunc.h b/vecfunc.h
new file mode 100644
index 0000000..e367e89
--- /dev/null
+++ b/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