Simulation primitives

Abstract

In various embodiments, information defining a first set of simulation primitives and a second set of simulation primitives is received at one or more computer systems. A first simulator and a second simulator are provided, using one or more processors associated with the one or more computer systems. The first simulator is based on the first set of simulation primitives and produces a first simulation. The second simulator is based on the second set of simulation primitives and produces a second simulation. A data structure is generated, using the one or more processors associated with the one or more computer systems, wherein the data structure represents dependencies between the first simulation and the second simulation.

What is claimed is: 
     
       1. A computer-implemented method for simulating animation, the method comprising:
 receiving, at one or more computer systems, information defining a first set of simulation primitives and a second set of simulation primitives; 
 providing, using one or more processors associated with the one or more computer systems, a first simulator based on the first set of simulation primitives, wherein the first simulator produces a first simulation, and a second simulator based on the second set of simulation primitives, wherein the second simulator produces a second simulation; and 
 generating, using the one or more processors associated with the one or more computer systems, a dependency graph that represents dependencies between the first simulation and the second simulation, wherein the dependency graph includes information usable for determining that an output of the first simulation is an input to the second simulation; 
 updating, using the one or more processors associated with the one or more computer systems, a simulation primitive in the first set of simulation primitives; 
 determining, using the one or more processors associated with the one or more computer systems, that the second simulation depends on the first simulation based on the dependency graph; and 
 updating, using the one or more processors associated with the one or more computer systems, the second simulator to comply with a change in the output from the first simulation. 
 
     
     
       2. The computer-implemented method of  claim 1  wherein the set of simulation primitives comprises one or more bodies. 
     
     
       3. The computer-implemented method of  claim 1  wherein the set of simulation primitives comprises one or more colliders. 
     
     
       4. The computer-implemented method of  claim 1  wherein the set of simulation primitives comprises one or more forces. 
     
     
       5. The computer-implemented method of  claim 1  wherein the set of simulation primitives comprises one or more unified primitives. 
     
     
       6. The computer-implemented method of  claim 1 , wherein the second simulation depends upon the first simulation in the case where the second simulation uses a body of the first simulation as a collider or as a force. 
     
     
       7. The computer-implemented method of  claim 6 , the method further comprising ensuring that the first simulation is executed before the second simulation, wherein the output of the first simulation is used as an input to the second simulation. 
     
     
       8. The method of  claim 1 , wherein each of the first simulation and the second simulation comprises a computational process that requires time-integration. 
     
     
       9. The method of  claim 1 , wherein the first simulator and the second simulator comprise software and/or hardware. 
     
     
       10. The method of  claim 1 , wherein the first simulator and the second simulator are different. 
     
     
       11. A computer-implemented method for controlling simulators, the method comprising:
 receiving, at one or more computer systems, information identifying a first simulator and a second simulator; 
 receiving, at the one or more computer systems, information identifying a dependency graph that represents dependencies between a first simulation associated with the first simulator and a second simulation associated with the second simulator, wherein the dependency graph includes information usable for determining that an output of the first simulation is an input to the second simulation; 
 retrieving the first simulator, the second simulator, and the dependency graph from a non-transitory computer-readable medium; 
 loading into a memory the first simulator, the second simulator, and the dependency graph; 
 receiving, into the memory, function calls associated with the first simulator and the second simulator, wherein the function calls do not require specification of any simulator-specific information; 
 determining, using one or more processors associated with the one or more computer systems, that the second simulation depends on the first simulation based on the dependency graph; and 
 executing, using one or more processors associated with the one or more computer systems, the function calls, wherein executing the function calls comprises running the first simulation and the second simulation in an order that is specified by the dependency graph. 
 
     
     
       12. The method of  claim 11 , wherein executing the function calls comprises associating, using the memory and the one or more processors associated with the one or more computer systems, the results of the simulation with one or more animations. 
     
     
       13. The method of  claim 11 , wherein executing the function calls comprises generating simulation data, using the one or more processors associated with the one or more computer systems, while recording an animation. 
     
     
       14. The method of  claim 11 , wherein executing the function calls comprises re-computing, using the one or more processors associated with the one or more computer systems, dependencies in the dependency graph. 
     
     
       15. A non-transitory computer-readable medium storing computer-executable program code for simulating animation using a simulator-independent API, the computer-readable medium comprising:
 program code for receiving, at one or more computer systems, information identifying a first simulator and a second simulator; 
 program code for receiving, at the one or more computer systems, information identifying a dependency graph that represents dependencies between a first simulation associated with the first simulator and a second simulation associated with the second simulator, wherein the dependency graph includes information usable for determining that an output of the first simulation is an input to the second simulation; 
 program code for retrieving the first simulator, the second simulator, and the dependency graph from a non-transitory computer-readable medium; 
 program code for loading into a memory the first simulator, the second simulator, and the dependency graph; 
 program code for receiving, into the memory, function calls associated with the first simulator and the second simulator, wherein the function calls do not require specification of any simulator-specific information; 
 program code for determining, using one or more processors associated with the one or more computer systems, that the second simulation depends on the first simulation based on the dependency graph; and 
 program code for executing, using one or more processors associated with the one or more computer systems, the function calls, wherein executing the function calls comprises running the first simulation and the second simulation in an order that is specified by the dependency graph. 
 
     
     
       16. The non-transitory computer-readable medium of  claim 15 , wherein executing the function calls comprises associating, using the memory and the one or more processors associated with the one or more computer systems, the results of the simulation with one or more animations. 
     
     
       17. The non-transitory computer-readable medium of  claim 15 , wherein executing the function calls comprises generating simulation data, using the one or more processors associated with the one or more computer systems, while recording an animation. 
     
     
       18. The non-transitory computer-readable medium of  claim 15 , wherein executing the function calls comprises re-computing, using the one or more processors associated with the one or more computer systems, dependencies in the dependency graph. 
     
     
       19. A system for simulating animation, the system comprising:
 a processor; and 
 a memory configured to store a set of instructions to be executed by the processor, the set of instructions comprising:
 receiving information defining a first set of simulation primitives and a second set of simulation primitives; 
 providing a first simulator based on the first set of simulation primitives and a second simulator based on the second set of simulation primitives; and 
 generating a dependency graph that represents dependencies between the first simulator and the second simulator, wherein the dependency graph includes information usable for determining that an output of the first simulation is an input to the second simulation; 
 updating a simulation primitive in the first set of simulation primitives; 
 determining that the second simulation depends on the first simulation based on the dependency graph; and 
 updating the second simulator to comply with a change in the output from the first simulation. 
 
 
     
     
       20. The system of  claim 19 , wherein the set of simulation primitives comprises one or more of the group consisting of bodies, colliders, forces, and unified primitives. 
     
     
       21. The system of  claim 19 , wherein the second simulator depends upon the first simulator in the case where the second simulator incorporates a body of the first simulator as a collider or as a force. 
     
     
       22. The system of  claim 21 , wherein the memory is configured to store further instructions comprising ensuring that the first simulator is executed before the second simulator, wherein the output of the first simulator is used as an input to the second simulator.