modeling the subject's reactions using a computer to simulate the physical interaction

Abstract

Modeling of reactions of objects using a computer to simulate physical interactions is disclosed. Specifically, when modeling contact between two or more objects (e.g., a robotic arm placing a block on a pile of blocks) or a series of linked connected articulations (e.g., modeling a digging shovel), current techniques can introduce extra energy into the system or fail to resolve constraints imposed on the system. Current techniques attempt to solve these problems, for example, by using very small time steps. However, very small time steps greatly increase the computational cost of the modeling simulation. The disclosed simulation system for rigid bodies uses time intervals to reduce linearization artifacts due to smaller time steps and reduce computational cost with faster solver convergence by allowing more efficient bias computation. High quality processing can also be improved with more efficient bias computation.

Description

TECHNICAL FIELD

[0001] The present application relates generally to linear or nonlinear constraint solver simulation systems, and more particularly to linear or nonlinear constraint solver simulation systems for modeling object interactions. BACKGROUND

[0002] Computers are used to simulate interactions between objects of an application, such as in a video game, where a user interacts with objects in a scene. However, it can be a challenging task to robustly, efficiently, and correctly simulate objects using a computer. Existing solutions often use constraints to compute the simulation in an attempt to correct for errors arising from the simulation.

[0003] For example, a rigid body solver simulation can be used to simulate contact or connection between two rigid bodies or entities. Rigid body solver simulations can result in errors, such as jitter and stutter, boxes swimming, and piles collapsing, when proper constraints are not used. These simulation errors can occur in several situations, such as when the mass difference between two objects is very high, if the angular velocity of one object is higher than the other object, if a relatively large time step is used, or if the simulation is performed on objects of a small size, such as toy-sized objects instead of human-sized objects.

[0004] Systems of linear or nonlinear constraint solvers, such as Jacobi and projected gauss seidel algorithms, can be used to define constraints on a simulation. These iterative solvers utilize the projection of object motion onto linear constraints to enforce contact, position, and angular constraints. However, these solvers can not fully constrain the simulation due to the nonlinearity of the motion of a rotating object at a point on its surface.

[0005] Another simulation error can occur when increasing the simulation speed. For example, running a simulation during gameplay can require the simulation to run at 60 Hertz (Hz) or higher to maintain a frame rate per second at an acceptable level. Conventional rigid body solvers can not account for the increased error that can occur at higher simulation speeds. SUMMARY

[0006] In one aspect, a method for iteratively solving a rigid body solver simulation is disclosed. In one embodiment, the method includes: (1) calculating a contact vector between a first object and a second object, and an impulse response vector between the first object and the second object, wherein the contact vector and the impulse response vector are determined using the first object as an origin; (2) accumulating a linear delta value and an angular delta value for each of the first object and the second object with a time interval value, wherein the time interval value is calculated using a number of solver iterations (N-iter) and a time step (dt); (3) updating a delta value with the contact vector, the impulse response vector, a linear delta value, and an angular delta value, wherein the linear delta value is accumulated with the linear delta value, and the angular delta value is accumulated with the angular delta value, and (4) iterating the rigid body solver N-iter times.

[0007] In another aspect, a computer program product having a series of operational instructions stored on a non-transitory computer readable medium that, when executed, direct a data processing apparatus to perform operations to generate results from a rigid body solver is disclosed. In one embodiment, the computer program product includes: (1) calculating a contact vector between a first object and a second object, and an impulse response vector between the first object and the second object, wherein the contact vector and the impulse response vector are determined using the first object as an origin, (2) accumulating a linear delta value and an angular delta value for each of the first object and the second object with a time interval value, wherein the time interval value is calculated using N-iter and dt, (3) updating a delta value with the contact vector, the impulse response vector, a linear delta value, and an angular delta value, wherein the linear delta value is accumulated with the linear delta value, and the angular delta value is accumulated with the angular delta value, (4) iterating the rigid body solver N times, wherein the iteration ends when a exit condition is met, (5) transmitting results, wherein the results are a set of parameters representative of the contact vector, the impulse vector, the delta value, and constraint parameters.

[0008] In another aspect, a rigid body solver system is disclosed. In one embodiment, the system includes: (1) a data receiver operable to receive an initial set of parameters for a rigid body simulation; (2) a data communicator operable to transmit a set of results; and (3) a processor operable to determine a time interval and a time step, operable to calculate an accumulation of a linear delta value and an angular delta value for two or more objects with the time interval and the time step, operable to update a delta value with the linear delta value and the angular delta value, and operable to generate the set of results with the rigid body solver, the time interval, the time step, a number of iterations, the delta value, and the initial set of parameters. BRIEF DESCRIPTION OF DRAWINGS

[0009] Reference will now be made to the following descriptions in conjunction with the accompanying drawings, wherein:

[0010] Figure 1FIG. 1 is an illustration of a graph of an example contact model simulation;

[0011] Figure 2 FIG. 1 is an illustration of a graph of an example contact model simulation;

[0012] Figure 3 FIG. 1 is an illustration of a graph of an example contact model simulation;

[0013] Figure 4 FIG. 1 is an illustration of a graph of an example contact model simulation;

[0014] Figure 5 FIG. 1 is an illustration of a graph of an example contact model simulation;

[0015] Figure 6 FIG. 1 is an illustration of a graph of an example contact model simulation;

[0016] Figure 7 FIG. 1 is an illustration of a graph of an example contact model simulation. DETAILED DESCRIPTION

[0017] Animating individual objects can be easily done manually. For example, it is not difficult to make an animation of a single box falling off the top of a stack of boxes. However, it can be difficult to make an animation of hundreds of boxes falling and a stack of boxes collapsing. To capture such a scene, computer simulations are typically used. This is especially true for real-time applications, such as games, where a user interacts with the objects in the scene and the user's interactions are unpredictable. A computer can simulate each object and the results that occur when the objects interact with each other. For example, objects can collide (e.g., two cars crash into each other), bounce off each other (e.g., a basketball bounces off the rim of a basketball hoop), break (e.g., a baseball goes through a window), or push one or the other in a new direction (e.g., billiard balls hit each other).

[0018] A computer can need to solve a lot of calculations to generate a simulation. Take the collision of a sword as an example. The speed at which the sword is swung, the strength of the character swinging the sword, the footing of the character, and the strength of the character's wrist are all factors that determine the outcome of the collision of the sword. The outcome can be that the sword moves in a particular direction, or that the sword is relatively stationary, but the character's feet slip in the mud. Combining the relevant motions and velocities (e.g., the velocity of an object in a particular direction) and other factors for each object in the model (e.g., simulating a person, a sword, a ground object, and other objects), and then quickly computing the results can be challenging.

