doesn't compile but i'm commiting anywya

1 files changed, 149 insertions, 0 deletions

diff --git a/tools/compile_assets/aseprite/util.odin b/tools/compile_assets/aseprite/util.odin
new file mode 100644
index 0000000..1333347
--- /dev/null
+++ b/tools/compile_assets/aseprite/util.odin
@@ -0,0 +1,149 @@
+package aseprite_file_handler
+
+import ir "base:intrinsics"
+import "core:log"
+import "core:reflect"
+import "core:encoding/endian"
+
+@(require) import "core:strconv"
+_ :: reflect
+
+get_chunk_type :: proc(c: Chunk) -> (type: WORD, err: Marshal_Error) {
+    switch _ in c {
+    case Old_Palette_256_Chunk: type = WORD(Chunk_Types.old_palette_256)
+    case Old_Palette_64_Chunk:  type = WORD(Chunk_Types.old_palette_64)
+    case Layer_Chunk:           type = WORD(Chunk_Types.layer)
+    case Cel_Chunk:             type = WORD(Chunk_Types.cel)
+    case Cel_Extra_Chunk:       type = WORD(Chunk_Types.cel_extra)
+    case Color_Profile_Chunk:   type = WORD(Chunk_Types.color_profile)
+    case External_Files_Chunk:  type = WORD(Chunk_Types.external_files)
+    case Mask_Chunk:            type = WORD(Chunk_Types.mask)
+    case Path_Chunk:            type = WORD(Chunk_Types.path)
+    case Tags_Chunk:            type = WORD(Chunk_Types.tags)
+    case Palette_Chunk:         type = WORD(Chunk_Types.palette)
+    case User_Data_Chunk:       type = WORD(Chunk_Types.user_data)
+    case Slice_Chunk:           type = WORD(Chunk_Types.slice)
+    case Tileset_Chunk:         type = WORD(Chunk_Types.tileset)
+    case:
+        err = .Invalid_Chunk_Type
+    }
+
+    return
+}
+
+get_cel_type :: proc(c: Cel_Type) -> (type: WORD, err: Marshal_Error) {
+    switch _ in c {
+    case Raw_Cel:         type = WORD(Cel_Types.Raw)
+    case Linked_Cel:      type = WORD(Cel_Types.Linked_Cel)
+    case Com_Image_Cel:   type = WORD(Cel_Types.Compressed_Image)
+    case Com_Tilemap_Cel: type = WORD(Cel_Types.Compressed_Tilemap)
+    case:
+        err = .Invalid_Cel_Type
+    }
+
+    return
+}
+
+get_property_type :: proc(v: Property_Value) -> (type: WORD, err: Marshal_Error) {
+    switch t in v {
+    case nil:        type = WORD(Property_Type.Null)
+    case bool:       type = WORD(Property_Type.Bool)
+    case i8:         type = WORD(Property_Type.I8)
+    case BYTE:       type = WORD(Property_Type.U8)
+    case SHORT:      type = WORD(Property_Type.I16)
+    case WORD:       type = WORD(Property_Type.U16)
+    case LONG:       type = WORD(Property_Type.I32)
+    case DWORD:      type = WORD(Property_Type.U32)
+    case LONG64:     type = WORD(Property_Type.I64)
+    case QWORD:      type = WORD(Property_Type.U64)
+    case FIXED:      type = WORD(Property_Type.Fixed)
+    case FLOAT:      type = WORD(Property_Type.F32)
+    case DOUBLE:     type = WORD(Property_Type.F64)
+    case STRING:     type = WORD(Property_Type.String)
+    case POINT:      type = WORD(Property_Type.Point)
+    case SIZE:       type = WORD(Property_Type.Size)
+    case RECT:       type = WORD(Property_Type.Rect)
+    case UUID:       type = WORD(Property_Type.UUID)
+    case UD_Vec:     type = WORD(Property_Type.Vector)
+    case Properties: type = WORD(Property_Type.Properties)
+    case:             err = Marshal_Errors.Invalid_Property_Type
+    }
+    return
+}
+
+tiles_to_u8 :: proc(tiles: []TILE, b: []u8) -> (pos: int, err: Write_Error) {
+    next: int
+    for t in tiles {
+        switch v in t {
+        case BYTE:
+            pos = next
+            next += size_of(BYTE)
+            b[pos] = v
+
+        case WORD:
+            pos = next
+            next += size_of(WORD)
+            if !endian.put_u16(b[pos:next], .Little, v) {
+                
+                return 0, .Unable_To_Encode_Data
+            }
+        case DWORD:
+            pos = next
+            next += size_of(DWORD)
+            if !endian.put_u32(b[pos:next], .Little, v) {
+                return 0, .Unable_To_Encode_Data
+            }
+        }
+    }
+
+    pos = next
+    return
+}
+
+
+@(private)
+fast_log_str :: proc(lvl: log.Level, str: string, loc := #caller_location) {
+    logger := context.logger
+    if logger.procedure == nil { return }
+    if lvl < logger.lowest_level { return }
+    logger.procedure(logger.data, lvl, str, logger.options, loc)
+}
+
+@(private)
+fast_log_str_enum :: proc(lvl: log.Level, str: string, val: $T, sep := " ", loc := #caller_location) where ir.type_is_enum(T) {
+    logger := context.logger
+    if logger.procedure == nil { return }
+    if lvl < logger.lowest_level { return }
+
+    s := reflect.enum_string(val)
+    buf := make([]u8, len(str) + len(sep) + len(s))
+    defer delete(buf)
+
+    n := copy(buf[:], str)
+    n += copy(buf[n:], sep)
+    copy(buf[n:], s)
+
+    logger.procedure(logger.data, lvl, string(buf), logger.options, loc)
+}
+
+@(private)
+fast_log_str_num :: proc(lvl: log.Level, str: string, val: $T, sep := " ", loc := #caller_location) where ir.type_is_numeric(T) {
+    logger := context.logger
+    if logger.procedure == nil { return }
+    if lvl < logger.lowest_level { return }
+
+    nb: [32]u8
+    s := strconv.append_int(nb[:], i64(val), 10)
+    buf := make([]u8, len(str) + len(sep) + len(s))
+    defer delete(buf)
+
+    n := copy(buf[:], str)
+    n += copy(buf[n:], sep)
+    copy(buf[n:], s)
+
+    logger.procedure(logger.data, lvl, string(buf), logger.options, loc)
+}
+
+@(private)
+fast_log :: proc { fast_log_str, fast_log_str_enum, fast_log_str_num }
+