Request for Proposal (RFP): High-Performance Procedural Voxel Engine Development for Unity
Project Overview
We are seeking a highly skilled development team or individual contractor to build a custom, high-performance voxel engine for Unity. The engine will power a survival game with a procedural world and a distinct aesthetic. Core requirements include the use of octrees for LOD, surface nets for terrain, efficient memory management, and seed-based procedural generation with change-based saving. The end goal is an optimized, scalable voxel system that delivers long render distances, rapid chunk loading/unloading, and light memory usage.
1. Project Goals
- Develop a performant voxel engine capable of handling near-infinite terrain in Unity.
- Support high render distances with optimized LOD.
- Provide fine-tuned procedural generation controls.
- Implement an efficient memory storage solution that saves only changes to the world.
- Ensure rapid chunk loading and unloading without compromising performance.
2. Technical Requirements
2.1 Core Engine Capabilities
- Infinite Terrain with Seed-Based Generation: Use a seed to procedurally generate the world, supporting vast and continuous terrain generation with minimal storage overhead.
- Surface Nets and Greedy Meshing: Utilize surface nets to achieve smooth terrain rendering and greedy meshing to reduce vertex count by merging adjacent voxels of the same type.
- Dynamic Level of Detail (LOD) with Octrees: Implement an octree-based LOD system for efficient long-distance rendering. Coarser detail should be used in the distance, with higher-resolution data loaded progressively as the player approaches.
2.2 Memory Management and Storage
- Sparse Data Storage: Store only the delta (changes) to the original procedurally generated world. Use a hashmap to track modified voxels by chunk, saving only the voxel ID, position, and modification type.
- Voxel Modification Log: Maintain a lightweight log of all modifications to the base world state. Log should allow quick lookup and retrieval of modifications without recalculating all changes.
- Efficient Save Format and Compression: Implement a binary serialization format with lightweight compression algorithms (e.g., LZ4, Zstandard) to store modified voxel data efficiently.
2.3 Chunk Loading and Unloading
- Paged Region Loading and Caching: Implement a paging system that loads chunks based on player proximity and caches frequently visited regions. Include a rolling buffer to manage memory and ensure seamless transitions between regions.
- Asynchronous Data Retrieval and Lazy Loading: Enable lazy loading for non-critical elements, like decorative features, and multithreaded chunk loading to prevent frame drops.
2.4 Rendering and Optimization
- Frustum and Occlusion Culling: Use frustum and occlusion culling optimized for voxel terrain to avoid rendering hidden or non-visible chunks.
- Region-Based LOD with Octree Simplification: Apply region-based LOD simplification to reduce memory usage for distant voxels, updating dynamically based on player position.
- GPU-based Voxel Generation: Offload LOD and mesh generation to the GPU for high efficiency, particularly at higher LODs and far render distances.
3. Data Storage Parameters
3.1 World Seed and Procedural Generation
- Primary seed to generate the world, with additional regional seeds for variety.
- Base terrain data should only load on demand, allowing for an infinite world within a reasonable memory footprint.
3.2 Sparse Chunk Storage
- Chunks should store only modified voxel data using sparse storage, reducing memory consumption.
- Chunks should be indexed in a hashmap by coordinates, with each modification recorded as a delta to the original state.
3.3 Delta Compression
- Save only the modifications from the original generated state, implementing delta compression to store differences efficiently.
- Periodically save world state in “snapshots” to minimize recalculation time.
3.4 Region Metadata and Prefetching
- Metadata should be stored for each region, including recent interaction frequency, modification density, and prefetching information.
- Prefetch regions based on player movement patterns to improve perceived performance during gameplay.
3.5 Predictive Prefetching and Lazy Loading
- Implement a system to predictively prefetch chunks based on the player’s movement, with lazy loading for distant, non-critical elements.
- Optimize load times by queuing chunks based on the player’s movement direction, prioritizing nearby chunks.
4. Project Deliverables
- Fully functional, high-performance voxel engine for Unity that meets all technical requirements.
- Documentation covering implementation details, including memory management, chunk loading/unloading, procedural generation controls, and LOD handling.
- A demo project showcasing the engine’s capabilities within Unity, including infinite terrain generation, dynamic LOD rendering, efficient loading and unloading of chunks, and memory-efficient data storage.
- Guidelines and support for integration with our existing Unity project.
5. Milestones and Timeline
- Milestone 1: Initial design and prototype for infinite terrain generation and seed-based procedural world generation. (Expected duration: X weeks)
- Milestone 2: Implementation of LOD with octrees, surface nets, and greedy meshing for optimized rendering. (Expected duration: X weeks)
- Milestone 3: Development of chunk loading/unloading and memory management systems, including sparse data storage and delta compression. (Expected duration: X weeks)
- Milestone 4: Integration of prefetching, caching, and lazy loading mechanisms. (Expected duration: X weeks)
- Milestone 5: Final testing, optimization, and documentation. (Expected duration: X weeks)
6. Submission Requirements
Interested parties should provide:
- A detailed project proposal including approach, relevant experience, and initial thoughts on technical implementation.
- A portfolio of previous work related to procedural generation, voxel-based games, or memory-efficient data storage.
- A project timeline with estimated completion dates for each milestone.
- A pricing model (fixed rate or hourly) and total cost estimate.
Evaluation Criteria
- Relevant experience and technical expertise.
- Feasibility and clarity of proposed approach.
- Timeline and budget suitability.
- Demonstrated ability to optimize for performance in similar projects.