diff options
Diffstat (limited to 'save.c')
| -rw-r--r-- | save.c | 1056 |
1 files changed, 1056 insertions, 0 deletions
@@ -0,0 +1,1056 @@ +#include "save.h" +#include "ent.h" + +typedef struct { + i64 size_pos; + i64 data_pos; +} SaveChunk; + +typedef struct { + u64 next_pid; +} SaveLoadContext; + +static bool +read_u8_le(FILE *fp, u8 *val) { + return fread(val, 1, 1, fp) == 1; +} + +static bool +write_u8_le(FILE *fp, u8 val) { + return fwrite(&val, 1, 1, fp) == 1; +} + +static bool +read_u16_le(FILE *fp, u16 *val) { + u8 bytes[2]; + + if (fread(bytes, 1, 2, fp) != 2) { + return false; + } + + *val = (u16)bytes[0] + | (u16)bytes[1] << 8; + + return true; +} + +static bool +write_u16_le(FILE *fp, u16 val) { + u8 bytes[2] = { + (u8)(val >> 0), + (u8)(val >> 8), + }; + + return fwrite(bytes, 1, 2, fp) == 2; +} + +static bool +read_u32_le(FILE *fp, u32 *val) { + u8 bytes[4]; + + if (fread(bytes, 1, 4, fp) != 4) { + return false; + } + + *val = (u32)bytes[0] << 0 + | (u32)bytes[1] << 8 + | (u32)bytes[2] << 16 + | (u32)bytes[3] << 24; + + return true; +} + +static bool +write_u32_le(FILE *fp, u32 val) { + u8 bytes[4] = { + (u8)(val >> 0), + (u8)(val >> 8), + (u8)(val >> 16), + (u8)(val >> 24), + }; + + return fwrite(bytes, 1, 4, fp) == 4; +} + +static bool +read_u64_le(FILE *fp, u64 *val) { + u8 bytes[8]; + + if (fread(bytes, 1, 8, fp) != 8) { + return false; + } + + *val = (u64)bytes[0] << 0 + | (u64)bytes[1] << 8 + | (u64)bytes[2] << 16 + | (u64)bytes[3] << 24 + | (u64)bytes[4] << 32 + | (u64)bytes[5] << 40 + | (u64)bytes[6] << 48 + | (u64)bytes[7] << 56; + + return true; +} + +static bool +write_u64_le(FILE *fp, u64 val) { + u8 bytes[8] = { + (u8)(val >> 0), + (u8)(val >> 8), + (u8)(val >> 16), + (u8)(val >> 24), + (u8)(val >> 32), + (u8)(val >> 40), + (u8)(val >> 48), + (u8)(val >> 56), + }; + + return fwrite(bytes, 1, 8, fp) == 8; +} + +static bool +read_f32_le(FILE *fp, f32 *val) { + u32 bits; + if (!read_u32_le(fp, &bits)) { + return false; + } + + memcpy(val, &bits, sizeof(*val)); + return true; +} + +static bool +write_f32_le(FILE *fp, f32 value) { + u32 bits; + memcpy(&bits, &value, 4); + return write_u32_le(fp, bits); +} + +static bool +read_vec3(FILE *fp, Vec3 *val) { + return read_f32_le(fp, &val->x) && + read_f32_le(fp, &val->y) && + read_f32_le(fp, &val->z); +} + +static bool +write_vec3(FILE *fp, Vec3 val) { + return write_f32_le(fp, val.x) && + write_f32_le(fp, val.y) && + write_f32_le(fp, val.z); +} + +static bool +read_quat(FILE *fp, Quaternion *val) { + return read_f32_le(fp, &val->x) && + read_f32_le(fp, &val->y) && + read_f32_le(fp, &val->z) && + read_f32_le(fp, &val->w); +} + +static bool +write_quat(FILE *fp, Quaternion val) { + return write_f32_le(fp, val.x) && + write_f32_le(fp, val.y) && + write_f32_le(fp, val.z) && + write_f32_le(fp, val.w); +} + +static bool +write_byte_arr(FILE *fp, const void *data, u32 len) { + return fwrite(data, 1, len, fp) == len; +} + +/* some entities are 'transient', so we need a persistent entity count */ +static u32 +persistent_entity_count(void) { + u32 cnt = 0; + + for (u32 i = 0; i < entity_count(); ++i) { + if (entity_data()[i].pid != 0) { + cnt++; + } + } + + return cnt; +} + +static bool +chunk_begin(FILE *fp, const char label[4], SaveChunk *chunk) { + if (!write_byte_arr(fp, label, 4)) { + return false; + } + + chunk->size_pos = ftell(fp); + if (chunk->size_pos < 0 || !write_u32_le(fp, 0)) { + return false; + } + + chunk->data_pos = ftell(fp); + return chunk->data_pos >= 0; +} + +static bool +chunk_end(FILE *fp, SaveChunk *chunk) { + u32 end_pos = ftell(fp); + if (end_pos < chunk->data_pos) { + return false; + } + + u64 size = (u64)(end_pos - chunk->data_pos); + if (size > UINT32_MAX) { + return false; + } + + if (fseek(fp, chunk->size_pos, SEEK_SET) != 0 || + !write_u32_le(fp, (u32)size) || + fseek(fp, end_pos, SEEK_SET) != 0) { + return false; + } + + return true; +} + +static bool +read_header(FILE *fp) { + char magic[4]; + u16 major, minor; + + if (fread(magic, 1, 4, fp) != 4 || + !read_u16_le(fp, &major) || + !read_u16_le(fp, &minor)) { + return false; + } + + if (memcmp(magic, "FGSF", 4) != 0) { + TraceLog(LOG_ERROR, "invalid save file magic."); + return false; + } + + if (major != SAVE_VERSION_MAJOR || + minor != SAVE_VERSION_MINOR) { + TraceLog(LOG_ERROR, "unsupported save file version %u.%u.", + major, minor); + return false; + } + + return true; +} + +static bool +write_header(FILE *fp) { + return fwrite("FGSF", 1, 4, fp) == 4 && + write_u16_le(fp, SAVE_VERSION_MAJOR) && + write_u16_le(fp, SAVE_VERSION_MINOR); +} + +static bool +read_entity_chunk(FILE *fp, SaveLoadContext *ctx) { + u64 next_pid; + u32 entity_cnt; + + if (!read_u64_le(fp, &next_pid) || + !read_u32_le(fp, &entity_cnt)) { + return false; + } + + if (next_pid == 0) { + return false; + } + + ctx->next_pid = next_pid; + + for (u32 i = 0; i < entity_cnt; ++i) { + u64 pid = 0; + read_u64_le(fp, &pid); + + if (pid == 0 || pid >= next_pid) { + TraceLog(LOG_ERROR, "entity PID invalid."); + return false; + } + + u32 name_len = 0; + read_u32_le(fp, &name_len); + + u64 id = entity_restore(pid); + if (!id) { + TraceLog(LOG_ERROR, "entity pid already exists."); + return false; + } + Entity *ent = entity_get(id); + ent->name = malloc(name_len + 1); + + if (name_len > 0 && + fread(ent->name, 1, name_len, fp) != name_len) { + TraceLog(LOG_ERROR, "failed to read entity name."); + return false; + } + + ent->name[name_len] = '\0'; + } + + entity_system_set_next_pid(next_pid); + return true; +} + +static bool +write_entity_chunk(FILE *fp) { + SaveChunk chunk = {0}; + + if (!chunk_begin(fp, "ENTT", &chunk) || + !write_u64_le(fp, entity_next_pid()) || + !write_u32_le(fp, persistent_entity_count())) { + return false; + } + + for (u32 i = 0; i < entity_count(); ++i) { + Entity *ent = &entity_data()[i]; + + if (ent->pid == 0) { + continue; + } + + if (!write_u64_le(fp, ent->pid) || + !write_u32_le(fp, strlen(ent->name)) || + !write_byte_arr(fp, ent->name, strlen(ent->name))) { + return false; + } + } + + return chunk_end(fp, &chunk); +} + +static bool +read_transform_chunk(FILE *fp, SaveLoadContext *ctx) { + u32 tr_cnt; + read_u32_le(fp, &tr_cnt); + + u64 *parent_pids = calloc(ctx->next_pid, sizeof(u64)); + if (!parent_pids) { + TraceLog(LOG_FATAL, "calloc failed."); + } + + for (u32 i = 0; i < tr_cnt; ++i) { + u64 pid, parent_pid; + + if (!read_u64_le(fp, &pid) || + !read_u64_le(fp, &parent_pid) || + pid == 0 || pid >= ctx->next_pid || + parent_pid >= ctx->next_pid) { + goto fail; + } + + u64 id = entity_id_from_pid(pid); + Entity *ent = entity_get(id); + if (!ent) { + TraceLog(LOG_ERROR, "failed to properly load entity"); + goto fail; + } + + if (!read_vec3(fp, &ent->tr.pos) || + !read_quat(fp, &ent->tr.rot) || + !read_vec3(fp, &ent->tr.scale)) { + goto fail; + } + + parent_pids[pid] = parent_pid; + } + + /* Build hierarchy only after all transforms exist. */ + for (u64 pid = 1; pid < ctx->next_pid; ++pid) { + u64 parent_pid = parent_pids[pid]; + + if (!parent_pid) { + continue; + } + + u64 id = entity_id_from_pid(pid); + u64 parent_id = entity_id_from_pid(parent_pid); + + if (!id || !parent_id || !entity_set_parent(id, parent_id)) { + TraceLog(LOG_ERROR, "entity hierarchy build failed."); + goto fail; + } + } + + free(parent_pids); + return true; + +fail: + free(parent_pids); + return false; +} + +static bool +write_transform_chunk(FILE *fp) { + SaveChunk chunk; + + u32 tr_cnt = 0; + for (u32 i = 0; i < entity_count(); ++i) { + if (entity_data()[i].pid) { + tr_cnt++; + } + } + + if (!chunk_begin(fp, "TRFM", &chunk) || + !write_u32_le(fp, tr_cnt)) { + return false; + } + + for (u32 i = 0; i < entity_count(); ++i) { + Entity *ent = &entity_data()[i]; + + if (!ent->pid) { + continue; + } + + u64 parent_pid = 0; + if (ent->tr.parent) { + Entity *parent = entity_get(ent->tr.parent); + if (!parent) { + return false; + } + parent_pid = parent->pid; + } + + if (!write_u64_le(fp, ent->pid) || + !write_u64_le(fp, parent_pid) || + !write_vec3(fp, ent->tr.pos) || + !write_quat(fp, ent->tr.rot) || + !write_vec3(fp, ent->tr.scale)) { + return false; + } + } + + return chunk_end(fp, &chunk); +} + +static bool +read_model_chunk(FILE *fp, SaveLoadContext *ctx) { + u32 mdl_cnt; + if (!read_u32_le(fp, &mdl_cnt)) { + return false; + } + + for (u32 i = 0; i < mdl_cnt; ++i) { + u64 pid; + u32 key_len; + u8 draw; + + if (!read_u64_le(fp, &pid) || !read_u32_le(fp, &key_len)) { + return false; + } + + if (pid == 0 || pid >= ctx->next_pid) { + return false; + } + + u64 id = entity_id_from_pid(pid); + Entity *ent = entity_get(id); + + if (!ent || ent->mdl.has) { + return false; + } + + char *key = malloc(key_len + 1); + if (!key) { + return false; + } + + if (key_len && fread(key, 1, key_len, fp) != key_len) { + free(key); + return false; + } + + key[key_len] = '\0'; + + if (!read_u8_le(fp, &draw)) { + free(key); + return false; + } + + ent->mdl.key = key; + ent->mdl.draw = draw; + ent->mdl.has = true; + } + + return true; +} + +static bool +write_model_chunk(FILE *fp) { + SaveChunk chunk = {0}; + u32 mdl_cnt = 0; + + for (u32 i = 0; i < entity_count(); ++i) { + Entity *ent = &entity_data()[i]; + + if (ent->pid && ent->mdl.has) { + mdl_cnt++; + } + } + + if (!chunk_begin(fp, "MODL", &chunk) || + !write_u32_le(fp, mdl_cnt)) { + return false; + } + + for (u32 i = 0; i < entity_count(); ++i) { + Entity *ent = &entity_data()[i]; + + if (!ent->pid || !ent->mdl.has) { + continue; + } + + u32 key_len = (u32)strlen(ent->mdl.key); + + if (!write_u64_le(fp, ent->pid) || + !write_u32_le(fp, key_len) || + !write_byte_arr(fp, ent->mdl.key, key_len) || + !write_u8_le(fp, ent->mdl.draw ? 1 : 0)) { + return false; + } + } + + return chunk_end(fp, &chunk); +} + +static bool +read_physics_shape(FILE *fp, PhysicsShape *shape) { + *shape = (PhysicsShape){0}; + + u8 tag = 0; + if (!read_u8_le(fp, &tag)) { + TraceLog(LOG_ERROR, "failed to read physics shape tag"); + return false; + } + shape->tag = tag; + + if (!read_vec3(fp, &shape->pos) || + !read_quat(fp, &shape->rot) || + !read_f32_le(fp, &shape->density) || + !read_f32_le(fp, &shape->friction) || + !read_f32_le(fp, &shape->restitution) || + !read_u32_le(fp, &shape->category_bits) || + !read_u32_le(fp, &shape->mask_bits)) { + TraceLog(LOG_ERROR, "failed to read physics shape."); + return false; + } + + switch (shape->tag) { + case PHYS_SHAPE_BOX: + return read_vec3(fp, &shape->Box.sz); + break; + + case PHYS_SHAPE_SPHERE: + return read_f32_le(fp, &shape->Sphere.radius); + break; + + case PHYS_SHAPE_CAPSULE: + return read_f32_le(fp, &shape->Capsule.height) && + read_f32_le(fp, &shape->Capsule.radius); + break; + + case PHYS_SHAPE_CYLINDER: + return read_f32_le(fp, &shape->Cylinder.height) && + read_f32_le(fp, &shape->Cylinder.radius); + break; + + case PHYS_SHAPE_CONVEX_HULL: + if (!read_u32_le(fp, &shape->ConvexHull.point_cnt)) { + return false; + } + + if (shape->ConvexHull.point_cnt) { + shape->ConvexHull.points = + calloc(shape->ConvexHull.point_cnt, + sizeof(Vec3)); + + if (!shape->ConvexHull.points) { + return false; + } + } + + for (u32 i = 0; i < shape->ConvexHull.point_cnt; ++i) { + if (!read_vec3(fp, &shape->ConvexHull.points[i])) { + return false; + } + } + break; + + case PHYS_SHAPE_STATIC_TRIMESH: + if (!read_u32_le(fp, &shape->TriMesh.point_cnt) || + !read_u32_le(fp, &shape->TriMesh.idx_cnt)) { + return false; + } + + if (shape->TriMesh.point_cnt) { + shape->TriMesh.points = + calloc(shape->TriMesh.point_cnt, + sizeof(Vec3)); + + if (!shape->TriMesh.points) { + return false; + } + } + + if (shape->TriMesh.idx_cnt) { + shape->TriMesh.indices = + calloc(shape->TriMesh.idx_cnt, sizeof(u32)); + + if (!shape->TriMesh.indices) { + return false; + } + } + + for (u32 i = 0; i < shape->TriMesh.point_cnt; ++i) { + if (!read_vec3(fp, &shape->TriMesh.points[i])) { + return false; + } + } + + for (u32 i = 0; i < shape->TriMesh.idx_cnt; ++i) { + if (!read_u32_le(fp, &shape->TriMesh.indices[i])) { + return false; + } + } + break; + }; + + return true; +} + +static bool +write_physics_shape(FILE *fp, PhysicsShape *shape) { + if (!write_u8_le(fp, (u8)shape->tag) || + !write_vec3(fp, shape->pos) || + !write_quat(fp, shape->rot) || + !write_f32_le(fp, shape->density) || + !write_f32_le(fp, shape->friction) || + !write_f32_le(fp, shape->restitution) || + !write_u32_le(fp, shape->category_bits) || + !write_u32_le(fp, shape->mask_bits)) { + return false; + } + + switch (shape->tag) { + case PHYS_SHAPE_BOX: + return write_vec3(fp, shape->Box.sz); + break; + + case PHYS_SHAPE_SPHERE: + return write_f32_le(fp, shape->Sphere.radius); + break; + + case PHYS_SHAPE_CAPSULE: + return write_f32_le(fp, shape->Capsule.height) && + write_f32_le(fp, shape->Capsule.radius); + break; + + case PHYS_SHAPE_CYLINDER: + return write_f32_le(fp, shape->Cylinder.height) && + write_f32_le(fp, shape->Cylinder.radius); + break; + + case PHYS_SHAPE_CONVEX_HULL: + if (shape->ConvexHull.point_cnt && + !shape->ConvexHull.points) { + return false; + } + + if (!write_u32_le(fp, shape->ConvexHull.point_cnt)) { + return false; + } + + for (u32 i = 0; i < shape->ConvexHull.point_cnt; ++i) { + if (!write_vec3(fp, shape->ConvexHull.points[i])) { + return false; + } + } + break; + + case PHYS_SHAPE_STATIC_TRIMESH: + if ((shape->TriMesh.point_cnt && !shape->TriMesh.points) || + (shape->TriMesh.idx_cnt && !shape->TriMesh.indices)) { + return false; + } + + if (!write_u32_le(fp, shape->TriMesh.point_cnt) || + !write_u32_le(fp, shape->TriMesh.idx_cnt)) { + return false; + } + + for (u32 i = 0; i < shape->TriMesh.point_cnt; ++i) { + if (!write_vec3(fp, shape->TriMesh.points[i])) { + return false; + } + } + + for (u32 i = 0; i < shape->TriMesh.idx_cnt; ++i) { + if (!write_u32_le(fp, shape->TriMesh.indices[i])) { + return false; + } + } + break; + } + + return true; +} + +static bool +read_physics_body(FILE *fp, PhysicsBody *body) { + u8 mode, enable_sleep; + *body = (PhysicsBody){0}; + + if (!read_vec3(fp, &body->pos) || + !read_quat(fp, &body->rot) || + !read_f32_le(fp, &body->linear_damping) || + !read_f32_le(fp, &body->angular_damping) || + !read_f32_le(fp, &body->gravity_scale) || + !read_u8_le(fp, &mode) || + !read_u8_le(fp, &enable_sleep) || + !read_u32_le(fp, &body->shape_cnt)) { + return false; + } + + body->mode = (PhysicsMode)mode; + body->enable_sleep = enable_sleep; + + if (body->shape_cnt) { + body->shapes = calloc(body->shape_cnt, sizeof(PhysicsShape)); + if (!body->shapes) { + return false; + } + } + + for (u32 i = 0; i < body->shape_cnt; ++i) { + if (!read_physics_shape(fp, &body->shapes[i])) { + return false; + } + } + + return true; +} + +static bool +write_physics_body(FILE *fp, PhysicsBody *body) { + if (!write_vec3(fp, body->pos) || + !write_quat(fp, body->rot) || + !write_f32_le(fp, body->linear_damping) || + !write_f32_le(fp, body->angular_damping) || + !write_f32_le(fp, body->gravity_scale) || + !write_u8_le(fp, (u8)body->mode) || + !write_u8_le(fp, body->enable_sleep ? 1 : 0) || + !write_u32_le(fp, body->shape_cnt)) { + return false; + } + + if (body->shape_cnt && !body->shapes) { + return false; + } + + for (u32 i = 0; i < body->shape_cnt; ++i) { + if (!write_physics_shape(fp, &body->shapes[i])) { + return false; + } + } + + return true; +} + +static bool +read_physics_joint(FILE *fp, PhysicsJoint *joint, u32 body_cnt) { + u8 tag; + *joint = (PhysicsJoint){0}; + + if (!read_u8_le(fp, &tag) || + tag > PHYS_JOINT_DISTANCE || + !read_u32_le(fp, &joint->body_a) || + !read_u32_le(fp, &joint->body_b) || + joint->body_a >= body_cnt || + joint->body_b >= body_cnt || + !read_u32_le(fp, &joint->flags) || + !read_vec3(fp, &joint->anchor_a) || + !read_vec3(fp, &joint->anchor_b) || + !read_vec3(fp, &joint->axis_a) || + !read_vec3(fp, &joint->axis_b) || + !read_f32_le(fp, &joint->lower) || + !read_f32_le(fp, &joint->upper) || + !read_f32_le(fp, &joint->spring_hz) || + !read_f32_le(fp, &joint->spring_damping) || + !read_f32_le(fp, &joint->motor_speed) || + !read_f32_le(fp, &joint->motor_force)) { + return false; + } + + joint->tag = (PhysicsJointTag)tag; + return true; +} + +static bool +write_physics_joint(FILE *fp, PhysicsJoint *joint, u32 body_cnt) { + if (joint->body_a >= body_cnt || + joint->body_b >= body_cnt) { + return false; + } + + return write_u8_le(fp, (u8)joint->tag) && + write_u32_le(fp, joint->body_a) && + write_u32_le(fp, joint->body_b) && + write_u32_le(fp, joint->flags) && + write_vec3(fp, joint->anchor_a) && + write_vec3(fp, joint->anchor_b) && + write_vec3(fp, joint->axis_a) && + write_vec3(fp, joint->axis_b) && + write_f32_le(fp, joint->lower) && + write_f32_le(fp, joint->upper) && + write_f32_le(fp, joint->spring_hz) && + write_f32_le(fp, joint->spring_damping) && + write_f32_le(fp, joint->motor_speed) && + write_f32_le(fp, joint->motor_force); +} + +static bool +read_physics_chunk(FILE *fp, SaveLoadContext *ctx) { + u32 phys_cnt = 0; + if (!read_u32_le(fp, &phys_cnt)) { + return false; + } + + for (u32 i = 0; i < phys_cnt; ++i) { + u64 pid; + u32 body_cnt, joint_cnt; + + if (!read_u64_le(fp, &pid) || !pid || pid >= ctx->next_pid) { + return false; + } + + u64 id = entity_id_from_pid(pid); + Entity *ent = entity_get(id); + + if (!read_u32_le(fp, &body_cnt) || !ent || ent->phys.has) { + return false; + } + + ent->phys.body_cnt = body_cnt; + + if (body_cnt) { + ent->phys.bodies = + calloc(body_cnt, sizeof(PhysicsBody)); + if (!ent->phys.bodies) { + return false; + } + } + + for (u32 j = 0; j < body_cnt; ++j) { + if (!read_physics_body(fp, &ent->phys.bodies[j])) { + return false; + } + } + + if (!read_u32_le(fp, &joint_cnt)) { + return false; + } + + ent->phys.joint_cnt = joint_cnt; + + if (joint_cnt) { + ent->phys.joints = + calloc(joint_cnt, sizeof(PhysicsJoint)); + if (!ent->phys.joints) { + return false; + } + } + + for (u32 j = 0; j < joint_cnt; ++j) { + if (!read_physics_joint(fp, + &ent->phys.joints[j], body_cnt)) { + return false; + } + } + + ent->phys.has = true; + } + + return true; +} + +static bool +write_physics_chunk(FILE *fp) { + SaveChunk chunk = {0}; + u32 phys_cnt = 0; + + for (u32 i = 0; i < entity_count(); ++i) { + Entity *ent = &entity_data()[i]; + + if (ent->pid && ent->phys.has) { + phys_cnt++; + } + } + + if (!chunk_begin(fp, "PHYS", &chunk) || + !write_u32_le(fp, phys_cnt)) { + return false; + } + + for (u32 i = 0; i < entity_count(); ++i) { + Entity *ent = &entity_data()[i]; + PhysicsCmp *phys = &ent->phys; + + if (!ent->pid || !phys->has) { + continue; + } + + if ((phys->body_cnt && !phys->bodies) || + (phys->joint_cnt && !phys->joints) || + !write_u64_le(fp, ent->pid) || + !write_u32_le(fp, phys->body_cnt)) { + return false; + } + + for (u32 j = 0; j < phys->body_cnt; ++j) { + if (!write_physics_body(fp, &phys->bodies[j])) { + return false; + } + } + + if (!write_u32_le(fp, phys->joint_cnt)) { + return false; + } + + for (u32 j = 0; j < phys->joint_cnt; ++j) { + if (!write_physics_joint(fp, + &phys->joints[j], phys->body_cnt)) { + return false; + } + } + } + + return chunk_end(fp, &chunk); +} + +bool +save_file_read(cstr path) { + FILE *fp = fopen(path, "rb"); + if (!fp) { + TraceLog(LOG_ERROR, "save file '%s' failed to load.", path); + return false; + } + + SaveLoadContext ctx = {0}; + bool success = read_header(fp); + bool read_entt = false; + + while (success) { + char label[4]; + size_t read_cnt = fread(label, 1, 4, fp); + if (read_cnt == 0 && feof(fp)) { + break; + } + + if (read_cnt != 4) { + TraceLog(LOG_ERROR, "failed to read chunk label."); + success = false; + break; + } + + u32 chunk_size; + if (!read_u32_le(fp, &chunk_size)) { + TraceLog(LOG_ERROR, "failed to read chunk size."); + success = false; + break; + } + + u32 data_pos = ftell(fp); + if (data_pos < 0) { + success = false; + break; + } + + u32 end_pos = data_pos + chunk_size; + + if (memcmp(label, "ENTT", 4) == 0) { + if (read_entt) { + TraceLog(LOG_ERROR, "duplicate ENTT chunk."); + success = false; + break; + } + + success = read_entity_chunk(fp, &ctx); + read_entt = success; + } else if (memcmp(label, "TRFM", 4) == 0) { + if (!read_entt) { + TraceLog(LOG_ERROR, "TRFM found before ENTT."); + success = false; + break; + } + success = read_transform_chunk(fp, &ctx); + } else if (memcmp(label, "MODL", 4) == 0) { + if (!read_entt) { + TraceLog(LOG_ERROR, "TRFM found before ENTT."); + success = false; + break; + } + success = read_model_chunk(fp, &ctx); + } else if (memcmp(label, "PHYS", 4) == 0) { + if (!read_entt) { + TraceLog(LOG_ERROR, "PHYS found before ENTT."); + success = false; + break; + } + success = read_physics_chunk(fp, &ctx); + } else { + TraceLog(LOG_INFO, "skipped unknown chunk."); + } + + if (!success) { + break; + } + + u32 pos = ftell(fp); + if (pos < 0 || pos > end_pos) { + TraceLog(LOG_ERROR, + "chunk reader exceeded chunk size."); + success = false; + break; + } + + if (fseek(fp, end_pos, SEEK_SET) != 0) { + success = false; + break; + } + } + + if (!read_entt) { + TraceLog(LOG_ERROR, "save contains no ENTT chunk."); + success = false; + } + + if (fclose(fp) != 0) { + success = false; + } + + return success; +} + +bool +save_file_write(cstr path) { + FILE *fp = fopen(path, "wb"); + if (!fp) { + return false; + } + + bool success = + write_header(fp) && + write_entity_chunk(fp) && + write_transform_chunk(fp) && + write_model_chunk(fp) && + write_physics_chunk(fp); + + if (fclose(fp) != 0) { + success = false; + } + + return success; +} + |