1 files changed, 42 insertions, 58 deletions

diff --git a/src/shader_sys.c b/src/shader_sys.c
index d19e64b..4d75b6a 100644
--- a/src/shader_sys.c
+++ b/src/shader_sys.c
@@ -1,10 +1,17 @@
 #include "utils.h"
 #include "config.h"
 
+#include "text.h"
+
 #include <stdlib.h>
+#include <stdio.h>
 
 #define MAX_SHADER_SIZE 8
 
+static const s8 version_st = String("#version 330\n");
+static const s8 type_markers[2] = {String("#define VERTEX_SHADER 1\n"), String("#define FRAG_SHADER 1\n")};
+static const s8 line_st = String("#line 1\n");
+
 // Internal Functions //
 
 // TODO: Compute?
@@ -17,69 +24,41 @@ typedef enum{
 
 // This returns *allocated* memory, 
 // should be manually free()'ed or some kind of arena used.
-static char* shader_block_preprocess(const char* shader_source, ShaderStep shader_step) {
-    static const char* start_markers[2] = {"@vertex", "@fragment"};
-    static const char* end_markers[2] = {"@vs_end", "@fs_end"};
-    static const char* version_statement = "#version 330\n";
-	
-	char* parsed_total = NULL;
-
-	i32 start_idx = TextFindIndex(shader_source, start_markers[shader_step]);
-	if (start_idx == BLANK_DEFAULT){
-		TRACELOG(LOG_ERROR, "%s could not be found.", start_markers[shader_step]);
-		goto parse_err;
-	}
-	start_idx += TextLength(start_markers[shader_step]);
-	
-	i32 end_idx = TextFindIndex(shader_source, end_markers[shader_step]);
-	if (end_idx == BLANK_DEFAULT){
-		TRACELOG(LOG_ERROR, "%s could not be found. Don't forget to end blocks!", end_markers[shader_step]);
-		goto parse_err;
-	}
-	
-	i32 block_sz = end_idx - start_idx;
-	
-	const char* block = TextSubtext(shader_source, start_idx, block_sz);
-	
-	i32 total_block_size = block_sz + TextLength(version_statement);
+static s8 shader_block_preprocess(const s8 source, const ShaderStep shader_step)
+{
+	size total = version_st.len + type_markers[shader_step].len + line_st.len + source.len;
 	
-	parsed_total = (char*)RL_MALLOC(total_block_size + NULL_TERM_SZ);
+	s8 parsed_total = create_s8(total + NULL_TERM_SZ);
 	
-	i32 cursor = 0;
-	TextAppend(parsed_total, version_statement, &cursor);
-	TextAppend(parsed_total, block, &cursor);
+	size cursor = 0;
+	add_s8(parsed_total, version_st, &cursor);
+	add_s8(parsed_total, type_markers[shader_step], &cursor);
+	add_s8(parsed_total, line_st, &cursor);
+	add_s8(parsed_total, source, &cursor);
+	parsed_total.buf[cursor] = NULL_TERM;
 
-parse_err:
 	return parsed_total;
 }
 
-static Shader load_joined_shader(const char* path)
+static Shader load_joined_shader(const s8 path)
 {
 	Shader something = (Shader){0};
 	
-	char* shr = LoadFileText(path);
-	
-	char* vs = shader_block_preprocess(shr, VERTEX);
-	if(vs == NULL){
-		TRACELOG(LOG_ERROR, "Unsuccessful vertex shader parse for %s", path);
-		goto vertex_err;
-	}
+	s8 file = load_file_text(path);
+	if(file.len == 0)
+		goto oops;
 	
-	char* fs = shader_block_preprocess(shr, FRAGMENT);
-	if(fs == NULL){
-		TRACELOG(LOG_ERROR, "Unsuccessful fragment shader parse for %s", path);
-		goto frag_err;
-	}
+	s8 vs = shader_block_preprocess(file, VERTEX);
+	s8 fs = shader_block_preprocess(file, FRAGMENT);
 	
-	something = LoadShaderFromMemory(vs, fs);
+	something = LoadShaderFromMemory((const char*)vs.buf, (const char*)fs.buf);
 	
-	RL_FREE(fs); 
-frag_err:
-	RL_FREE(vs); 
+	free_s8(&fs);
+	free_s8(&vs);
 
-vertex_err:
-	UnloadFileText(shr);
+	free_s8(&file);
 
+oops:
 	return something;
 }
 
@@ -87,29 +66,35 @@ vertex_err:
 
 static Shader shader_slots[MAX_SHADER_SIZE] = {0};
 static i32 shader_modtimes[MAX_SHADER_SIZE] = {0};
-static const char* shader_paths[MAX_SHADER_SIZE] = {0};
+static s8 shader_paths[MAX_SHADER_SIZE] = {0};
 
 void init_shader_sys(void)
 {
 	for(i32 i = 0; i < MAX_SHADER_SIZE; ++i){
-        shader_slots[i] = (Shader){0};
 		shader_modtimes[i] = BLANK_DEFAULT;
-		shader_paths[i] = NULL;
     }
 }
 
 i32 load_new_shader(const char* path)
 {
+	s8 path_str = cstr_to_s8(path);
+	
 	i32 current_idx = BLANK_DEFAULT;
     for(i32 i = 0; i < MAX_SHADER_SIZE; ++i){
+		if(equal_s8(path_str, shader_paths[current_idx])){
+			free_s8(&path_str);
+			return i;
+		}
+		
         if(shader_slots[i].id <= 0){
             current_idx = i;
-            shader_slots[current_idx] = load_joined_shader(path);
-			shader_modtimes[current_idx] = GetFileModTime(path);
-			shader_paths[current_idx] = path;
+            shader_slots[current_idx] = load_joined_shader(path_str);
+			shader_modtimes[current_idx] = GetFileModTime((const char*)path_str.buf);
+			shader_paths[current_idx] = path_str;
             break;
         }
     }
+	
 	//TODO: Handle slots a bit better.
 	assert(current_idx != BLANK_DEFAULT);
     
@@ -126,7 +111,7 @@ void update_shaders(void)
 {
     for(i32 i = 0; i < MAX_SHADER_SIZE; ++i){
         if(shader_slots[i].id > 0){
-            i32 current_mod = GetFileModTime(shader_paths[i]);
+            i32 current_mod = GetFileModTime((const char*)shader_paths[i].buf);
             
             if(current_mod != shader_modtimes[i]){
                 shader_modtimes[i] = current_mod;
@@ -148,9 +133,8 @@ void unload_shader(i32 idx)
 	assert(idx >= 0 && idx < MAX_SHADER_SIZE);
 	
 	UnloadShader(shader_slots[idx]);
-	shader_slots[idx] = (Shader){0};
 	shader_modtimes[idx] = BLANK_DEFAULT;
-	shader_paths[idx] = NULL;
+	free_s8(&shader_paths[idx]);
 }
 
 void unload_active_shaders(void)