Struct PhysicsWorld 

pub struct PhysicsWorld {

    pub weather: Weather,
    pub integrator: Integrator,
    pub solver: ConstraintSolver,
    pub spatial_hash: SpatialHash,
    pub collision_events: Vec<CollisionEvent>,
    pub trigger_events: Vec<TriggerEvent>,
    pub fracture_events: Vec<FractureEvent>,
    pub fracture_cache: PreFracturedCache,
    pub joints: Vec<Joint>,
    pub joint_solver: JointSolver,
    pub gravity_fields: Vec<GravityField>,
    pub fluid_zones: Vec<FluidZone>,
    pub accumulator: f32,
    pub render_alpha: f32,
    pub metrics: PhysicsMetrics,
    pub entities: Vec<Entity>,
    pub rigid_bodies: Vec<RigidBody>,
    pub transforms: Vec<Transform>,
    pub velocities: Vec<Velocity>,
    pub colliders: Vec<Collider>,
    pub entity_index_map: HashMap<u32, usize>,
    pub is_paused: bool,
    pub step_once: bool,
    pub rewind_requested: bool,
    pub history: VecDeque<PhysicsStateSnapshot>,
    pub max_history_frames: usize,
    pub watchlist: HashSet<Entity>,
    /* private fields */
}

Main physics world that manages all physics simulation

Fields

weather: Weather

integrator: Integrator

solver: ConstraintSolver

spatial_hash: SpatialHash

collision_events: Vec<CollisionEvent>

trigger_events: Vec<TriggerEvent>

fracture_events: Vec<FractureEvent>

fracture_cache: PreFracturedCache

joints: Vec<Joint>

joint_solver: JointSolver

gravity_fields: Vec<GravityField>

fluid_zones: Vec<FluidZone>

accumulator: f32

render_alpha: f32

metrics: PhysicsMetrics

entities: Vec<Entity>

rigid_bodies: Vec<RigidBody>

transforms: Vec<Transform>

velocities: Vec<Velocity>

colliders: Vec<Collider>

entity_index_map: HashMap<u32, usize>

is_paused: bool

step_once: bool

rewind_requested: bool

history: VecDeque<PhysicsStateSnapshot>

max_history_frames: usize

watchlist: HashSet<Entity>

Implementations

impl PhysicsWorld

pub fn new() -> PhysicsWorld

pub fn with_gravity(self, gravity: Vec3) -> PhysicsWorld

pub fn enable_gpu_compute(&mut self)

pub fn with_cell_size(self, cell_size: f32) -> PhysicsWorld

pub fn add_body( &mut self, entity: Entity, rb: RigidBody, t: Transform, v: Velocity, c: Collider, )

pub fn clear_bodies(&mut self)

pub fn sync_bodies<'a>( &mut self, incoming_bodies: impl Iterator<Item = &'a (Entity, RigidBody, Transform, Velocity, Collider)>, )

pub fn remove_body_at(&mut self, idx: usize)

pub fn step(&mut self, dt: f32) -> Result<(), GizmoError>

Ana fizik adımı — sabit 120Hz sub-stepping ile Render dt’yi (değişken) sabit iç fizik dt’ye dönüştürür.

pub fn collision_events(&self) -> &[CollisionEvent]

Get collision events from last step

pub fn trigger_events(&self) -> &[TriggerEvent]

Get trigger events from last step

pub fn apply_impulse( &self, rb: &RigidBody, transform: &Transform, vel: &mut Velocity, impulse: Vec3, point: Vec3, )

Apply an impulse to a body at a point

pub fn apply_force( &self, rb: &RigidBody, vel: &mut Velocity, force: Vec3, dt: f32, )

Apply a force to a body

pub fn raycast(&self, ray: &Ray, max_distance: f32) -> Option<RaycastHit>

Perform a raycast against all bodies

pub fn raycast_all(&self, ray: &Ray, max_distance: f32) -> Vec<RaycastHit>

Perform a raycast and return all hits

pub fn trigger_snapshot(&self, reason: &str)

Telemetry and Debugging: Create a JSON snapshot of the physical world state

pub fn calculate_total_energy(&self) -> f32

Calculate total kinetic and potential energy of the simulation

Trait Implementations

impl Default for PhysicsWorld

fn default() -> PhysicsWorld

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PhysicsWorld

fn deserialize<__D>( __deserializer: __D, ) -> Result<PhysicsWorld, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PhysicsWorld

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.