work towards normals

modules/stb_image/bindings.jai

@@ -0,0 +1,145 @@
+//
+// This file was auto-generated using the following command:
+//
+// jai generate.jai
+//
+
+
+
+STBI_VERSION :: 1;
+
+STBI :: enum u32 {
+    default    :: 0;
+
+    grey       :: 1;
+    grey_alpha :: 2;
+    rgb        :: 3;
+    rgb_alpha  :: 4;
+
+    STBI_default    :: default;
+
+    STBI_grey       :: grey;
+    STBI_grey_alpha :: grey_alpha;
+    STBI_rgb        :: rgb;
+    STBI_rgb_alpha  :: rgb_alpha;
+}
+
+//
+// load image by filename, open file, or memory buffer
+//
+stbi_io_callbacks :: struct {
+    read: #type (user: *void, data: *u8, size: s32) -> s32 #c_call; // fill 'data' with 'size' bytes.  return number of bytes actually read
+    skip: #type (user: *void, n: s32) -> void #c_call; // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
+    eof:  #type (user: *void) -> s32 #c_call; // returns nonzero if we are at end of file/data
+}
+
+////////////////////////////////////
+//
+// 8-bits-per-channel interface
+//
+stbi_load_from_memory :: (buffer: *u8, len: s32, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u8 #foreign stb_image;
+stbi_load_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u8 #foreign stb_image;
+
+stbi_load :: (filename: *u8, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u8 #foreign stb_image;
+stbi_load_from_file :: (f: *FILE, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u8 #foreign stb_image;
+
+stbi_load_gif_from_memory :: (buffer: *u8, len: s32, delays: **s32, x: *s32, y: *s32, z: *s32, comp: *s32, req_comp: s32) -> *u8 #foreign stb_image;
+
+////////////////////////////////////
+//
+// 16-bits-per-channel interface
+//
+stbi_load_16_from_memory :: (buffer: *u8, len: s32, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u16 #foreign stb_image;
+stbi_load_16_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u16 #foreign stb_image;
+
+stbi_load_16 :: (filename: *u8, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u16 #foreign stb_image;
+stbi_load_from_file_16 :: (f: *FILE, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u16 #foreign stb_image;
+
+stbi_loadf_from_memory :: (buffer: *u8, len: s32, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *float #foreign stb_image;
+stbi_loadf_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *float #foreign stb_image;
+
+stbi_loadf :: (filename: *u8, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *float #foreign stb_image;
+stbi_loadf_from_file :: (f: *FILE, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *float #foreign stb_image;
+
+stbi_hdr_to_ldr_gamma :: (gamma: float) -> void #foreign stb_image;
+stbi_hdr_to_ldr_scale :: (scale: float) -> void #foreign stb_image;
+
+stbi_ldr_to_hdr_gamma :: (gamma: float) -> void #foreign stb_image;
+stbi_ldr_to_hdr_scale :: (scale: float) -> void #foreign stb_image;
+
+// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
+stbi_is_hdr_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void) -> s32 #foreign stb_image;
+stbi_is_hdr_from_memory :: (buffer: *u8, len: s32) -> s32 #foreign stb_image;
+
+stbi_is_hdr :: (filename: *u8) -> s32 #foreign stb_image;
+stbi_is_hdr_from_file :: (f: *FILE) -> s32 #foreign stb_image;
+
+// get a VERY brief reason for failure
+// on most compilers (and ALL modern mainstream compilers) this is threadsafe
+stbi_failure_reason :: () -> *u8 #foreign stb_image;
+
+// free the loaded image -- this is just free()
+stbi_image_free :: (retval_from_stbi_load: *void) -> void #foreign stb_image;
+
+// get image dimensions & components without fully decoding
+stbi_info_from_memory :: (buffer: *u8, len: s32, x: *s32, y: *s32, comp: *s32) -> s32 #foreign stb_image;
+stbi_info_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void, x: *s32, y: *s32, comp: *s32) -> s32 #foreign stb_image;
+stbi_is_16_bit_from_memory :: (buffer: *u8, len: s32) -> s32 #foreign stb_image;
+stbi_is_16_bit_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void) -> s32 #foreign stb_image;
+
+stbi_info :: (filename: *u8, x: *s32, y: *s32, comp: *s32) -> s32 #foreign stb_image;
+stbi_info_from_file :: (f: *FILE, x: *s32, y: *s32, comp: *s32) -> s32 #foreign stb_image;
+stbi_is_16_bit :: (filename: *u8) -> s32 #foreign stb_image;
+stbi_is_16_bit_from_file :: (f: *FILE) -> s32 #foreign stb_image;
+
+// for image formats that explicitly notate that they have premultiplied alpha,
+// we just return the colors as stored in the file. set this flag to force
+// unpremultiplication. results are undefined if the unpremultiply overflow.
+stbi_set_unpremultiply_on_load :: (flag_true_if_should_unpremultiply: s32) -> void #foreign stb_image;
+
+// indicate whether we should process iphone images back to canonical format,
+// or just pass them through "as-is"
+stbi_convert_iphone_png_to_rgb :: (flag_true_if_should_convert: s32) -> void #foreign stb_image;
+
+// flip the image vertically, so the first pixel in the output array is the bottom left
+stbi_set_flip_vertically_on_load :: (flag_true_if_should_flip: s32) -> void #foreign stb_image;
+
+// as above, but only applies to images loaded on the thread that calls the function
+// this function is only available if your compiler supports thread-local variables;
+// calling it will fail to link if your compiler doesn't
+stbi_set_unpremultiply_on_load_thread :: (flag_true_if_should_unpremultiply: s32) -> void #foreign stb_image;
+stbi_convert_iphone_png_to_rgb_thread :: (flag_true_if_should_convert: s32) -> void #foreign stb_image;
+stbi_set_flip_vertically_on_load_thread :: (flag_true_if_should_flip: s32) -> void #foreign stb_image;
+
+// ZLIB client - used by PNG, available for other purposes
+stbi_zlib_decode_malloc_guesssize :: (buffer: *u8, len: s32, initial_size: s32, outlen: *s32) -> *u8 #foreign stb_image;
+stbi_zlib_decode_malloc_guesssize_headerflag :: (buffer: *u8, len: s32, initial_size: s32, outlen: *s32, parse_header: s32) -> *u8 #foreign stb_image;
+stbi_zlib_decode_malloc :: (buffer: *u8, len: s32, outlen: *s32) -> *u8 #foreign stb_image;
+stbi_zlib_decode_buffer :: (obuffer: *u8, olen: s32, ibuffer: *u8, ilen: s32) -> s32 #foreign stb_image;
+
+stbi_zlib_decode_noheader_malloc :: (buffer: *u8, len: s32, outlen: *s32) -> *u8 #foreign stb_image;
+stbi_zlib_decode_noheader_buffer :: (obuffer: *u8, olen: s32, ibuffer: *u8, ilen: s32) -> s32 #foreign stb_image;
+
+#scope_file
+
+
+#if OS == .WINDOWS {
+    stb_image :: #library "windows/stb_image";
+} else #if OS == .LINUX {
+    stb_image :: #library "linux/stb_image";
+} else #if OS == .MACOS {
+    stb_image :: #library "macos/stb_image";
+} else #if OS == .ANDROID {
+    #if CPU == .X64 {
+        stb_image :: #library "android/x64/stb_image";
+    } else #if CPU == .ARM64 {
+        stb_image :: #library "android/arm64/stb_image";
+    }
+} else #if OS == .PS5 {
+    stb_image :: #library "ps5/stb_image";
+} else #if OS == .WASM {
+    stb_image :: #library "wasm/stb_image";
+} else {
+    #assert false;
+}
+

