Soft-body dynamics

Last updated

Soft-body dynamics is a field of computer graphics that focuses on visually realistic physical simulations of the motion and properties of [[deformation (engineering)|deformable objects (or soft bodies). [1] The applications are mostly in video games and films. Unlike in simulation of rigid bodies, the shape of soft bodies can change, meaning that the relative distance of two points on the object is not fixed. While the relative distances of points are not fixed, the body is expected to retain its shape to some degree (unlike a fluid). The scope of soft body dynamics is quite broad, including simulation of soft organic materials such as muscle, fat, hair and vegetation, as well as other deformable materials such as clothing and fabric. Generally, these methods only provide visually plausible emulations rather than accurate scientific/engineering simulations, though there is some crossover with scientific methods, particularly in the case of finite element simulations. Several physics engines currently provide software for soft-body simulation. [2] [3] [4] [5] [6] [7]

Contents

Softbody objects react to forces and are able to collide with other 3D objects. This example has been created with Blender.

Deformable solids

The simulation of volumetric solid soft bodies [8] can be realised by using a variety of approaches.

Spring/mass models

Two nodes as mass points connected by a parallel circuit of a spring and a damper. Two nodes as mass points connected by parallel circuit of spring and damper.svg
Two nodes as mass points connected by a parallel circuit of a spring and a damper.

In this approach, the body is modeled as a set of point masses (nodes) connected by ideal weightless elastic springs obeying some variant of Hooke's law. The nodes may either derive from the edges of a two-dimensional polygonal mesh representation of the surface of the object, or from a three-dimensional network of nodes and edges modeling the internal structure of the object (or even a one-dimensional system of links, if for example a rope or hair strand is being simulated). Additional springs between nodes can be added, or the force law of the springs modified, to achieve desired effects. Applying Newton's second law to the point masses including the forces applied by the springs and any external forces (due to contact, gravity, air resistance, wind, and so on) gives a system of differential equations for the motion of the nodes, which is solved by standard numerical schemes for solving ODEs. [9] Rendering of a three-dimensional mass-spring lattice is often done using free-form deformation, [10] in which the rendered mesh is embedded in the lattice and distorted to conform to the shape of the lattice as it evolves. Assuming all point masses equal to zero one can obtain the Stretched grid method aimed at several engineering problems solution relative to the elastic grid behavior. These are sometimes known as mass-spring-damper models. In pressurized soft bodies [11] spring-mass model is combined with a pressure force based on the ideal gas law.

Finite element simulation

This is a more physically accurate approach, which uses the widely used finite element method to solve the partial differential equations which govern the dynamics of an elastic material. The body is modeled as a three-dimensional elastic continuum by breaking it into a large number of solid elements which fit together, and solving for the stresses and strains in each element using a model of the material. [12] The elements are typically tetrahedral, the nodes being the vertices of the tetrahedra (relatively simple methods exist [13] [14] to tetrahedralize a three dimensional region bounded by a polygon mesh into tetrahedra, similarly to how a two-dimensional polygon may be triangulated into triangles). The strain (which measures the local deformation of the points of the material from their rest state) is quantified by the strain tensor . The stress (which measures the local forces per-unit area in all directions acting on the material) is quantified by the Cauchy stress tensor . Given the current local strain, the local stress can be computed via the generalized form of Hooke's law: where is the elasticity tensor, which encodes the material properties (parametrized in linear elasticity for an isotropic material by the Poisson ratio and Young's modulus).

The equation of motion of the element nodes is obtained by integrating the stress field over each element and relating this, via Newton's second law, to the node accelerations.

Pixelux (developers of the Digital Molecular Matter system) use a finite-element-based approach for their soft bodies, using a tetrahedral mesh and converting the stress tensor directly into node forces. [15] Rendering is done via a form of free-form deformation. [10]

Energy minimization methods

This approach is motivated by variational principles and the physics of surfaces, which dictate that a constrained surface will assume the shape which minimizes the total energy of deformation (analogous to a soap bubble). Expressing the energy of a surface in terms of its local deformation (the energy is due to a combination of stretching and bending), the local force on the surface is given by differentiating the energy with respect to position, yielding an equation of motion which can be solved in the standard ways. [16] [17]

Shape matching

In this scheme, penalty forces or constraints are applied to the model to drive it towards its original shape [18] (i.e. the material behaves as if it has shape memory). To conserve momentum the rotation of the body must be estimated properly, for example via polar decomposition. To approximate finite element simulation, shape matching can be applied to three dimensional lattices and multiple shape matching constraints blended. [19]

Rigid-body based deformation

Deformation can also be handled by a traditional rigid-body physics engine, modeling the soft-body motion using a network of multiple rigid bodies connected by constraints, and using (for example) matrix-palette skinning to generate a surface mesh for rendering. This is the approach used for deformable objects in Havok Destruction. [20]

Cloth simulation

In the context of computer graphics, cloth simulation refers to the simulation of soft bodies in the form of two dimensional continuum elastic membranes, that is, for this purpose, the actual structure of real cloth on the yarn level can be ignored (though modeling cloth on the yarn level has been tried). [21] Via rendering effects, this can produce a visually plausible emulation of textiles and clothing, used in a variety of contexts in video games, animation, and film. It can also be used to simulate two dimensional sheets of materials other than textiles, such as deformable metal panels or vegetation. In video games it is often used to enhance the realism of clothed animated characters.

Cloth simulators are generally based on mass-spring models, but a distinction must be made between force-based and position-based solvers.

Force-based cloth

The mass-spring model (obtained from a polygonal mesh representation of the cloth) determines the internal spring forces acting on the nodes at each timestep (in combination with gravity and applied forces). Newton's second law gives equations of motion which can be solved via standard ODE solvers. To create high resolution cloth with a realistic stiffness is not possible however with simple explicit solvers (such as forward Euler integration), unless the timestep is made too small for interactive applications (since as is well known[ citation needed ], explicit integrators are numerically unstable for sufficiently stiff systems). Therefore, implicit solvers must be used, [22] requiring solution of a large sparse matrix system (via e.g. the conjugate gradient method), which itself may also be difficult to achieve at interactive frame rates. An alternative [23] [24] is to use an explicit method with low stiffness, with ad hoc methods to avoid instability and excessive stretching (e.g. strain limiting corrections).

Position-based dynamics

To avoid needing to do an expensive implicit solution of a system of ODEs, many real-time cloth simulators (notably PhysX, Havok Cloth, and Maya nCloth) use position based dynamics (PBD), [25] an approach based on constraint relaxation. The mass-spring model is converted into a system of constraints, which demands that the distance between the connected nodes be equal to the initial distance. This system is solved sequentially and iteratively, by directly moving nodes to satisfy each constraint, until sufficiently stiff cloth is obtained. This is similar to a Gauss-Seidel solution of the implicit matrix system for the mass-spring model. Care must be taken though to solve the constraints in the same sequence each timestep, to avoid spurious oscillations, and to make sure that the constraints do not violate linear and angular momentum conservation. Additional position constraints can be applied, for example to keep the nodes within desired regions of space (sufficiently close to an animated model for example), or to maintain the body's overall shape via shape matching.

Collision detection for deformable objects

Realistic interaction of simulated soft objects with their environment may be important for obtaining visually realistic results. Cloth self-intersection is important in some applications for acceptably realistic simulated garments. This is challenging to achieve at interactive frame rates, particularly in the case of detecting and resolving self collisions and mutual collisions between two or more deformable objects.

Collision detection may be discrete/a posteriori (meaning objects are advanced in time through a pre-determined interval, and then any penetrations detected and resolved), or continuous/a priori (objects are advanced only until a collision occurs, and the collision is handled before proceeding). The former is easier to implement and faster, but leads to failure to detect collisions (or detection of spurious collisions) if objects move fast enough. Real-time systems generally have to use discrete collision detection, with other ad hoc ways to avoid failing to detect collisions.

Detection of collisions between cloth and environmental objects with a well defined "inside" is straightforward since the system can detect unambiguously whether the cloth mesh vertices and faces are intersecting the body and resolve them accordingly. If a well defined "inside" does not exist (e.g. in the case of collision with a mesh which does not form a closed boundary), an "inside" may be constructed via extrusion. Mutual- or self-collisions of soft bodies defined by tetrahedra is straightforward, since it reduces to detection of collisions between solid tetrahedra.

However, detection of collisions between two polygonal cloths (or collision of a cloth with itself) via discrete collision detection is much more difficult, since there is no unambiguous way to locally detect after a timestep whether a cloth node which has penetrated is on the "wrong" side or not. Solutions involve either using the history of the cloth motion to determine if an intersection event has occurred, or doing a global analysis of the cloth state to detect and resolve self-intersections. Pixar has presented a method which uses a global topological analysis of mesh intersections in configuration space to detect and resolve self-interpenetration of cloth. [26] Currently, this is generally too computationally expensive for real-time cloth systems.

To do collision detection efficiently, primitives which are certainly not colliding must be identified as soon as possible and discarded from consideration to avoid wasting time. To do this, some form of spatial subdivision scheme is essential, to avoid a brute force test of primitive collisions. Approaches used include:

Other applications

Other effects which may be simulated via the methods of soft-body dynamics are:

Simulating fluids in the context of computer graphics would not normally be considered soft-body dynamics, which is usually restricted to mean simulation of materials which have a tendency to retain their shape and form. In contrast, a fluid assumes the shape of whatever vessel contains it, as the particles are bound together by relatively weak forces.

Software supporting soft body physics

Simulation engines

EngineWebsiteLicenseDescription
Bullet http://bulletphysics.org zlib license
Carbon http://numerion-software.com Proprietary
CryEngine 3 http://mycryengine.com Non-free
Digital Molecular Matter http://pixelux.com Proprietary
Havok Cloth http://havok.com Non-free
Houdini https://www.sidefx.com/products/houdini/ Proprietary Procedural generation & VFX software - soft-body FEM, cloth simulation (Vellum)
Maya nCloth http://autodesk.com/maya Non-free
OpenCloth https://github.com/mmmovania/opencloth ?A collection of source codes implementing cloth simulation algorithms as well as soft body dynamics in OpenGL.
OpenTissue http://opentissue.org zlib license
Physics Abstraction Layer http://www.adrianboeing.com/pal/index.html 3-clause BSD license Uniform API, supports multiple physics engines.
PhysX http://developer.nvidia.com/physx Non-free
Phyz http://phyz.ath.cx Public domain
Simulation Open Framework Architecture http://www.sofa-framework.org/ GNU Lesser General Public License v2.1+
Source Engine https://developer.valvesoftware.com Proprietary Supports the use of simulated hair and cloth physics. [33]
Step http://edu.kde.org/step/ GNU General Public License v2
SyFlex http://syflex.biz Non-free
Torque https://torque3d.org/torque3d/ MIT License
Unreal Engine https://unrealengine.com Proprietary
Vega FEM https://viterbi-web.usc.edu/~jbarbic/vega/ 3-clause BSD license
Blender (software) https://www.blender.org/ GNU General Public License v2
Ziva VFX http://zivadynamics.com Proprietary Character simulation software - FEM muscles, fat, skin and cloth

Games

GameWebsiteLicenseDescription
BeamNG.drive http://beamng.com Non-freeCommercial sandbox-esque game based on soft-body vehicle physics. Simulates the vehicles' structure rather than its operation.
Crash Effects Inc. https://www.crasheffects.com/ Non-freeVehicle construction / first person crash test simulator. Soft-body physics are implemented for superstructures, some vehicle components use simple damage modeling.
Rigs of Rods https://rigsofrods.github.io GNU General Public License v3Free and open source vehicle simulator.
Wreckfest http://nextcargame.com Non-freeDerby racing game. Soft-body physics are implemented for superstructures, but parts and components (e.g. the engine) use simple damage modeling.

See also

Related Research Articles

Collision detection is the computational problem of detecting an intersection of two or more spatial objects, commonly computer graphics objects. It has applications in various computing fields, primarily in computer graphics, computer games, computer simulations, robotics and computational physics. Collision detection is a classic problem of computational geometry. Collision detection algorithms can be divided into operating on 2D or 3D spatial objects.

In physics and materials science, elasticity is the ability of a body to resist a distorting influence and to return to its original size and shape when that influence or force is removed. Solid objects will deform when adequate loads are applied to them; if the material is elastic, the object will return to its initial shape and size after removal. This is in contrast to plasticity, in which the object fails to do so and instead remains in its deformed state.

Autodesk 3ds Max, formerly 3D Studio and 3D Studio Max, is a professional 3D computer graphics program for making 3D animations, models, games and images. It is developed and produced by Autodesk Media and Entertainment. It has modeling capabilities and a flexible plugin architecture and must be used on the Microsoft Windows platform. It is frequently used by video game developers, many TV commercial studios, and architectural visualization studios. It is also used for movie effects and movie pre-visualization. 3ds Max features shaders, dynamic simulation, particle systems, radiosity, normal map creation and rendering, global illumination, a customizable user interface, and its own scripting language.

<span class="mw-page-title-main">LS-DYNA</span>

LS-DYNA is an advanced general-purpose multiphysics simulation software package developed by the former Livermore Software Technology Corporation (LSTC), which was acquired by Ansys in 2019. While the package continues to contain more and more possibilities for the calculation of many complex, real world problems, its origins and core-competency lie in highly nonlinear transient dynamic finite element analysis (FEA) using explicit time integration. LS-DYNA is used by the automobile, aerospace, construction and civil engineering, military, manufacturing, and bioengineering industries.

Dynamical simulation, in computational physics, is the simulation of systems of objects that are free to move, usually in three dimensions according to Newton's laws of dynamics, or approximations thereof. Dynamical simulation is used in computer animation to assist animators to produce realistic motion, in industrial design, and in video games. Body movement is calculated using time integration methods.

<span class="mw-page-title-main">Physics engine</span> Software for approximate simulation of physical systems

A physics engine is computer software that provides an approximate simulation of certain physical systems, such as rigid body dynamics, soft body dynamics, and fluid dynamics, of use in the domains of computer graphics, video games and film (CGI). Their main uses are in video games, in which case the simulations are in real-time. The term is sometimes used more generally to describe any software system for simulating physical phenomena, such as high-performance scientific simulation.

<span class="mw-page-title-main">Blender Game Engine</span> Discontinued game engine

The Blender Game Engine was a free and open-source 3D production suite used for making real-time interactive content. It was previously embedded within Blender, but support for it was dropped in 2019, with the release of Blender 2.8. The game engine was written from scratch in C++ as a mostly independent component, and includes support for features such as Python scripting and OpenAL 3D sound.

<span class="mw-page-title-main">Mesh generation</span> Subdivision of space into cells

Mesh generation is the practice of creating a mesh, a subdivision of a continuous geometric space into discrete geometric and topological cells. Often these cells form a simplicial complex. Usually the cells partition the geometric input domain. Mesh cells are used as discrete local approximations of the larger domain. Meshes are created by computer algorithms, often with human guidance through a GUI, depending on the complexity of the domain and the type of mesh desired. A typical goal is to create a mesh that accurately captures the input domain geometry, with high-quality (well-shaped) cells, and without so many cells as to make subsequent calculations intractable. The mesh should also be fine in areas that are important for the subsequent calculations.

In materials science, hardness is a measure of the resistance to localized plastic deformation, such as an indentation or a scratch (linear), induced mechanically either by pressing or abrasion. In general, different materials differ in their hardness; for example hard metals such as titanium and beryllium are harder than soft metals such as sodium and metallic tin, or wood and common plastics. Macroscopic hardness is generally characterized by strong intermolecular bonds, but the behavior of solid materials under force is complex; therefore, hardness can be measured in different ways, such as scratch hardness, indentation hardness, and rebound hardness. Hardness is dependent on ductility, elastic stiffness, plasticity, strain, strength, toughness, viscoelasticity, and viscosity. Common examples of hard matter are ceramics, concrete, certain metals, and superhard materials, which can be contrasted with soft matter.

<span class="mw-page-title-main">Crash simulation</span> Virtual recreation of a destructive car crash

A crash simulation is a virtual recreation of a destructive crash test of a car or a highway guard rail system using a computer simulation in order to examine the level of safety of the car and its occupants. Crash simulations are used by automakers during computer-aided engineering (CAE) analysis for crashworthiness in the computer-aided design (CAD) process of modelling new cars. During a crash simulation, the kinetic energy, or energy of motion, that a vehicle has before the impact is transformed into deformation energy, mostly by plastic deformation (plasticity) of the car body material, at the end of the impact.

<span class="mw-page-title-main">Bullet (software)</span> Open-source physics engine

Bullet is a physics engine which simulates collision detection as well as soft and rigid body dynamics. It has been used in video games and for visual effects in movies. Erwin Coumans, its main author, won a Scientific and Technical Academy Award for his work on Bullet. He worked for Sony Computer Entertainment US R&D from 2003 until 2010, for AMD until 2014, for Google until 2022 and he now works for Nvidia.

<span class="mw-page-title-main">Meshfree methods</span> Methods in numerical analysis not requiring knowledge of neighboring points

In the field of numerical analysis, meshfree methods are those that do not require connection between nodes of the simulation domain, i.e. a mesh, but are rather based on interaction of each node with all its neighbors. As a consequence, original extensive properties such as mass or kinetic energy are no longer assigned to mesh elements but rather to the single nodes. Meshfree methods enable the simulation of some otherwise difficult types of problems, at the cost of extra computing time and programming effort. The absence of a mesh allows Lagrangian simulations, in which the nodes can move according to the velocity field.

Interactive skeleton-driven simulation is a scientific computer simulation technique used to approximate realistic physical deformations of dynamic bodies in real-time. It involves using elastic dynamics and mathematical optimizations to decide the body-shapes during motion and interaction with forces. It has various applications within realistic simulations for medicine, 3D computer animation and virtual reality.

The material point method (MPM) is a numerical technique used to simulate the behavior of solids, liquids, gases, and any other continuum material. Especially, it is a robust spatial discretization method for simulating multi-phase (solid-fluid-gas) interactions. In the MPM, a continuum body is described by a number of small Lagrangian elements referred to as 'material points'. These material points are surrounded by a background mesh/grid that is used to calculate terms such as the deformation gradient. Unlike other mesh-based methods like the finite element method, finite volume method or finite difference method, the MPM is not a mesh based method and is instead categorized as a meshless/meshfree or continuum-based particle method, examples of which are smoothed particle hydrodynamics and peridynamics. Despite the presence of a background mesh, the MPM does not encounter the drawbacks of mesh-based methods which makes it a promising and powerful tool in computational mechanics.

<span class="mw-page-title-main">Phyz</span>

Phyz is a public domain, 2.5D physics engine with built-in editor and DirectX graphics and sound. In contrast to most other real-time physics engines, it is vertex based and stochastic. Its integrator is based on a SIMD-enabled assembly version of the Mersenne Twister random number generator, instead of traditional LCP or iterative methods, allowing simulation of large numbers of micro objects with Brownian motion and macro effects such as object resonance and deformation.

In computational fluid dynamics, the immersed boundary method originally referred to an approach developed by Charles Peskin in 1972 to simulate fluid-structure (fiber) interactions. Treating the coupling of the structure deformations and the fluid flow poses a number of challenging problems for numerical simulations. In the immersed boundary method the fluid is represented in an Eulerian coordinate system and the structure is represented in Lagrangian coordinates. For Newtonian fluids governed by the Navier–Stokes equations, the fluid equations are

<span class="mw-page-title-main">Simulation Open Framework Architecture</span> Open source framework primarily targeted at real-time physical simulation

Simulation Open Framework Architecture (SOFA) is an open source framework primarily targeted at real-time physical simulation, with an emphasis on medical simulation.

The applied element method (AEM) is a numerical analysis used in predicting the continuum and discrete behavior of structures. The modeling method in AEM adopts the concept of discrete cracking allowing it to automatically track structural collapse behavior passing through all stages of loading: elastic, crack initiation and propagation in tension-weak materials, reinforcement yield, element separation, element contact and collision, as well as collision with the ground and adjacent structures.

Physically based animation is an area of interest within computer graphics concerned with the simulation of physically plausible behaviors at interactive rates. Advances in physically based animation are often motivated by the need to include complex, physically inspired behaviors in video games, interactive simulations, and movies. Although off-line simulation methods exist to solve most all of the problems studied in physically-based animation, these methods are intended for applications that necessitate physical accuracy and slow, detailed computations. In contrast to methods common in offline simulation, techniques in physically based animation are concerned with physical plausibility, numerical stability, and visual appeal over physical accuracy. Physically based animation is often limited to loose approximations of physical behaviors because of the strict time constraints imposed by interactive applications. The target frame rate for interactive applications such as games and simulations is often 25-60 hertz, with only a small fraction of the time allotted to an individual frame remaining for physical simulation. Simplified models of physical behaviors are generally preferred if they are more efficient, easier to accelerate, or satisfy desirable mathematical properties. Fine details are not important when the overriding goal of a visualization is aesthetic appeal or the maintenance of player immersion since these details are often difficult for humans to notice or are otherwise impossible to distinguish at human scales.

<span class="mw-page-title-main">Asynchronous multi-body framework</span> Robotic simulator

Asynchronous multi-body framework (AMBF) is an open-source 3D versatile simulator for robots developed in April 2019. This multi-body framework provides a real-time dynamic simulation of multi-bodies such as robots, free bodies, and multi-link puzzles, paired with real-time haptic interaction with various input devices. The framework integrates a real surgeon master console, haptic or not, to control simulated robots in real-time. This feature results in the simulator being used in real-time training applications for surgical and non-surgical tasks. It offers the possibility to interact with soft bodies to simulate surgical tasks where tissues are subject to deformations. It also provides a Python Client to interact easily with the simulated bodies and train neural networks on real-time data with in-loop simulation. It includes a wide range of robots, grippers, sensors, puzzles, and soft bodies. Each simulated object is represented as an afObject; likewise, the simulation world is represented as an afWorld. Both utilize two communication interfaces: state and command. Through the State command, the object can send data outside the simulation environment, while the Command allows to apply commands to the underlying afObject.

References

  1. ↑ Nealen, Müller, Keiser, Boxerman & Carlson (2005). "Physically Based Deformable Models in Computer Graphics". CiteSeerX   10.1.1.124.4664 .{{cite web}}: Missing or empty |url= (help)CS1 maint: multiple names: authors list (link)
  2. ↑ "Numerion Software - Carbon Physics".
  3. ↑ "PhysX soft bodies". 24 February 2014.
  4. ↑ "Pixelux's Digital Molecular Matter (DMM)". Archived from the original on 2009-09-21. Retrieved 2010-03-07.
  5. ↑ "Havok Cloth". Archived from the original on 2012-02-29. Retrieved 2010-03-07.
  6. ↑ "Bullet Physics".
  7. ↑ "Maya Nucleus".
  8. ↑ "Doc:2.4/Manual/Physics/Soft Bodies 2.46 - BlenderWiki". wiki.blender.org. Archived from the original on 2015-11-04. Retrieved 2015-09-19.
  9. ↑ Desbrun, Schroder & Barr (1999). "Interactive animation of structured deformable objects" (PDF).
  10. 1 2 Sederberg & Parry (1986). "Free-Form Deformation of Solid Geometric Models" (PDF).
  11. ↑ Matyka & Ollila (2003). "A pressure model for soft body simulation" (PDF).
  12. ↑ Kaufmann, Martin, Botsch & Gross (2008). "Flexible Simulation of Deformable Models Using Discontinuous Galerkin FEM" (PDF).{{cite web}}: CS1 maint: multiple names: authors list (link)
  13. ↑ Spillmann, Wagner & Teschner (2006). "Robust Tetrahedral Meshing of Triangle Soups" (PDF).
  14. ↑ Bridson, Teran, Molino & Fedkiw (2003). "Adaptive Physics Based Tetrahedral Mesh Generation Using Level Sets" (PDF).{{cite web}}: CS1 maint: multiple names: authors list (link)
  15. 1 2 Parker & O'Brien (2009). "Real-Time Deformation and Fracture in a Game Environment".
  16. ↑ Terzopoulos, Platt, Barr & Fleischer (1987). "Elastically Deformable Models" (PDF).{{cite web}}: CS1 maint: multiple names: authors list (link)
  17. ↑ Wardetzky, Bergou, Harmon, Zorin & Grinspun (2007). "Discrete Quadratic Curvature Energies" (PDF).{{cite web}}: CS1 maint: multiple names: authors list (link)
  18. 1 2 Müller, Heidelberger, Teschner & Gross (2005). "Meshless Deformations Based on Shape Matching" (PDF).{{cite web}}: CS1 maint: multiple names: authors list (link)
  19. ↑ Steinemann, Otaduy & Gross (2008). "Fast Adaptive Shape Matching Deformations". Archived from the original on 2011-01-10. Retrieved 2010-03-08.
  20. ↑ "Havok Destruction". Archived from the original on 2010-02-21. Retrieved 2010-03-07.
  21. ↑ Kaldor, James & Marschner (2008). "Simulating Knitted Cloth at the Yarn Level" (PDF).
  22. ↑ Baraff & Witkin (1998). "Large Steps in Cloth Simulation" (PDF).
  23. ↑ Provot (1997). "Collision and self-collision handling in cloth model dedicated to design garments". CiteSeerX   10.1.1.89.9232 .{{cite web}}: Missing or empty |url= (help)
  24. ↑ Bridson, Fedkiw & Anderson (2002). "Robust Treatment of Collisions, Contact and Friction for Cloth Animation" (PDF).
  25. ↑ Müller, Heidelberger, Hennix & Ratcliff (2006). "Position Based Dynamics" (PDF).{{cite web}}: CS1 maint: multiple names: authors list (link)
  26. ↑ Baraff, Witkin & Kass (2003). "Untangling Cloth" (PDF).
  27. ↑ Van Den Bergen (1998). "Efficient Collision Detection of Complex Deformable Models using AABB Trees" (PDF).
  28. ↑ Teschner, Heidelberger, Müller, Pomeranets & Gross (2003). "Optimized Spatial Hashing for Collision Detection of Deformable Objects" (PDF).{{cite web}}: CS1 maint: multiple names: authors list (link)
  29. ↑ Steinemann, Otaduy & Gross (2006). "Fast Arbitrary Splitting of Deforming Objects" (PDF).
  30. ↑ Müller, Keiser, Nealen, Pauly, Gross & Alexa (2004). "Point Based Animation of Elastic, Plastic and Melting Objects" (PDF).{{cite web}}: CS1 maint: multiple names: authors list (link)
  31. ↑ Selle, Lentine & Fedkiw (2008). "A Mass Spring Model for Hair Simulation". Archived from the original on 2009-12-14. Retrieved 2010-03-07.
  32. ↑ "When Will Virtual Surgery Make the Cut?". Scientific American. 2007.
  33. ↑ "$jigglebone". developer.valvesoftware. Retrieved 4 August 2022.
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.