[0019] Solving multiple calculations can take a significant amount of time, especially when there are more and more objects in the area of object interaction, the simulation becomes more complex. For example, a highly complex simulation can involve hundreds of different blades of grass and weeds interacting with a human foot as it slides across the ground, or can involve modeling hundreds of building girders and power line pylons in an earthquake. Existing processes, solvers, that are typically used to solve or resolve simulations of interacting objects can take a long time to get an answer. This is never good when swinging a sword in a video game. To speed up the process, a computer can simplify the simulation to reduce the amount of calculations needed. However, this can affect the quality of the simulation.

[0020] What is introduced herein is a new method of solving a simulation, using small time slice information to obtain results of objects interacting with each other. At each time slice, e.g., time interval, the simulation updates itself at a partial resolution. Then, the simulation parameters are updated using the partial resolution. The simulation parameters include the position of each object, its velocity / rate, and the direction of movement of the object. The simulation is executed again using the new parameters. This continues until all time slices / time intervals are used up. This new method of solving a simulation can provide more accurate simulation results without increasing the amount of time needed to generate the results.

[0021] Computer simulations can be performed in a test type of environment, e.g., testing a robotic arm for a spatial based robot task, or in an industrial environment, e.g., testing an industrial robot, such as a robotic arm that builds a car. Simulations can also be performed within an application as described above, e.g., a game, where a box is stacked on top of another, or a collision between two swords held by an avatar. Real time and near real time simulations can also be used in other situations, e.g., as part of a prosthetic limb to help a user control an arm without breaking a glass or an egg.

[0022] These simulations can be generalized to any system with linear or non-linear constraints, e.g., rigid body, particle, fluid, cloth, and soft body simulations. For the present disclosure, a rigid body solver will be used as an example. These simulations use a rigid body solver to determine what happens when a rigid body moves, interacts with other objects, and interacts with other parts of itself. Rigid body motion can be jointed simulations, i.e., a jointed body solver. For example, a jointed simulation can include modeling a robotic arm where a clasper (i.e., manipulator or hand) rotates and one part of the robotic arm is moved. Rigid body interaction can be contact simulations. For example, a contact simulation can involve modeling a stack of boxes on top of each other or the interaction of two colliding swords in a game. Rigid body interaction with other parts of itself can be articulation simulations. For example, an articulation simulation can be a backhoe that includes a main body, two-part arm segments, and a bucket. Each part of the articulation is a link. Motion of one or both of the arm segments also directly affects (e.g., controls) the motion of the bucket element.

[0023] Objects can be movable objects (e.g., vehicles, weapons, cloth, or fluids) or immovable objects that interact with movable objects (e.g., rock walls or buildings). Motion of each of these objects or parts thereof can be represented as linear motion and angular motion. Linear motion is motion in a straight line, usually expressed as a vector that represents the translational motion of the center of mass of a rigid body or link. Up, down, left, right, forward, backward motion are examples of linear motion. A backhoe can lift an arm segment, causing the segment to move in the simulation space. Angular motion is rotational motion. Rotating 90° (degrees) to the left is an example of angular motion. In the backhoe example above, angular motion also occurs when an arm segment is lifted. Since the arm segment is connected to the backhoe base, the arm segment must pivot on the joint between the backhoe and the arm segment when it is lifted. The pivot action is angular motion. The backhoe main body can be considered the center of mass (COM) of the object.

[0024] In rigid body simulations, each body has a well-defined COM, mass, and inertia tensor. These properties are often required for rigid body simulations. The COM defines the frame, i.e., point, about which rotation occurs. Mass can be a scalar that represents the relationship between linear velocity and linear momentum and between force and acceleration. The inertia tensor is a rotational equivalent of mass. It can be a 3x3 matrix that defines the relationship between angular velocity and angular momentum and between torque and angular acceleration. Rigid body simulations tend to exploit the inverse of these mass properties in computations, i.e., 1 / m and I -1 .

[0025] Articulation simulation extends this concept by computing a spatial inertia matrix for each link. These matrices can be 6x6 matrices that represent the mass and inertia of the articulation at each link. This matrix includes the rigid body mass / inertia of the link's body, in addition to the cumulative mass / inertia of the suspended loads, i.e. the mass / inertia of the child, grandchild, and any other links. The spatial inertia matrix is computed recursively from tip-to-root, where the spatial inertia of a link with no children is equal to its rigid body mass / inertia. Positional offsets between the connection anchor and the COM of the respective link are taken into account in these computations, so the spatial inertia also includes COM information. As with the rigid body simulation, the inverse of the spatial inertia can generally be used in most computations.

[0026] Simulations that include rigid body objects can use a rigid body solver to help perform the simulation modeling. Solvers, such as the Projected Gauss-Seidel (PGS) algorithm and the Jacobi algorithm, can take in a set of parameters related to the objects of the simulation, run a set of iterations using those parameters, and output an updated set of parameters. These parameters can include the position of each object being simulated, the linear velocity of each object, the angular velocity of each object, the connection positioning relative to other links in the object, and constraint information. Constraints are limitations that can be imposed on the simulation modeling. For example, a bucket on an excavator cannot move linearly independently of the arm segment it is attached to. Those two objects must move linearly together. The bucket can move angularly independently, i.e. rotate. Simulating a human elbow or knee requires restricting the motion between two arm or leg segments. Constraints are that they can generally bend in one direction, and can also rotate slightly.

[0027] PGS and Jacobi are two solvers that can solve the Jacobian (the constraint row, which can be stored in matrix form or vector form). The vector form can be more efficient to solve and take up less space, and requires specialized code for a given kind of constraint, while the matrix form can use general code to solve, to solve out different kinds of constraints. When the solvers perform their respective algorithms, they can introduce too much energy into the simulation when correcting errors (e.g. when an object is rotating at high speed). They can also introduce errors. This happens because existing solvers use linear analysis in their respective algorithms. Angular motion can have to be estimated. Fast angular velocities can also increase bias, because they can create more errors.