modules/stb_image/generate.jai

@@ -0,0 +1,151 @@
+AT_COMPILE_TIME :: true;
+
+SOURCE_PATH :: "source";
+LIB_BASE_NAME :: "stb_image";
+
+#if AT_COMPILE_TIME {
+    #run,stallable {
+        set_build_options_dc(.{do_output=false});
+        options := get_build_options();
+        args := options.compile_time_command_line;
+        if !generate_bindings(args, options.minimum_os_version) {
+            compiler_set_workspace_status(.FAILED);
+        }
+    }
+} else {
+    #import "System";
+
+    main :: () {
+        set_working_directory(path_strip_filename(get_path_of_running_executable()));
+        if !generate_bindings(get_command_line_arguments(), #run get_build_options().minimum_os_version) {
+            exit(1);
+        }
+    }
+}
+
+generate_bindings :: (args: [] string, minimum_os_version: type_of(Build_Options.minimum_os_version)) -> bool {
+    target_android := array_find(args, "-android");
+    target_x64     := array_find(args, "-x64");
+    target_arm     := array_find(args, "-arm64");
+    compile        := array_find(args, "-compile");
+    compile_debug  := array_find(args, "-debug");
+
+    os_target  := OS;
+    cpu_target := CPU;
+    if target_android os_target  = .ANDROID;
+    if target_x64     cpu_target = .X64;
+    if target_arm     cpu_target = .ARM64;
+ 
+    lib_directory: string;
+    if os_target == {
+        case .WINDOWS;
+            lib_directory = "windows";
+        case .LINUX;
+            lib_directory = "linux";
+        case .MACOS;
+            lib_directory = "macos";
+        case .ANDROID;
+            lib_directory = ifx cpu_target == .X64 then "android/x64" else "android/arm64";
+        case .PS5;
+            lib_directory = "ps5";
+        case;
+            assert(false);
+    }
+
+    if compile {
+        source_file := tprint("%/stb_image.c", SOURCE_PATH);
+
+        make_directory_if_it_does_not_exist(lib_directory, recursive = true);
+        lib_path := tprint("%/%", lib_directory, LIB_BASE_NAME);
+        success := true;
+        if os_target == .MACOS {
+            lib_path_x64   := tprint("%_x64", lib_path);
+            lib_path_arm64 := tprint("%_arm64", lib_path);
+            macos_x64_version_arg   := "-mmacos-version-min=10.13"; // Our current x64 min version
+            macos_arm64_version_arg := "-mmacos-version-min=11.0";  // Earliest version that supports arm64
+            // x64 variant
+            success &&= build_cpp_dynamic_lib(lib_path_x64,   source_file, extra = .["-arch", "x86_64", macos_x64_version_arg],   debug=compile_debug);
+            success &&= build_cpp_static_lib( lib_path_x64,   source_file, extra = .["-arch", "x86_64", macos_x64_version_arg],   debug=compile_debug);
+            // arm64 variant
+            success &&= build_cpp_dynamic_lib(lib_path_arm64, source_file, extra = .["-arch", "arm64",  macos_arm64_version_arg], debug=compile_debug);
+            success &&= build_cpp_static_lib( lib_path_arm64, source_file, extra = .["-arch", "arm64",  macos_arm64_version_arg], debug=compile_debug);
+            // create universal binaries
+            run_result := run_command("lipo", "-create", tprint("%.dylib", lib_path_x64), tprint("%.dylib", lib_path_arm64), "-output", tprint("%.dylib", lib_path));
+            success &&= (run_result.exit_code == 0);
+            run_result  = run_command("lipo", "-create", tprint("%.a",     lib_path_x64), tprint("%.a",     lib_path_arm64), "-output", tprint("%.a",     lib_path));
+            success &&= (run_result.exit_code == 0);
+        } else {
+            extra: [..] string;
+            if os_target == .ANDROID {
+                _, target_triple_with_sdk := get_android_target_triple(cpu_target);
+                array_add(*extra, "-target", target_triple_with_sdk);
+            }
+            if os_target != .WINDOWS {
+                array_add(*extra, "-fPIC");
+            }
+
+            if os_target != .PS5 && os_target != .WASM {
+                success &&= build_cpp_dynamic_lib(lib_path, source_file, target = os_target, debug = compile_debug, extra = extra);
+            }
+            success &&= build_cpp_static_lib(lib_path, source_file, target = os_target, debug = compile_debug, extra = extra);
+        }
+
+        if !success     return false;
+    }
+
+    options: Generate_Bindings_Options;
+    options.os = os_target;
+    options.cpu = cpu_target;
+    {
+        using options;
+
+        array_add(*libpaths, lib_directory);
+        array_add(*libnames, LIB_BASE_NAME);
+        array_add(*source_files, tprint("%/stb_image.h", SOURCE_PATH));
+        array_add(*typedef_prefixes_to_unwrap, "stbi_");
+
+
+        generate_library_declarations = false;
+        footer = tprint(FOOTER_TEMPLATE, LIB_BASE_NAME);
+
+        auto_detect_enum_prefixes = true;
+        log_stripped_declarations = false;
+        generate_compile_time_struct_checks = false;
+    }
+
+    output_filename := "bindings.jai";
+    return generate_bindings(options, output_filename);
+}
+
+FOOTER_TEMPLATE :: #string END
+
+#if OS == .WINDOWS {
+    %1 :: #library "windows/%1";
+} else #if OS == .LINUX {
+    %1 :: #library "linux/%1";
+} else #if OS == .MACOS {
+    %1 :: #library "macos/%1";
+} else #if OS == .ANDROID {
+    #if CPU == .X64 {
+        %1 :: #library "android/x64/%1";
+    } else #if CPU == .ARM64 {
+        %1 :: #library "android/arm64/%1";
+    }
+} else #if OS == .PS5 {
+    %1 :: #library "ps5/%1";
+} else #if OS == .WASM {
+    // Wasm will be linked with emcc.
+} else {
+    #assert false;
+}
+
+END
+
+#import "Basic";
+#import "Bindings_Generator";
+#import "BuildCpp";
+#import "Compiler";
+#import "File";
+#import "Process";
+#import "Toolchains/Android";
+

