diff options
| -rw-r--r-- | CMakeLists.txt | 6 | ||||
| -rw-r--r-- | PROJECT_CONTEXT.md | 8 | ||||
| -rw-r--r-- | TODO.md | 6 | ||||
| -rw-r--r-- | doc/HANDOFF_SCENE_LOADER.md | 40 | ||||
| -rw-r--r-- | doc/SCENE_FORMAT.md | 59 | ||||
| -rw-r--r-- | src/3d/scene_loader.cc | 108 | ||||
| -rw-r--r-- | src/3d/scene_loader.h | 14 | ||||
| -rw-r--r-- | src/generated/assets_data.cc | 46 | ||||
| -rw-r--r-- | src/tests/test_scene_loader.cc | 107 | ||||
| -rw-r--r-- | src/util/asset_manager.h | 3 | ||||
| -rw-r--r-- | tools/asset_packer.cc | 9 | ||||
| -rw-r--r-- | tools/blender_export.py | 117 |
12 files changed, 514 insertions, 9 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index f2ab936..0a0b8ad 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -125,6 +125,7 @@ set(3D_SOURCES src/3d/visual_debug.cc src/3d/bvh.cc src/3d/physics.cc + src/3d/scene_loader.cc ) set(PLATFORM_SOURCES src/platform/platform.cc third_party/glfw3webgpu/glfw3webgpu.c) set(UTIL_SOURCES src/util/asset_manager.cc) @@ -533,6 +534,11 @@ if(DEMO_BUILD_TESTS) add_demo_executable(test_platform src/tests/test_platform.cc ${PLATFORM_SOURCES}) target_link_libraries(test_platform PRIVATE util ${DEMO_LIBS}) + add_demo_executable(test_scene_loader src/tests/test_scene_loader.cc ${PLATFORM_SOURCES} ${GEN_DEMO_CC}) + target_link_libraries(test_scene_loader PRIVATE 3d util procedural ${DEMO_LIBS}) + add_dependencies(test_scene_loader generate_demo_assets) + add_test(NAME SceneLoaderTest COMMAND test_scene_loader) + # GPU Effects Test Infrastructure (Phase 1: Foundation) add_demo_test(test_effect_base EffectBaseTest src/tests/test_effect_base.cc diff --git a/PROJECT_CONTEXT.md b/PROJECT_CONTEXT.md index 273acd7..7a4fadb 100644 --- a/PROJECT_CONTEXT.md +++ b/PROJECT_CONTEXT.md @@ -36,7 +36,8 @@ Style: - Audio system: Stable with real-time peak tracking, variable tempo support, comprehensive test coverage - Build system: Optimized with proper asset dependency tracking - Shader system: Modular with comprehensive compilation tests -- 3D rendering: Hybrid SDF/rasterization with BVH acceleration +- 3D rendering: Hybrid SDF/rasterization with BVH acceleration and binary scene loader +- Asset pipeline: Blender export script and binary scene ingestion supported --- ## Next Up @@ -49,11 +50,6 @@ Style: - Phase 3: File I/O (load .wav/.spec, export procedural_params.txt + C++ code) - See `doc/SPECTRAL_BRUSH_EDITOR.md` for complete design -- **Task #18: 3D System Enhancements** - - [ ] **Task #18.0: Basic OBJ Asset Pipeline**: Implement `ASSET_MESH` type, `asset_packer` OBJ support, and `Renderer3D` mesh rendering. - - [ ] **Task #37: Asset Ingestion**: Update `asset_packer` to handle the new 3D binary format. - - [ ] **Task #38: Runtime Loader**: Implement a minimal C++ parser to load the scene data into the ECS/Renderer. - - **Visuals & Content** - [ ] **Task #52: Procedural SDF Font**: Minimal bezier/spline set for [A-Z, 0-9] and SDF rendering. - [ ] **Task #53: Particles Shader Polish**: Improve visual quality of particles. @@ -99,9 +99,9 @@ This file tracks prioritized tasks with detailed attack plans. - [x] Define `ASSET_MESH` type in `asset_manager`. - [x] Update `asset_packer` to parse simple `.obj` files (positions, normals, UVs) and serialize them. - [x] Update `Renderer3D` to handle `ObjectType::MESH` in the rasterization path. -- [ ] **Task #36: Blender Exporter:** Create a Python script (`tools/blender_export.py`) to export meshes/cameras/lights to a binary asset format. (Deprioritized) -- [ ] **Task #37: Asset Ingestion:** Update `asset_packer` to handle the new 3D binary format. - - [ ] **Task #38: Runtime Loader:** Implement a minimal C++ parser to load the scene data into the ECS/Renderer. +- [x] **Task #36: Blender Exporter:** Create a Python script (`tools/blender_export.py`) to export meshes/cameras/lights to a binary asset format. +- [x] **Task #37: Asset Ingestion:** Update `asset_packer` to handle the new 3D binary format. + - [x] **Task #38: Runtime Loader:** Implement a minimal C++ parser to load the scene data into the ECS/Renderer. - [x] **Task #18-B: GPU BVH & Shadows** (Optimization) - [x] **Upload BVH:** Create a storage buffer for `BVHNode` data and upload the CPU-built BVH every frame in `Renderer3D`. diff --git a/doc/HANDOFF_SCENE_LOADER.md b/doc/HANDOFF_SCENE_LOADER.md new file mode 100644 index 0000000..b218d0b --- /dev/null +++ b/doc/HANDOFF_SCENE_LOADER.md @@ -0,0 +1,40 @@ +# Handoff: 3D Scene Pipeline (February 8, 2026) + +## Summary +Implemented a complete pipeline for exporting 3D scenes from Blender and loading them at runtime. + +## Accomplishments + +### Task #18: 3D System Enhancements +- **Blender Exporter**: Created `tools/blender_export.py` to export scenes to a binary format (`SCN1`). + - Exports objects, transforms, types, and mesh references. + - Handles string-based asset resolution. +- **Asset System Update**: Updated `asset_packer` to generate `GetAssetIdByName` for runtime string lookup. +- **Runtime Loader**: Implemented `SceneLoader` (`src/3d/scene_loader.h/cc`) to parse the binary scene format. +- **Verification**: Added `test_scene_loader` to verify the pipeline. + +## Key Components + +### Binary Format (`doc/SCENE_FORMAT.md`) +- Magic: `SCN1` +- Supports Objects (Mesh, Primitives), Cameras, Lights. +- Compact binary representation. + +### Runtime Integration +- `SceneLoader::LoadScene(scene, data, size)` populates a `Scene` object. +- Uses `GetAssetIdByName` to resolve mesh references (e.g. "MESH_CUBE" -> `ASSET_MESH_CUBE`). + +## Next Steps +- Use the exporter in a real workflow (requires Blender). +- Update `Renderer3D` or `MainSequence` to actually use `SceneLoader` for a level (e.g. `assets/final/level1.bin`). +- Implement `Task #5: Spectral Brush Editor` (In Progress). + +## Files Modified +- `tools/blender_export.py` (New) +- `src/3d/scene_loader.h` (New) +- `src/3d/scene_loader.cc` (New) +- `src/tests/test_scene_loader.cc` (New) +- `tools/asset_packer.cc` (Updated) +- `src/util/asset_manager.h` (Updated) +- `CMakeLists.txt` (Updated) +- `doc/SCENE_FORMAT.md` (New) diff --git a/doc/SCENE_FORMAT.md b/doc/SCENE_FORMAT.md new file mode 100644 index 0000000..679ab5e --- /dev/null +++ b/doc/SCENE_FORMAT.md @@ -0,0 +1,59 @@ +# Scene Binary Format (SCN1) + +This document describes the binary format used for 3D scenes exported from Blender. + +## Overview + +- **Extension:** `.bin` or `.scene` +- **Endianness:** Little Endian +- **Layout:** Header followed by sequential blocks. + +## Header (16 bytes) + +| Offset | Type | Description | +|--------|----------|-------------| +| 0 | char[4] | Magic bytes "SCN1" | +| 4 | uint32_t | Number of objects | +| 8 | uint32_t | Number of cameras (reserved) | +| 12 | uint32_t | Number of lights (reserved) | + +## Object Block + +Repeated `num_objects` times. + +| Offset | Type | Description | +|--------|----------|-------------| +| 0 | char[64] | Object Name (UTF-8, null-padded) | +| 64 | uint32_t | Object Type (Enum) | +| 68 | vec3 | Position (x, y, z) - 12 bytes | +| 80 | quat | Rotation (x, y, z, w) - 16 bytes | +| 96 | vec3 | Scale (x, y, z) - 12 bytes | +| 108 | vec4 | Color (r, g, b, a) - 16 bytes | +| 124 | uint32_t | Mesh Name Length (N) | +| 128 | char[N] | Mesh Asset Name (if N > 0) | +| 128+N | float | Mass | +| 132+N | float | Restitution | +| 136+N | uint32_t | Is Static (0=Dynamic, 1=Static) | + +### Object Types + +```cpp +enum class ObjectType { + CUBE = 0, + SPHERE = 1, + PLANE = 2, + TORUS = 3, + BOX = 4, + SKYBOX = 5, + MESH = 6 +}; +``` + +## Coordinate System + +- **Position**: Blender coordinates (Z-up) should be converted to engine coordinates (Y-up) by the exporter or loader. Currently raw export. +- **Rotation**: Blender quaternions are (w, x, y, z). Exporter writes (x, y, z, w). Engine uses (x, y, z, w). + +## Asset Resolution + +Mesh assets are referenced by name string (e.g., "MESH_CUBE"). The loader uses `GetAssetIdByName` to resolve this to a runtime `AssetId`. diff --git a/src/3d/scene_loader.cc b/src/3d/scene_loader.cc new file mode 100644 index 0000000..69079ef --- /dev/null +++ b/src/3d/scene_loader.cc @@ -0,0 +1,108 @@ +#include "3d/scene_loader.h" +#include "util/asset_manager.h" +#include "generated/assets.h" +#include "util/mini_math.h" +#include <cstring> +#include <cstdio> +#include <vector> + +bool SceneLoader::LoadScene(Scene& scene, const uint8_t* data, size_t size) { + if (!data || size < 16) { // Header size check + printf("SceneLoader: Data too small\n"); + return false; + } + + // Check Magic + if (std::memcmp(data, "SCN1", 4) != 0) { + printf("SceneLoader: Invalid magic (expected SCN1)\n"); + return false; + } + + size_t offset = 4; + + uint32_t num_objects = *reinterpret_cast<const uint32_t*>(data + offset); offset += 4; + uint32_t num_cameras = *reinterpret_cast<const uint32_t*>(data + offset); offset += 4; + uint32_t num_lights = *reinterpret_cast<const uint32_t*>(data + offset); offset += 4; + + // printf("SceneLoader: Loading %d objects, %d cameras, %d lights\n", num_objects, num_cameras, num_lights); + + for (uint32_t i = 0; i < num_objects; ++i) { + if (offset + 64 > size) return false; // Name check + + char name[65] = {0}; + std::memcpy(name, data + offset, 64); offset += 64; + + if (offset + 4 > size) return false; + uint32_t type_val = *reinterpret_cast<const uint32_t*>(data + offset); offset += 4; + ObjectType type = (ObjectType)type_val; + + if (offset + 12 + 16 + 12 + 16 > size) return false; // Transforms + Color + + float px = *reinterpret_cast<const float*>(data + offset); offset += 4; + float py = *reinterpret_cast<const float*>(data + offset); offset += 4; + float pz = *reinterpret_cast<const float*>(data + offset); offset += 4; + vec3 pos(px, py, pz); + + float rx = *reinterpret_cast<const float*>(data + offset); offset += 4; + float ry = *reinterpret_cast<const float*>(data + offset); offset += 4; + float rz = *reinterpret_cast<const float*>(data + offset); offset += 4; + float rw = *reinterpret_cast<const float*>(data + offset); offset += 4; + quat rot(rx, ry, rz, rw); + + float sx = *reinterpret_cast<const float*>(data + offset); offset += 4; + float sy = *reinterpret_cast<const float*>(data + offset); offset += 4; + float sz = *reinterpret_cast<const float*>(data + offset); offset += 4; + vec3 scale(sx, sy, sz); + + float cr = *reinterpret_cast<const float*>(data + offset); offset += 4; + float cg = *reinterpret_cast<const float*>(data + offset); offset += 4; + float cb = *reinterpret_cast<const float*>(data + offset); offset += 4; + float ca = *reinterpret_cast<const float*>(data + offset); offset += 4; + vec4 color(cr, cg, cb, ca); + + // Mesh Asset Name Length + if (offset + 4 > size) return false; + uint32_t name_len = *reinterpret_cast<const uint32_t*>(data + offset); offset += 4; + + AssetId mesh_id = (AssetId)0; // Default or INVALID (if 0 is invalid) + + if (name_len > 0) { + if (offset + name_len > size) return false; + char mesh_name[128] = {0}; + if (name_len < 128) { + std::memcpy(mesh_name, data + offset, name_len); + } + offset += name_len; + + // Resolve Asset ID + mesh_id = GetAssetIdByName(mesh_name); + if (mesh_id == AssetId::ASSET_LAST_ID) { + printf("SceneLoader: Warning: Mesh asset '%s' not found for object '%s'\n", mesh_name, name); + } + } + + // Physics properties + if (offset + 4 + 4 + 4 > size) return false; + float mass = *reinterpret_cast<const float*>(data + offset); offset += 4; + float restitution = *reinterpret_cast<const float*>(data + offset); offset += 4; + uint32_t is_static_u32 = *reinterpret_cast<const uint32_t*>(data + offset); offset += 4; + bool is_static = (is_static_u32 != 0); + + // Create Object3D + Object3D obj(type); + obj.position = pos; + obj.rotation = rot; + obj.scale = scale; + obj.color = color; + obj.mesh_asset_id = mesh_id; + obj.mass = mass; + obj.restitution = restitution; + obj.is_static = is_static; + // user_data is nullptr by default + + // Add to scene + scene.add_object(obj); + } + + return true; +}
\ No newline at end of file diff --git a/src/3d/scene_loader.h b/src/3d/scene_loader.h new file mode 100644 index 0000000..15f08c7 --- /dev/null +++ b/src/3d/scene_loader.h @@ -0,0 +1,14 @@ +#pragma once + +#include "3d/scene.h" +#include <cstdint> +#include <cstddef> + +// SceneLoader handles parsing of binary scene files (.bin) exported from Blender. +// It populates a Scene object with objects, lights, and cameras. +class SceneLoader { + public: + // Loads a scene from a binary buffer. + // Returns true on success, false on failure (e.g., invalid magic, version mismatch). + static bool LoadScene(Scene& scene, const uint8_t* data, size_t size); +}; diff --git a/src/generated/assets_data.cc b/src/generated/assets_data.cc index 49d7368..b9a6a8a 100644 --- a/src/generated/assets_data.cc +++ b/src/generated/assets_data.cc @@ -1,5 +1,6 @@ // This file is auto-generated by asset_packer.cc. Do not edit. +#include <cstring> #include "util/asset_manager.h" #include "assets.h" namespace procedural { void gen_noise(uint8_t*, int, int, const float*, int); } @@ -369390,3 +369391,48 @@ size_t GetAssetCount() { return 41; } +AssetId GetAssetIdByName(const char* name) { + if (std::strcmp(name, "KICK_1") == 0) return AssetId::ASSET_KICK_1; + if (std::strcmp(name, "KICK_2") == 0) return AssetId::ASSET_KICK_2; + if (std::strcmp(name, "SNARE_1") == 0) return AssetId::ASSET_SNARE_1; + if (std::strcmp(name, "SNARE_2") == 0) return AssetId::ASSET_SNARE_2; + if (std::strcmp(name, "SNARE_3") == 0) return AssetId::ASSET_SNARE_3; + if (std::strcmp(name, "HIHAT_1") == 0) return AssetId::ASSET_HIHAT_1; + if (std::strcmp(name, "HIHAT_2") == 0) return AssetId::ASSET_HIHAT_2; + if (std::strcmp(name, "HIHAT_3") == 0) return AssetId::ASSET_HIHAT_3; + if (std::strcmp(name, "CRASH_1") == 0) return AssetId::ASSET_CRASH_1; + if (std::strcmp(name, "RIDE_1") == 0) return AssetId::ASSET_RIDE_1; + if (std::strcmp(name, "SPLASH_1") == 0) return AssetId::ASSET_SPLASH_1; + if (std::strcmp(name, "BASS_1") == 0) return AssetId::ASSET_BASS_1; + if (std::strcmp(name, "BASS_2") == 0) return AssetId::ASSET_BASS_2; + if (std::strcmp(name, "BASS_3") == 0) return AssetId::ASSET_BASS_3; + if (std::strcmp(name, "NOISE_TEX") == 0) return AssetId::ASSET_NOISE_TEX; + if (std::strcmp(name, "SHADER_RENDERER_3D") == 0) return AssetId::ASSET_SHADER_RENDERER_3D; + if (std::strcmp(name, "SHADER_COMMON_UNIFORMS") == 0) return AssetId::ASSET_SHADER_COMMON_UNIFORMS; + if (std::strcmp(name, "SHADER_SDF_PRIMITIVES") == 0) return AssetId::ASSET_SHADER_SDF_PRIMITIVES; + if (std::strcmp(name, "SHADER_LIGHTING") == 0) return AssetId::ASSET_SHADER_LIGHTING; + if (std::strcmp(name, "SHADER_RAY_BOX") == 0) return AssetId::ASSET_SHADER_RAY_BOX; + if (std::strcmp(name, "SHADER_MAIN") == 0) return AssetId::ASSET_SHADER_MAIN; + if (std::strcmp(name, "SHADER_PARTICLE_COMPUTE") == 0) return AssetId::ASSET_SHADER_PARTICLE_COMPUTE; + if (std::strcmp(name, "SHADER_PARTICLE_RENDER") == 0) return AssetId::ASSET_SHADER_PARTICLE_RENDER; + if (std::strcmp(name, "SHADER_PASSTHROUGH") == 0) return AssetId::ASSET_SHADER_PASSTHROUGH; + if (std::strcmp(name, "SHADER_ELLIPSE") == 0) return AssetId::ASSET_SHADER_ELLIPSE; + if (std::strcmp(name, "SHADER_PARTICLE_SPRAY_COMPUTE") == 0) return AssetId::ASSET_SHADER_PARTICLE_SPRAY_COMPUTE; + if (std::strcmp(name, "SHADER_GAUSSIAN_BLUR") == 0) return AssetId::ASSET_SHADER_GAUSSIAN_BLUR; + if (std::strcmp(name, "SHADER_SOLARIZE") == 0) return AssetId::ASSET_SHADER_SOLARIZE; + if (std::strcmp(name, "SHADER_DISTORT") == 0) return AssetId::ASSET_SHADER_DISTORT; + if (std::strcmp(name, "SHADER_CHROMA_ABERRATION") == 0) return AssetId::ASSET_SHADER_CHROMA_ABERRATION; + if (std::strcmp(name, "SHADER_VISUAL_DEBUG") == 0) return AssetId::ASSET_SHADER_VISUAL_DEBUG; + if (std::strcmp(name, "SHADER_SKYBOX") == 0) return AssetId::ASSET_SHADER_SKYBOX; + if (std::strcmp(name, "SHADER_MATH_SDF_SHAPES") == 0) return AssetId::ASSET_SHADER_MATH_SDF_SHAPES; + if (std::strcmp(name, "SHADER_MATH_SDF_UTILS") == 0) return AssetId::ASSET_SHADER_MATH_SDF_UTILS; + if (std::strcmp(name, "SHADER_RENDER_SHADOWS") == 0) return AssetId::ASSET_SHADER_RENDER_SHADOWS; + if (std::strcmp(name, "SHADER_RENDER_SCENE_QUERY_BVH") == 0) return AssetId::ASSET_SHADER_RENDER_SCENE_QUERY_BVH; + if (std::strcmp(name, "SHADER_RENDER_SCENE_QUERY_LINEAR") == 0) return AssetId::ASSET_SHADER_RENDER_SCENE_QUERY_LINEAR; + if (std::strcmp(name, "SHADER_RENDER_LIGHTING_UTILS") == 0) return AssetId::ASSET_SHADER_RENDER_LIGHTING_UTILS; + if (std::strcmp(name, "SHADER_MESH") == 0) return AssetId::ASSET_SHADER_MESH; + if (std::strcmp(name, "MESH_CUBE") == 0) return AssetId::ASSET_MESH_CUBE; + if (std::strcmp(name, "DODECAHEDRON") == 0) return AssetId::ASSET_DODECAHEDRON; + return AssetId::ASSET_LAST_ID; +} + diff --git a/src/tests/test_scene_loader.cc b/src/tests/test_scene_loader.cc new file mode 100644 index 0000000..e14054b --- /dev/null +++ b/src/tests/test_scene_loader.cc @@ -0,0 +1,107 @@ +#include "3d/scene_loader.h" +#include "util/mini_math.h" +#include "util/asset_manager.h" +#include "generated/assets.h" +#include <cstdio> +#include <cstring> +#include <vector> +#include <cassert> + +int main() { + Scene scene; + std::vector<uint8_t> buffer; + + // Header + const char* magic = "SCN1"; + for(int i=0; i<4; ++i) buffer.push_back(magic[i]); + + uint32_t num_obj = 2; // Increased to 2 + uint32_t num_cam = 0; + uint32_t num_light = 0; + + auto push_u32 = [&](uint32_t v) { + uint8_t* p = (uint8_t*)&v; + for(int i=0; i<4; ++i) buffer.push_back(p[i]); + }; + auto push_f = [&](float v) { + uint8_t* p = (uint8_t*)&v; + for(int i=0; i<4; ++i) buffer.push_back(p[i]); + }; + + push_u32(num_obj); + push_u32(num_cam); + push_u32(num_light); + + // --- Object 1: Basic Cube --- + char name1[64] = {0}; + std::strcpy(name1, "TestObject"); + for(int i=0; i<64; ++i) buffer.push_back(name1[i]); + + push_u32(0); // CUBE + + // Pos + push_f(1.0f); push_f(2.0f); push_f(3.0f); + // Rot (0,0,0,1) + push_f(0.0f); push_f(0.0f); push_f(0.0f); push_f(1.0f); + // Scale + push_f(1.0f); push_f(1.0f); push_f(1.0f); + // Color + push_f(1.0f); push_f(0.0f); push_f(0.0f); push_f(1.0f); + + // Mesh Name length 0 + push_u32(0); + + // Physics + push_f(10.0f); // mass + push_f(0.8f); // restitution + push_u32(1); // static + + // --- Object 2: Mesh with Asset Ref --- + char name2[64] = {0}; + std::strcpy(name2, "MeshObject"); + for(int i=0; i<64; ++i) buffer.push_back(name2[i]); + + push_u32(6); // MESH + + // Pos + push_f(0.0f); push_f(0.0f); push_f(0.0f); + // Rot + push_f(0.0f); push_f(0.0f); push_f(0.0f); push_f(1.0f); + // Scale + push_f(1.0f); push_f(1.0f); push_f(1.0f); + // Color + push_f(0.0f); push_f(1.0f); push_f(0.0f); push_f(1.0f); + + // Mesh Name "MESH_CUBE" + const char* mesh_name = "MESH_CUBE"; + uint32_t mesh_name_len = std::strlen(mesh_name); + push_u32(mesh_name_len); + for(size_t i=0; i<mesh_name_len; ++i) buffer.push_back(mesh_name[i]); + + // Physics + push_f(1.0f); + push_f(0.5f); + push_u32(0); // dynamic + + // --- Load --- + if (SceneLoader::LoadScene(scene, buffer.data(), buffer.size())) { + printf("Scene loaded successfully.\n"); + assert(scene.objects.size() == 2); + + // Check Obj 1 + assert(scene.objects[0].type == ObjectType::CUBE); + assert(scene.objects[0].position.x == 1.0f); + assert(scene.objects[0].is_static == true); + + // Check Obj 2 + assert(scene.objects[1].type == ObjectType::MESH); + assert(scene.objects[1].mesh_asset_id == AssetId::ASSET_MESH_CUBE); + printf("Mesh Asset ID resolved to: %d (Expected %d)\n", (int)scene.objects[1].mesh_asset_id, (int)AssetId::ASSET_MESH_CUBE); + + } else { + printf("Scene load failed.\n"); + return 1; + } + + return 0; +} diff --git a/src/util/asset_manager.h b/src/util/asset_manager.h index ed7f1aa..59bf7a0 100644 --- a/src/util/asset_manager.h +++ b/src/util/asset_manager.h @@ -24,3 +24,6 @@ struct AssetRecord { // - 'out_size' returns the original asset size (excluding the null terminator). const uint8_t* GetAsset(AssetId asset_id, size_t* out_size = nullptr); void DropAsset(AssetId asset_id, const uint8_t* asset); + +// Returns the AssetId for a given asset name, or AssetId::ASSET_LAST_ID if not found. +AssetId GetAssetIdByName(const char* name); diff --git a/tools/asset_packer.cc b/tools/asset_packer.cc index 32742bd..42dfa7a 100644 --- a/tools/asset_packer.cc +++ b/tools/asset_packer.cc @@ -127,6 +127,7 @@ int main(int argc, char* argv[]) { fprintf( assets_data_cc_file, "// This file is auto-generated by asset_packer.cc. Do not edit.\n\n"); + fprintf(assets_data_cc_file, "#include <cstring>\n"); fprintf(assets_data_cc_file, "#include \"util/asset_manager.h\"\n"); fprintf(assets_data_cc_file, "#include \"%s\"\n", generated_header_name.c_str()); @@ -499,6 +500,14 @@ int main(int argc, char* argv[]) { fprintf(assets_data_cc_file, " return %zu;\n", asset_build_infos.size()); fprintf(assets_data_cc_file, "}\n\n"); + fprintf(assets_data_cc_file, "AssetId GetAssetIdByName(const char* name) {\n"); + for (const auto& info : asset_build_infos) { + fprintf(assets_data_cc_file, " if (std::strcmp(name, \"%s\") == 0) return AssetId::ASSET_%s;\n", + info.name.c_str(), info.name.c_str()); + } + fprintf(assets_data_cc_file, " return AssetId::ASSET_LAST_ID;\n"); + fprintf(assets_data_cc_file, "}\n\n"); + std::fclose(assets_data_cc_file); printf("Asset packer successfully generated records for %zu assets.\n", diff --git a/tools/blender_export.py b/tools/blender_export.py new file mode 100644 index 0000000..da7b986 --- /dev/null +++ b/tools/blender_export.py @@ -0,0 +1,117 @@ +import bpy +import struct +import os + +# Output format: +# Header: +# char[4] magic = "SCN1" +# uint32_t num_objects +# uint32_t num_cameras (reserved) +# uint32_t num_lights (reserved) +# +# Object Block: +# char[64] name +# uint32_t type (0=CUBE, 1=SPHERE, 2=PLANE, 3=TORUS, 4=BOX, 5=SKYBOX, 6=MESH) +# vec3 position +# quat rotation (x, y, z, w) +# vec3 scale +# vec4 color +# uint32_t mesh_name_len +# char[] mesh_name (if type == MESH) +# float mass +# float restitution +# uint32_t is_static (bool) + +def export_scene(filepath): + print(f"Exporting scene to {filepath}...") + + objects = [obj for obj in bpy.context.scene.objects if obj.visible_get() and obj.type == 'MESH'] + + with open(filepath, 'wb') as f: + # Header + f.write(b'SCN1') + f.write(struct.pack('<III', len(objects), 0, 0)) + + for obj in objects: + print(f" Exporting {obj.name}...") + + # Name (64 bytes, null-padded) + name_bytes = obj.name.encode('utf-8')[:63] + f.write(struct.pack('<64s', name_bytes)) + + # Type detection + # Default to MESH (6) + obj_type = 6 + + # Simple heuristic for primitives based on name + # In a real pipeline, we might use custom properties + name_lower = obj.name.lower() + if 'cube' in name_lower and 'mesh' not in name_lower: obj_type = 0 + elif 'sphere' in name_lower: obj_type = 1 + elif 'plane' in name_lower: obj_type = 2 + elif 'torus' in name_lower: obj_type = 3 + elif 'box' in name_lower: obj_type = 4 + + f.write(struct.pack('<I', obj_type)) + + # Transform + # Blender uses Z-up. We typically use Y-up. + # Conversion: + # Pos: (x, z, -y) + # Rot: Convert quaternion + + pos = obj.location + rot = obj.rotation_quaternion + scale = obj.scale + + # Position + # For now, exporting raw Blender coordinates. + # We can fix coordinate system in C++ or here if decided. + # Keeping raw for now to avoid confusion until verified. + f.write(struct.pack('<3f', pos.x, pos.y, pos.z)) + + # Rotation (x, y, z, w) + # Blender provides (w, x, y, z) + f.write(struct.pack('<4f', rot.x, rot.y, rot.z, rot.w)) + + # Scale + f.write(struct.pack('<3f', scale.x, scale.y, scale.z)) + + # Color (RGBA) + # Try to get from material + color = (1.0, 1.0, 1.0, 1.0) + if obj.active_material: + c = obj.active_material.diffuse_color + color = (c[0], c[1], c[2], c[3]) + f.write(struct.pack('<4f', *color)) + + # Mesh Asset Name + mesh_asset_name = "" + if obj_type == 6: # MESH + # Ensure the mesh name is sanitized for AssetId (e.g. MESH_CUBE) + # Convention: MESH_<ObjectName_Upper> + mesh_asset_name = "MESH_" + obj.name.upper().replace('.', '_') + + name_len = len(mesh_asset_name) + f.write(struct.pack('<I', name_len)) + if name_len > 0: + f.write(mesh_asset_name.encode('utf-8')) + + # Physics properties (from custom properties or defaults) + mass = obj.get('mass', 1.0) + restitution = obj.get('restitution', 0.5) + is_static = obj.get('is_static', 0) + + f.write(struct.pack('<ffI', float(mass), float(restitution), int(is_static))) + + print("Export complete.") + +# To run in Blender: +# import sys +# sys.path.append('/path/to/demo/tools') +# import blender_export +# blender_export.export_scene('/path/to/demo/assets/final/scene.bin') + +if __name__ == "__main__": + # Standalone test (won't work outside Blender environment usually) + pass |