[0028] Existing solvers can be inefficient due to the position constraint of the joint, where the anchor position is offset from the COM of the respective body. In this case, the translational velocity of the joint bodies should be a circular arc centered at the joint position. These can become the tangents of the circular arc sampled at each time step. Integrating the tangents introduces error. Even when the constraints are successfully resolved by the linear solver, the integration error can still be introduced. Existing linear solvers can not handle non-linear relationships properly. When the time step is small enough or the angular velocity is small enough, integrating the tangents can match the ideal arc well, and thus, the error can be small. When the time step is large or the angular velocity is large, then integrating the tangents can deviate significantly from the ideal arc, resulting in error and separation.

[0029] Additionally, in some cases, existing rigid body solver algorithms can not resolve to a steady state. For example, they can not handle high mass ratios. Simulating small objects at requested speeds can be difficult. For some simulations, it can be acceptable to stack a cubic meter of cubes at 60 Hertz (Hz), while stacking a cubic centimeter of cubes at 60 Hz can cause the stack to be unstable. Long chains of joints (i.e., chains of connections) can increase the error at each joint.

[0030] Common workarounds for traditional rigid body solvers are: (1) increase the number of iterations; (2) step the simulation; (3) adjust the mass ratio; (4) simplify the inertia to ensure it is always diagonally dominant; (5) globally scale the inertia tensor to bias the impulses to produce more linear and less angular effects; (6) use joint projection to recover from larger errors; (7) limit angular velocity; (8) implement additional distance constraints to keep the system together. These workarounds can impose additional constraints on the simulation that would not normally occur and result in additional errors.

[0031] In some cases, the additional constraints can cause the solver to produce poor results. Stepping the simulation and running more solver iterations can be considered a solution to improve the solver. Techniques to change the mass properties can not be accurate enough for the simulation, as the results needed in the simulation should be as realistic as possible. Additionally, introducing additional constraints, such as distance constraints, can produce behavior similar to the physical world in some cases. The problem with additional constraints can be that it can be difficult to extract useful secondary information from the simulation, such as the force exerted at a joint, as additional artificial constraints are introduced to hold the system together. Secondary values can be used to extract meaningful information from the simulation, such as the force exerted on a spring, which can be used to measure the weight of an object, such as when implementing a mechanical scale using a rigid body solver.

[0032] The present disclosure demonstrates a nonlinear rigid body solver, Temporal Gauss-Seidel (TGS), which can have similar performance to traditional solvers. TGS can improve high mass ratio handling, simulate small objects, simulate long links with connections, and relatively fast angular velocities. The TGS solver iterates the solver with smaller time step values. The time step value can be a time period or a fraction of it (e.g., one tenth of a second) divided by the number of iterations (e.g., three). The solver then step throughs the simulation, in this example, with ~0.033 seconds per step. It can move each object with the parameters of each object (e.g., linear and angular velocities). It can apply the provided constraints and adjust the bias and update the simulation. The solver can then repeat these steps until the number of iterations is complete. TGS can also be applied as a general linear and nonlinear iterative solver outside of physical simulation, for example, for mixed linear complementarity problems (MLCP).

[0033] The TGS rigid body solver extends the PGS algorithm and can also resolve constraints and biases iteratively by advancing the rigid body solver with the time step value described above, applying it to the Jacobi algorithm. The time step can be identified with dt, and the specified number of iterations can be identified with N. The time step value is equal to dt divided by N, for example TGS can alleviate linearization artifacts and can establish biases that are proportional to the inverse of dt multiplied by N, for example

[0034] This can improve the convergence of TGS and provide better high mass ratio handling due to the stronger bias values. Additionally, the stability of the simulation can be improved due to the larger bias component or smaller error resulting from using smaller time steps, and the bias coefficient can be used to correct the bias, which is proportional to In simulations with stacked objects or where one object has a large mass relative to another, the bias can be a major factor in the constraints. Since the bias is proportional to the inverse of the time step, the rate of convergence of the solver will increase as the time step is decreased. This can produce better results compared to simulating contacts with large time steps and a large number of iterations.

[0035] Using a time step ratio can provide better convergence compared to utilizing smaller time steps by passing through the forces between the iterative time steps. This approach is similar to a warm start rigid body solver with the added benefit of reducing the energy introduced to correct for errors. In other aspects, better performance of velocity driven can be provided by integrating the velocity target to produce a bias from the second solver iteration, satisfying the velocity driven. In other aspects, some calculations can be pre-computed, reducing the number of calculations performed within each iteration of the rigid body solver.

[0036] In addition to the connection and contact simulation, another use of the rigid body solver is in the field of articulated simulation, such as a rigid body articulated solver. Featherstone's articulated body algorithm (ABA) is a common algorithm. ABA can produce energy by using Coriolis and centrifugal terms, which can introduce forces proportional to the square of the velocity. As the velocity increases, energy can be introduced if the integrator used is not very accurate. A common solution is to heavily dampen the simulation to reduce the energy gained. Damping can cause the simulation to differ from the analytical model, which means that the accuracy can be reduced and thus can not be suitable for industrial simulations. As described herein, adaptive time steps can be used to mitigate the energy gain in the simulation to produce acceptable results without significantly increasing the simulation cost.

[0037] The motion and pose of a link in an articulation can be defined using the velocity and position (angle) stored in the connection frame, which can define the relative orientation and velocity between a parent link and a child link. Articulations do not directly support closed loops, but supplemental code is needed to handle loops, contacts, and constraints. Unlike the implicit constraints in a kinematic tree, these loop constraints can be violated and can require correction of the error. These loop constraints, constraints, and contacts can be solved using a traditional rigid body solver, which allows them to interact with other articulations, traditional rigid bodies, and other simulation actors in the simulation.

[0038] The motion of an articulation can be defined relative to a root link, which can be free or fixed. When fixed, the root link is an immovable object and the motion of the link is entirely defined by the velocity of the connection space. These velocities can be integrated into the connection position (angle), which can be used to define the relative pose between a parent link and a child link.

[0039] When the root link is free, the motion of the link can utilize the motion of the root link, which is integrated like a free rigid body. In addition to the root link, the link can follow a non-linear trajectory behavior due to the way the angle (i.e., the offset) is integrated with the connection velocity, while the root link follows a path defined by its linear velocity vector and angular velocity vector. For example, this can cause problems when using a position constraint to connect the link. This behavior can be acceptable if a position constraint is used to connect the root link, for example, to implement a pickup in a game engine. If the picked-up link is not the root link, the connection solver can fail to fully satisfy the constraint because the motion caused by the impulse applied by the solver does not follow the predictable linear path assumed by a linear constraint solver.