modules/stb_image/module.jai

@@ -0,0 +1,12 @@
+#load "bindings.jai";
+
+#if OS == .WINDOWS ||  OS == .PS5 || OS == .WASM {
+    #scope_module
+    FILE :: void;
+} else #if OS_IS_UNIX {
+    #import "POSIX";
+    #library,system,link_always "libm";
+} else {
+    #assert false;
+}
+

modules/stb_image/source/stb_image.c

@@ -0,0 +1,11 @@
+#ifdef WIN32
+#define __EXPORT __declspec(dllexport)
+#else
+#define __EXPORT
+#endif
+
+#define STBIDEF extern __EXPORT
+
+#define STBI_NO_STDIO
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"

src/editor/editor.jai

@@ -17,7 +17,4 @@ draw_editor_ui :: (theme: *GR.Overall_Theme) {
 tick_editor_ui :: () {
     tick_trile_editor();
     tick_console();
-
-    
-    
 }

src/pipelines.jai

@@ -38,11 +38,13 @@ create_trixel_pipeline :: () {
     shader_desc := trixel_shader_desc(sg_query_backend());
     pipeline.shader = sg_make_shader(*shader_desc);
     pipeline.layout.buffers[0].stride = 4*3;
-    pipeline.layout.buffers[1].step_func = .PER_INSTANCE;
+    pipeline.layout.buffers[1].stride = 4*3;
+    pipeline.layout.buffers[2].step_func = .PER_INSTANCE;
     
     pipeline.layout.attrs[ATTR_trixel_position] = .{ format = .FLOAT3, buffer_index = 0 };
-    pipeline.layout.attrs[ATTR_trixel_inst]     = .{ format = .FLOAT4, buffer_index = 1 };
-    pipeline.layout.attrs[ATTR_trixel_inst_col] = .{ format = .FLOAT4, buffer_index = 1 };
+    pipeline.layout.attrs[ATTR_trixel_normal]   = .{ format = .FLOAT3, buffer_index = 1 };
+    pipeline.layout.attrs[ATTR_trixel_inst]     = .{ format = .FLOAT4, buffer_index = 2 };
+    pipeline.layout.attrs[ATTR_trixel_inst_col] = .{ format = .FLOAT4, buffer_index = 2 };
     pipeline.index_type = .UINT16;
     pipeline.depth = .{
             write_enabled = true,
@@ -58,45 +60,77 @@ create_trixel_pipeline :: () {
         }
     };
 
-    verts : [24] Vector3;
-	verts[0] = .{ -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF };
-	verts[1] = .{ TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF  };
-	verts[2] = .{ TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF   };
-	verts[3] = .{ -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF  };
 
-	verts[4] = .{ -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF  };
-	verts[5] = .{ TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF   };
-	verts[6] = .{ TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF    };
-	verts[7] = .{ -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF   };
+    vertices : [24]Vector3 = .[
+        .{-TRIXEL_SIZE/2, -TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, -TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, -TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, -TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, -TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, -TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, -TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, -TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, -TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{TRIXEL_SIZE/2, -TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, -TRIXEL_SIZE/2, -TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, -TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, TRIXEL_SIZE/2, TRIXEL_SIZE/2},
+        .{-TRIXEL_SIZE/2, TRIXEL_SIZE/2, -TRIXEL_SIZE/2}
+    ];
 
-	verts[8] =  .{ -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF };
-	verts[9] =  .{ -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF  };
-	verts[10] = .{ -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF   };
-	verts[11] = .{ -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF  };
+    normals : [24]Vector3 = .[
+        .{0.0, 0.0, 1.0},
+        .{0.0, 0.0, 1.0},
+        .{0.0, 0.0, 1.0},
+        .{0.0, 0.0, 1.0},
+        .{0.0, 0.0,-1.0},
+        .{0.0, 0.0,-1.0},
+        .{0.0, 0.0,-1.0},
+        .{0.0, 0.0,-1.0},
+        .{0.0, 1.0, 0.0},
+        .{0.0, 1.0, 0.0},
+        .{0.0, 1.0, 0.0},
+        .{0.0, 1.0, 0.0},
+        .{0.0,-1.0, 0.0},
+        .{0.0,-1.0, 0.0},
+        .{0.0,-1.0, 0.0},
+        .{0.0,-1.0, 0.0},
+        .{1.0, 0.0, 0.0},
+        .{1.0, 0.0, 0.0},
+        .{1.0, 0.0, 0.0},
+        .{1.0, 0.0, 0.0},
+        .{-1.0, 0.0, 0.0},
+        .{-1.0, 0.0, 0.0},
+        .{-1.0, 0.0, 0.0},
+        .{-1.0, 0.0, 0.0}
+    ];
 
-	verts[12] = .{ TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF };
-	verts[13] = .{ TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF  };
-	verts[14] = .{ TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF   };
-	verts[15] = .{ TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF  };
+    k : u16 = 0;
+    i : u16 = 0;
 
-	verts[16] = .{ -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF };
-	verts[17] = .{ -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF  };
-	verts[18] = .{ TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF   };
-	verts[19] = .{ TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF  };
+    indices : [36]u16;
     
-	verts[20] = .{ -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF  };
-	verts[21] = .{ -TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF   };
-	verts[22] = .{ TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF    };
-	verts[23] = .{ TRIXEL_SIZE_HALF, TRIXEL_SIZE_HALF, -TRIXEL_SIZE_HALF   };
+    while i < 36 {
+        indices[i] = 4*k;
+        indices[i + 1] = 4*k + 1;
+        indices[i + 2] = 4*k + 2;
+        indices[i + 3] = 4*k;
+        indices[i + 4] = 4*k + 2;
+        indices[i + 5] = 4*k + 3;
+        k += 1;
+        i += 6;
+    }
 
-	indices: [] u16 = .[
-		0, 2, 1, 0, 3, 2,
-		4, 6, 5, 4, 7, 6,
-		8, 10, 9, 8, 11, 10,
-		12, 14, 13, 12, 15, 14,
-		16, 18, 17, 16, 19, 18,
-		20, 22, 21, 20, 23, 22
-	];
     
     pipeline.color_count = 1;
     pipeline.colors[0]   = color_state;
@@ -104,12 +138,14 @@ create_trixel_pipeline :: () {
     gPipelines.trixel.pipeline = sg_make_pipeline(*pipeline);
     
     ibuffer         := sg_buffer_desc.{ type = .INDEXBUFFER, data = .{ ptr = indices.data, size = 36 * 2 } };
-    vbuffer         := sg_buffer_desc.{ data = .{ ptr = verts.data, size = 24 * 3 * 4 } };
+    vbuffer         := sg_buffer_desc.{ data = .{ ptr = vertices.data, size = 24 * 3 * 4 } };
+    nbuffer         := sg_buffer_desc.{ data = .{ ptr = normals.data, size = 24 * 3 * 4 } };
     instance_buffer := sg_buffer_desc.{ usage = .STREAM, size = 4096 * size_of(Position_Color)};
 
     gPipelines.trixel.bind.index_buffer      = sg_make_buffer(*ibuffer);
     gPipelines.trixel.bind.vertex_buffers[0] = sg_make_buffer(*vbuffer);
-    gPipelines.trixel.bind.vertex_buffers[1] = sg_make_buffer(*instance_buffer);
+    gPipelines.trixel.bind.vertex_buffers[1] = sg_make_buffer(*nbuffer);
+    gPipelines.trixel.bind.vertex_buffers[2] = sg_make_buffer(*instance_buffer);
 }
 
 create_arbtri_pipeline :: () {

src/shaders/compile_shaders.sh

@@ -1,4 +1,5 @@
-rm -rf .jai
+rm -rf jai
+mkdir jai
 
 for filename in *.glsl; do
     if [ -f "$filename" ]; then

src/shaders/jai/shader_trixel.jai

@@ -14,16 +14,18 @@
         Fragment Shader: fs_trixel
         Attributes:
             ATTR_trixel_position => 0
-            ATTR_trixel_inst => 1
-            ATTR_trixel_inst_col => 2
+            ATTR_trixel_normal => 1
+            ATTR_trixel_inst => 2
+            ATTR_trixel_inst_col => 3
     Bindings:
         Uniform block 'vs_params':
             Jai struct: Vs_Params
             Bind slot: UB_vs_params => 0
 */
 ATTR_trixel_position :: 0;
-ATTR_trixel_inst :: 1;
-ATTR_trixel_inst_col :: 2;
+ATTR_trixel_normal :: 1;
+ATTR_trixel_inst :: 2;
+ATTR_trixel_inst_col :: 3;
 UB_vs_params :: 0;
 Vs_Params :: struct {
     mvp: [16]float;
@@ -32,10 +34,11 @@ Vs_Params :: struct {
     #version 430
 
     uniform vec4 vs_params[4];
-    layout(location = 1) in vec4 inst;
+    layout(location = 2) in vec4 inst;
     layout(location = 0) in vec4 position;
     layout(location = 0) out vec4 color;
-    layout(location = 2) in vec4 inst_col;
+    layout(location = 3) in vec4 inst_col;
+    layout(location = 1) in vec4 normal;
 
     void main()
     {
@@ -48,25 +51,28 @@ vs_trixel_source_glsl430 := u8.[
     0x23,0x76,0x65,0x72,0x73,0x69,0x6f,0x6e,0x20,0x34,0x33,0x30,0x0a,0x0a,0x75,0x6e,
     0x69,0x66,0x6f,0x72,0x6d,0x20,0x76,0x65,0x63,0x34,0x20,0x76,0x73,0x5f,0x70,0x61,
     0x72,0x61,0x6d,0x73,0x5b,0x34,0x5d,0x3b,0x0a,0x6c,0x61,0x79,0x6f,0x75,0x74,0x28,
-    0x6c,0x6f,0x63,0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x31,0x29,0x20,0x69,0x6e,
+    0x6c,0x6f,0x63,0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x32,0x29,0x20,0x69,0x6e,
     0x20,0x76,0x65,0x63,0x34,0x20,0x69,0x6e,0x73,0x74,0x3b,0x0a,0x6c,0x61,0x79,0x6f,
     0x75,0x74,0x28,0x6c,0x6f,0x63,0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x30,0x29,
     0x20,0x69,0x6e,0x20,0x76,0x65,0x63,0x34,0x20,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,
     0x6e,0x3b,0x0a,0x6c,0x61,0x79,0x6f,0x75,0x74,0x28,0x6c,0x6f,0x63,0x61,0x74,0x69,
     0x6f,0x6e,0x20,0x3d,0x20,0x30,0x29,0x20,0x6f,0x75,0x74,0x20,0x76,0x65,0x63,0x34,
     0x20,0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x6c,0x61,0x79,0x6f,0x75,0x74,0x28,0x6c,
-    0x6f,0x63,0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x32,0x29,0x20,0x69,0x6e,0x20,
-    0x76,0x65,0x63,0x34,0x20,0x69,0x6e,0x73,0x74,0x5f,0x63,0x6f,0x6c,0x3b,0x0a,0x0a,
-    0x76,0x6f,0x69,0x64,0x20,0x6d,0x61,0x69,0x6e,0x28,0x29,0x0a,0x7b,0x0a,0x20,0x20,
-    0x20,0x20,0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,
-    0x6d,0x61,0x74,0x34,0x28,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x30,
-    0x5d,0x2c,0x20,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x31,0x5d,0x2c,
-    0x20,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x32,0x5d,0x2c,0x20,0x76,
-    0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x33,0x5d,0x29,0x20,0x2a,0x20,0x76,
-    0x65,0x63,0x34,0x28,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x2e,0x78,0x79,0x7a,
-    0x20,0x2b,0x20,0x69,0x6e,0x73,0x74,0x2e,0x78,0x79,0x7a,0x2c,0x20,0x31,0x2e,0x30,
-    0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3d,0x20,0x69,
-    0x6e,0x73,0x74,0x5f,0x63,0x6f,0x6c,0x3b,0x0a,0x7d,0x0a,0x0a,0x00,
+    0x6f,0x63,0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x33,0x29,0x20,0x69,0x6e,0x20,
+    0x76,0x65,0x63,0x34,0x20,0x69,0x6e,0x73,0x74,0x5f,0x63,0x6f,0x6c,0x3b,0x0a,0x6c,
+    0x61,0x79,0x6f,0x75,0x74,0x28,0x6c,0x6f,0x63,0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,
+    0x20,0x31,0x29,0x20,0x69,0x6e,0x20,0x76,0x65,0x63,0x34,0x20,0x6e,0x6f,0x72,0x6d,
+    0x61,0x6c,0x3b,0x0a,0x0a,0x76,0x6f,0x69,0x64,0x20,0x6d,0x61,0x69,0x6e,0x28,0x29,
+    0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,
+    0x6f,0x6e,0x20,0x3d,0x20,0x6d,0x61,0x74,0x34,0x28,0x76,0x73,0x5f,0x70,0x61,0x72,
+    0x61,0x6d,0x73,0x5b,0x30,0x5d,0x2c,0x20,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,
+    0x73,0x5b,0x31,0x5d,0x2c,0x20,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,
+    0x32,0x5d,0x2c,0x20,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x33,0x5d,
+    0x29,0x20,0x2a,0x20,0x76,0x65,0x63,0x34,0x28,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,
+    0x6e,0x2e,0x78,0x79,0x7a,0x20,0x2b,0x20,0x69,0x6e,0x73,0x74,0x2e,0x78,0x79,0x7a,
+    0x2c,0x20,0x31,0x2e,0x30,0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,0x63,0x6f,0x6c,0x6f,
+    0x72,0x20,0x3d,0x20,0x69,0x6e,0x73,0x74,0x5f,0x63,0x6f,0x6c,0x3b,0x0a,0x7d,0x0a,
+    0x0a,0x00,
 ];
 /*
     #version 430
@@ -95,10 +101,11 @@ fs_trixel_source_glsl430 := u8.[
     #version 300 es
 
     uniform vec4 vs_params[4];
-    layout(location = 1) in vec4 inst;
+    layout(location = 2) in vec4 inst;
     layout(location = 0) in vec4 position;
     out vec4 color;
-    layout(location = 2) in vec4 inst_col;
+    layout(location = 3) in vec4 inst_col;
+    layout(location = 1) in vec4 normal;
 
     void main()
     {
@@ -111,24 +118,27 @@ vs_trixel_source_glsl300es := u8.[
     0x23,0x76,0x65,0x72,0x73,0x69,0x6f,0x6e,0x20,0x33,0x30,0x30,0x20,0x65,0x73,0x0a,
     0x0a,0x75,0x6e,0x69,0x66,0x6f,0x72,0x6d,0x20,0x76,0x65,0x63,0x34,0x20,0x76,0x73,
     0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x34,0x5d,0x3b,0x0a,0x6c,0x61,0x79,0x6f,
-    0x75,0x74,0x28,0x6c,0x6f,0x63,0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x31,0x29,
+    0x75,0x74,0x28,0x6c,0x6f,0x63,0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x32,0x29,
     0x20,0x69,0x6e,0x20,0x76,0x65,0x63,0x34,0x20,0x69,0x6e,0x73,0x74,0x3b,0x0a,0x6c,
     0x61,0x79,0x6f,0x75,0x74,0x28,0x6c,0x6f,0x63,0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,
     0x20,0x30,0x29,0x20,0x69,0x6e,0x20,0x76,0x65,0x63,0x34,0x20,0x70,0x6f,0x73,0x69,
     0x74,0x69,0x6f,0x6e,0x3b,0x0a,0x6f,0x75,0x74,0x20,0x76,0x65,0x63,0x34,0x20,0x63,
     0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x6c,0x61,0x79,0x6f,0x75,0x74,0x28,0x6c,0x6f,0x63,
-    0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x32,0x29,0x20,0x69,0x6e,0x20,0x76,0x65,
-    0x63,0x34,0x20,0x69,0x6e,0x73,0x74,0x5f,0x63,0x6f,0x6c,0x3b,0x0a,0x0a,0x76,0x6f,
-    0x69,0x64,0x20,0x6d,0x61,0x69,0x6e,0x28,0x29,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,
-    0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x6d,0x61,
-    0x74,0x34,0x28,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x30,0x5d,0x2c,
-    0x20,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x31,0x5d,0x2c,0x20,0x76,
-    0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x32,0x5d,0x2c,0x20,0x76,0x73,0x5f,
-    0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x33,0x5d,0x29,0x20,0x2a,0x20,0x76,0x65,0x63,
-    0x34,0x28,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x2e,0x78,0x79,0x7a,0x20,0x2b,
-    0x20,0x69,0x6e,0x73,0x74,0x2e,0x78,0x79,0x7a,0x2c,0x20,0x31,0x2e,0x30,0x29,0x3b,
-    0x0a,0x20,0x20,0x20,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3d,0x20,0x69,0x6e,0x73,
-    0x74,0x5f,0x63,0x6f,0x6c,0x3b,0x0a,0x7d,0x0a,0x0a,0x00,
+    0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x33,0x29,0x20,0x69,0x6e,0x20,0x76,0x65,
+    0x63,0x34,0x20,0x69,0x6e,0x73,0x74,0x5f,0x63,0x6f,0x6c,0x3b,0x0a,0x6c,0x61,0x79,
+    0x6f,0x75,0x74,0x28,0x6c,0x6f,0x63,0x61,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x31,
+    0x29,0x20,0x69,0x6e,0x20,0x76,0x65,0x63,0x34,0x20,0x6e,0x6f,0x72,0x6d,0x61,0x6c,
+    0x3b,0x0a,0x0a,0x76,0x6f,0x69,0x64,0x20,0x6d,0x61,0x69,0x6e,0x28,0x29,0x0a,0x7b,
+    0x0a,0x20,0x20,0x20,0x20,0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,
+    0x20,0x3d,0x20,0x6d,0x61,0x74,0x34,0x28,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,
+    0x73,0x5b,0x30,0x5d,0x2c,0x20,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,
+    0x31,0x5d,0x2c,0x20,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x32,0x5d,
+    0x2c,0x20,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,0x73,0x5b,0x33,0x5d,0x29,0x20,
+    0x2a,0x20,0x76,0x65,0x63,0x34,0x28,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x2e,
+    0x78,0x79,0x7a,0x20,0x2b,0x20,0x69,0x6e,0x73,0x74,0x2e,0x78,0x79,0x7a,0x2c,0x20,
+    0x31,0x2e,0x30,0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x20,
+    0x3d,0x20,0x69,0x6e,0x73,0x74,0x5f,0x63,0x6f,0x6c,0x3b,0x0a,0x7d,0x0a,0x0a,0x00,
+
 ];
 /*
     #version 300 es
@@ -177,8 +187,8 @@ fs_trixel_source_glsl300es := u8.[
     struct main0_in
     {
         float4 position [[attribute(0)]];
-        float4 inst [[attribute(1)]];
-        float4 inst_col [[attribute(2)]];
+        float4 inst [[attribute(2)]];
+        float4 inst_col [[attribute(3)]];
     };
 
     vertex main0_out main0(main0_in in [[stage_in]], constant vs_params& _26 [[buffer(0)]])
@@ -209,9 +219,9 @@ vs_trixel_source_metal_macos := u8.[
     0x74,0x69,0x6f,0x6e,0x20,0x5b,0x5b,0x61,0x74,0x74,0x72,0x69,0x62,0x75,0x74,0x65,
     0x28,0x30,0x29,0x5d,0x5d,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,
     0x34,0x20,0x69,0x6e,0x73,0x74,0x20,0x5b,0x5b,0x61,0x74,0x74,0x72,0x69,0x62,0x75,
-    0x74,0x65,0x28,0x31,0x29,0x5d,0x5d,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,
+    0x74,0x65,0x28,0x32,0x29,0x5d,0x5d,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,
     0x61,0x74,0x34,0x20,0x69,0x6e,0x73,0x74,0x5f,0x63,0x6f,0x6c,0x20,0x5b,0x5b,0x61,
-    0x74,0x74,0x72,0x69,0x62,0x75,0x74,0x65,0x28,0x32,0x29,0x5d,0x5d,0x3b,0x0a,0x7d,
+    0x74,0x74,0x72,0x69,0x62,0x75,0x74,0x65,0x28,0x33,0x29,0x5d,0x5d,0x3b,0x0a,0x7d,
     0x3b,0x0a,0x0a,0x76,0x65,0x72,0x74,0x65,0x78,0x20,0x6d,0x61,0x69,0x6e,0x30,0x5f,
     0x6f,0x75,0x74,0x20,0x6d,0x61,0x69,0x6e,0x30,0x28,0x6d,0x61,0x69,0x6e,0x30,0x5f,
     0x69,0x6e,0x20,0x69,0x6e,0x20,0x5b,0x5b,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,
@@ -287,9 +297,11 @@ trixel_shader_desc :: (backend: sg_backend) -> sg_shader_desc {
         desc.attrs[0].base_type = .FLOAT;
         desc.attrs[0].glsl_name = "position";
         desc.attrs[1].base_type = .FLOAT;
-        desc.attrs[1].glsl_name = "inst";
+        desc.attrs[1].glsl_name = "normal";
         desc.attrs[2].base_type = .FLOAT;
-        desc.attrs[2].glsl_name = "inst_col";
+        desc.attrs[2].glsl_name = "inst";
+        desc.attrs[3].base_type = .FLOAT;
+        desc.attrs[3].glsl_name = "inst_col";
         desc.uniform_blocks[0].stage = .VERTEX;
         desc.uniform_blocks[0].layout = .STD140;
         desc.uniform_blocks[0].size = 64;
@@ -304,9 +316,11 @@ trixel_shader_desc :: (backend: sg_backend) -> sg_shader_desc {
         desc.attrs[0].base_type = .FLOAT;
         desc.attrs[0].glsl_name = "position";
         desc.attrs[1].base_type = .FLOAT;
-        desc.attrs[1].glsl_name = "inst";
+        desc.attrs[1].glsl_name = "normal";
         desc.attrs[2].base_type = .FLOAT;
-        desc.attrs[2].glsl_name = "inst_col";
+        desc.attrs[2].glsl_name = "inst";
+        desc.attrs[3].base_type = .FLOAT;
+        desc.attrs[3].glsl_name = "inst_col";
         desc.uniform_blocks[0].stage = .VERTEX;
         desc.uniform_blocks[0].layout = .STD140;
         desc.uniform_blocks[0].size = 64;
@@ -321,6 +335,7 @@ trixel_shader_desc :: (backend: sg_backend) -> sg_shader_desc {
         desc.attrs[0].base_type = .FLOAT;
         desc.attrs[1].base_type = .FLOAT;
         desc.attrs[2].base_type = .FLOAT;
+        desc.attrs[3].base_type = .FLOAT;
         desc.uniform_blocks[0].stage = .VERTEX;
         desc.uniform_blocks[0].layout = .STD140;
         desc.uniform_blocks[0].size = 64;

src/shaders/shader_trixel.glsl

@@ -1,6 +1,7 @@
 @vs vs_trixel
 
 in vec4 position;
+in vec4 normal;
 in vec4 inst;
 in vec4 inst_col;
 
@@ -10,21 +11,24 @@ layout(binding=0) uniform vs_params {
 
 
 out vec4 color;
+out vec4 fnormal;
 
 void main() {
     vec3 instancepos = inst.xyz;
     gl_Position = mvp * (vec4(position.xyz + instancepos, 1.0));
+    fnormal = normal;
     color = inst_col;
 }
 @end
 
 @fs fs_trixel
 in vec4 color;
+in vec4 fnormal;
 out vec4 frag_color;
 
 
 void main() {
-    frag_color = color;
+    frag_color = color * 0.1 + fnormal;
 }
 @end
 

src/shapes.jai

@@ -0,0 +1,8 @@
+Shape :: struct {
+    verts   : [..]Vector4;
+    normals : [..]Vector4;
+}
+
+create_cube :: () {
+    
+}