1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
// Copyright 2017 Matthew Plant. This file is part of MGF. // // MGF is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // MGF is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with MGF. If not, see <http://www.gnu.org/licenses/>. //! A low-level 3D collision and physics library intended for use in 3D video //! game development. //! //! # Collision detection overview //! //! An object implements collision detection routines through the various traits //! provided by MGF. Each trait provides a disparate form of collision detection: //! //! - `Overlaps`: Specifies a collision where the only information required is //! whether or not two objects overlap. //! - `Contains`: Specifies a collision where one object completely contains //! another. For bounding volumes. //! - `Intersection`: For linear geometries, describes a collision at some time //! during the motion of a particle (represented with a Ray or Segment) with //! only one point of contact. //! - `Contacts`: For moving volumetric geometries, describes a collision with //! possibly multiple contacts occuring at some time during the motion of the //! geometries. //! - `LocalContacts`: Similar to `Contacts`, but returns contacts with local //! contact points as well as globals. //! //! In addition to these traits, MGF supports broad-phase colision detection //! through a bounding volume hierarch (`BVH`) //! //! # Physics resolution overview //! //! Types that satisfy the `PhysicsObject` trait can resolve collisions in //! accordance with the laws of classical mechanics. To do this it is //! recommended to generate a `Manifold` type and pass it to the resolution //! function. This method handles any geometry and number of contacts: //! //! ```rust //! use mgf::cgmath::{Vector3, Point3, Zero}; //! use mgf::{Sphere, RigidBody, LocalContacts, Manifold, PhysicsState, //! DefaultPhysConfig, Component, PhysicsObject, Shape}; //! //! const RESTITUTION: f32 = 1.0; //! const FRICTION: f32 = 0.0; //! //! let gravity = Vector3::new(0.0, -9.8, 0.0); //! //! let body_geom = vec![ //! Component::from(Sphere{ c: Point3::new(0.0, 0.0, 0.0), r: 1.0 }) //! ]; //! let body_masses = vec![ 1.0 ]; //! //! let mut rigid_body_a = RigidBody::new(RESTITUTION, FRICTION, gravity, //! body_geom, body_masses); //! // Since constructing a rigid body calculates the center of mass and the //! // inertia tensor for an object, it is more efficient to clone a rigid //! // body into a new one that shares the same geometry. //! let mut rigid_body_b = rigid_body_a.clone(); //! //! // Set the initial positions of the bodies //! rigid_body_a.set_pos(Point3::new(0.0, -5.0, 0.0)); //! rigid_body_b.set_pos(Point3::new(0.0, 5.0, 0.0)); //! //! // Apply an impulse to the bodies to set them in motion. //! rigid_body_a.apply_impulse( //! Vector3::new(5.0, 0.0, 0.0), // Linear impulse //! Vector3::zero() // Angular impulse //! ); //! rigid_body_b.apply_impulse(Vector3::new(-5.0, 0.0, 0.0), Vector3::zero()); //! //! // Integrate the bodies once per frame to produce the correct motion. //! rigid_body_a.integrate(1.0); //! rigid_body_b.integrate(1.0); //! //! let mut manifold = Manifold::new(); //! //! rigid_body_a.local_contacts(&rigid_body_b, |c|{ manifold.push(c); }); //! //! PhysicsState::resolve_manifold::<DefaultPhysConfig, _, _>( //! &mut rigid_body_a, //! &mut rigid_body_b, //! &manifold, //! 1.0 // The same timestep passed to integrate. //! ); //! ``` //! //! `DefaultPhysConfig` is a struct that passes various constants to the //! resolver. It does not incur any runtime penalty. #[macro_use] pub extern crate cgmath; extern crate smallvec; mod bvh; pub use bvh::*; mod bounds; pub use bounds::*; pub mod bitset; mod compound; pub use compound::*; mod collision; pub use collision::*; mod geom; pub use geom::*; mod manifold; pub use manifold::*; mod mesh; pub use mesh::*; mod physics; pub use physics::*; mod pool; pub use pool::*;