[0040] Furthermore, when integrating the root link (whose integration is linear), the error introduces more error at the anchor position (i.e., the connection point between the first object and the second object). The accumulation of error leads to energy introduction into the system. This accumulation of error can be overcome by using very small time steps in the simulation. This greatly increases the computational cost of the simulation.

[0041] Contact simulation using TGS occurs when a rigid body comes into contact with a second rigid body (see, e.g., Figure 1 ). For example, a robotic arm touches a box, or places one box on top of a second box. Since the velocities of the rigid bodies tend to be slower compared to their respective masses in the case of linear solvers that can produce simulation errors, the contact simulation can use coarser approximations. Stacking and piling motions are representative contact simulations. The tangent velocities used by the linear solver at the contact point can produce the desired rolling behavior for contacts with friction. In this case, linearization artifacts do not affect the simulation. The results can be very close to the desired behavior, so there is no need to change the model to a nonlinear model for the velocities at the contact point.

[0042] Contact simulation can be achieved by pre-computing the Jacobian vector and the impulse response vector. In alternative aspects, the Jacobian vector and the impulse response vector can be the same vector when the angular velocity is stored proportionally to the square root of the inertia tensor.

[0043] Equation 1: Example angular velocity ratio when the Jacobian vector and the impulse response vector are the same vector

[0044]

[0045] where ω is the angular velocity, and I is the inertia tensor of the rigid body.

[0046] In contact simulation, the time step ratio can be exploited by accumulating the linear and angular increments of the first and second rigid bodies involved in the contact. The linear and angular increments are initialized to zero vectors. After each iteration is completed, i.e., after the constraints are solved, the accumulation step is performed (see, e.g., Figure 2 ).

[0047] Equation 2: Linear and angular increment accumulation example

[0048]

[0049] where Δp i is the linear increment of rigid body i,

[0050] v i is the linear velocity of rigid body i,

[0051] Δθ iis the angular increment of rigid body i,

[0052] ω i is the angular velocity of rigid body i.

[0053] The linear and angular increments computed in equation 2 can be used to update the bias component. Bias update can utilize example equation 3.

[0054] Equation 3: Example of updating bias

[0055]

[0056] where N lin is the normal vector, i.e. normal vector,

[0057] Δp0and Δp1are the linear increments of the first and second rigid bodies, respectively,

[0058] raXnIis the current angular offset from the COM of the first rigid body,

[0059] rbXnIis the current angular offset from the COM of the second rigid body,

[0060] Δθ0and Δθ1are the angular increments of the first and second rigid bodies, respectively.

[0061] Alternatively, for contacts that share the same normal, the dot product of the linear increments of the first rigid body can be constant. Thus, this part of equation 3 can be pre-computed and the result treated as a constant for bias update computation. For example, (Δp0- Δp1) can be computed prior to the input of the TGS iteration loop and its resulting value can be treated as a constant in equation 3.

[0062] When a rigid body has a common connection with a second rigid body, a connection simulation using the rigid body solver occurs (see, e.g., Figure 3 ). For example, a robotic arm where the hand and arm are connected. In the case where the two rigid bodies change velocity slowly relative to their respective masses, the connection simulation can use the rigid body solver similar to the contact simulation. When the velocity is higher, for example when one of the rigid bodies is shaking or rotating, a more refined approximation can be needed. For example, a robotic arm rotating a stick. This example can result in the velocity of the object changing proportionally higher compared to the mass of the object, where the proportionality is higher than what the contact simulation can handle.

[0063] On the basis of the contact simulation, the connection simulation can also include a process of computing new bias values with updated position constraints and updated angular constraints (see, e.g., Figure 4 ). The bias values can be added to the position constraints and angular constraints as shown in equation 4.

[0064] Equation 4: Example of updating bias using position constraints and angular constraints

[0065] Bias = Bias + PositionConstraint

[0066] Bias = Bias + AngleConstraint

[0067] PositionConstraint utilizes the dot product of the linear delta values of the first and second rigid bodies, and the dot product of the angular position change of each of the first and second rigid bodies. As shown in Equation 5.

[0068] Equation 5: PositionConstraint calculation example

[0069] PositionConstraint

[0070] = (p0 · Δp0) - (p1 · Δp1) + ((cur_r0 - init_r0) · θ0)

[0071] - ((cur_r1 - init_r1) · θ1) + τ * accum_dt

[0072] where cur_r0 and cur_r1 are the current offset vectors from the respective COMs of the first and second rigid bodies to the respective anchor positions. The anchor positions can be the joint positions or the contact positions,

[0073] init_r0 and init_r1 are the initial offset vectors from the respective first and second rigid bodies,

[0074] τ is the target velocity,

[0075] accum_dt is the accumulated elapsed time at the point of the iteration being evaluated.

[0076] AngleConstraint utilizes the dot product of the angular delta values of the first and second rigid bodies with the current angular positions, and the target velocity and the accumulated dt. As shown in Equation 6.

[0077] Equation 6: AngleConstraint calculation example

[0078] AngleConstraint = (θ0 · Δθ0) - (θ1 · Δθ1) + τ * accum_dt

[0079] Additionally, the connection rows can be orthogonal. The constraints can be ordered so that the angular lock axis constraints appear before other axis constraints, e.g., non-angular lock axis constraints. The position constraints are orthogonal to the angular lock axis. Since the r0 and r1 vectors of the position update are used with the position constraints, the other constraints can be orthogonalized during the constraint preparation phase. Due to the non-linear nature of the articulation, it cannot be guaranteed that the change in linear velocity of the link caused by a force in a particular direction is the same as the direction of the force. The same is true for torque. Therefore, when simulating articulation, it is not possible to orthogonalize the constraints to guarantee that the Jacobian rows are independent. Orthogonalization can improve solver convergence with the TGS solver when simulating rigid bodies. Due to the incompatibility between orthogonalization and articulation, it can not be performed when simulating articulation.

[0080] In addition to the contact and connection simulations discussed above, the TGS solver can be applied to articulation simulation. Articulation simulation can occur when two or more rigid bodies are attached and move. For example, a simulation of an excavator, where there is an excavator body, two arm sections, and a bucket section. Each excavator component controls the motion of the attached next component, which moves away from the COM of the rigid body, which is the excavator body. For example, the excavator body can influence the motion of the first arm section. The first arm section can influence the motion of the second arm section, and the second arm section can influence the bucket section. The present disclosure proposes a method to address the deficiencies of existing solvers for articulation simulation. Energy accumulation due to Coriolis and centrifugal forces can be addressed without reducing the accuracy of the simulation, nor impacting the use of inverse dynamics to drive the simulation, compared to analytical models. Furthermore, the simulation can limit the introduction of excessive energy when addressing external constraints that influence non-root links.

