Where to Put Your Code: Update(), Flush() or Render()
The world script has a number of functions that are used to code logic of the application. Initialization function of the world script (init()) is used to create objects and initialize all other necessary resources on the world load. Shutdown function (shutdown()) is called when the world is unloaded and is used to delete resources that were created during script execution to avoid memory leaks.
But what about the frame-by-frame update? In the world script there are three blocks for that:
- in the update() you can put any logic: control what to render on the screen and how to do it, render to textures, create nodes, call console commands, and a lot more
- in the flush() you can simulate physics: perform continuous operations (pushing a car forward depending on current motor's RPM, simulating a wind blowing constantly, perform immediate collision response, etc.).
- in the render() you can correct behavior according to the updated node states in the same frame
In the world script update() you can put all functions to be called every frame while your application executes. It serves for implementing any logic. In brief, you can control a lot of things (whether graphics-related or not) from within the update(). Here you can:
- create and delete nodes
- move nodes around the scene and rotate them
- change any parameters of nodes
- simulate particle systems
- control skinned animation
- set global rendering settings
- create and manipulate your GUI
- render to textures
- execute console commands
- even do some physics - perform some momentary actions: add impulses, simulate a hit or a push, set linear or angular velocity, add or remove shapes and joints and change their parameters
Callbacks set in the update() (for example, by using WorldTrigger or widget callbacks) are not executed immediately. They will be run only when the next engine function is called: that is, before flush(), if any (in the current frame), or before the next update() (in the following frame) — whatever comes first.
The flush() function of the world script is used to control physics in your application. This function should be used for continuous operations such as pushing a car forward depending on current motor's RPM, simulating a wind blowing constantly, perform immediate collision response (as flush() can be executed several times during a single rendering frame you can process multiple bounces of objects, when they collide with each other and monitor them, while the update() will only show us the final result), etc. So, in the flush() you can:
- Operate on all physical bodies and shapes.
- Apply forces, impulses and torques to rigid bodies.
- Create, attach or break joints, as well as modify their parameters.
- Create, and manipulate shapes and modify their parameters.
- Create and adjust physicals.
- Make reposition and transform nodes if they are enabled.
- Create new nodes.
- Delete nodes.
Just like in case with update(), if you set any physics-based callbacks in the flush() or use a PhysicalTrigger, they cannot be executed immediately, as rendering process is already in action and they can violate it. If there is one more physics iteration to go, they are executed before the next flush(); if not, before the next world script update().
If you want to reposition or transform, create or delete nodes that are returned by your physics callback, the workflow is as follows: store them in the array and then perform all necessary operations in the update().
The render() function of the world script is an additional function used to correct behavior after the state of the node has been updated (for example, skinned animation has been played in the current frame or particle system has spawn its particles).
Imagine a situation when we need to attach an object (let's say, a sword) to the hand of a skinned mesh character. If we get transformation of the character hand bone and set it to the sword in the update() function, the attachment will be loose rather than precise. The sword will not be tightly hold in the hand, because the animation is actually played right after the world script update() has been executed. This means, returned bone transformations in the update() will be for the previous frame. World script render() is executed after animation is played, which means from within this function you can get updated bone transformations for the current frame and set them to the sword.