Clean-up and deinit proc

editor/editor.jai

@@ -166,7 +166,7 @@ init_transform_gizmo :: () {
         vs := create_vertex_shader_from_source(engine.renderer, "Transform Gizmo", TRANSFORM_GIZMO_SHADER, "VS", mesh_data_types = .[.POSITION]);
         ps := create_pixel_shader_from_source(engine.renderer, "Transform Gizmo", TRANSFORM_GIZMO_SHADER, "PS");
 
-        engine.editor.transform_gizmo.pipeline = create_pipeline_state2(engine.renderer, vs, ps, blend_type=.OPAQUE);
+        engine.editor.transform_gizmo.pipeline = create_pipeline_state(engine.renderer, vs, ps, blend_type=.OPAQUE);
     }
 }
 

metaprogram.jai

@@ -532,9 +532,14 @@ message_loop :: () {
                     array_add(*deinit_entity_procs, struct_type.name);
                 } else {
                     for note: it.expression.notes {
-                        if to_lower_copy(note.text,, allocator = temp) == "newentity" {
+                        if to_lower_copy(note.text,, temp) == {
+                            case "newentity"; {
                                 array_add(*new_entity_procs, it.expression.name);
                             }
+                            case "engineinit"; {
+                                array_add(*engine_init_procs, it.expression.name);
+                            }
+                        }
                     }
                 }
             }
@@ -597,6 +602,17 @@ generate_code :: (w: Workspace) {
         add_build_string(build_string, w, message);
     }
 
