glew, map parsing for windows

11 files changed, 222 insertions, 83 deletions

diff --git a/src/game.h b/src/game.h
index b0307a1..653eb91 100644
--- a/src/game.h
+++ b/src/game.h
@@ -19,7 +19,7 @@ typedef struct {
   GL_SHADER_PROGRAM* gl2d;
   GL_SHADER_PROGRAM* gl2d_texcoord;
 
-  struct GL_3D* gl3d;
+  struct GL3D* gl3d;
 } GAME_SHADERS;
 
 typedef struct {
diff --git a/src/game/raycast.cpp b/src/game/raycast.cpp
index c82a3ed..d38eb0a 100644
--- a/src/game/raycast.cpp
+++ b/src/game/raycast.cpp
@@ -126,7 +126,7 @@ U32 ray_trace( TRACE* tr, VEC3 end ) {
 }
 
 void draw_player( GAME_DATA* game, PLAYER* pl ) {
-  GL_PROGRAM* gl2d = game->shaders.gl2d;
+  GL_SHADER_PROGRAM* gl2d = game->shaders.gl2d;
   VEC2 xy = { pl->pos.x, pl->pos.y };
 
   gl_2d_frect( gl2d, xy - VEC2{ 5.f, 5.f }, { 10.f, 10.f }, CLR::RED() );
diff --git a/src/game/world/draw.cpp b/src/game/world/draw.cpp
index 9269a21..aad4d09 100644
--- a/src/game/world/draw.cpp
+++ b/src/game/world/draw.cpp
@@ -11,7 +11,7 @@ VEC2 world_project_pos(
   GAME_DATA* game,
   VEC3 pos
 ) {
-  GL_3D* gl3d = (GL_3D*)game->shaders.gl3d;
+  GL3D* gl3d = (GL3D*)game->shaders.gl3d;
 
   VEC4 clip = { pos.x, pos.z, pos.y, 1.f };
   VEC4 ndc;
diff --git a/src/main.cpp b/src/main.cpp
index 28886fa..5d70ef8 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -33,7 +33,7 @@ void loop() {
   game_main_loop( game );
 }
 
-int main() {
+int main(int argc, char* argv[]) {
   if( !canvas )
     canvas = (I32*)malloc( sizeof(I32) * 2 );
 
diff --git a/src/render/gl.cpp b/src/render/gl.cpp
index 915722e..6654dd4 100644
--- a/src/render/gl.cpp
+++ b/src/render/gl.cpp
@@ -29,7 +29,7 @@ GL_DATA* gl_create( I32* _canvas ) {
     return 0;
   }
 
-  SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES );
+  SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );
   SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 3 );
   SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 2 );
   SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
@@ -43,8 +43,8 @@ GL_DATA* gl_create( I32* _canvas ) {
   GL_DATA* gl = new GL_DATA;
   gl->window = SDL_CreateWindow(
     "game",
-    0,
-    0,
+    SDL_WINDOWPOS_CENTERED,  // Use centered position
+    SDL_WINDOWPOS_CENTERED,
     _canvas[0],
     _canvas[1],
     SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN
@@ -52,22 +52,40 @@ GL_DATA* gl_create( I32* _canvas ) {
 
   if( !gl->window ) {
     dlog( "gl_init() could not create window: %s\n", SDL_GetError() );
-    return 0;
-  }
-
-  U32 renderer_flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
-  gl->renderer = SDL_CreateRenderer( gl->window, -1, renderer_flags );
-  if( !gl->renderer ) {
-    dlog( "gl_init() could not create renderer: %s\n", SDL_GetError() );
+    delete gl;
     return 0;
   }
 
   gl->ctx = SDL_GL_CreateContext( gl->window );
   if( !gl->ctx ) {
     dlog( "gl_init() could not create context: %s\n", SDL_GetError() );
+    SDL_DestroyWindow( gl->window );
+    delete gl;
+    return 0;
+  }
+
+  SDL_GL_MakeCurrent( gl->window, gl->ctx );
+
+  GLenum glewError = glewInit();
+  if( glewError != GLEW_OK ) {
+    dlog( "gl_create() : Failed to initialize GLEW: %s\n", glewGetErrorString(glewError) );
+    SDL_GL_DeleteContext( gl->ctx );
+    SDL_DestroyWindow( gl->window );
+    delete gl;
     return 0;
   }
 
+  dlog( "OpenGL Version: %s\n", glGetString(GL_VERSION) );
+  dlog( "GLSL Version: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION) );
+  dlog( "Renderer: %s\n", glGetString(GL_RENDERER) );
+  dlog( "Vendor: %s\n", glGetString(GL_VENDOR) );
+
+  // Set up V-Sync (0 = off, 1 = on, -1 = adaptive)
+  SDL_GL_SetSwapInterval(1);
+
+  // Clear any OpenGL errors that might have occurred during initialization
+  while( glGetError() != GL_NO_ERROR );
+
   glGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS, &gl->shader_texture_limit );
   if( gl->shader_texture_limit > 255 )
     gl->shader_texture_limit = 255;
@@ -78,18 +96,28 @@ GL_DATA* gl_create( I32* _canvas ) {
   memcpy( gl->canvas_size, _canvas, sizeof(I32) * 2 );
   gl->clip_start = { 0, 0 };
   gl->clip_dim = { (F32)gl->canvas_size[0], (F32)gl->canvas_size[1] };
+  
+  // Set initial viewport
+  glViewport( 0, 0, gl->canvas_size[0], gl->canvas_size[1] );
+  
+  // Set initial clear color (so you can see if clearing is working)
+  glClearColor( 0.2f, 0.2f, 0.2f, 1.0f );
 
   gl_inst = gl;
   return gl;
 }
 
 void gl_gen_buffers( GL_DATA* gl ) {
+  // Generate and bind VAO first
+  glGenVertexArrays( 1, &gl->vao );
+  glBindVertexArray( gl->vao );
+  
   glGenBuffers( 1, &gl->vbuffer );
-
   glBindBuffer( GL_ARRAY_BUFFER, gl->vbuffer );
   glBufferData( GL_ARRAY_BUFFER, 8192, 0, GL_STATIC_DRAW );
-
   glBindBuffer( GL_ARRAY_BUFFER, 0 );
+  
+  glBindVertexArray( 0 ); // Unbind VAO
 }
 
 void gl_destroy( GL_DATA *gl ) {
@@ -131,7 +159,7 @@ void gl_update_window( GL_DATA* gl, I32* size ) {
   glUseProgram( 0 );
 }
 
-STAT gl_shader_compile( GL_DATA* gl, GL_SHADER* shader ) {
+STAT gl_shader_compile( GL_DATA* gl, GL_SHADER_DEF* shader ) {
   static char* log_buf = 0;
   if( !log_buf )
     log_buf = (char*)malloc( 8192 );
@@ -154,7 +182,7 @@ STAT gl_shader_compile( GL_DATA* gl, GL_SHADER* shader ) {
   return STAT_OK;
 }
 
-void gl_shader_destroy( GL_DATA* gl, GL_SHADER* shader ) {
+void gl_shader_destroy( GL_DATA* gl, GL_SHADER_DEF* shader ) {
   if( shader->code )
     free( (void*)shader->code );
 }
@@ -287,7 +315,6 @@ GL_TEX2D* gl_texture_from_bitmap( GL_DATA* gl, const char* name, U8* bitmap, U32
   return tex;
 }
 
-
 GL_TEX2D* gl_texture_create( GL_DATA* gl, const char* name ) {
   GL_TEX2D* tex = (GL_TEX2D*)malloc( sizeof(GL_TEX2D) );
   strcpy( tex->name, name );
@@ -307,10 +334,6 @@ void gl_texture_destroy( GL_DATA* gl, GL_TEX2D* tex ) {
 }
 
 STAT gl_beginframe( GL_DATA* gl ) {
-  SDL_SetRenderTarget( gl->renderer, 0 );
-  SDL_SetRenderDrawColor( gl->renderer, 0, 0, 0, 255 );
-  SDL_RenderClear( gl->renderer );
-
   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
   gl->last_tick = u_tick();
   return STAT_OK;
diff --git a/src/render/gl.h b/src/render/gl.h
index cf2b5dd..e4e2d5a 100644
--- a/src/render/gl.h
+++ b/src/render/gl.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #include <SDL.h>
-#include <GLES2/gl2.h>
+// #include <GLES2/gl2.h>
+#include <GL/glew.h>
 
 #include "../util.h"
 #include "../util/matrix.h"
@@ -68,6 +69,8 @@ typedef struct GL_DATA {
   VEC2 viewport_dim;
 
   MAT4* proj_matrix;
+
+  GLuint vao;
 } *PGL_DATA;
 
 GL_DATA*    gl_instance();
diff --git a/src/render/gl_2d.cpp b/src/render/gl_2d.cpp
index 44e7e00..ca3a338 100644
--- a/src/render/gl_2d.cpp
+++ b/src/render/gl_2d.cpp
@@ -1,8 +1,8 @@
 #include "gl_2d.h"
 #include "../util.h"
 
-GL_PROGRAM* gl_2d_init( GL_DATA* gl, VEC2 screensize, const char* shadername ) {
-  GL_PROGRAM* program = gl_program_create( gl, shadername );
+GL_SHADER_PROGRAM* gl_2d_init( GL_DATA* gl, VEC2 screensize, const char* shadername ) {
+  GL_SHADER_PROGRAM* program = gl_program_create( gl, shadername );
   if( !OK( gl_program_compile( gl, program ) ) )
     dlog( "gl_2d_init() : error compiling shader %s\n", shadername );
 
@@ -26,10 +26,11 @@ GL_PROGRAM* gl_2d_init( GL_DATA* gl, VEC2 screensize, const char* shadername ) {
   return program;
 }
 
-void gl_2d_line( GL_PROGRAM* gl2d, VEC2 start, VEC2 end, CLR col ) {
+void gl_2d_line( GL_SHADER_PROGRAM* gl2d, VEC2 start, VEC2 end, CLR col ) {
   static const U16 order[] = { 0, 1 };
 
   glUseProgram( gl2d->id );
+  glBindVertexArray( gl2d->gl->vao );
 
   VERTEX vertices[] = {
     { .pos = { start.x, start.y }, .clr = col },
@@ -47,12 +48,15 @@ void gl_2d_line( GL_PROGRAM* gl2d, VEC2 start, VEC2 end, CLR col ) {
 
   glBindBuffer( GL_ARRAY_BUFFER, 0 );
   glDrawElements( GL_LINES, 2, GL_UNSIGNED_SHORT, order );
+
+  glBindVertexArray( 0 );
 }
 
-void gl_2d_rect( GL_PROGRAM* gl2d, VEC2 origin, VEC2 dim, CLR col ) {
+void gl_2d_rect( GL_SHADER_PROGRAM* gl2d, VEC2 origin, VEC2 dim, CLR col ) {
   static const U16 order[] = { 0, 1, 2, 3, 4 };
 
   glUseProgram( gl2d->id );
+  glBindVertexArray( gl2d->gl->vao );
 
   VERTEX vertices[] = {
     { .pos = { origin.x        , origin.y         }, .clr = col },
@@ -73,12 +77,16 @@ void gl_2d_rect( GL_PROGRAM* gl2d, VEC2 origin, VEC2 dim, CLR col ) {
 
   glBindBuffer( GL_ARRAY_BUFFER, 0 );
   glDrawElements( GL_LINE_STRIP, 5, GL_UNSIGNED_SHORT, order ); 
+
+  glBindVertexArray( 0 );
 }
 
-void gl_2d_textured_frect( GL_PROGRAM* gl2d, VEC2 origin, VEC2 dim, GL_TEX2D* texture, CLR col, VEC2* uv, F32 rotation ) {
+void gl_2d_textured_frect( GL_SHADER_PROGRAM* gl2d, VEC2 origin, VEC2 dim, GL_TEX2D* texture, CLR col, VEC2* uv, F32 rotation ) {
   static const U16 order[] = { 0, 1, 2, 3 };
 
   glUseProgram( gl2d->id );
+  glBindVertexArray( gl2d->gl->vao );
+
   VERTEX vertices[] = {
     { { origin.x,         origin.y         }, uv? uv[0] : VEC2{ 0.f, 0.f }, col, 0 },
     { { origin.x + dim.x, origin.y         }, uv? uv[1] : VEC2{ 1.f, 0.f }, col, 0 },
@@ -125,12 +133,16 @@ void gl_2d_textured_frect( GL_PROGRAM* gl2d, VEC2 origin, VEC2 dim, GL_TEX2D* te
 
   glDrawElements( GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, order );
   glBindTexture( GL_TEXTURE_2D, 0 );
+
+  glBindVertexArray( 0 );
 }
 
-void gl_2d_frect( GL_PROGRAM* gl2d, VEC2 origin, VEC2 dim, CLR col ) {
+void gl_2d_frect( GL_SHADER_PROGRAM* gl2d, VEC2 origin, VEC2 dim, CLR col ) {
   static const U16 order[] = { 0, 1, 2, 3 };
 
   glUseProgram( gl2d->id );
+  glBindVertexArray( gl2d->gl->vao );
+  
   VERTEX vertices[] = {
     { .pos = { origin.x,         origin.y         }, .uv = { 0.f, 0.f }, .clr = col },
     { .pos = { origin.x + dim.x, origin.y         }, .uv = { 1.f, 0.f }, .clr = col },
@@ -140,25 +152,38 @@ void gl_2d_frect( GL_PROGRAM* gl2d, VEC2 origin, VEC2 dim, CLR col ) {
 
   glBindBuffer( GL_ARRAY_BUFFER, gl2d->gl->vbuffer );
   glBufferData( GL_ARRAY_BUFFER, sizeof(vertices), &vertices[0], GL_DYNAMIC_DRAW );
+  
   I32 position = glGetAttribLocation( gl2d->id, "in_pos" );
-  glEnableVertexAttribArray( position );
-  glVertexAttribPointer( position, 2, GL_FLOAT, 0, sizeof(VERTEX), 0 );
   I32 color = glGetAttribLocation( gl2d->id, "in_col" );
-  glEnableVertexAttribArray( color );
-  glVertexAttribPointer( color, 4, GL_FLOAT, 0, sizeof(VERTEX), &( (VERTEX*)nullptr)->clr );
+  
+  if (position >= 0) {
+    glEnableVertexAttribArray( position );
+    glVertexAttribPointer( position, 2, GL_FLOAT, 0, sizeof(VERTEX), 0 );
+  }
+  
+  if (color >= 0) {
+    glEnableVertexAttribArray( color );
+    glVertexAttribPointer( color, 4, GL_FLOAT, 0, sizeof(VERTEX), &( (VERTEX*)nullptr)->clr );
+  }
+
   I32 texcoord = glGetAttribLocation( gl2d->id, "in_texcoord" );
-  glEnableVertexAttribArray( texcoord );
-  glVertexAttribPointer( texcoord, 2, GL_FLOAT, 0, sizeof(VERTEX), &( (VERTEX*)nullptr)->uv );
+  if (texcoord >= 0) {
+    glEnableVertexAttribArray( texcoord );
+    glVertexAttribPointer( texcoord, 2, GL_FLOAT, 0, sizeof(VERTEX), &( (VERTEX*)nullptr)->uv );
+  }
 
   glBindBuffer( GL_ARRAY_BUFFER, 0 );
   glDrawElements( GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, order );
+  
+  glBindVertexArray( 0 ); // Unbind VAO
 }
 
-void gl_2d_circle( GL_PROGRAM* gl2d, VEC2 origin, F32 radius, CLR col, U32 res ) {
+void gl_2d_circle( GL_SHADER_PROGRAM* gl2d, VEC2 origin, F32 radius, CLR col, U32 res ) {
   static U16*      order = 0;
   const  F32 step = 360.f / (F32)res;
 
   glUseProgram( gl2d->id );
+  glBindVertexArray( gl2d->gl->vao );
 
   if( !order ) {
     order = (U16*)malloc( sizeof( U16 ) * (res + 1) );
@@ -193,13 +218,16 @@ void gl_2d_circle( GL_PROGRAM* gl2d, VEC2 origin, F32 radius, CLR col, U32 res )
 
   glDrawElements( GL_LINE_STRIP, res + 1, GL_UNSIGNED_SHORT, order );
   free( vertices );
+  
+  glBindVertexArray( 0 );
 }
 
-void gl_2d_fcircle( GL_PROGRAM* gl2d, VEC2 origin, F32 radius, CLR col, U32 res ) {
+void gl_2d_fcircle( GL_SHADER_PROGRAM* gl2d, VEC2 origin, F32 radius, CLR col, U32 res ) {
   static U16*      order = 0;
   const  F32 step = 360.f / (F32)res;
 
   glUseProgram( gl2d->id );
+  glBindVertexArray( gl2d->gl->vao );
 
   if( !order ) {
     order = (U16*)malloc( sizeof( U16 ) * (res * 2) );
@@ -246,10 +274,13 @@ void gl_2d_fcircle( GL_PROGRAM* gl2d, VEC2 origin, F32 radius, CLR col, U32 res
 
   glDrawElements( GL_TRIANGLE_STRIP, res + 2, GL_UNSIGNED_SHORT, order );
   free( vertices );
+
+  glBindVertexArray( 0 );
 }
 
-void gl_polygon( GL_PROGRAM* gl2d, VERTEX* vertices, U32 vertices_count ) {
+void gl_polygon( GL_SHADER_PROGRAM* gl2d, VERTEX* vertices, U32 vertices_count ) {
   glUseProgram( gl2d->id );
+  glBindVertexArray( gl2d->gl->vao );
 
   glBindBuffer( GL_ARRAY_BUFFER, gl2d->gl->vbuffer );
   glBufferData( GL_ARRAY_BUFFER, sizeof(VERTEX) * vertices_count, vertices, GL_STATIC_DRAW );
@@ -271,15 +302,18 @@ void gl_polygon( GL_PROGRAM* gl2d, VERTEX* vertices, U32 vertices_count ) {
     order[i] = i;
 
   glDrawElements( GL_TRIANGLE_FAN, vertices_count, GL_UNSIGNED_SHORT, order );
+
+  glBindVertexArray( 0 );
 }
 
 void gl_textured_polygon(
-  GL_PROGRAM *gl2d,
+  GL_SHADER_PROGRAM *gl2d,
   VERTEX *vertices,
   U32 vertices_count,
   GL_TEX2D *tex
 ) {
   glUseProgram( gl2d->id );
+  glBindVertexArray( gl2d->gl->vao );
 
   for( U32 i = 0; i < vertices_count; ++i )
     vertices[i].sampler = 0;
@@ -311,4 +345,6 @@ void gl_textured_polygon(
     order[i] = i;
 
   glDrawElements( GL_TRIANGLE_FAN, vertices_count, GL_UNSIGNED_SHORT, order );
+
+  glBindVertexArray( 0 );
 }
diff --git a/src/render/gl_2d_font.cpp b/src/render/gl_2d_font.cpp
index 1dc498b..a104124 100644
--- a/src/render/gl_2d_font.cpp
+++ b/src/render/gl_2d_font.cpp
@@ -207,24 +207,38 @@ void gl_font_draw( GL_FONT* font, GL_SHADER_PROGRAM* shader, VEC2 origin, const
 
   gl_font_calc_vertices_uvs( font, origin, text, _scale, vertices, indices, coords, clr );
   glUseProgram( shader->id );
+  glBindVertexArray( shader->gl->vao );
 
   glBindBuffer( GL_ARRAY_BUFFER, shader->gl->vbuffer );
   glBufferData( GL_ARRAY_BUFFER, sizeof(VERTEX) * 6 * len, vertices, GL_STATIC_DRAW );
+  
   I32 position = glGetAttribLocation( shader->id, "in_pos" );
-  glEnableVertexAttribArray( position );
-  glVertexAttribPointer( position, 2, GL_FLOAT, 0, sizeof(VERTEX), &( (VERTEX*)nullptr)->pos );
-
   I32 color = glGetAttribLocation( shader->id, "in_clr" );
-  glEnableVertexAttribArray( color );
-  glVertexAttribPointer( color, 4, GL_FLOAT, 0, sizeof(VERTEX), &( (VERTEX*)nullptr)->clr );
-
   I32 texcoord = glGetAttribLocation( shader->id, "in_texcoord" );
-  glEnableVertexAttribArray( texcoord );
-  glVertexAttribPointer( texcoord, 2, GL_FLOAT, 0, sizeof(VERTEX), &( (VERTEX*)nullptr)->uv );
-
   I32 sampler = glGetAttribLocation( shader->id, "in_sampler" );
-  glEnableVertexAttribArray( sampler );
-  glVertexAttribPointer( sampler, 1, GL_UNSIGNED_BYTE, 1, sizeof(VERTEX), &( (VERTEX*)nullptr)->sampler );
+  
+  if (position >= 0) {
+    glEnableVertexAttribArray( position );
+    glVertexAttribPointer( position, 2, GL_FLOAT, 0, sizeof(VERTEX), &( (VERTEX*)nullptr)->pos );
+  }
+
+  if (color >= 0) {
+    glEnableVertexAttribArray( color );
+    glVertexAttribPointer( color, 4, GL_FLOAT, 0, sizeof(VERTEX), &( (VERTEX*)nullptr)->clr );
+  }
+
+  if (texcoord >= 0) {
+    glEnableVertexAttribArray( texcoord );
+    glVertexAttribPointer( texcoord, 2, GL_FLOAT, 0, sizeof(VERTEX), &( (VERTEX*)nullptr)->uv );
+  }
+
+  if (sampler >= 0) {
+    glEnableVertexAttribArray( sampler );
+    glVertexAttribPointer( sampler, 1, GL_UNSIGNED_BYTE, 1, sizeof(VERTEX), &( (VERTEX*)nullptr)->sampler );
+  }
+
+  glActiveTexture( GL_TEXTURE0 );
+  glBindTexture( GL_TEXTURE_2D, font->atlas->id );
 
   glBindBuffer( GL_ARRAY_BUFFER, 0 );
 
@@ -234,10 +248,12 @@ void gl_font_draw( GL_FONT* font, GL_SHADER_PROGRAM* shader, VEC2 origin, const
 
   glDrawElements( GL_TRIANGLES, len * 6, GL_UNSIGNED_SHORT, indices );
   glBindTexture( GL_TEXTURE_2D, 0 );
-
+  
   free( vertices );
   free( indices );
   free( coords );
+
+  glBindVertexArray( 0 );
 }
 
 void gl_font_textured(
@@ -272,6 +288,7 @@ void gl_font_textured(
   }
 
   glUseProgram( shader->id );
+  glBindVertexArray( shader->gl->vao );
 
   glBindBuffer( GL_ARRAY_BUFFER, shader->gl->vbuffer );
   glBufferData( GL_ARRAY_BUFFER, sizeof(FONT_CUSTOM_VERTEX) * 6 * len, custom_vertices, GL_STATIC_DRAW ); 
@@ -303,6 +320,8 @@ void gl_font_textured(
   free( indices );
   free( coords );
   free( custom_vertices );
+
+  glBindVertexArray( 0 );
 }
 
 
diff --git a/src/render/gl_3d.cpp b/src/render/gl_3d.cpp
index 78e7f5e..7209f61 100644
--- a/src/render/gl_3d.cpp
+++ b/src/render/gl_3d.cpp
@@ -3,8 +3,8 @@
 #include "gl.h"
 #include "gl_batch.h"
 
-GL_3D* gl_3d_init( GL_DATA* gl, VEC2 screensize, const char* shadername ) {
-  GL_3D *gl3d = (GL_3D*)gl_program_create( gl, shadername, sizeof(GL_3D) );
+GL3D* gl_3d_init( GL_DATA* gl, VEC2 screensize, const char* shadername ) {
+  GL3D *gl3d = (GL3D*)gl_program_create( gl, shadername, sizeof(GL3D) );
   if( !OK( gl_program_compile( gl, gl3d ) ) )
     dlog( "gl_2d_init() : error compiling shader %s\n", shadername );
 
@@ -17,8 +17,8 @@ GL_3D* gl_3d_init( GL_DATA* gl, VEC2 screensize, const char* shadername ) {
   return gl3d;
 }
 
-void gl_3d_projection_setup( GL_PROGRAM *_gl3d, VEC3 pos, F32 fov_deg, F32 yaw, F32 pitch, F32 near, F32 far, VEC2 winsize ) {
-  GL_3D* gl3d = (GL_3D*)_gl3d;
+void gl_3d_projection_setup( GL_SHADER_PROGRAM *_gl3d, VEC3 pos, F32 fov_deg, F32 yaw, F32 pitch, F32 near, F32 far, VEC2 winsize ) {
+  GL3D* gl3d = (GL3D*)_gl3d;
   MAT4 proj, yaw_rot, pitch_rot, view, transl, tmp;
 
   F32 fov_rad = m_deg2rad( fov_deg );
@@ -63,12 +63,13 @@ void gl_3d_batch_setup( GL_BATCH3D *batch ) {
 }
 
 void gl_3d_polygon(
-  GL_PROGRAM* gl3d,
+  GL_SHADER_PROGRAM* gl3d,
   VERTEX3D* vertices,
   U32 vertices_count,
   GL_TEX2D* tex
 ) {
   glUseProgram( gl3d->id );
+  glBindVertexArray( gl3d->gl->vao );
 
   if( !!tex ) {
     glActiveTexture( GL_TEXTURE0 );
@@ -99,6 +100,8 @@ void gl_3d_polygon(
 
   glBindBuffer( GL_ARRAY_BUFFER, 0 );
   glDrawElements( GL_TRIANGLE_FAN, vertices_count, GL_UNSIGNED_SHORT, order );
+
+  glBindVertexArray( 0 );
 }
 
 void gl_3d_polygon_fan(
diff --git a/src/render/gl_3d.h b/src/render/gl_3d.h
index 531c3a3..69f171a 100644
--- a/src/render/gl_3d.h
+++ b/src/render/gl_3d.h
@@ -13,7 +13,7 @@ struct VERTEX3D {
 };
 
 using GL_BATCH3D = GL_BATCH<VERTEX3D>;
-struct GL_3D : GL_SHADER_PROGRAM {
+struct GL3D : GL_SHADER_PROGRAM {
   F32 aspect;
   MAT4 projmat;
 
@@ -21,7 +21,7 @@ struct GL_3D : GL_SHADER_PROGRAM {
 };
 
 // shader init -----------------------------------------------------------
-extern GL_3D* gl_3d_init( GL_DATA* gl, VEC2 screensize, const char* shadername );
+extern GL3D* gl_3d_init( GL_DATA* gl, VEC2 screensize, const char* shadername );
 // sets up projection matrix and sends it to the gpu ------------------------------------------------------------
 extern void gl_3d_projection_setup( GL_SHADER_PROGRAM* gl3d, VEC3 pos, F32 fov_deg, F32 yaw, F32 pitch, F32 near, F32 far, VEC2 winsize );
 extern void gl_3d_batch_setup( GL_BATCH3D* batch );
diff --git a/src/util/config/config.cpp b/src/util/config/config.cpp
index 1601afe..6c2d021 100644
--- a/src/util/config/config.cpp
+++ b/src/util/config/config.cpp
@@ -12,20 +12,24 @@ void cfg_seterr( CFG_PARSER* p, const char* fmt, ... ) {
 }
 
 inline U8 is_whitespace( char c ) {
-  return c == ' ' || c == '\t' || c == '\n';
+  return c == ' ' || c == '\t' || c == '\n' || c == '\r';  // Added \r
 }
 
 inline void trim_whitespace( char* buf ) {
-  U32 i;
-  for( i = 0; !!buf[i]; ++i )
-    if( !is_whitespace( buf[i] ) ) break;
-  for( U32 i2 = i; !!buf[i2]; ++i2 ) {
-    if( is_whitespace( buf[i2] ) ) {
-      buf[i2 - i] = 0;
-      return;
-    }
-    buf[i2 - i] = buf[i2];
-  }
+  if (!buf || !*buf) return;
+  
+  // Find first non-whitespace character
+  U32 start = 0;
+  while( buf[start] && is_whitespace( buf[start] ) ) start++;
+  
+  // Find last non-whitespace character
+  U32 end = strlen( buf );
+  while( end > start && is_whitespace( buf[end - 1] ) ) end--;
+  
+  // Move string to beginning and null-terminate
+  U32 len = end - start;
+  memmove( buf, buf + start, len );
+  buf[len] = '\0';
 }
 
 inline void init_cfg_node( CFG_NODE* node, const char* name, CFG_NODE* parent, U8 type ) {
@@ -179,65 +183,116 @@ void parse_section( CFG_PARSER* parser, CFG_SECTION* current_section ) {
   char* next_token;
 
   while( fgets( line, sizeof(line), parser->file ) ) {
-    token = strtok( line, " \t\n" );
+    parser->linen++;
+    
+    // Remove all whitespace including \r\n
+    trim_whitespace( line );
+    
+    // Skip empty lines
+    if( strlen(line) == 0 ) continue;
+    
+    // Use a copy for tokenization to preserve original
+    char line_copy[8192];
+    strcpy( line_copy, line );
+    
+    token = strtok( line_copy, " \t\r\n" );  // Added \r
     if( !token ) continue;
-    if( strcmp( token, "{" ) == 0 )
+    
+    if( strcmp( token, "{" ) == 0 ) {
       continue;
-    else if( strcmp( token, "}" ) == 0 ) {
+    } else if( strcmp( token, "}" ) == 0 ) {
       return;
     } else if( strcmp( token, cfg_types[CFGT_SECTION].def ) == 0 ) {
-      next_token = strtok( NULL, " \t\n" );
+      next_token = strtok( NULL, " \t\r\n" );
+      if( !next_token ) {
+        cfg_seterr( parser, "Missing section name at line %d", parser->linen );
+        return;
+      }
+      
       char sectname[64];
-      strcpy( sectname, next_token );
+      strncpy( sectname, next_token, sizeof(sectname) - 1 );
+      sectname[sizeof(sectname) - 1] = '\0';
       trim_whitespace( sectname );
 
       CFG_SECTION* new_section = cfg_section_new( sectname, (CFG_NODE*)current_section );
-      strtok( NULL, " \t\n" );
+      
+      // Look for opening brace
+      char* brace = strtok( NULL, " \t\r\n" );
+      if( !brace || strcmp( brace, "{" ) != 0 ) {
+        cfg_seterr( parser, "Expected '{' after section name at line %d", parser->linen );
+        return;
+      }
+      
       parse_section( parser, new_section );
     } else {
+      // Parse variable declaration
       char name[64];
-      strcpy( name, token );
+      strncpy( name, token, sizeof(name) - 1 );
+      name[sizeof(name) - 1] = '\0';
       trim_whitespace( name );
 
+      // Find the variable name (between type and =)
       token = strtok( NULL, "=[" );
-      if( !token )
+      if( !token ) {
+        cfg_seterr( parser, "Invalid variable declaration at line %d", parser->linen );
         continue;
+      }
 
       char varname[64];
-      strcpy( varname, token );
+      strncpy( varname, token, sizeof(varname) - 1 );
+      varname[sizeof(varname) - 1] = '\0';
       trim_whitespace( varname );
 
+      // Find matching parser
+      bool found = false;
       for( I32 i = 0; i < sizeof(cfg_types) / sizeof(CFG_TYPE); ++i ) {
         const CFG_TYPE* fn = &cfg_types[i];
-        if( strncmp( name, fn->def, strlen( fn->def ) ) == 0 ) {
+        if( strcmp( name, fn->def ) == 0 ) {
+          // Reset strtok to work on original line for parser
+          strcpy( line_copy, line );
+          strtok( line_copy, " \t\r\n" );  // Skip type
+          strtok( NULL, "=[" );            // Skip variable name
+          
           fn->parser( parser, current_section, varname );
+          found = true;
           break;
         }
       }
+      
+      if( !found ) {
+        cfg_seterr( parser, "Unknown type '%s' at line %d", name, parser->linen );
+        return;
+      }
 
       if( parser->iserr ) {
         dlog( "parse_section() : %s parse error:\n  - %s\n", name, parser->err );
         return;
       }
     }
-
-    parser->linen++;
   }
 }
 
 CFG_SECTION* cfg_load( const char* path ) {
-  FILE* f = fopen( path, "rb" );
+  FILE* f = fopen( path, "r" );  // Changed from "rb" to "r" for text mode
   if( !f )
     return 0;
 
   CFG_PARSER p;
+  memset( &p, 0, sizeof(p) );  // Initialize all fields
   p.iserr = 0;
   p.file = f;
   p.linen = 0;
   p.root = cfg_section_new( "root", 0 );
+  
   parse_section( &p, p.root );
 
   fclose( f );
+  
+  if( p.iserr ) {
+    cfg_free( (CFG_NODE*)p.root );
+    return 0;
+  }
+  
   return p.root;
 }