Unigine::World Class
Header: | #include <UnigineWorld.h> |
This class provides functionality for the world script. It contains methods required for loading the world with all its nodes, managing a spatial tree and handling nodes collisions and intersections.
Loading of nodes on demand is managed via the AsyncQueue Class.
See also#
- AsyncQueue Class to manage loading nodes and other resources on demand.
- The Intersections article demonstrating how to use intersection-related functions
World Class
Members
int isAutoReloadNodeReferences ( ) #
Returns a value indicating if automatic reloading of NodeReferences is enabled. If enabled all NodeReference nodes will reload their *.node files, when the saveNode() method is called.Return value
1 if automatic reloading of NodeReferences is enabled; otherwise, 0.void setAutoReloadNodeReferences ( int references ) #
Enables automatic reloading of NodeReferences. If enabled all NodeReference nodes will reload their *.node files, when the saveNode() method is called.Arguments
- int references - 1 to enable automatic reloading of NodeReferences; 0 - to disable it. The default value is 0.
void setBudget ( float budget ) #
Sets the world generation budget value for Grass and Clutter objects. New objects are not created when time is out of the budget.Arguments
- float budget - The budget value in seconds.
float getBudget ( ) #
Returns the value of the world generation budget for Grass and Clutter objects. New objects are not created when time is out of the budget.Return value
The budget value in seconds. The default value is 1/60.int getCollision ( const UNIGINE_BOUND_BOX & bb, Vector< Ptr<Object> > & objects ) #
Searches for all collider objects within a given bounding box.Arguments
- const UNIGINE_BOUND_BOX & bb - Bounding box.
- Vector< Ptr<Object> > & objects - Array with collider objects' smart pointers.
Return value
1 if collider objects are found; otherwise, 0.int getCollision ( const UNIGINE_BOUND_SPHERE & bs, Vector< Ptr<Object> > & objects ) #
Searches for all collider objects within a given bounding sphere.Arguments
- const UNIGINE_BOUND_SPHERE & bs - Bounding sphere.
- Vector< Ptr<Object> > & objects - Array with collider objects' smart pointers.
Return value
1 if collider objects are found; otherwise, 0.int getCollision ( const Math::Vec3 & p0, const Math::Vec3 & p1, Vector< Ptr<Object> > & objects ) #
Performs tracing from the p0 point to the p1 point to find all collider objects intersecting the line. This function detects intersection with surfaces (polygons) of mesh and terrain objects.
Collisions with the surface can be found only if the following conditions are fulfilled:
- The surface is enabled.
- Per-surface Collision flag is enabled.
- The surface has a material assigned.
Arguments
- const Math::Vec3 & p0 - The start point coordinates.
- const Math::Vec3 & p1 - The end point coordinates.
- Vector< Ptr<Object> > & objects - Array with collider objects' smart pointers.
Return value
1 if collider objects are found; otherwise, 0.void setData ( const char * data ) #
Sets user data associated with the world. In the *.world file, the data is set in the data tag.Arguments
- const char * data - New user data.
const char * getData ( ) #
Returns user string data associated with the world. This string is written directly into the data tag of the *.world file.Return value
User string data.void setDistance ( float distance ) #
Updates the distance, at which (and farther) nothing will be rendered or simulated.Arguments
- float distance - New distance in units.
float getDistance ( ) #
Returns a distance, at which (and farther) nothing will be rendered or simulated.Return value
Distance in units.Ptr<Object> getIntersection ( const Math::Vec3 & p0, const Math::Vec3 & p1, int mask ) #
Performs tracing from the p0 point to the p1 point to find the first object intersected by the line. This function detects intersection with surfaces (polygons) of meshes. An intersection can be found only if an object has a matching intersection mask.
Intersections with the surface can be found only if the following conditions are fulfilled:
- The surface is enabled.
- Per-surface Intersection flag is enabled.
- The surface has a material assigned.
Arguments
- const Math::Vec3 & p0 - Line start point coordinates.
- const Math::Vec3 & p1 - Line end point coordinates.
- int mask - Intersection mask. If 0 is passed, the function will return NULL.
Return value
Pointer to the first intersected object.Ptr<Object> getIntersection ( const Math::Vec3 & p0, const Math::Vec3 & p1, int mask, const Vector< Ptr<Node> > & exclude ) #
Performs tracing from the p0 point to the p1 point to find the first object intersected by the line (except for the ones passed in the exclude list). This function detects intersection with surfaces (polygons) of meshes. An intersection can be found only if an object has a matching intersection mask.
Intersections with the surface can be found only if the following conditions are fulfilled:
- The surface is enabled.
- Per-surface Intersection flag is enabled.
- The surface has a material assigned.
Arguments
- const Math::Vec3 & p0 - Line start point coordinates.
- const Math::Vec3 & p1 - Line end point coordinates.
- int mask - Intersection mask. If 0 is passed, the function will return NULL.
- const Vector< Ptr<Node> > & exclude - List of nodes to be ignored when searching for intersection by the traced line.
Return value
The first intersected object found at the line (except for the ones passed in the exclude list); otherwise, NULL pointer.Ptr<Object> getIntersection ( const Math::Vec3 & p0, const Math::Vec3 & p1, int mask, const Ptr<WorldIntersection> & intersection ) #
Performs tracing from the p0 point to the p1 point to find the first object intersecting the line. This function detects intersection with surfaces (polygons) of meshes. An intersection can be found only if an object is matching the intersection mask.
Intersections with the surface can be found only if the following conditions are fulfilled:
- The surface is enabled.
- Per-surface Intersection flag is enabled.
- The surface has a material assigned.
Arguments
- const Math::Vec3 & p0 - Coordinates of the line start point.
- const Math::Vec3 & p1 - Coordinates of the line end point.
- int mask - Intersection mask. If 0 is passed, the function will return NULL.
- const Ptr<WorldIntersection> & intersection - Pointer to the WorldIntersection object to be filled.
Return value
Pointer to the first intersected object.Ptr<Object> getIntersection ( const Math::Vec3 & p0, const Math::Vec3 & p1, int mask, const Ptr<WorldIntersectionNormal> & intersection ) #
Performs tracing from the p0 point to the p1 point to find the first object intersecting the line. This function detects intersection with surfaces (polygons) of meshes. An intersection can be found only if an object is matching the intersection mask.
Intersections with the surface can be found only if the following conditions are fulfilled:
- The surface is enabled.
- Per-surface Intersection flag is enabled.
- The surface has a material assigned.
Arguments
- const Math::Vec3 & p0 - Coordinates of the line start point.
- const Math::Vec3 & p1 - Coordinates of the line end point.
- int mask - Intersection mask. If 0 is passed, the function will return NULL.
- const Ptr<WorldIntersectionNormal> & intersection - Pointer to the WorldIntersectionNormal object to be filled.
Return value
Pointer to the first intersected object.Ptr<Object> getIntersection ( const Math::Vec3 & p0, const Math::Vec3 & p1, int mask, const Ptr<WorldIntersectionTexCoord> & intersection ) #
Performs tracing from the p0 point to the p1 point to find the first object intersecting the line. This function detects intersection with surfaces (polygons) of meshes. An intersection can be found only if an object is matching the intersection mask.
Intersections with the surface can be found only if the following conditions are fulfilled:
- The surface is enabled.
- Per-surface Intersection flag is enabled.
- The surface has a material assigned.
Arguments
- const Math::Vec3 & p0 - Coordinates of the line start point.
- const Math::Vec3 & p1 - Coordinates of the line end point.
- int mask - Intersection mask. If 0 is passed, the function will return NULL.
- const Ptr<WorldIntersectionTexCoord> & intersection - Pointer to the WorldIntersectionTexCoord object to be filled.
Return value
Pointer to the first intersected object.Ptr<Object> getIntersection ( const Math::Vec3 & p0, const Math::Vec3 & p1, int mask, const Vector< Ptr<Node> > & exclude, const Ptr<WorldIntersection> & intersection ) #
Performs tracing from the p0 point to the p1 point to find the first object intersecting the line. This function detects intersection with surfaces (polygons) of meshes. An intersection can be found only if an object is matching the intersection mask.
Intersections with the surface can be found only if the following conditions are fulfilled:
- The surface is enabled.
- Per-surface Intersection flag is enabled.
- The surface has a material assigned.
Arguments
- const Math::Vec3 & p0 - Coordinates of the line start point.
- const Math::Vec3 & p1 - Coordinates of the line end point.
- int mask - Intersection mask. If 0 is passed, the function will return NULL.
- const Vector< Ptr<Node> > & exclude - The list of nodes to be excluded.
- const Ptr<WorldIntersection> & intersection - Pointer to the WorldIntersection object to be filled.
Return value
Pointer to the first intersected object.Ptr<Object> getIntersection ( const Math::Vec3 & p0, const Math::Vec3 & p1, int mask, const Vector< Ptr<Node> > & exclude, const Ptr<WorldIntersectionNormal> & intersection ) #
Performs tracing from the p0 point to the p1 point to find the first object intersecting the line. This function detects intersection with surfaces (polygons) of meshes. An intersection can be found only if an object is matching the intersection mask.
Intersections with the surface can be found only if the following conditions are fulfilled:
- The surface is enabled.
- Per-surface Intersection flag is enabled.
- The surface has a material assigned.
Arguments
- const Math::Vec3 & p0 - Coordinates of the line start point.
- const Math::Vec3 & p1 - Coordinates of the line end point.
- int mask - Intersection mask. If 0 is passed, the function will return NULL.
- const Vector< Ptr<Node> > & exclude - The list of nodes to be excluded.
- const Ptr<WorldIntersectionNormal> & intersection - Pointer to the WorldIntersectionNormal object to be filled.
Return value
Pointer to the first intersected object.Ptr<Object> getIntersection ( const Math::Vec3 & p0, const Math::Vec3 & p1, int mask, const Vector< Ptr<Node> > & exclude, const Ptr<WorldIntersectionTexCoord> & intersection ) #
Performs tracing from the p0 point to the p1 point to find the first object intersecting the line. This function detects intersection with surfaces (polygons) of meshes. An intersection can be found only if an object is matching the intersection mask.
Intersections with the surface can be found only if the following conditions are fulfilled:
- The surface is enabled.
- Per-surface Intersection flag is enabled.
- The surface has a material assigned.
Arguments
- const Math::Vec3 & p0 - Coordinates of the line start point.
- const Math::Vec3 & p1 - Coordinates of the line end point.
- int mask - Intersection mask. If 0 is passed, the function will return NULL.
- const Vector< Ptr<Node> > & exclude - The list of nodes to be excluded.
- const Ptr<WorldIntersectionTexCoord> & intersection - Pointer to the WorldIntersectionTexCoord object to be filled.
Return value
Pointer to the first intersected object.int getIntersection ( const Math::Vec3 & p0, const Math::Vec3 & p1, Vector< Ptr<Object> > & objects ) #
Performs tracing from the p0 point to the p1 point to find objects that intersecting the line. This function detects intersection with surfaces (polygons) of meshes. An intersection can be found only if an object is matching the intersection mask.
Intersections with the surface can be found only if the following conditions are fulfilled:
- The surface is enabled.
- Per-surface Intersection flag is enabled.
- The surface has a material assigned.
Arguments
- const Math::Vec3 & p0 - Coordinates of the line start point.
- const Math::Vec3 & p1 - Coordinates of the line end point.
- Vector< Ptr<Object> > & objects - Array of intersected objects' smart pointers.
Return value
1 if intersections are found; otherwise, 0.int getIntersection ( const UNIGINE_BOUND_BOX & bb, Vector< Ptr<Object> > & objects ) #
Searches for intersections with objects that are found in a given bounding box.
Arguments
- const UNIGINE_BOUND_BOX & bb - Bounding box where intersection search will be performed.
- Vector< Ptr<Object> > & objects - Array of intersected objects' smart pointers.
Return value
1 if intersections are found; otherwise, 0.int getIntersection ( const UNIGINE_BOUND_SPHERE & bs, Vector< Ptr<Object> > & objects ) #
Searches for intersections with objects that are found in a given bounding sphere.
Arguments
- const UNIGINE_BOUND_SPHERE & bs - Bounding sphere where intersection search will be performed.
- Vector< Ptr<Object> > & objects - Array of intersected objects' smart pointers.
Return value
1 if intersections are found; otherwise, 0.int getIntersection ( const UNIGINE_BOUND_FRUSTUM & bf, Vector< Ptr<Object> > & objects ) #
Searches for intersections with objects that are found in a given bounding frustum.
Arguments
- const UNIGINE_BOUND_FRUSTUM & bf - Bounding frustum where intersection search will be performed.
- Vector< Ptr<Object> > & objects - Array of intersected objects' smart pointers.
Return value
1 if intersections are found; otherwise, 0.int getIntersection ( const UNIGINE_BOUND_BOX & bb, Vector< Ptr<Node> > & nodes ) #
Searches for intersections with nodes that are found in a given bounding box.
Arguments
- const UNIGINE_BOUND_BOX & bb - Bounding box where intersection search will be performed.
- Vector< Ptr<Node> > & nodes - Array of intersected nodes' smart pointers.
Return value
1 if intersections are found; otherwise, 0.int getIntersection ( const UNIGINE_BOUND_SPHERE & bs, Vector< Ptr<Node> > & nodes ) #
Searches for intersections with nodes that are found in a given bounding sphere.
Arguments
- const UNIGINE_BOUND_SPHERE & bs - Bounding sphere where intersection search will be performed.
- Vector< Ptr<Node> > & nodes - Array of intersected nodes' smart pointers.
Return value
1 if intersections are found; otherwise, 0.int getIntersection ( const UNIGINE_BOUND_BOX & bb, int type, Vector< Ptr<Node> > & nodes ) #
Searches for intersections with specified type of nodes that are found in a given bounding box.
Arguments
- const UNIGINE_BOUND_BOX & bb - Bounding box where intersection search will be performed.
- int type - Node type filter. Only the nodes of the specified type will be checked.
- Vector< Ptr<Node> > & nodes - Array of intersected nodes' smart pointers.
Return value
1 if intersections are found; otherwise, 0.int getIntersection ( const UNIGINE_BOUND_SPHERE & bs, int type, Vector< Ptr<Node> > & nodes ) #
Searches for intersections with specified type of nodes that are found in a given bounding sphere.
Arguments
- const UNIGINE_BOUND_SPHERE & bs - Bounding sphere where intersection search will be performed.
- int type - Node type filter. Only the nodes of the specified type will be checked.
- Vector< Ptr<Node> > & nodes - Array of intersected nodes' smart pointers.
Return value
1 if intersections are found; otherwise, 0.int getIntersection ( const UNIGINE_BOUND_FRUSTUM & bf, int type, Vector< Ptr<Node> > & nodes ) #
Searches for intersections with specified type of nodes that are found in a given bounding frustum.
Arguments
- const UNIGINE_BOUND_FRUSTUM & bf - Bounding frustum where intersection search will be performed.
- int type - Node type filter. Only the nodes of the specified type will be checked.
- Vector< Ptr<Node> > & nodes - Array of intersected nodes' smart pointers.
Return value
1 if intersections are found; otherwise, 0.int loadWorld ( const char * name ) #
Loads a world from a file and replaces the current world with it.Arguments
- const char * name - Name of the file describing the world.
Return value
1 if the world is loaded successfully; otherwise, 0.int isLoaded ( ) #
Returns a value indicating if the current world is fully loaded.Return value
1 if the world is loaded; otherwise, 0.void setName ( const char * name ) #
Sets a new name for the world.Arguments
- const char * name - Name of the world.
const char * getName ( ) #
Returns the name of the currently loaded world. (If a path was specified in the name, the returned string will contain both the world name and a path).Return value
Name of the world.void setPath ( const char * path ) #
Sets the path to the *.world-file where the world is stored.Arguments
- const char * path - Path to the *.world-file.
const char * getPath ( ) #
Returns the current path to the *.world-file where the world is stored.Return value
Path to the *.world-file.void setScriptName ( const char * name ) #
Sets the name of the world script file *.usc.Arguments
- const char * name - Name of the world script file *.usc.
const char * getScriptName ( ) #
Returns the name of the world script file *.usc.Return value
Name of the world script file *.usc.int isNode ( int id ) #
Checks if a node with a given ID exists in the world.Arguments
- int id - Node ID.
Return value
1 if the node with the given ID exists; otherwise, 0.void getNodes ( Vector< Ptr<Node> > & nodes ) #
Gets all nodes (either loaded from the *.world file or created dynamically at run time).Arguments
- Vector< Ptr<Node> > & nodes - Return array with node smart pointers.
int getNumUpdateNodes ( ) #
Returns the number of currently updating nodes in the world.Return value
Number of updating nodes.Ptr<Node> getUpdateNode ( int num ) #
Returns an updated node by its ID.Arguments
- int num - Node ID.
Return value
The node smart pointer, if found; otherwise - 0.void addUpdateNode ( const Ptr<Node> & node ) #
Adds a node that should be updated even if it is outside of the viewing frustum. This function should be called every frame.Arguments
- const Ptr<Node> & node - Node to be updated.
void addUpdateNodes ( const Vector< Ptr<Node> > & nodes ) #
Adds a node array that should be updated even if the nodes are outside of the viewing frustum. This function should be called every frame.Arguments
- const Vector< Ptr<Node> > & nodes - Nodes array to be updated.
int addWorld ( const char * name ) #
Loads a world from a file and adds it to the current world.Arguments
- const char * name - Name of the file describing the world.
Return value
1 if the world is loaded and added successfully; otherwise, 0.int clearNode ( const char * name ) #
Clears a cache of a given node.Arguments
- const char * name - Path to the *.node file.
Return value
1 if the cache is cleared successfully; otherwise, 0.Ptr<Node> loadNode ( const char * name, int cache = 1 ) #
Loads a node from a file. If the node is loaded successfully, it does not belong to any node hierarchy or list, so be careful and make sure to handle it properly, when it is no longer needed.Arguments
- const char * name - Path to the *.node file.
- int cache - 1 to use the file cache, 0 not to use.
Return value
Loaded node; NULL if the node cannot be loaded.int loadNodes ( const char * name, Vector< Ptr<Node> > & nodes ) #
Loads nodes from a file.Arguments
- const char * name - Path to the *.node file.
- Vector< Ptr<Node> > & nodes - Array of nodes' smart pointers to which the loaded nodes are appended.
Return value
1 if the nodes are loaded successfully; otherwise, 0.int saveNode ( const char * name, const Ptr<Node> & node, int binary = 0 ) #
Saves a given node to a file.Arguments
- const char * name - Path to the *.node file.
- const Ptr<Node> & node - Pointer to the node to save.
- int binary - If set to 1, the node is saved to the binary *.xml. This file cannot be read, but using it speeds up the saving of the node and requires less disk space.
Return value
1 if the node is saved successfully; otherwise, 0.int saveNodes ( const char * name, const Vector< Ptr<Node> > & nodes, int binary = 0 ) #
Saves nodes to a file.Arguments
- const char * name - Path to the *.node file.
- const Vector< Ptr<Node> > & nodes - Array of nodes' smart pointers to be saved.
- int binary - If set to 1, the node is saved to the binary *.xml. This file cannot be read, but using it speeds up the saving of the node and requires less disk space.
Return value
1 if the nodes are saved successfully; otherwise, 0.void setUnpackNodeReferences ( int references ) #
Enables or disables automatic unpacking of node references at run time. This option can be used to simplify hierarchy management, as when it is enabled all nodes contained in node references will be present in the world hierarchy. When disabled you have to check the hierarchy of each node reference individually (e.g. to find the number of children or manage some of them). The content of NodeReference nodes is unpacked only at run time and does not affect your *.world and *.node files. So, you can use all advantages of node references when building worlds in the UnigineEditor and manage a clear and straightforward hierarchy at run time.Arguments
- int references - 1 - to enable automatic unpacking of node references at run time, 0 - to disable it.
int isUnpackNodeReferences ( ) #
Returns the value indicating if automatic unpacking of node references at run time is enabled. This option can be used to simplify hierarchy management, as when it is enabled all nodes contained in node references will be present in the world hierarchy. When disabled you have to check the hierarchy of each node reference individually (e.g. to find the number of children or manage some of them). The content of NodeReference nodes is unpacked only at run time and does not affect your *.world and *.node files. So, you can use all advantages of node references when building worlds in the UnigineEditor and manage a clear and straightforward hierarchy at run time.Return value
1 if automatic unpacking of node references at run time is enabled; otherwise, 0.void updateSpatial ( ) #
Updates the node BSP (binary space partitioning) tree.
The engine calls this method automatically each frame after the world script update() code is executed. As a new node becomes a part of the BSP tree only after this method is called, all engine subsystems (renderer, physics, sound, pathfinding, collisions, intersections, etc.) can process this node only in the next frame. If you need the subsystem to process the node in the very first frame, you can call the updateSpatial() method manually. The engine will call this method automatically after the update() code is executed anyways.
void setUpdateGridSize ( float size ) #
Sets the size of the grid to be used for spatial tree update. The default value is an average one, and can be adjusted when necessary depending on the scene.Arguments
- float size - New grid size, in units. The default value is 1000 units.
float getUpdateGridSize ( ) #
Returns the current size of the grid to be used for spatial tree update. The default value is an average one, and can be adjusted when necessary depending on the scene.Return value
Current grid size, in units. The default value is 1000 units.void setScriptExecute ( int execute ) #
Sets a value indicating if a logic script associated with the world is to be loaded with it.Arguments
- int execute - 1 - to load the world along with the associated logic script (if any), 0 - to ignore it.
int isScriptExecute ( ) #
Returns a value indicating if a logic script associated with the world is to be loaded with it.Return value
1 if a logic script associated with the world is to be loaded with it; otherwise, 0.Ptr<Node> getNodeById ( int node_id ) #
Returns a node by its identifier if it exists.Arguments
- int node_id - Node ID.
Return value
Node, if it exists in the world; otherwise, nullptr.Ptr<Node> getNodeByName ( const char * name ) #
Returns a node by its name if it exists. If the world contains multiple nodes having the same name, only the first one found shall be returned. To get all nodes having the same name, use the getNodesByName() method.Arguments
- const char * name - Node name.
Return value
Node, if it exists in the world; otherwise, nullptr.void getNodesByName ( const char * name, Vector< Ptr<Node> > & nodes ) #
Generates a list of nodes in the world with a given name and puts it to nodes.Arguments
- const char * name - Node name.
- Vector< Ptr<Node> > & nodes - List of nodes with the given name (if any); otherwise, nullptr.
bool isNode ( const char * name ) #
Checks if a node with a given name exists in the world.Arguments
- const char * name - Node name.
Return value
true if a node with the specified name exists in the world; otherwise, false.void clearBindings ( ) #
Clears internal buffers with pointers and instances. This function is used for proper cloning of objects with hierarchies, for example, bodies and joints. Should be called before cloning.void getRootNodes ( Vector< Ptr<Node> > & nodes ) #
Gets all root nodes in the world hierarchy and puts them to nodes.Arguments
- Vector< Ptr<Node> > & nodes - Vector, to which all root nodes of the world hierarchy are to be put.Array, to which all root nodes of the world hierarchy are to be put.
int getRootNodeIndex ( const Ptr<Node> & node ) #
Returns the index for the specified root node, that belongs to the world hierarchy.Arguments
- const Ptr<Node> & node - Root node, for which an index is to be obtained.
Return value
Index of the specified root node if it exists; otherwise, -1.void setRootNodeIndex ( const Ptr<Node> & node, int index ) #
Sets a new index for the specified root node, that belongs to the world hierarchy.Arguments
- const Ptr<Node> & node - Root node, for which a new index is to be set.
- int index - New index to be set for the specified root node.