[0081] Articulation simulation with the TGS solver can be achieved by solving the TGS solver with optional damping and velocity clamps (i.e., constraints) as described above, which are treated with forces to ensure constant internal state of the articulation. When there are external constraints, the system will start calculating the velocity of each component of the articulation from the root link since it influences the rest of the links. With a time step value, each link in the articulation can be stepped forward, and the position and velocity of each link can be recalculated. This approach can mitigate the deficiencies of the PGS solver. In the PGS solver algorithm, where constraints interact with non-root links, the linear approximation of motion expected by the PGS solver does not match the non-linear motion produced by the non-root links.

[0082] Turning now to the drawings, Figure 1is an illustration of a diagram of an example contact model simulation 100. The contact model simulation 100 shows contact between two rigid bodies, a block and a stack of blocks. The contact model simulation 100 includes a robotic arm 110 that holds a block 120. The block 120 is placed on top of a stack of blocks 124. An element 126 identifies the point of contact, i.e., the contact patch, between the block 120 and the stack of blocks 124. A TGS solver can be used to produce results, i.e., updated positions, velocities, and constraints, for the block 120 and the stack of blocks 124.

[0083] Figure 2 is an illustration of a flowchart of an example method 200 for resolving a contact model simulation. The method 200 starts at step 201 and proceeds to step 205. At step 205, the bias can be initialized to a default value, such as the value of the velocity target. The use of a velocity target can improve the execution force of the velocity driver, thereby improving the convergence to a solution. Proceeding to step 210, the linear bias can be calculated using the initialized bias value. The linear bias can utilize the linear delta value and the angular delta value shown in Equation 3. A portion of the linear bias calculation can be pre-computed prior to step 201, and the pre-computed value can be treated as a constant when calculating the linear bias. Proceeding to step 215, the contact vector and the impulse response vector between the two rigid bodies can be calculated. In some aspects, the contact vector and the impulse response vector can be the same vector, such as storing the angular velocity as a proportion of the inertia tensor of the rigid body. When the same vector, one of the contact vector or the impulse response vector will need to be calculated.

[0084] At step 220, the solver can resolve the constraint equations, i.e., the algorithm. The constraint equations represent the objects and the constraints on their motion in the simulation system. For example, one object can not be able to move below the surface of another object, such as the ground. These constraint equations can be the same or different for each simulation that is being solved. At step 225, the linear delta value and the angular delta value for each rigid body can be updated by calculating the time interval portion of the change in position (for linear delta) and angular velocity (for angular delta). Equation 2 shows an example algorithm for updating the linear delta value and the angular delta value. The time interval is used to distribute the respective linear and angular velocities on the respective linear (Apj) and angular (A0i) delta accumulators. Proceeding to step 230, the bias can be updated with the updated linear and angular deltas. The bias update can be shown again using equation 3. In iteration, the linear and angular deltas have been updated in step 225. Further, the updated current angular offset of the first and second rigid bodies has been determined in step 220. The method 200 returns to step 220 for N iterations of the solver step. Upon completion of N iterations, the method 200 ends at step 250. In another aspect, the method 200 can exit earlier than N iterations if the solver detects that the changes in position and velocity are below a target level, that is, a level of convergence has been reached and further iterations are unlikely to significantly improve the convergence.

[0085] Figure 3 is an illustration of a diagram of an example connection model simulation 300. The connection model simulation 300 illustrates connection motion between two connected rigid bodies. The connection model simulation 300 includes a robotic mechanism 305, a robotic arm 310, and a gripper 315. Between the robotic arm 310 and the gripper 315 is a connection 320. The connection 320 can undergo various types of motion, for example, from one side to the other, rotation, and other combinations of motion. The TGS solver can generate results for the connection motion between the two rigid bodies (the robotic arm 310 and the gripper 315).

[0086] Figure 4 is an illustration of a flowchart of an example method 400 for solving a connection model simulation. The method 400 begins at step 401 and proceeds to step 405. At step 405, the bias can be initialized to the value of the velocity target. Utilizing the velocity target can improve the execution force of the velocity driven, thereby increasing the convergence to the solution. At step 410, the linear bias can be computed. The linear bias can utilize the linear and angular deltas shown in equation 3. A portion of the linear bias computation can be pre-computed prior to step 401, and the pre-computed value can be treated as a constant when computing the linear bias. At step 415, the non-position constraints can be made orthogonal. The constraints can be ordered so that the angular lock axis constraints are evaluated prior to other axes. The orthogonalization can reduce the time to achieve target solver convergence.

[0087] Proceeding to step 420, the position constraints can be orthonormalized. The position constraints are typically orthonormalized with respect to the angular lock axes. Since the r0 and r1 vectors are used with the position constraints, the non-position constraints are orthonormalized prior to the position constraints. Proceeding to step 425, the contact response vector and impulse response vector can be calculated. In some aspects, the contact vector and impulse response vector can be the same vector, such as storing the angular velocity as a proportion of the inertia tensor of the rigid body. When the same vector, one of the contact vector or impulse response vector will need to be calculated.

[0088] In step 430, the order of the position constraints and the angular constraints can be determined. The position constraint algorithm is indicated by equation 5, where the position is calculated from the current relative offset from the original anchor position of each rigid body. Each respective offset is modified by the time interval proportion. The angular constraint algorithm is indicated by equation 6, where the angular offset from the original anchor position is calculated using the time interval proportion. In step 435, the line constraints and the angular constraints are orthonormalized. Similar to steps 415 and 420, the constraints can be orthonormalized to use fewer iterations to improve solver convergence speed.

[0089] In step 440, the constraint equations and equations can be resolved. The constraint equations represent the objects and the constraints on their motion in the simulation system. For example, an object can not be able to move below the surface of another object, such as the ground. These constraint equations can be the same or different for each simulation that is being solved. In step 445, the line delta values and the angular delta values can be updated with the proportion of the respective line change and angular change proportional to the time interval value. Equation 2 indicates an example algorithm for updating the line delta values and the angular delta values. The time interval is used to distribute the respective linear velocity and angular velocity on the respective line delta value (Ap i ) and angular delta value (A0 i ) accumulators.