+    {
+        builder: String_Builder;
+
+        for engine_init_procs {
+            print_to_builder(*builder, "%();", it);
+        }
+        
+        build_string := sprint(RUN_ENGINE_INIT, builder_to_string(*builder));
+        add_build_string(build_string, w, message);
+    }
+
     {
         builder: String_Builder;
 
@@ -708,6 +724,7 @@ generate_code :: (w: Workspace) {
 generated_code := false;
 entity_type_names: [..] string;
 new_entity_procs: [..] string;
+engine_init_procs: [..] string;
 deinit_entity_procs: [..] string;
 
 // INSERTION_STRING represents the code we want to add to the target program.
@@ -815,6 +832,12 @@ init_scene :: (scene: *Scene) {
 }
 DONE
 
+RUN_ENGINE_INIT :: #string DONE
+run_engine_inits :: () {
+    %1
+}
+DONE
+
 
 EDITOR_UI_ENTITY_CREATION :: #string DONE
 #if EDITOR {
@@ -835,6 +858,7 @@ PLACEHOLDER :: #string DONE
 #poke_name Coven serialize_entity;
 #poke_name Coven new_mesh_entity;
 #poke_name Coven call_correct_deinit_entity;
+#poke_name Coven run_engine_inits;
 
 #if EDITOR {
     #poke_name Coven editor_ui_entity_creation;

module.jai

@@ -84,6 +84,8 @@ coven_init :: (window_title: string, window_width: u32, window_height: u32, full
     }
 
     find_all_mesh_entities();
+
+    run_engine_inits();
 }
 
 coven_run :: (game_update_proc: (float), game_editor_update_proc: (float), game_update_post_physics_proc: (float)) {

renderer/dx11_renderer.jai

@@ -334,7 +334,7 @@ compile_shader :: (name: string, source: string, entry_point: string, shader_mod
 
     if FAILED(hr) { 
         free(bytecode);
-        if errors print ("Shader compilation error in shader '%': %\n", name, errors);
+        if errors print("Shader compilation error in shader '%': %", name, errors);
         return "", null, hr;
     } 
     
@@ -865,7 +865,7 @@ create_backend_input_layout :: (using renderer: *D3D11_Backend, layout: [] Verte
     hr := ID3D11Device_CreateInputLayout(d3d_device, d3d_layout.data, cast(u32) d3d_layout.count, shader.bytecode.data, cast(u64) shader.bytecode.count, *vertex_layout);
 
     if FAILED(hr) {
-        log_error("CreateInputLayout failed: %", hr);
+        //log_error("CreateInputLayout failed: %", hr);
         return null;
     }
 

renderer/renderer.jai

@@ -171,6 +171,7 @@ Shader_Info :: struct {
 }
 
 Shader :: struct {
+    compiled        : bool;
     type            : Shader_Type;
     backend_shader  : Backend_Shader;
     defines : [..] string;
@@ -720,6 +721,13 @@ init_default_pipelines :: () {
 
         engine.renderer.default_pipelines.message_text = create_pipeline_state(renderer, vs, ps, layout, params, blend_type=.TRANSPARENT);
     }
+
+    {
+        vs := create_vertex_shader_from_source(engine.renderer, FALLBACK_SHADER, "VS", mesh_data_types = .[.POSITION]);
+        ps := create_pixel_shader_from_source(engine.renderer, FALLBACK_SHADER, "PS");
+
+        projectile_pipeline = create_pipeline_state2(engine.renderer, vs, ps, blend_type=.OPAQUE);
+    }
 }
 
 init_default_meshes :: () {
@@ -879,14 +887,17 @@ create_shader :: (using renderer: *Renderer, path: string, entry_point: string,
 
     backend_shader, info, success := create_backend_shader(engine.renderer.backend, path, entry_point, shader_type, defines);
 
-    if success {
+    if !success {
-        shader.info = info;
+        log_error("Error: Failed compiling shader '%'\n", path);
-        shader.backend_shader = backend_shader;
-        array_add(*shaders, shader);
-        return xx shaders.count;
     }
 
-    return 0;
+    shader.info = info;
+    shader.compiled = success;
+    shader.backend_shader = backend_shader;
+    array_add(*shaders, shader);
+
+    return xx shaders.count;
+
 }
 
 reload_shader :: (using renderer: *Renderer, shader: *Shader) {
@@ -922,14 +933,16 @@ create_shader_from_source :: (using renderer: *Renderer, name: string, source: s
 
     backend_shader, info, success := create_backend_shader_from_source(engine.renderer.backend, name, source, entry_point, shader_type, defines);
 
-    if success {
+    if !success {
+        log_error("Error: Failed compiling shader '%'\n", name);
+    }
+
     shader.info = info;
+    shader.compiled = success;
     shader.backend_shader = backend_shader;
     array_add(*shaders, shader);
     return xx shaders.count;
-    }
 
-    return 0;
 }
 
 create_vertex_shader :: #bake_arguments create_shader(shader_type=.VERTEX);
@@ -1067,7 +1080,7 @@ create_sampler :: (using renderer: *Renderer, filter: Sampling_Filter = .LINEAR,
     return 0;
 }
 
-create_pipeline_state2 :: (using renderer: *Renderer, vs: Shader_Handle, ps: Shader_Handle, blend_type: Blend_Type = .OPAQUE) -> Pipeline_State_Handle {
+create_pipeline_state :: (using renderer: *Renderer, vs: Shader_Handle, ps: Shader_Handle, blend_type: Blend_Type = .OPAQUE) -> Pipeline_State_Handle {
     pipeline_state : Pipeline_State;
     pipeline_state.is_new = true;
     pipeline_state.vs = vs;
@@ -1688,3 +1701,26 @@ file_change_callback :: (watcher: *File_Watcher(string), change: *File_Change, u
         }
     }
 }
+
+FALLBACK_SHADER :: #string DONE 
+cbuffer Model : register(b0)
+{
+    float4x4 model;
+};
+
+struct PSInput {
+    float4 position : SV_POSITION;
+};
+
+PSInput VS(float3 pos : POSITION) {
+    PSInput input;
+
+    input.position = mul(float4(pos, 1.0), model);
+
+    return input;
+}
+
+float4 PS(PSInput input) : SV_Target {
+    return float4(1,0,1,1);
+}
+DONE

renderer/trigger_rendering.jai

@@ -54,7 +54,7 @@ init_trigger_line_rendering :: () {
 		vs := create_vertex_shader_from_source(engine.renderer, "trigger_vertex_shader", TRIGGER_VERTEX_SHADER, "main_vs", mesh_data_types = .[.POSITION, .NORMAL, .TEXCOORD, .BONE_INDICES, .BONE_WEIGHTS], defines = string.["SKINNING"]);
 		ps := create_pixel_shader_from_source(engine.renderer, "trigger_pixel_shader", TRIGGER_PIXEL_SHADER, "main_ps");
 
-		trigger_pipeline = create_pipeline_state2(engine.renderer, vs, ps, blend_type=.TRANSPARENT);
+		trigger_pipeline = create_pipeline_state(engine.renderer, vs, ps, blend_type=.TRANSPARENT);
 	}
 }