mirror of
https://github.com/Ed94/Odin.git
synced 2026-08-03 22:28:46 +00:00
Remove unneeded semicolons from the core library
This commit is contained in:
gingerBill
+46
-46
@@ -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)
|
||||
}
|
||||
|
||||
+101
-101
@@ -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);
|
||||
defer if err != nil {
|
||||
nodes_destroy(file.nodes);
|
||||
file.nodes = nil;
|
||||
}
|
||||
defer file.nodes = file.nodes[:node_count];
|
||||
|
||||
node_count := 0
|
||||
file.nodes = make([]Node, header.internal_node_count)
|
||||
defer if err != nil {
|
||||
nodes_destroy(file.nodes)
|
||||
file.nodes = nil
|
||||
}
|
||||
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
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user