[0090] In step 450, the offset vectors can be recalculated. This can be represented as a rotation of the offset vectors with the angular delta values. In equation 5, the current rotated offset vectors are represented as cur_r0 and cur_r1. The offset vectors are indicated with the quaternion unit vectors to indicate the angular change due to the change of the first object affecting the second object. Proceeding to step 455, the bias can be updated with the values calculated above. The bias update can be demonstrated again using equation 3. In this iteration, the line delta values and the angular delta values have been updated in step 445. Furthermore, the updated current angular offsets of the first and second rigid bodies have been determined in step 450.

[0091] Method 400 can return to step 435 and repeat the steps of method 400 for N iterations. Method 400 can also exit before N iterations are complete if the change in value is below a target level. For example, if additional iterations will not significantly improve the result parameter. When no further iterations are processed, the method proceeds to step 490 and ends.

[0092] Figure 5 is an illustration of a diagram of an example articulated model simulation 500. Articulated model simulation 500 shows the articulated motion between 4 rigid bodies that are linked together. Articulated model simulation 500 includes a robot base 505, a first arm portion 510, a second arm portion 515, and a gripper 520. Robot base 505 can be considered the root link of articulated model simulation 500. Robot base 505 can be fixed, for example in the classic robotics case, or free, for example in the Featherstone articulated case. First arm portion 510 is attached to robot base 505 at anchor point 511. Second arm portion 515 is attached to first arm portion at anchor point 516. Gripper 520 is attached to second arm portion at anchor point 521. First arm portion 510, second arm portion 515, and gripper 520 are non-root links of articulated model simulation 500. If first arm portion 510 moves, second arm portion 515 and gripper 520 also move positionally and angularly. A TGS solver can generate results for articulated model simulation 500.

[0093] Figure 6 is an illustration of a flowchart of an example method 600 for resolving articulated model simulations. Method 600 can be used to mitigate the articulated problem at the interaction of constraints with non-root links. Method 600 starts at step 601 and proceeds to step 605. At step 605, a step-wise unconstrained velocity solver computation is generated on the set of articulated links. Step 605 can be performed similar to method 200 and can be used to overcome instability due to Coriolis forces caused by inaccurate computation.

[0094] Proceeding to step 610, the solver result from step 605 can be modified by constraining the unconstrained velocity values and introducing constraint clamping on the solver, then re-generating the solver result. These additional constraints can be handled with forces to ensure that the internal state of the articulation remains in a consistent state. This can help to minimize the number of sub-steps required for computation. Step 610 is an optional step. In many robotics cases, the velocities are low enough that a single step of 60Hz can be used for stabilization. Coriolis forces are proportional to the square of the velocity, so as the velocity gets large, step-wise or clamping / damping becomes a more important step to include in the solver method.

[0095] Proceeding to step 615, a final unconstrained pose for the articulated link can be generated. Due to the limitations of the articulated simulation, the rigid body articulation can be calculated at the final state. Proceeding to decision step 620, if there are no external constraints, the method ends at step 680. If there are external constraints, the method 600 proceeds to step 625. External constraints can be factors that prevent the articulation from moving exactly as requested. For example, on a simulation, the movement of a robotic arm in a weightless environment will be different than the movement of a robotic arm on the surface of the Earth where gravity provides an external constraint to the simulation. Other examples can include movement underwater, or whether there is another object such as a ceiling or wall that obstructs the path of the articulation.

[0096] In step 625, an approximate velocity of the root link is calculated. The velocity can be estimated using the pose difference of the root link. The root link can be fixed (i.e., immovable), or free. The root link is the relative root of the articulation for the current iteration of the simulation. Each link of the articulation can be considered the root link during the iteration of the respective link. Since the root link influences the remaining links in the articulation, it should be evaluated before the remaining links. In step 630, the velocity of the non-root links can be estimated using the difference in joint angles, which are then projected through the joint motion matrix. The non-root velocities can be used to calculate adjustments to the linear and angular delta values. In step 635, the joint velocities can be recalculated using the joint constraints. This can be added to the current joint velocities, and the delta changes are integrated into the joint position parameters. Since the offsets are integrated from the joint velocities, the links can follow a non-linear orbital path.

[0097] Proceeding to step 640, the articulated link can be advanced through the time interval values in steps. In this regard, the value of N is the number of iterations of velocity delta produced using the constraint correction impulses. In step 645, the joint and contact biases can be recalculated as part of the TGS algorithm. The linear biases use the linear and angular delta values shown in equation 3. A portion of the linear bias calculation can be pre-computed prior to step 601, and the pre-computed values can be treated as constants when calculating the linear biases. The method 600 can return to step 625 for N iterations. After N iterations or if the exit condition is true, the method 600 proceeds to step 680 and ends.

[0098] As Figure 2As described in step 215, optimization requires a vector that is possible under the constraints between rigid bodies. For constraints that affect a hinge, the spatial inertia matrix can not be a linear projection of velocity, so an auxiliary response vector can be needed to define the change in linear and angular velocity that the constraint will produce. The response vector cannot be computed directly using the mass properties of the hinge effectively. For each Jacobian, they can be computed indirectly by propagating an impulse of size 1 through the hinge in the direction of the Jacobian row of the constraint. The velocity change produced by these impulses can be recorded. From this, the unit response value can be computed by projecting the response vector onto the original Jacobian. The unit response can be multiplied by the desired change in velocity in the direction of the Jacobian to produce the size of the impulse force needed to achieve that change. The response vector can be stored so that it can be scaled by the size of the force applied to compute the change in velocity that will be affected by the applied force.

[0099] The concept equivalent for a rigid body collision can be computed using the closed form rigid body equations shown in equation 7.

[0100] Equation 7: Impulse propagation example for a rigid body collision

[0101]

[0102] where m0and m1are the masses of the first and second rigid bodies, respectively,

[0103] raXnand rbXnare the offsets from the COM to the contact or connection location of the first and second rigid objects, respectively,

[0104] raXnI0 -1 and rbXnI1 -1 are the offsets from the COM multiplied by the inverse of the inertia tensor of the first and second rigid bodies, respectively.

[0105] Equation 7 can produce an equivalent scalar impulse response value for a pair of rigid bodies. When the constraint contains a mix of rigid bodies and hinges, equation 7 will be used to compute the response of the rigid body components, while the impulse propagation method will be used to compute the response of the hinges.

