Remove unneeded semicolons from the core library

3 files changed, 241 insertions, 241 deletions

diff --git a/core/encoding/hxa/hxa.odin b/core/encoding/hxa/hxa.odin
index 31113f907..f47661bad 100644
--- a/core/encoding/hxa/hxa.odin
+++ b/core/encoding/hxa/hxa.odin
@@ -2,10 +2,10 @@ package encoding_hxa
 
 import "core:mem"
 
-LATEST_VERSION :: 3;
-VERSION_API :: "0.3";
+LATEST_VERSION :: 3
+VERSION_API :: "0.3"
 
-MAGIC_NUMBER :: 'H'<<0 | 'x'<<8 | 'A'<<16 | '\x00'<<24;
+MAGIC_NUMBER :: 'H'<<0 | 'x'<<8 | 'A'<<16 | '\x00'<<24
 
 Header :: struct #packed {
 	magic_number:        u32le,
@@ -48,7 +48,7 @@ Meta_Value_Type :: enum u8 {
 	Text   = 3,
 	Binary = 4,
 	Meta   = 5,
-};
+}
 
 Meta :: struct {
 	name: string, // name of the meta data value (maximum length is 255)
@@ -74,7 +74,7 @@ Layer :: struct {
 }
 
 // Layers stacks are arrays of layers where all the layers have the same number of entries (polygons, edges, vertices or pixels)
-Layer_Stack :: distinct []Layer;
+Layer_Stack :: distinct []Layer
 
 Node_Geometry :: struct {
 	vertex_count:      u32le,       // number of vertices
@@ -92,7 +92,7 @@ Node_Image :: struct {
 	image_stack: Layer_Stack,
 }
 
-Node_Index :: distinct u32le;
+Node_Index :: distinct u32le
 
 // A file consists of an array of nodes, All nodes have meta data. Geometry nodes have geometry, image nodes have pixels
 Node :: struct {
@@ -114,15 +114,15 @@ If you use HxA for something not covered by the conventions but need a conventio
 /* Hard conventions */
 /* ---------------- */
 
-CONVENTION_HARD_BASE_VERTEX_LAYER_NAME       :: "vertex";
-CONVENTION_HARD_BASE_VERTEX_LAYER_ID         :: 0;
-CONVENTION_HARD_BASE_VERTEX_LAYER_COMPONENTS :: 3;
-CONVENTION_HARD_BASE_CORNER_LAYER_NAME       :: "reference";
-CONVENTION_HARD_BASE_CORNER_LAYER_ID         :: 0;
-CONVENTION_HARD_BASE_CORNER_LAYER_COMPONENTS :: 1;
-CONVENTION_HARD_BASE_CORNER_LAYER_TYPE       :: Layer_Data_Type.Int32;
-CONVENTION_HARD_EDGE_NEIGHBOUR_LAYER_NAME    :: "neighbour";
-CONVENTION_HARD_EDGE_NEIGHBOUR_LAYER_TYPE    :: Layer_Data_Type.Int32;
+CONVENTION_HARD_BASE_VERTEX_LAYER_NAME       :: "vertex"
+CONVENTION_HARD_BASE_VERTEX_LAYER_ID         :: 0
+CONVENTION_HARD_BASE_VERTEX_LAYER_COMPONENTS :: 3
+CONVENTION_HARD_BASE_CORNER_LAYER_NAME       :: "reference"
+CONVENTION_HARD_BASE_CORNER_LAYER_ID         :: 0
+CONVENTION_HARD_BASE_CORNER_LAYER_COMPONENTS :: 1
+CONVENTION_HARD_BASE_CORNER_LAYER_TYPE       :: Layer_Data_Type.Int32
+CONVENTION_HARD_EDGE_NEIGHBOUR_LAYER_NAME    :: "neighbour"
+CONVENTION_HARD_EDGE_NEIGHBOUR_LAYER_TYPE    :: Layer_Data_Type.Int32
 
 
 
@@ -131,63 +131,63 @@ CONVENTION_HARD_EDGE_NEIGHBOUR_LAYER_TYPE    :: Layer_Data_Type.Int32;
 
 /* geometry layers */
 
-CONVENTION_SOFT_LAYER_SEQUENCE0      :: "sequence";
-CONVENTION_SOFT_LAYER_NAME_UV0       :: "uv";
-CONVENTION_SOFT_LAYER_NORMALS        :: "normal";
-CONVENTION_SOFT_LAYER_BINORMAL       :: "binormal";
-CONVENTION_SOFT_LAYER_TANGENT        :: "tangent";
-CONVENTION_SOFT_LAYER_COLOR          :: "color";
-CONVENTION_SOFT_LAYER_CREASES        :: "creases";
-CONVENTION_SOFT_LAYER_SELECTION      :: "select";
-CONVENTION_SOFT_LAYER_SKIN_WEIGHT    :: "skining_weight";
-CONVENTION_SOFT_LAYER_SKIN_REFERENCE :: "skining_reference";
-CONVENTION_SOFT_LAYER_BLENDSHAPE     :: "blendshape";
-CONVENTION_SOFT_LAYER_ADD_BLENDSHAPE :: "addblendshape";
-CONVENTION_SOFT_LAYER_MATERIAL_ID    :: "material";
+CONVENTION_SOFT_LAYER_SEQUENCE0      :: "sequence"
+CONVENTION_SOFT_LAYER_NAME_UV0       :: "uv"
+CONVENTION_SOFT_LAYER_NORMALS        :: "normal"
+CONVENTION_SOFT_LAYER_BINORMAL       :: "binormal"
+CONVENTION_SOFT_LAYER_TANGENT        :: "tangent"
+CONVENTION_SOFT_LAYER_COLOR          :: "color"
+CONVENTION_SOFT_LAYER_CREASES        :: "creases"
+CONVENTION_SOFT_LAYER_SELECTION      :: "select"
+CONVENTION_SOFT_LAYER_SKIN_WEIGHT    :: "skining_weight"
+CONVENTION_SOFT_LAYER_SKIN_REFERENCE :: "skining_reference"
+CONVENTION_SOFT_LAYER_BLENDSHAPE     :: "blendshape"
+CONVENTION_SOFT_LAYER_ADD_BLENDSHAPE :: "addblendshape"
+CONVENTION_SOFT_LAYER_MATERIAL_ID    :: "material"
 
 /* Image layers */
 
-CONVENTION_SOFT_ALBEDO            :: "albedo";
-CONVENTION_SOFT_LIGHT             :: "light";
-CONVENTION_SOFT_DISPLACEMENT      :: "displacement";
-CONVENTION_SOFT_DISTORTION        :: "distortion";
-CONVENTION_SOFT_AMBIENT_OCCLUSION :: "ambient_occlusion";
+CONVENTION_SOFT_ALBEDO            :: "albedo"
+CONVENTION_SOFT_LIGHT             :: "light"
+CONVENTION_SOFT_DISPLACEMENT      :: "displacement"
+CONVENTION_SOFT_DISTORTION        :: "distortion"
+CONVENTION_SOFT_AMBIENT_OCCLUSION :: "ambient_occlusion"
 
 /* tags layers */
 
-CONVENTION_SOFT_NAME      :: "name";
-CONVENTION_SOFT_TRANSFORM :: "transform";
+CONVENTION_SOFT_NAME      :: "name"
+CONVENTION_SOFT_TRANSFORM :: "transform"
 
 /* destroy procedures */
 
 meta_destroy :: proc(meta: Meta, allocator := context.allocator) {
 	if nested, ok := meta.value.([]Meta); ok {
 		for m in nested {
-			meta_destroy(m);
+			meta_destroy(m)
 		}
-		delete(nested, allocator);
+		delete(nested, allocator)
 	}
 }
 nodes_destroy :: proc(nodes: []Node, allocator := context.allocator) {
 	for node in nodes {
 		for meta in node.meta_data {
-			meta_destroy(meta);
+			meta_destroy(meta)
 		}
-		delete(node.meta_data, allocator);
+		delete(node.meta_data, allocator)
 
 		switch n in node.content {
 		case Node_Geometry:
-			delete(n.corner_stack, allocator);
-			delete(n.edge_stack, allocator);
-			delete(n.face_stack, allocator);
+			delete(n.corner_stack, allocator)
+			delete(n.edge_stack, allocator)
+			delete(n.face_stack, allocator)
 		case Node_Image:
-			delete(n.image_stack, allocator);
+			delete(n.image_stack, allocator)
 		}
 	}
-	delete(nodes, allocator);
+	delete(nodes, allocator)
 }
 
 file_destroy :: proc(file: File) {
-	nodes_destroy(file.nodes, file.allocator);
-	delete(file.backing, file.allocator);
+	nodes_destroy(file.nodes, file.allocator)
+	delete(file.backing, file.allocator)
 }
diff --git a/core/encoding/hxa/read.odin b/core/encoding/hxa/read.odin
index 0cf58dce0..ef7edc8b7 100644
--- a/core/encoding/hxa/read.odin
+++ b/core/encoding/hxa/read.odin
@@ -12,20 +12,20 @@ Read_Error :: enum {
 }
 
 read_from_file :: proc(filename: string, print_error := false, allocator := context.allocator) -> (file: File, err: Read_Error) {
-	context.allocator = allocator;
+	context.allocator = allocator
 
-	data, ok := os.read_entire_file(filename);
+	data, ok := os.read_entire_file(filename)
 	if !ok {
-		err = .Unable_To_Read_File;
-		return;
+		err = .Unable_To_Read_File
+		return
 	}
 	defer if !ok {
-		delete(data);
+		delete(data)
 	} else {
-		file.backing = data;
+		file.backing = data
 	}
-	file, err = read(data, filename, print_error, allocator);
-	return;
+	file, err = read(data, filename, print_error, allocator)
+	return
 }
 
 read :: proc(data: []byte, filename := "<input>", print_error := false, allocator := context.allocator) -> (file: File, err: Read_Error) {
@@ -34,182 +34,182 @@ read :: proc(data: []byte, filename := "<input>", print_error := false, allocato
 		data:        []byte,
 		offset:      int,
 		print_error: bool,
-	};
+	}
 
 	read_value :: proc(r: ^Reader, $T: typeid) -> (value: T, err: Read_Error) {
-		remaining := len(r.data) - r.offset;
+		remaining := len(r.data) - r.offset
 		if remaining < size_of(T) {
-			err = .Short_Read;
-			return;
+			err = .Short_Read
+			return
 		}
-		ptr := raw_data(r.data[r.offset:]);
-		value = (^T)(ptr)^;
-		r.offset += size_of(T);
-		return;
+		ptr := raw_data(r.data[r.offset:])
+		value = (^T)(ptr)^
+		r.offset += size_of(T)
+		return
 	}
 
 	read_array :: proc(r: ^Reader, $T: typeid, count: int) -> (value: []T, err: Read_Error) {
-		remaining := len(r.data) - r.offset;
+		remaining := len(r.data) - r.offset
 		if remaining < size_of(T)*count {
-			err = .Short_Read;
-			return;
+			err = .Short_Read
+			return
 		}
-		ptr := raw_data(r.data[r.offset:]);
+		ptr := raw_data(r.data[r.offset:])
 
-		value = mem.slice_ptr((^T)(ptr), count);
-		r.offset += size_of(T)*count;
-		return;
+		value = mem.slice_ptr((^T)(ptr), count)
+		r.offset += size_of(T)*count
+		return
 	}
 
 	read_string :: proc(r: ^Reader, count: int) -> (string, Read_Error) {
-		buf, err := read_array(r, byte, count);
-		return string(buf), err;
+		buf, err := read_array(r, byte, count)
+		return string(buf), err
 	}
 
 	read_name :: proc(r: ^Reader) -> (value: string, err: Read_Error) {
-		len  := read_value(r, u8)             or_return;
-		data := read_array(r, byte, int(len)) or_return;
-		return string(data[:len]), nil;
+		len  := read_value(r, u8)             or_return
+		data := read_array(r, byte, int(len)) or_return
+		return string(data[:len]), nil
 	}
 
 	read_meta :: proc(r: ^Reader, capacity: u32le) -> (meta_data: []Meta, err: Read_Error) {
-		meta_data = make([]Meta, int(capacity));
-		count := 0;
-		defer meta_data = meta_data[:count];
+		meta_data = make([]Meta, int(capacity))
+		count := 0
+		defer meta_data = meta_data[:count]
 		for m in &meta_data {
-			m.name = read_name(r) or_return;
+			m.name = read_name(r) or_return
 
-			type := read_value(r, Meta_Value_Type) or_return;
+			type := read_value(r, Meta_Value_Type) or_return
 			if type > max(Meta_Value_Type) {
 				if r.print_error {
-					fmt.eprintf("HxA Error: file '%s' has meta value type %d. Maximum value is ", r.filename, u8(type), u8(max(Meta_Value_Type)));
+					fmt.eprintf("HxA Error: file '%s' has meta value type %d. Maximum value is ", r.filename, u8(type), u8(max(Meta_Value_Type)))
 				}
-				err = .Invalid_Data;
-				return;
+				err = .Invalid_Data
+				return
 			}
-			array_length := read_value(r, u32le) or_return;
+			array_length := read_value(r, u32le) or_return
 
 			switch type {
-			case .Int64:  m.value = read_array(r, i64le, int(array_length))      or_return;
-			case .Double: m.value = read_array(r, f64le, int(array_length))      or_return;
-			case .Node:   m.value = read_array(r, Node_Index, int(array_length)) or_return;
-			case .Text:   m.value = read_string(r, int(array_length))            or_return;
-			case .Binary: m.value = read_array(r, byte, int(array_length))       or_return;
-			case .Meta:   m.value = read_meta(r, array_length)                   or_return;
+			case .Int64:  m.value = read_array(r, i64le, int(array_length))      or_return
+			case .Double: m.value = read_array(r, f64le, int(array_length))      or_return
+			case .Node:   m.value = read_array(r, Node_Index, int(array_length)) or_return
+			case .Text:   m.value = read_string(r, int(array_length))            or_return
+			case .Binary: m.value = read_array(r, byte, int(array_length))       or_return
+			case .Meta:   m.value = read_meta(r, array_length)                   or_return
 			}
 
-			count += 1;
+			count += 1
 		}
-		return;
+		return
 	}
 
 	read_layer_stack :: proc(r: ^Reader, capacity: u32le) -> (layers: Layer_Stack, err: Read_Error) {
-		stack_count := read_value(r, u32le) or_return;
-		layer_count := 0;
-		layers = make(Layer_Stack, stack_count);
-		defer layers = layers[:layer_count];
+		stack_count := read_value(r, u32le) or_return
+		layer_count := 0
+		layers = make(Layer_Stack, stack_count)
+		defer layers = layers[:layer_count]
 		for layer in &layers {
-			layer.name = read_name(r) or_return;
-			layer.components = read_value(r, u8) or_return;
-			type := read_value(r, Layer_Data_Type) or_return;
+			layer.name = read_name(r) or_return
+			layer.components = read_value(r, u8) or_return
+			type := read_value(r, Layer_Data_Type) or_return
 			if type > max(type) {
 				if r.print_error {
-					fmt.eprintf("HxA Error: file '%s' has layer data type %d. Maximum value is ", r.filename, u8(type), u8(max(Layer_Data_Type)));
+					fmt.eprintf("HxA Error: file '%s' has layer data type %d. Maximum value is ", r.filename, u8(type), u8(max(Layer_Data_Type)))
 				}
-				err = .Invalid_Data;
-				return;
+				err = .Invalid_Data
+				return
 			}
-			data_len := int(layer.components) * int(capacity);
+			data_len := int(layer.components) * int(capacity)
 
 			switch type {
-			case .Uint8:  layer.data = read_array(r, u8,    data_len) or_return;
-			case .Int32:  layer.data = read_array(r, i32le, data_len) or_return;
-			case .Float:  layer.data = read_array(r, f32le, data_len) or_return;
-			case .Double: layer.data = read_array(r, f64le, data_len) or_return;
+			case .Uint8:  layer.data = read_array(r, u8,    data_len) or_return
+			case .Int32:  layer.data = read_array(r, i32le, data_len) or_return
+			case .Float:  layer.data = read_array(r, f32le, data_len) or_return
+			case .Double: layer.data = read_array(r, f64le, data_len) or_return
 			}
-			layer_count += 1;
+			layer_count += 1
 		}
 
-		return;
+		return
 	}
 
 	if len(data) < size_of(Header) {
-		return;
+		return
 	}
 
-	context.allocator = allocator;
+	context.allocator = allocator
 
-	header := cast(^Header)raw_data(data);
-	assert(header.magic_number == MAGIC_NUMBER);
+	header := cast(^Header)raw_data(data)
+	assert(header.magic_number == MAGIC_NUMBER)
 
 	r := &Reader{
 		filename    = filename,
 		data        = data[:],
 		offset      = size_of(Header),
 		print_error = print_error,
-	};
+	}
 
-	node_count := 0;
-	file.nodes = make([]Node, header.internal_node_count);
+	node_count := 0
+	file.nodes = make([]Node, header.internal_node_count)
 	defer if err != nil {
-		nodes_destroy(file.nodes);
-		file.nodes = nil;
+		nodes_destroy(file.nodes)
+		file.nodes = nil
 	}
-	defer file.nodes = file.nodes[:node_count];
+	defer file.nodes = file.nodes[:node_count]
 
 	for node_idx in 0..<header.internal_node_count {
-		node := &file.nodes[node_count];
-		type := read_value(r, Node_Type) or_return;
+		node := &file.nodes[node_count]
+		type := read_value(r, Node_Type) or_return
 		if type > max(Node_Type) {
 			if r.print_error {
-				fmt.eprintf("HxA Error: file '%s' has node type %d. Maximum value is ", r.filename, u8(type), u8(max(Node_Type)));
+				fmt.eprintf("HxA Error: file '%s' has node type %d. Maximum value is ", r.filename, u8(type), u8(max(Node_Type)))
 			}
-			err = .Invalid_Data;
-			return;
+			err = .Invalid_Data
+			return
 		}
-		node_count += 1;
+		node_count += 1
 
-		node.meta_data = read_meta(r, read_value(r, u32le) or_return) or_return;
+		node.meta_data = read_meta(r, read_value(r, u32le) or_return) or_return
 
 		switch type {
 		case .Meta_Only:
 			// Okay
 		case .Geometry:
-			g: Node_Geometry;
+			g: Node_Geometry
 
-			g.vertex_count      = read_value(r, u32le)                     or_return;
-			g.vertex_stack      = read_layer_stack(r, g.vertex_count)      or_return;
-			g.edge_corner_count = read_value(r, u32le)                     or_return;
-			g.corner_stack      = read_layer_stack(r, g.edge_corner_count) or_return;
+			g.vertex_count      = read_value(r, u32le)                     or_return
+			g.vertex_stack      = read_layer_stack(r, g.vertex_count)      or_return
+			g.edge_corner_count = read_value(r, u32le)                     or_return
+			g.corner_stack      = read_layer_stack(r, g.edge_corner_count) or_return
 			if header.version > 2 {
-				g.edge_stack = read_layer_stack(r, g.edge_corner_count) or_return;
+				g.edge_stack = read_layer_stack(r, g.edge_corner_count) or_return
 			}
-			g.face_count = read_value(r, u32le)              or_return;
-			g.face_stack = read_layer_stack(r, g.face_count) or_return;
+			g.face_count = read_value(r, u32le)              or_return
+			g.face_stack = read_layer_stack(r, g.face_count) or_return
 
-			node.content = g;
+			node.content = g
 
 		case .Image:
-			img: Node_Image;
+			img: Node_Image
 
-			img.type = read_value(r, Image_Type) or_return;
-			dimensions := int(img.type);
+			img.type = read_value(r, Image_Type) or_return
+			dimensions := int(img.type)
 			if img.type == .Image_Cube {
-				dimensions = 2;
+				dimensions = 2
 			}
-			img.resolution = {1, 1, 1};
+			img.resolution = {1, 1, 1}
 			for d in 0..<dimensions {
-				img.resolution[d] = read_value(r, u32le) or_return;
+				img.resolution[d] = read_value(r, u32le) or_return
 			}
-			size := img.resolution[0]*img.resolution[1]*img.resolution[2];
+			size := img.resolution[0]*img.resolution[1]*img.resolution[2]
 			if img.type == .Image_Cube {
-				size *= 6;
+				size *= 6
 			}
-			img.image_stack = read_layer_stack(r, size) or_return;
+			img.image_stack = read_layer_stack(r, size) or_return
 
-			node.content = img;
+			node.content = img
 		}
 	}
 
-	return;
+	return
 }
diff --git a/core/encoding/hxa/write.odin b/core/encoding/hxa/write.odin
index 4391e700a..e774018b2 100644
--- a/core/encoding/hxa/write.odin
+++ b/core/encoding/hxa/write.odin
@@ -10,36 +10,36 @@ Write_Error :: enum {
 }
 
 write_to_file :: proc(filepath: string, file: File) -> (err: Write_Error) {
-	required := required_write_size(file);
-	buf, alloc_err := make([]byte, required);
+	required := required_write_size(file)
+	buf, alloc_err := make([]byte, required)
 	if alloc_err == .Out_Of_Memory {
-		return .Failed_File_Write;
+		return .Failed_File_Write
 	}
-	defer delete(buf);
+	defer delete(buf)
 
-	write_internal(&Writer{data = buf}, file);
+	write_internal(&Writer{data = buf}, file)
 	if !os.write_entire_file(filepath, buf) {
-		err =.Failed_File_Write;
+		err =.Failed_File_Write
 	}
-	return;
+	return
 }
 
 write :: proc(buf: []byte, file: File) -> (n: int, err: Write_Error) {
-	required := required_write_size(file);
+	required := required_write_size(file)
 	if len(buf) < required {
-		err = .Buffer_Too_Small;
-		return;
+		err = .Buffer_Too_Small
+		return
 	}
-	n = required;
-	write_internal(&Writer{data = buf}, file);
-	return;
+	n = required
+	write_internal(&Writer{data = buf}, file)
+	return
 }
 
 required_write_size :: proc(file: File) -> (n: int) {
-	writer := &Writer{dummy_pass = true};
-	write_internal(writer, file);
-	n = writer.offset;
-	return;
+	writer := &Writer{dummy_pass = true}
+	write_internal(writer, file)
+	n = writer.offset
+	return
 }
 
 
@@ -48,146 +48,146 @@ Writer :: struct {
 	data:   []byte,
 	offset: int,
 	dummy_pass: bool,
-};
+}
 
 @(private)
 write_internal :: proc(w: ^Writer, file: File) {
 	write_value :: proc(w: ^Writer, value: $T) {
 		if !w.dummy_pass {
-			remaining := len(w.data) - w.offset;
-			assert(size_of(T) <= remaining);
-			ptr := raw_data(w.data[w.offset:]);
-			(^T)(ptr)^ = value;
+			remaining := len(w.data) - w.offset
+			assert(size_of(T) <= remaining)
+			ptr := raw_data(w.data[w.offset:])
+			(^T)(ptr)^ = value
 		}
-		w.offset += size_of(T);
+		w.offset += size_of(T)
 	}
 	write_array :: proc(w: ^Writer, array: []$T) {
 		if !w.dummy_pass {
-			remaining := len(w.data) - w.offset;
-			assert(size_of(T)*len(array) <= remaining);
-			ptr := raw_data(w.data[w.offset:]);
-			dst := mem.slice_ptr((^T)(ptr), len(array));
-			copy(dst, array);
+			remaining := len(w.data) - w.offset
+			assert(size_of(T)*len(array) <= remaining)
+			ptr := raw_data(w.data[w.offset:])
+			dst := mem.slice_ptr((^T)(ptr), len(array))
+			copy(dst, array)
 		}
-		w.offset += size_of(T)*len(array);
+		w.offset += size_of(T)*len(array)
 	}
 	write_string :: proc(w: ^Writer, str: string) {
 		if !w.dummy_pass {
-			remaining := len(w.data) - w.offset;
-			assert(size_of(byte)*len(str) <= remaining);
-			ptr := raw_data(w.data[w.offset:]);
-			dst := mem.slice_ptr((^byte)(ptr), len(str));
-			copy(dst, str);
+			remaining := len(w.data) - w.offset
+			assert(size_of(byte)*len(str) <= remaining)
+			ptr := raw_data(w.data[w.offset:])
+			dst := mem.slice_ptr((^byte)(ptr), len(str))
+			copy(dst, str)
 		}
-		w.offset += size_of(byte)*len(str);
+		w.offset += size_of(byte)*len(str)
 	}
 
 	write_metadata :: proc(w: ^Writer, meta_data: []Meta) {
 		for m in meta_data {
-			name_len := max(len(m.name), 255);
-			write_value(w, u8(name_len));
-			write_string(w, m.name[:name_len]);
+			name_len := max(len(m.name), 255)
+			write_value(w, u8(name_len))
+			write_string(w, m.name[:name_len])
 
-			meta_data_type: Meta_Value_Type;
-			length: u32le = 0;
+			meta_data_type: Meta_Value_Type
+			length: u32le = 0
 			switch v in m.value {
 			case []i64le:
-				meta_data_type = .Int64;
-				length = u32le(len(v));
+				meta_data_type = .Int64
+				length = u32le(len(v))
 			case []f64le:
-				meta_data_type = .Double;
-				length = u32le(len(v));
+				meta_data_type = .Double
+				length = u32le(len(v))
 			case []Node_Index:
-				meta_data_type = .Node;
-				length = u32le(len(v));
+				meta_data_type = .Node
+				length = u32le(len(v))
 			case string:
-				meta_data_type = .Text;
-				length = u32le(len(v));
+				meta_data_type = .Text
+				length = u32le(len(v))
 			case []byte:
-				meta_data_type = .Binary;
-				length = u32le(len(v));
+				meta_data_type = .Binary
+				length = u32le(len(v))
 			case []Meta:
-				meta_data_type = .Meta;
-				length = u32le(len(v));
+				meta_data_type = .Meta
+				length = u32le(len(v))
 			}
-			write_value(w, meta_data_type);
-			write_value(w, length);
+			write_value(w, meta_data_type)
+			write_value(w, length)
 
 			switch v in m.value {
-			case []i64le:      write_array(w, v);
-			case []f64le:      write_array(w, v);
-			case []Node_Index: write_array(w, v);
-			case string:       write_string(w, v);
-			case []byte:       write_array(w, v);
-			case []Meta:       write_metadata(w, v);
+			case []i64le:      write_array(w, v)
+			case []f64le:      write_array(w, v)
+			case []Node_Index: write_array(w, v)
+			case string:       write_string(w, v)
+			case []byte:       write_array(w, v)
+			case []Meta:       write_metadata(w, v)
 			}
 		}
-		return;
+		return
 	}
 	write_layer_stack :: proc(w: ^Writer, layers: Layer_Stack) {
-		write_value(w, u32(len(layers)));
+		write_value(w, u32(len(layers)))
 		for layer in layers {
-			name_len := max(len(layer.name), 255);
-			write_value(w, u8(name_len));
-			write_string(w, layer .name[:name_len]);
+			name_len := max(len(layer.name), 255)
+			write_value(w, u8(name_len))
+			write_string(w, layer .name[:name_len])
 
-			write_value(w, layer.components);
+			write_value(w, layer.components)
 
-			layer_data_type: Layer_Data_Type;
+			layer_data_type: Layer_Data_Type
 			switch v in layer.data {
-			case []u8:    layer_data_type = .Uint8;
-			case []i32le: layer_data_type = .Int32;
-			case []f32le: layer_data_type = .Float;
-			case []f64le: layer_data_type = .Double;
+			case []u8:    layer_data_type = .Uint8
+			case []i32le: layer_data_type = .Int32
+			case []f32le: layer_data_type = .Float
+			case []f64le: layer_data_type = .Double
 			}
-			write_value(w, layer_data_type);
+			write_value(w, layer_data_type)
 
 			switch v in layer.data {
-			case []u8:   write_array(w, v);
-			case []i32le: write_array(w, v);
-			case []f32le: write_array(w, v);
-			case []f64le: write_array(w, v);
+			case []u8:   write_array(w, v)
+			case []i32le: write_array(w, v)
+			case []f32le: write_array(w, v)
+			case []f64le: write_array(w, v)
 			}
 		}
-		return;
+		return
 	}
 
 	write_value(w, &Header{
 		magic_number = MAGIC_NUMBER,
 		version = LATEST_VERSION,
 		internal_node_count = u32le(len(file.nodes)),
-	});
+	})
 
 	for node in file.nodes {
-		node_type: Node_Type;
+		node_type: Node_Type
 		switch content in node.content {
-		case Node_Geometry: node_type = .Geometry;
-		case Node_Image:    node_type = .Image;
+		case Node_Geometry: node_type = .Geometry
+		case Node_Image:    node_type = .Image
 		}
-		write_value(w, node_type);
+		write_value(w, node_type)
 
-		write_value(w, u32(len(node.meta_data)));
-		write_metadata(w, node.meta_data);
+		write_value(w, u32(len(node.meta_data)))
+		write_metadata(w, node.meta_data)
 
 		switch content in node.content {
 		case Node_Geometry:
-			write_value(w, content.vertex_count);
-			write_layer_stack(w, content.vertex_stack);
-			write_value(w, content.edge_corner_count);
-			write_layer_stack(w, content.corner_stack);
-			write_layer_stack(w, content.edge_stack);
-			write_value(w, content.face_count);
-			write_layer_stack(w, content.face_stack);
+			write_value(w, content.vertex_count)
+			write_layer_stack(w, content.vertex_stack)
+			write_value(w, content.edge_corner_count)
+			write_layer_stack(w, content.corner_stack)
+			write_layer_stack(w, content.edge_stack)
+			write_value(w, content.face_count)
+			write_layer_stack(w, content.face_stack)
 		case Node_Image:
-			write_value(w, content.type);
-			dimensions := int(content.type);
+			write_value(w, content.type)
+			dimensions := int(content.type)
 			if content.type == .Image_Cube {
-				dimensions = 2;
+				dimensions = 2
 			}
 			for d in 0..<dimensions {
-				write_value(w, content.resolution[d]);
+				write_value(w, content.resolution[d])
 			}
-			write_layer_stack(w, content.image_stack);
+			write_layer_stack(w, content.image_stack)
 		}
 	}
 }