diff --git a/client/main.c b/client/main.c
index 3ebaeed..2bc1d4e 100644
--- a/client/main.c
+++ b/client/main.c
@@ -56,16 +56,14 @@ static void render(GSEngine self){
 
 	for(i = 0; i < sizeof(obj) / sizeof(obj[0]); i++){
 		GSVector3 rv;
-		GSMatrix3x3 rm;
+		GSRotation rot;
+
+		rot.use_matrix = GSTrue;
 
 		GSPhysicsGetPosition(obj[i], rv);
-		GSPhysicsGetRotation(obj[i], rm);
+		GSPhysicsGetRotation(obj[i], rot.u.matrix);
 
-		GSGLPushMatrix(gl);
-		GSGLSetPosition(gl, rv);
-		GSGLSetRotation3x3(gl, rm);
-		GSModelDraw(mdl);
-		GSGLPopMatrix(gl);
+		GSModelDraw(mdl, rv, &rot);
 	}
 
 	GSGLSetColor(gl, col2);
@@ -106,7 +104,7 @@ int main(int argc, char** argv){
 		GSVector3 pos = {0, 1, 0};
 		GSVector3 sz = {1, 1, 1};
 
-		mdl = GSModelOpen(engine, "game:/mdl/fish.gsm");
+		mdl = GSModelOpen(engine, "game:/mdl/crate.gsm");
 
 		for(i = 0; i < sizeof(obj) / sizeof(obj[0]); i++){
 			obj[i] = GSPhysicsCreateSphere(GSServerGetPhysics(GSEngineGetServer(engine)), 1, 0.5);
diff --git a/engine/data/shader/shadow.fs b/engine/data/shader/shadow.fs
index 2acc948..5d1894c 100644
--- a/engine/data/shader/shadow.fs
+++ b/engine/data/shader/shadow.fs
@@ -13,6 +13,7 @@ uniform sampler2D shadow_map2;
 uniform sampler2D current_texture;
 uniform float enable_lighting;
 uniform float enable_texture;
+uniform float enable_shadow;
 uniform vec3 camera;
 
 vec4 PhongShading(void)
@@ -83,7 +84,11 @@ float ShadowCoef(void){
 void main(void){
 	vec4 c = PhongShading();
 	vec4 ambient = gl_LightSource[0].ambient;
-	float shadow_coef = ShadowCoef();
+	float shadow_coef = 1.0;
+	
+	if(enable_shadow >= 0.5){
+		shadow_coef = ShadowCoef();
+	}
 
 	if(enable_texture >= 0.5){
 		c = c * texture2D(current_texture, gl_TexCoord[0].st);
diff --git a/engine/include/GearSrc/GL.h b/engine/include/GearSrc/GL.h
index 92a23b1..7c9cb4c 100644
--- a/engine/include/GearSrc/GL.h
+++ b/engine/include/GearSrc/GL.h
@@ -45,7 +45,8 @@ GSDECL void   GSGLShadowEnd(GSGL gl);
 GSDECL void   GSGLShadowDeinit(GSGL gl);
 GSDECL void   GSGLShadowDisable(GSGL gl);
 GSDECL void   GSGLShadowEnable(GSGL gl);
-GSDECL int GSGLShadowCascadeSteps(GSGL gl);
+GSDECL int    GSGLShadowCascadeSteps(GSGL gl);
+GSDECL void GSGLShadowRender(GSGL gl, int toggle);
 
 /* gl.c */
 GSDECL GSGL   GSGLCreate(GSClient client);
@@ -59,8 +60,7 @@ GSDECL void   GSGLPolygon2D(GSGL gl, int pairs, GSVector2* vert, GSVector2* tex)
 GSDECL void   GSGLBegin2D(GSGL gl);
 GSDECL void   GSGLEnd2D(GSGL gl);
 GSDECL void   GSGLSetPosition(GSGL gl, GSVector3 pos);
-GSDECL void   GSGLSetRotation(GSGL gl, GSVector3 rot);
-GSDECL void   GSGLSetRotation3x3(GSGL gl, GSMatrix3x3 rot);
+GSDECL void   GSGLSetRotation(GSGL gl, GSRotation* rot);
 GSDECL void   GSGLPushMatrix(GSGL gl);
 GSDECL void   GSGLPopMatrix(GSGL gl);
 GSDECL GLuint GSGLBeginList(GSGL gl);
@@ -71,10 +71,12 @@ GSDECL void   GSGLClearDepth(GSGL gl);
 GSDECL void   GSGLInitialTranslation(GSGL gl);
 
 /* gl_camera.c */
-GSDECL void GSGLCameraPerspective(GSGL gl, GSNumber width, GSNumber height);
-GSDECL void GSGLCameraSet(GSGL gl);
-GSDECL void GSGLCameraLookAt(GSGL gl, GSVector3 camera, GSVector3 look_at);
-GSDECL void GSGLCameraSetup(GSGL gl);
+GSDECL void   GSGLCameraPerspective(GSGL gl, GSNumber width, GSNumber height);
+GSDECL void   GSGLCameraSet(GSGL gl);
+GSDECL void   GSGLCameraLookAt(GSGL gl, GSVector3 camera, GSVector3 look_at);
+GSDECL void   GSGLCameraSetup(GSGL gl);
+GSDECL void   GSGLCameraFrustum(GSGL gl);
+GSDECL GSBool GSGLCameraFrustumContain(GSGL gl, GSVector3 a, GSVector3 b);
 
 #ifdef __cplusplus
 }
diff --git a/engine/include/GearSrc/Model.h b/engine/include/GearSrc/Model.h
index a7f3f3e..b4ea1bc 100644
--- a/engine/include/GearSrc/Model.h
+++ b/engine/include/GearSrc/Model.h
@@ -9,7 +9,7 @@ extern "C" {
 #endif
 
 GSDECL GSModel GSModelOpen(GSEngine engine, const char* path);
-GSDECL void    GSModelDraw(GSModel model);
+GSDECL void    GSModelDraw(GSModel model, GSVector3 pos, GSRotation* rot);
 GSDECL void    GSModelClose(GSModel model);
 
 #ifdef __cplusplus
diff --git a/engine/include/GearSrc/TypeDefs.h b/engine/include/GearSrc/TypeDefs.h
index ab640d4..090f842 100644
--- a/engine/include/GearSrc/TypeDefs.h
+++ b/engine/include/GearSrc/TypeDefs.h
@@ -51,6 +51,8 @@ typedef struct _GSNetAddress	  GSNetAddress;
 typedef struct _GSBinary	  GSBinary;
 typedef struct _GSNetState	  GSNetState;
 typedef struct _GSNetKV		  GSNetKV;
+typedef union _GSRotationUnion	  GSRotationUnion;
+typedef struct _GSRotation	  GSRotation;
 #ifdef _GEARSRC
 typedef struct _GSClient*	 GSClient;
 typedef struct _GSServer*	 GSServer;
@@ -176,6 +178,16 @@ struct _GSNetKV {
 	GSNetState   value;
 };
 
+union _GSRotationUnion {
+	GSVector3   vector;
+	GSMatrix3x3 matrix;
+};
+
+struct _GSRotation {
+	GSBool		use_matrix;
+	GSRotationUnion u;
+};
+
 #ifdef _GEARSRC
 #include <GearSrc/GL/GL.h>
 #include <miniaudio.h>
@@ -194,7 +206,13 @@ struct _GSGL {
 	GLdouble shadow_old_projection[16];
 	GLdouble shadow_old_modelview[16];
 
+	GLdouble frustum_projection[16];
+	GLdouble frustum_modelview[16];
+	GSNumber frustum_planes[6][16];
+	GSNumber frustum_clip[16];
+
 	GSBool bold;
+	GSBool shadow;
 };
 
 struct _GSSkyBox {
@@ -241,6 +259,8 @@ struct _GSModel {
 	float*	     vertex;
 	float*	     texcoord;
 	GSModelFace* face;
+
+	GSVector3 bbox[2];
 };
 
 struct _GSSound {
diff --git a/engine/src/client.c b/engine/src/client.c
index 959a3d9..8d8088f 100644
--- a/engine/src/client.c
+++ b/engine/src/client.c
@@ -132,6 +132,7 @@ void GSClientStep(GSClient client) {
 
 	GSGLTextBold(client->gl, 0);
 
+#ifdef SHADOW
 	if(GSGLShadowBegin(client->gl)) {
 		int c;
 		for(c = 0; c < GSGLShadowCascadeSteps(client->gl); c++) {
@@ -141,12 +142,17 @@ void GSClientStep(GSClient client) {
 		}
 		GSGLShadowApply(client->gl);
 	}
+#else
+	GSGLShadowRender(client->gl, 0);
+#endif
 
 	if(client->skybox_enabled) {
 		if(client->skybox != NULL) GSSkyBoxDraw(client->skybox);
 	}
 	scene(client);
+#ifdef SHADOW
 	GSGLShadowEnd(client->gl);
+#endif
 
 	GSVersionGet(&ver);
 
diff --git a/engine/src/core.c b/engine/src/core.c
index e9e57bd..91a8209 100644
--- a/engine/src/core.c
+++ b/engine/src/core.c
@@ -16,7 +16,7 @@
 #include <stb_ds.h>
 
 #ifdef _WIN32
-static void init_winsock(void){
+static void init_winsock(void) {
 	WSADATA wsa;
 
 	WSAStartup(MAKEWORD(1, 1), &wsa);
diff --git a/engine/src/gl/gl.c b/engine/src/gl/gl.c
index 7b671cc..589c1ed 100644
--- a/engine/src/gl/gl.c
+++ b/engine/src/gl/gl.c
@@ -121,21 +121,21 @@ void GSGLSetPosition(GSGL gl, GSVector3 pos) {
 	glTranslatef(pos[0], pos[1], -pos[2]);
 }
 
-void GSGLSetRotation(GSGL gl, GSVector3 rot) {
-	glRotatef(rot[0], 1, 0, 0);
-	glRotatef(rot[1], 0, 1, 0);
-	glRotatef(rot[2], 0, 0, 1);
-}
+void GSGLSetRotation(GSGL gl, GSRotation* rot) {
+	if(rot->use_matrix) {
+		GSMatrix4x4 out, out2;
+		GLdouble    mat[16];
+		int	    i;
 
-void GSGLSetRotation3x3(GSGL gl, GSMatrix3x3 rot) {
-	GSMatrix4x4 out, out2;
-	GLdouble    mat[16];
-	int	    i;
-
-	GSMath3x3To4x4(out, rot);
-	GSMathRowToColumn4x4(out2, out);
-	for(i = 0; i < 16; i++) mat[i] = out2[i];
-	glMultMatrixd(mat);
+		GSMath3x3To4x4(out, rot->u.matrix);
+		GSMathRowToColumn4x4(out2, out);
+		for(i = 0; i < 16; i++) mat[i] = out2[i];
+		glMultMatrixd(mat);
+	} else {
+		glRotatef(rot->u.vector[0], 1, 0, 0);
+		glRotatef(rot->u.vector[1], 0, 1, 0);
+		glRotatef(rot->u.vector[2], 0, 0, 1);
+	}
 }
 
 void GSGLPushMatrix(GSGL gl) {
diff --git a/engine/src/gl/gl_camera.c b/engine/src/gl/gl_camera.c
index b8962e0..d96a48c 100644
--- a/engine/src/gl/gl_camera.c
+++ b/engine/src/gl/gl_camera.c
@@ -64,7 +64,7 @@ void GSGLCameraLookAt(GSGL gl, GSVector3 camera, GSVector3 look_at) {
 	glMultMatrixd(matrix);
 	glTranslated(-camera[0], -camera[1], camera[2]);
 
-	if(gl->shadow_use_shader){
+	if(gl->shadow_use_shader) {
 		glUseProgram(gl->shadow_shader);
 		glUniform3f(glGetUniformLocation(gl->shadow_shader, "camera"), camera[0], camera[1], camera[2]);
 		glUseProgram(0);
@@ -79,4 +79,93 @@ void GSGLCameraSetup(GSGL gl) {
 	glMatrixMode(GL_MODELVIEW);
 	glLoadIdentity();
 	GSGLCameraSet(gl);
+
+	GSGLCameraFrustum(gl);
+}
+
+static void frustum_normalize(GSGL gl, int plane) {
+	GSVector3 v;
+	GSNumber  l;
+	int	  i;
+
+	v[0] = gl->frustum_planes[plane][0];
+	v[1] = gl->frustum_planes[plane][1];
+	v[2] = gl->frustum_planes[plane][2];
+
+	l = GSMathLength3(v);
+
+	for(i = 0; i < 4; i++) {
+		gl->frustum_planes[plane][i] /= l;
+	}
+}
+
+void GSGLCameraFrustum(GSGL gl) {
+	glGetDoublev(GL_PROJECTION_MATRIX, gl->frustum_projection);
+	glGetDoublev(GL_MODELVIEW_MATRIX, gl->frustum_modelview);
+
+	gl->frustum_clip[0x0]	 = gl->frustum_modelview[0x0] * gl->frustum_projection[0x0] + gl->frustum_modelview[0x1] * gl->frustum_projection[0x4] + gl->frustum_modelview[0x2] * gl->frustum_projection[0x8] + gl->frustum_modelview[0x3] * gl->frustum_projection[0xc];
+	gl->frustum_clip[0x1]	 = gl->frustum_modelview[0x0] * gl->frustum_projection[0x1] + gl->frustum_modelview[0x1] * gl->frustum_projection[0x5] + gl->frustum_modelview[0x2] * gl->frustum_projection[0x9] + gl->frustum_modelview[0x3] * gl->frustum_projection[0xd];
+	gl->frustum_clip[0x2]	 = gl->frustum_modelview[0x0] * gl->frustum_projection[0x2] + gl->frustum_modelview[0x1] * gl->frustum_projection[0x6] + gl->frustum_modelview[0x2] * gl->frustum_projection[0xa] + gl->frustum_modelview[0x3] * gl->frustum_projection[0xe];
+	gl->frustum_clip[0x3]	 = gl->frustum_modelview[0x0] * gl->frustum_projection[0x3] + gl->frustum_modelview[0x1] * gl->frustum_projection[0x7] + gl->frustum_modelview[0x2] * gl->frustum_projection[0xb] + gl->frustum_modelview[0x3] * gl->frustum_projection[0xf];
+	gl->frustum_clip[0x4]	 = gl->frustum_modelview[0x4] * gl->frustum_projection[0x0] + gl->frustum_modelview[0x5] * gl->frustum_projection[0x4] + gl->frustum_modelview[0x6] * gl->frustum_projection[0x8] + gl->frustum_modelview[0x7] * gl->frustum_projection[0xc];
+	gl->frustum_clip[0x5]	 = gl->frustum_modelview[0x4] * gl->frustum_projection[0x1] + gl->frustum_modelview[0x5] * gl->frustum_projection[0x5] + gl->frustum_modelview[0x6] * gl->frustum_projection[0x9] + gl->frustum_modelview[0x7] * gl->frustum_projection[0xd];
+	gl->frustum_clip[0x6]	 = gl->frustum_modelview[0x4] * gl->frustum_projection[0x2] + gl->frustum_modelview[0x5] * gl->frustum_projection[0x6] + gl->frustum_modelview[0x6] * gl->frustum_projection[0xa] + gl->frustum_modelview[0x7] * gl->frustum_projection[0xe];
+	gl->frustum_clip[0x7]	 = gl->frustum_modelview[0x4] * gl->frustum_projection[0x3] + gl->frustum_modelview[0x5] * gl->frustum_projection[0x7] + gl->frustum_modelview[0x6] * gl->frustum_projection[0xb] + gl->frustum_modelview[0x7] * gl->frustum_projection[0xf];
+	gl->frustum_clip[0x8]	 = gl->frustum_modelview[0x8] * gl->frustum_projection[0x0] + gl->frustum_modelview[0x9] * gl->frustum_projection[0x4] + gl->frustum_modelview[0xa] * gl->frustum_projection[0x8] + gl->frustum_modelview[0xb] * gl->frustum_projection[0xc];
+	gl->frustum_clip[0x9]	 = gl->frustum_modelview[0x8] * gl->frustum_projection[0x1] + gl->frustum_modelview[0x9] * gl->frustum_projection[0x5] + gl->frustum_modelview[0xa] * gl->frustum_projection[0x9] + gl->frustum_modelview[0xb] * gl->frustum_projection[0xd];
+	gl->frustum_clip[0xa]	 = gl->frustum_modelview[0x8] * gl->frustum_projection[0x2] + gl->frustum_modelview[0x9] * gl->frustum_projection[0x6] + gl->frustum_modelview[0xa] * gl->frustum_projection[0xa] + gl->frustum_modelview[0xb] * gl->frustum_projection[0xe];
+	gl->frustum_clip[0xb]	 = gl->frustum_modelview[0x8] * gl->frustum_projection[0x3] + gl->frustum_modelview[0x9] * gl->frustum_projection[0x7] + gl->frustum_modelview[0xa] * gl->frustum_projection[0xb] + gl->frustum_modelview[0xb] * gl->frustum_projection[0xf];
+	gl->frustum_clip[0xc]	 = gl->frustum_modelview[0xc] * gl->frustum_projection[0x0] + gl->frustum_modelview[0xd] * gl->frustum_projection[0x4] + gl->frustum_modelview[0xe] * gl->frustum_projection[0x8] + gl->frustum_modelview[0xf] * gl->frustum_projection[0xc];
+	gl->frustum_clip[0xd]	 = gl->frustum_modelview[0xc] * gl->frustum_projection[0x1] + gl->frustum_modelview[0xd] * gl->frustum_projection[0x5] + gl->frustum_modelview[0xe] * gl->frustum_projection[0x9] + gl->frustum_modelview[0xf] * gl->frustum_projection[0xd];
+	gl->frustum_clip[0xe]	 = gl->frustum_modelview[0xc] * gl->frustum_projection[0x2] + gl->frustum_modelview[0xd] * gl->frustum_projection[0x6] + gl->frustum_modelview[0xe] * gl->frustum_projection[0xa] + gl->frustum_modelview[0xf] * gl->frustum_projection[0xe];
+	gl->frustum_clip[0xf]	 = gl->frustum_modelview[0xc] * gl->frustum_projection[0x3] + gl->frustum_modelview[0xd] * gl->frustum_projection[0x7] + gl->frustum_modelview[0xe] * gl->frustum_projection[0xb] + gl->frustum_modelview[0xf] * gl->frustum_projection[0xf];
+	gl->frustum_planes[0][0] = gl->frustum_clip[0x3] - gl->frustum_clip[0x0];
+	gl->frustum_planes[0][1] = gl->frustum_clip[0x7] - gl->frustum_clip[0x4];
+	gl->frustum_planes[0][2] = gl->frustum_clip[0xb] - gl->frustum_clip[0x8];
+	gl->frustum_planes[0][3] = gl->frustum_clip[0xf] - gl->frustum_clip[0xc];
+	frustum_normalize(gl, 0);
+	gl->frustum_planes[1][0] = gl->frustum_clip[0x3] + gl->frustum_clip[0x0];
+	gl->frustum_planes[1][1] = gl->frustum_clip[0x7] + gl->frustum_clip[0x4];
+	gl->frustum_planes[1][2] = gl->frustum_clip[0xb] + gl->frustum_clip[0x8];
+	gl->frustum_planes[1][3] = gl->frustum_clip[0xf] + gl->frustum_clip[0xc];
+	frustum_normalize(gl, 1);
+	gl->frustum_planes[2][0] = gl->frustum_clip[0x3] - gl->frustum_clip[0x1];
+	gl->frustum_planes[2][1] = gl->frustum_clip[0x7] - gl->frustum_clip[0x5];
+	gl->frustum_planes[2][2] = gl->frustum_clip[0xb] - gl->frustum_clip[0x9];
+	gl->frustum_planes[2][3] = gl->frustum_clip[0xf] - gl->frustum_clip[0xd];
+	frustum_normalize(gl, 2);
+	gl->frustum_planes[3][0] = gl->frustum_clip[0x3] + gl->frustum_clip[0x1];
+	gl->frustum_planes[3][1] = gl->frustum_clip[0x7] + gl->frustum_clip[0x5];
+	gl->frustum_planes[3][2] = gl->frustum_clip[0xb] + gl->frustum_clip[0x9];
+	gl->frustum_planes[3][3] = gl->frustum_clip[0xf] + gl->frustum_clip[0xd];
+	frustum_normalize(gl, 3);
+	gl->frustum_planes[4][0] = gl->frustum_clip[0x3] - gl->frustum_clip[0x2];
+	gl->frustum_planes[4][1] = gl->frustum_clip[0x7] - gl->frustum_clip[0x6];
+	gl->frustum_planes[4][2] = gl->frustum_clip[0xb] - gl->frustum_clip[0xa];
+	gl->frustum_planes[4][3] = gl->frustum_clip[0xf] - gl->frustum_clip[0xe];
+	frustum_normalize(gl, 4);
+	gl->frustum_planes[5][0] = gl->frustum_clip[0x3] + gl->frustum_clip[0x2];
+	gl->frustum_planes[5][1] = gl->frustum_clip[0x7] + gl->frustum_clip[0x6];
+	gl->frustum_planes[5][2] = gl->frustum_clip[0xb] + gl->frustum_clip[0xa];
+	gl->frustum_planes[5][3] = gl->frustum_clip[0xf] + gl->frustum_clip[0xe];
+	frustum_normalize(gl, 5);
+}
+
+GSBool GSGLCameraFrustumContain(GSGL gl, GSVector3 a, GSVector3 b) {
+	int i;
+	for(i = 0; i < 6; i++) {
+		GSBool bv = GSTrue;
+
+		bv = bv && gl->frustum_planes[i][0] * a[0] + gl->frustum_planes[i][1] * a[1] + gl->frustum_planes[i][2] * a[2] + gl->frustum_planes[i][3] <= 0.0;
+		bv = bv && gl->frustum_planes[i][0] * b[0] + gl->frustum_planes[i][1] * a[1] + gl->frustum_planes[i][2] * a[2] + gl->frustum_planes[i][3] <= 0.0;
+		bv = bv && gl->frustum_planes[i][0] * a[0] + gl->frustum_planes[i][1] * b[1] + gl->frustum_planes[i][2] * a[2] + gl->frustum_planes[i][3] <= 0.0;
+		bv = bv && gl->frustum_planes[i][0] * b[0] + gl->frustum_planes[i][1] * b[1] + gl->frustum_planes[i][2] * a[2] + gl->frustum_planes[i][3] <= 0.0;
+		bv = bv && gl->frustum_planes[i][0] * a[0] + gl->frustum_planes[i][1] * a[1] + gl->frustum_planes[i][2] * b[2] + gl->frustum_planes[i][3] <= 0.0;
+		bv = bv && gl->frustum_planes[i][0] * b[0] + gl->frustum_planes[i][1] * a[1] + gl->frustum_planes[i][2] * b[2] + gl->frustum_planes[i][3] <= 0.0;
+		bv = bv && gl->frustum_planes[i][0] * a[0] + gl->frustum_planes[i][1] * b[1] + gl->frustum_planes[i][2] * b[2] + gl->frustum_planes[i][3] <= 0.0;
+		bv = bv && gl->frustum_planes[i][0] * b[0] + gl->frustum_planes[i][1] * b[1] + gl->frustum_planes[i][2] * b[2] + gl->frustum_planes[i][3] <= 0.0;
+		if(bv) return GSFalse;
+	}
+
+	return GSTrue;
 }
diff --git a/engine/src/gl/gl_common.c b/engine/src/gl/gl_common.c
index 162d5b8..4a71628 100644
--- a/engine/src/gl/gl_common.c
+++ b/engine/src/gl/gl_common.c
@@ -179,11 +179,11 @@ void GSGLTetrakis(GSGL gl, GSNumber scale, GSVector4 col1, GSVector4 col2) {
 	    {0, 1, 0},
 	    {-0.75, 0.75, -0.75},
 	    {0.75, 0.75, -0.75}};
-	GSVector3 n;
-	GSVector3 rot2 = {0, 90, 0};
-	GSVector3 rot3 = {0, 0, 90};
-	GSVector3 rot4 = {90, 0, 0};
-	int	  i, j, k = 0;
+	GSVector3  n;
+	GSRotation rot2 = {0, {0, 90, 0}};
+	GSRotation rot3 = {0, {0, 0, 90}};
+	GSRotation rot4 = {0, {90, 0, 0}};
+	int	   i, j, k = 0;
 
 	for(i = 0; i < 3; i++) {
 		for(j = 0; j < 3; j++) v[i][j] *= scale;
@@ -197,17 +197,17 @@ void GSGLTetrakis(GSGL gl, GSNumber scale, GSVector4 col1, GSVector4 col2) {
 			GSGLSetColor(gl, ((k + j) % 2) ? col2 : col1);
 			GSGLPolygon(gl, 3, v, NULL, n);
 
-			GSGLSetRotation(gl, rot2);
+			GSGLSetRotation(gl, &rot2);
 		}
 
 		if(i == 3) {
-			GSGLSetRotation(gl, rot4);
+			GSGLSetRotation(gl, &rot4);
 			k++;
 		} else if(i == 4) {
-			GSGLSetRotation(gl, rot4);
-			GSGLSetRotation(gl, rot4);
+			GSGLSetRotation(gl, &rot4);
+			GSGLSetRotation(gl, &rot4);
 		} else {
-			GSGLSetRotation(gl, rot3);
+			GSGLSetRotation(gl, &rot3);
 			k++;
 		}
 	}
diff --git a/engine/src/gl/gl_shadow.c b/engine/src/gl/gl_shadow.c
index 6171532..e11076d 100644
--- a/engine/src/gl/gl_shadow.c
+++ b/engine/src/gl/gl_shadow.c
@@ -40,6 +40,7 @@ void GSGLShadowInit(GSGL gl) {
 		glUniform1i(glGetUniformLocation(gl->shadow_shader, "current_texture"), 0);
 		glUniform1f(glGetUniformLocation(gl->shadow_shader, "enable_lighting"), 1);
 		glUniform1f(glGetUniformLocation(gl->shadow_shader, "enable_texture"), 0);
+		glUniform1f(glGetUniformLocation(gl->shadow_shader, "enable_shadow"), 1);
 		glUseProgram(0);
 
 		gl->shadow_use_shader = 1;
@@ -48,6 +49,8 @@ void GSGLShadowInit(GSGL gl) {
 
 		gl->shadow_use_shader = 0;
 	}
+
+	gl->shadow = GSFalse;
 }
 
 GSBool GSGLShadowBegin(GSGL gl) {
@@ -74,7 +77,7 @@ GSBool GSGLShadowBegin(GSGL gl) {
 	return GSTrue;
 }
 
-int GSGLShadowCascadeSteps(GSGL gl){
+int GSGLShadowCascadeSteps(GSGL gl) {
 	if(gl->engine->client->light0[3]) return 1;
 
 	return GSGL_SHADOW_CASCADES;
@@ -92,8 +95,10 @@ void GSGLShadowCascade(GSGL gl, int cascade) {
 
 	// Simple cascade sizing
 	if(cascade == 0) size = 10;
-	else if(cascade == 1) size = 40;
-	else size = 100; // Covers max distance roughly
+	else if(cascade == 1)
+		size = 40;
+	else
+		size = 100; // Covers max distance roughly
 
 	// If light is directional (light0[3] == 0)
 	// Current existing code logic:
@@ -205,6 +210,8 @@ void GSGLShadowDisable(GSGL gl) {
 		}
 		glActiveTexture(GL_TEXTURE0);
 	}
+
+	gl->shadow = GSFalse;
 }
 
 void GSGLShadowEnable(GSGL gl) {
@@ -220,6 +227,16 @@ void GSGLShadowEnable(GSGL gl) {
 		}
 		glActiveTexture(GL_TEXTURE0);
 	}
+
+	gl->shadow = GSTrue;
+}
+
+void GSGLShadowRender(GSGL gl, int toggle){
+	if(gl->shadow_use_shader){
+		if(!gl->shadow) glUseProgram(gl->shadow_shader);
+		glUniform1f(glGetUniformLocation(gl->shadow_shader, "enable_shadow"), toggle);
+		if(!gl->shadow) glUseProgram(0);
+	}
 }
 
 void GSGLShadowEnd(GSGL gl) {
diff --git a/engine/src/model.c b/engine/src/model.c
index 127429a..ed7f2d6 100644
--- a/engine/src/model.c
+++ b/engine/src/model.c
@@ -10,13 +10,17 @@
 #include <stb_ds.h>
 
 static void parse_obj(GSModel model, char* txt) {
-	char* f	 = txt;
-	float lm = 0; /* leftmost */
-	float rm = 0; /* rightmost */
-	float um = 0; /* upmost */
-	float dm = 0; /* downmost */
-	float fm = 0; /* frontmost */
-	float bm = 0; /* backmost */
+	char* f	  = txt;
+	float lm  = 0; /* leftmost */
+	float rm  = 0; /* rightmost */
+	float um  = 0; /* upmost */
+	float dm  = 0; /* downmost */
+	float fm  = 0; /* frontmost */
+	float bm  = 0; /* backmost */
+	float l	  = 0;
+	float blr = fabs(lm - rm);
+	float bud = fabs(um - dm);
+	float bbf = fabs(fm - bm);
 
 	while(1) {
 		char* s = strchr(f, '\n');
@@ -158,6 +162,22 @@ static void parse_obj(GSModel model, char* txt) {
 		if(s == NULL) break;
 		f = s + 1;
 	}
+
+	blr = fabs(lm - rm);
+	bud = fabs(um - dm);
+	bbf = fabs(fm - bm);
+
+	if(l < blr) l = blr;
+	if(l < bud) l = bud;
+	if(l < bbf) l = bbf;
+
+	model->bbox[0][0] = -l * 2;
+	model->bbox[0][1] = -l * 2;
+	model->bbox[0][2] = -l * 2;
+
+	model->bbox[1][0] = -model->bbox[0][0];
+	model->bbox[1][1] = -model->bbox[0][1];
+	model->bbox[1][2] = -model->bbox[0][2];
 }
 
 static void parse_mtl(GSModel model, char* txt) {
@@ -274,8 +294,16 @@ GSModel GSModelOpen(GSEngine engine, const char* path) {
 
 	/* TODO: check for animation */
 	if(gl != NULL) {
-		GLuint list = GSGLBeginList(gl);
-		GSModelDraw(model);
+		GLuint	   list = GSGLBeginList(gl);
+		GSVector3  pos	= {0, 0, 0};
+		GSRotation rot;
+
+		rot.use_matrix	= GSFalse;
+		rot.u.vector[0] = 0;
+		rot.u.vector[1] = 0;
+		rot.u.vector[2] = 0;
+
+		GSModelDraw(model, pos, &rot);
 		GSGLEndList(gl);
 
 		model->call_list = list;
@@ -284,10 +312,13 @@ GSModel GSModelOpen(GSEngine engine, const char* path) {
 	return model;
 }
 
-void GSModelDraw(GSModel model) {
+void GSModelDraw(GSModel model, GSVector3 pos, GSRotation* rot) {
 	GSGL gl = model->engine->client->gl;
 	int  i;
 
+	GSGLPushMatrix(gl);
+	GSGLSetPosition(gl, pos);
+	GSGLSetRotation(gl, rot);
 	if(model->call_list == 0) {
 		char* k = "default";
 
@@ -305,8 +336,18 @@ void GSModelDraw(GSModel model) {
 
 		GSGLTextureSet(gl, 0);
 	} else {
-		GSGLCallList(gl, model->call_list);
+		GSVector3 a, b;
+
+		for(i = 0; i < 3; i++) {
+			a[i] = b[i] = pos[i];
+
+			a[i] += model->bbox[0][i];
+			b[i] += model->bbox[1][i];
+		}
+
+		if(GSGLCameraFrustumContain(gl, a, b)) GSGLCallList(gl, model->call_list);
 	}
+	GSGLPopMatrix(gl);
 }
 
 void GSModelClose(GSModel model) {