[0106] The impulse response vector for a hinged link is different from that of a rigid body because it can not be in the same direction as the Jacobian vector. This is different from a rigid body simulation where the response to an impulse is projected exactly on the Jacobian direction. When a large portion of the impulse response vector for a hinged link is not projected on the Jacobian, then a linear solver like PGS can accumulate large errors. If smaller time steps are not used, the simulation can become unstable. The TGS solver, with its constantly adjusted constraints, can identify the increasing errors and adjust the bias to correct the errors. In addition, the TGS can update the velocities to account for the non-linear motion of the links around the connections, resulting in less error and a more stable simulation.

[0107] Figure 7 FIG. 1 is an illustration of an example rigid body solver system 700. The system 700 can receive a set of rigid body solver parameters and can return results of the parameter set, including updated positions, velocities, and constraints of a rigid body model. The solver system 700 includes a simulator 705, a rigid body solver system 710, and a simulator 740. The rigid body solver system 710 includes a data receiver 720, data and application storage 725, a processor 730, and a data communicator 735, each of which is communicatively coupled to another.

[0108] The simulator 705 can be a computing system, a portion of a computing system, an application, an application module, a subsystem, a simulator, a portion of a mechanical device, and a local storage medium, such as a memory, a hard drive, a server, a portable memory stick, a CD, a DVD, and other storage media. In alternative aspects, the simulator 705 can be located at a distance from the rigid body solver system 710, such as a data center, a cloud environment, and other locations separate from the simulator 705. The simulator 705 is a source of rigid body parameters for the rigid body solver system 710.

[0109] The data receiver 720 of the rigid body solver system 710 is capable of receiving rigid body parameters. The data receiver 720 can store the rigid body parameters in the data and application storage 725 and provide it directly to the processor 730. The data and application storage 725 can be various storage media, such as a processor register, a cache memory, a local memory, and other storage media.

[0110] The processor 730 can generate a result parameter with the rigid body parameters. The processor 730 can execute the TGS solver using one or more of the different method forms 200, 400, and 600 or combinations thereof. The result parameter can be stored in the data and application memory 725 and transmitted directly to other systems. The processor 730 can then indicate to the data communicator 735 that the result parameter from the processor 730 or from the data and application memory 725 can be sent to the simulator 740. The simulator 740 can be the same simulator as the simulator 705, e.g., the simulator 705 requests the solver to generate a result and returns the result to the simulator 705. In another aspect, the simulator 740 can be a different simulator than the simulator 705.

[0111] The rigid body solver system 710 can be one or more processors and chips and can be part of another processing system. The rigid body solver system 710 can be part of a computing system and can be encapsulated in an application library, e.g., part of an application, a subroutine, a dll, or other software component. The rigid body solver system 710 can be implemented in a graphics processing unit, a central processing unit, and other processing systems.

[0112] A portion of the above-described apparatus, system, or method can be embodied in or performed by various digital data processors or computers, which can be programmed or store executable program sequences of software instructions to perform one or more steps of the method. The software instructions of such programs can represent algorithms and be encoded on non-transitory digital data storage media, such as magnetic or optical disks, random access memory (RAM), magnetic hard disks, flash memories, and / or read only memories (ROM), to enable various types of digital data processors or computers to perform one or more or all of the steps of one or more of the above-described methods or functions, systems, or apparatuses described herein.

[0113] Portions of the disclosed embodiments can relate to computer storage products with a non-transitory computer-readable medium having stored thereon program code that is used to program computing devices to perform various computer-implemented operations. The program code embodied on the non-transitory computer-readable medium is used to program computing devices to perform a number of operations described herein. Non-transitory, as used herein, is merely to denote that the computer-readable medium is not a transitory propagating signal. Examples of non-transitory computer-readable media include, but are not limited to: magnetic media such as hard disks, floppy disks, and magnetic tape; optical media such as CD-ROM disks; magneto-optical media such as optical disks; and hardware devices that are specially configured to store and perform program code, such as ROM and RAM devices. Examples of program code include both machine code produced by a compiler and higher level code that is executed by an interpreter.

[0114] In interpreting this disclosure, all terminology should be construed in the broadest possible manner consistent with the context. In particular, the terms "comprises" and "comprising" should be interpreted as referring to elements, components, or steps in a non-exclusive manner, indicating that the referenced elements, components, or steps can be present, utilized, or combined with other elements, components, or steps not expressly referenced.

[0115] Those skilled in the art related to the present application will appreciate that other and further additions, deletions, substitutions, and modifications can be made to the described embodiments. It is also to be understood that the terminology used herein is for the purpose of describing particular embodiments only, and is not intended to be limiting, as the scope of the present disclosure will only be limited by the claims. Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this disclosure belongs. Although any methods and materials similar or equivalent to those described herein can also be used in the practice or testing of the present disclosure, a limited number of the exemplary methods and materials are described herein.

[0116] Note that, as used herein and in the appended claims, the singular forms "a", "an", and "the" include plural referents unless the context clearly dictates otherwise.

Claims

1. A method for simulating analytical rigid body solvers, comprising: Calculate the contact vector between the first object and the second object, and the impulse response vector between the first object and the second object, wherein the contact vector and the impulse response vector are determined using the first object as the origin; For each of the first object and the second object, the line increment value and the angle increment value are accumulated using a time interval value, wherein the time interval value is calculated using the number of iterations N-iter of the solver and the time step dt; The deviation value is updated using the contact vector, the impulse response vector, the line deviation value, and the angle deviation value, wherein the line deviation value is calculated using the line increment value, and the angle deviation value is calculated using the angle increment value; and The rigid body solver is iterated N-iter times.

2. The method according to claim 1, further comprising: The line increment value is calculated using the time interval value and the line velocity; as well as The angular increment value is calculated using the time interval value and the angular velocity.

3. The method according to claim 2, further comprising: The line deviation value is calculated using the first dot product of the normal vector relative to the first object and the line increment value; The angle deviation value is calculated using the second dot product of the first offset vector and the angle increment value, and the third dot product of the second offset vector and the second angle increment value. Wherein, the first offset vector is offset from the centroid COM of the first object to the first anchor position, and the second offset vector is offset from the COM of the second object to the second anchor position; as well as The deviation value is recalculated using the line deviation value, the angle deviation value, and the dt.

