Phenix Dev Log

Worked on planning and refining the collision detection system, improving how particles interact with solid surfaces. Focused on flat plane colliders and the underlying math for detecting surface contacts accurately. Added automated tests to validate the new collision behavior and catch regressions early.

Explored a new simulation scenario: a cloth draping over a sphere, showcasing how particle constraints can realistically model flexible fabric. This type of scene demonstrates the power of the constraint system for soft-body effects. Also set up a release notes template to make future version documentation faster and more consistent.

A new Constraint Preset node was added to the particle system, giving artists a convenient way to apply predefined constraint configurations without manually setting up every parameter. The node exposes a curated set of commonly-used constraint setups, making it faster to iterate on simulations with physical constraints. The existing constraint nodes were updated to integrate smoothly with the new preset system.

A bug causing infinite recursion in the constraint evaluation system was identified and resolved. The fix ensures the solver correctly exits evaluation loops without getting stuck, improving stability when using complex constraint chains. A minor additional fix was also applied for edge cases in the node system.

The GPU binding resolver was significantly streamlined, reducing its codebase by over a third while keeping all features intact. All simulation modules were updated to use StandardLayouts, making the binding system more consistent and maintainable across the board. Minor input handling fixes were applied to several nodes to improve reliability in the Blender interface. Documentation was also updated to reflect these structural changes.

A brand-new Event Spawner node was built from scratch, allowing particles to spawn new particles when specific conditions are met. The system runs entirely on the GPU through dedicated compute shaders for event detection and spawning. Collision-based spawning was added the same day, letting the simulation react to mesh or primitive hits in real time. Particle configuration properties were also extended with a new Particle Properties node for more granular per-emitter control.

The hook-solver branch was merged into the main codebase: springs and hook constraints are now fully integrated, tested, and working. All automated tests pass. A set of new example scenes was added — vertical chains, suspended tori, rigid cubes, large ground simulations — showcasing what the constraint system can do. Further determinism improvements were also applied, ensuring simulations produce identical results every run.

Pin constraints — which allow particles to be locked to a fixed point in space, like nailing one end of a chain to a wall — are now fully functional and validated by tests. This is a key building block for scenes like hanging ropes, suspended objects, and anchored structures.

Fixed an issue with how simulation results are transferred back from the graphics card to the CPU for inspection and validation. With that corrected, nearly all automated tests were passing again, bringing the codebase close to a fully stable state.

The motion integration system — the part that moves each particle forward in time — was significantly simplified and cleaned up, cutting the code roughly in half while making it easier to maintain. A small dedicated integrator was extracted as its own component, and all automated tests came back green, confirming the refactor did not break anything.

The spring and hook constraint formulas were reworked to match established molecular dynamics calculations, ensuring the simulation behaves in a physically accurate way. The older position-based solver was cleared out to make room for this cleaner approach, and the GPU constraint shader received a significant overhaul as a result.

Continued refining the test scenes for the constraint system — tweaking how suspended objects, stiff links, and large particle groups behave. Small adjustments were also made to how the GPU integration communicates results back, laying the groundwork for more accurate physics calculations in the following days.

Implemented a neighbor sorting system to ensure that simulations produce identical results every time they run. This is critical for reproducibility and debugging. Also diagnosed and resolved a conflict between the grab interaction and spring forces that was causing instability during user interaction.

Fixed issues in the fluid simulation, gravity, and vorticity systems. Enhanced the standalone viewer with better rendering capabilities. Created example scenes to demonstrate different constraint behaviors like ground contact, rigid body cubes, and stiffness comparison. Added extensive constraint validation tests.

Massive testing effort across the entire simulation engine. Added reliable tests for combustion, fluid dynamics, noise generation, reaction-diffusion, and vorticity. Improved the test framework itself to produce more consistent and meaningful validation results. Fixed several bugs discovered during testing across multiple simulation modules.

Investigated and documented a constraint collapse issue where particles would unexpectedly converge to a single point. Improved the GPU debugging tools to make it easier to diagnose simulation problems in real time.

Rewrote the core constraint solver with a new GPU pipeline architecture. This new approach splits the computation into prediction, conversion, and iteration stages for better stability and performance. Also cleaned up a significant amount of legacy code that was no longer needed.

Refined constraint grabbing, position-based dynamics, and visual relationship links. Improved debugging integration for constraint graph topology.

Replaced generic neighbor-search with domain-specific VOX (voxel-based spatial indexing) system with O(1) hash lookups and seamless collision integration.

Achieved 0.013ms filter execution by removing GPU-to-CPU mask transfer. Optimized particle-to-particle collision with spatial acceleration for millions of interactions per frame.

Completed central buffer management in gpu_device. Particles live exclusively in GPU VRAM with on-demand CPU access, achieving zero-copy architecture.

Merged Rust simulation engine into main project structure. Established workspace with neighbor-vox, bake, and gpu_particle crates for shared types and dependencies.

Migrated entire filtering system to GPU shaders in WGSL. Achieved sub-millisecond filter execution with zero CPU synchronization.

Eliminated all CPU particle data storage. Forced GPU-exclusive compute with CSR (Compressed Sparse Row) format for neighbor results. Major breaking change for massive performance gains.

Implemented CCD for high-speed particle impacts with real-world gravity validation. Solved the bullet-through-paper problem with swept collision detection.

Created headless sandbox framework with complete mock Blender API for testing without GUI, enabling fast iteration and CI/CD integration.

Migrated spatial queries to GPU using Z-Order (Morton) curves for neighbor finding. Designed transparent KDTree-compatible API for real-time multi-million particle simulation.

Introduced CustomAttributeNode allowing user-defined per-particle attributes and dynamic properties, integrated into baking and preview systems.

Extended object scanning to capture vertex colors and face corner data. Added random particle spawning from mesh vertices for refined emission patterns.

Implemented particle history tracking (tracer) for velocity-colored visualization and path animation support. Built for motion visualization and debugging.

Extended filter system to support multiple sequential filters on single node with unified interface, enabling complex particle transformations through stacked operations.

Overhauled emitter system with deterministic spawning and mesh deformation support. Introduced constraint node framework for verlet integration and particle linking.

Implemented SPH (Smoothed Particle Hydrodynamics) fluid system with Gaussian kernels, curl noise, turbulence, and vorticity for complete fluid simulation.

Enhanced simulation playback with frame-accurate scrubbing, object tracking in node trees, and improved cache management with performance profiling.

Added particle rotation tracking and morphing (shape interpolation) as first-class attributes, integrated into the node graph for advanced animation.

Refactored execution to single update loop with Arc/RwLock synchronization. Consolidated multi-threaded particle updates for improved stability and determinism.

Developed frame-based baking engine to pre-compute particle simulations. Added cache invalidation, UNDO/REDO support, and timeline scrubbing for Blender workflow.

Implemented Python FFI layer using PyO3 for Blender addon communication. Enabled bidirectional data exchange between Rust particle engine and Blender 3.x.

Built foundation for declarative, graph-based particle system workflows with nodes for emitters, forces, filters, and lifecycle management.

Implemented boid flocking behavior with collision avoidance and path following. Refactored force application to centralized queue pattern for extensibility.

Established foundational particle system architecture with basic physics, noise-driven movement, and Bevy GL visualization pipeline.