4. The method according to claim 2, wherein, The contact vector and the impulse response vector are the same vector, and the method further includes: The angular velocity is calculated using the second angular velocity of the first object and the square root of the inverse inertia tensor of the first object.

5. The method according to claim 1, wherein, The line deviation value is calculated before the iteration and remains unchanged during the iteration, wherein the first object and the second object have the same normal vector.

6. The method according to claim 1, wherein, The deviation value is initialized using the velocity target value.

7. The method according to claim 1, wherein, The iteration ends when the exit condition is met.

8. The method according to claim 1, wherein, The rigid body solver is a rigid body connection solver, and the method further includes: before updating the deviation value, Rotate the current first offset vector and the current second offset vector using the angular increment value; Calculate angular and positional constraints; and Add the position constraint and the angle constraint to the deviation value.

9. The method according to claim 8, wherein, The angular constraint is calculated using the first dot product of the first current angular velocity of the first object and the first angular increment value of the first object, the second dot product of the second current angular velocity of the second object and the second angular increment value of the second object, the current velocity target value, and the accumulated dt.

10. The method according to claim 8, The positional constraints are calculated using the following method: The first dot product of the first current linear velocity of the first object and the linear increment value of the first object; The second dot product of the second current linear velocity of the second object and the linear increment value of the second object; The third dot product of the current first offset vector minus the initial first offset vector and the first current angular velocity of the first object; The fourth dot product of the current second offset vector minus the initial second offset vector and the second current angular velocity of the second object; Current speed target; as well as Cumulative dt; as well as Wherein, the current first offset vector and the initial first offset vector are vectors from the first COM of the first object to the first anchor position, and the current second offset vector and the initial second offset vector are vectors from the second COM of the second object to the second anchor position.

11. The method of claim 8, further comprising: The position constraints and the angular constraints are sorted, wherein the angular locking axis constraints are sorted before the non-angular locking axis constraints.

12. The method of claim 11, further comprising: The position constraint is orthogonalized using the angle-locked axis constraint.

13. The method of claim 11, further comprising: Orthogonalize the non-positional constraints before iterating the rigid body connection solver.

14. The method according to claim 1, wherein, The rigid body solver is a rigid body hinge solver, and also includes: Before performing the calculations, intermediate results are generated using a step-by-step unconstrained velocity solver; Wherein, the first object is the first link of the hinge model, the second object is the second link of the hinge model, and the first link is the root link; and The accumulation of the angular increment values ​​utilizes unconstrained velocity values.

15. The method of claim 14, further comprising: The intermediate results are modified using velocity constraints and decay constraints.

16. The method of claim 14, wherein an external constraint exists, the method further comprising: The root link velocity value is approximated by the estimated velocity derived from the attitude difference of the root link; The non-root link velocity value of the second link is approximated by the difference in the connection angles projected by the connection motion matrix; For each of the first link and the second link, the adjustment of the line increment value and the angle increment value is calculated using the root link speed value and the non-root link speed value; The rigid body hinge solver is stepped according to the time interval value; as well as The deviation value is recalculated using the line increment value and the angle increment value.

17. The method according to claim 16, wherein, There is more than one non-root link, and the approximate non-root link speed and the computational adjustment utilize each of the non-root links.

18. A computer program product having a series of operation instructions stored on a non-transitory computer-readable medium, the operation instructions, when executed, instruct a data processing device to perform operations to generate results from a rigid body solver, the operations including: Calculate the contact vector between the first object and the second object, and the impulse response vector between the first object and the second object, wherein the contact vector and the impulse response vector are determined using the first object as the origin; For each of the first object and the second object, the line increment value and the angle increment value are accumulated using a time interval value, wherein the time interval value is calculated using the number of iterations N-iter of the solver and the time step dt; The deviation value is updated using the contact vector, the impulse response vector, the line deviation value, and the angle deviation value, wherein the line deviation value is calculated using the line increment value, and the angle deviation value is calculated using the angle increment value; The rigid body solver is iterated N-iter times, wherein the iteration ends when an exit condition is met; and The results are transmitted, wherein the results represent a set of parameters representing the contact vector, the impulse response vector, the deviation value, and the constraint parameters.

19. The computer program product according to claim 18, wherein, The rigid body solver is a rigid body connection solver, and the operation further includes: before updating the deviation value, Rotate the current first offset vector and the current second offset vector using the angular increment value; Calculate angular and positional constraints; Add the position constraint and the angular constraint to the deviation value; and The parameter set mentioned therein includes connection positioning parameters.

20. The computer program product of claim 19, wherein the operation further comprises: The position constraints are orthogonalized using angle-locked axis constraints.

21. The computer program product according to claim 18, wherein, The rigid body solver is a rigid body hinge solver, and the operation further includes: Before performing the calculations, intermediate results are generated using a step-by-step unconstrained velocity solver; Wherein, the first object is the first link of the hinge model, the second object is the second link of the hinge model, and the first link is the root link; and The accumulation of the angular increment value utilizes the unconstrained velocity value.

22. The computer program product according to claim 21, wherein, Given the existence of external constraints, the operation further includes: The root link velocity value is approximated by the estimated velocity derived from the attitude difference of the root link; The non-root link velocity value of the second link is approximated by the difference in the connection angles projected by the connection motion matrix; For each of the first link and the second link, the changes in the line increment value and the angle increment value are calculated using the root link speed value and the non-root link speed value; The rigid body hinge solver is stepped according to the time interval value; and The deviation value is recalculated using the line increment value and the angle increment value.

23. A rigid body solver system, comprising: A data receiver operable to receive an initial parameter set for rigid body simulation, the initial parameter set including a contact vector and an impulse response vector between two of two or more objects, wherein the contact vector and the impulse response vector are determined using a first of the two or more objects as the origin; A data communicator capable of transmitting result sets; as well as The processor is operable to determine a time interval and a time step, operable to calculate the sum of line increment values ​​and angular increment values ​​of the two or more objects using the time interval and the time step, operable to update the deviation value using the line increment value and the angular increment value, and operable to generate the result set using a rigid body solver, the time interval, the time step, the number of iterations, the deviation value, and the initial parameter set.

24. The rigid body solver system according to claim 23, wherein, The result set includes one or more of the updated speed, updated constraints, and updated connectivity.

25. The rigid body solver system according to claim 23, wherein, The rigid body solver is encapsulated in the application library.

26. The rigid body solver system according to claim 23, wherein, The processor is a graphics processing unit.

Images