Unigine::Node Class

Creating a Node#

The Node class doesn't provide creating of a node. You can create an instance of any class inherited from the Node class and then obtain the node via automatic upcasting.

For example:

Create a box mesh by using the Mesh class.
Use the box mesh to create an instance of the ObjectMeshDynamic class. This class is inherited from the Node class.
Get the node via upcasting.

Source code (C++)

// AppWorldLogic.cpp
			
#include "AppWorldLogic.h"

using namespace Unigine;
using namespace Math;

int AppWorldLogic::init() {

	
	// declare a smart pointer for any type of the node inherited from the Node class (e.g. ObjectMeshDynamic)
	// and call a constructor of the corresponding class
	ObjectMeshDynamicPtr object_mesh = ObjectMeshDynamic::create("core/meshes/box.mesh");

	// declare a smart pointer for the node
	// and obtain the node pointer from the created ObjectMeshDynamic
	NodePtr node = object_mesh;

	return 1;
}

Now you can operate the ObjectMeshDynamic instance as a node.

Editing a Node and Saving Changes#

The Node class contains common settings of the node. Also each node has special settings, which vary depending on the type of the node.

NoticeThe special settings of a node can be found in the article on the corresponding class.

Editing the node also includes editing materials and properties assigned to the node.

For the edited node to be saved in the .world file, you should enable the corresponding option via the setSaveToWorldEnabled() method.

NoticeThe node shall be saved to a *.world file only if this option is enabled for all of its ancestors as well.

For example:

Create a box mesh by using the Mesh class.
Save the mesh on the disk. It is required as the node we are going to save to the .world file need to reference to a mesh stored on the disk.
Use the saved .mesh file to create an instance of the ObjectMeshStatic class. This class is inherited from the Node class.
Get the node from the ObjectMeshStatic instance via upcasting.
Enable saving to .world file for the node (and all its children).
Edit the node and save the world by calling the world_saveconsole command.

Source code (C++)

#include "AppWorldLogic.h"

#include <UnigineConsole.h>

using namespace Unigine;
using namespace Math;

int AppWorldLogic::init() {

	// create a mesh
	MeshPtr mesh = Mesh::create();
	mesh->addBoxSurface("box_0",vec3(1.0f));
	// save a mesh into a file on the disk
	mesh->save("unigine_project/meshes/my_mesh.mesh");
	// declare a smart pointer for any type of the node inherited from the Node class (e.g. ObjectMeshStatic)
	// and call a constructor of the corresponding class create an instance of any class inherited from the Node class (e.g. ObjectMeshStatic)
	ObjectMeshStaticPtr object_mesh = ObjectMeshStatic::create("unigine_project/meshes/my_mesh.mesh");

	// declare a smart pointer for the node,
	// obtain the node pointer from the created ObjectMeshStatic,
	NodePtr node = object_mesh;
	
	// enable saving the node(and all its children) to a .world file
	node->setSaveToWorldEnabledRecursive(true);

	// change the node name
	node->setName("my_node");
	// change node transformation
	node->setWorldTransform(translate(Vec3(0.0f, 0.0f, 2.0f)));

	// save node changes in the .world file
	Console::run("world_save");

	return 1;
}

Exporting and Importing a Node#

To export a node stored in the world into the external .node file, you should pass it to the saveNode() method of the World class.

To import the existing node stored in the .node file to the world, you should call the loadNode() method of the World class.

For example:

Create a box mesh by using the Mesh class.
Save the mesh on the disk. It is required as the node we are going to export need to reference to a mesh stored on the disk.
Use the saved .mesh file to create an instance of the ObjectMeshDynamic class. This class is inherited from the Node class.
Get the node from the ObjectMeshStatic instance via upcasting.
Export the node to an external .node file.
Import the prevoiusly exported node to check the result.

Source code (C++)

#include "AppWorldLogic.h"

#include <UnigineNode.h>
#include <UnigineObjects.h>
#include <UnigineWorld.h>
#include <UnigineEditor.h>
#include <UnigineConsole.h>

using namespace Unigine;
using namespace Math;

int AppWorldLogic::init() {

	// create a mesh
	MeshPtr mesh = Mesh::create();
	mesh->addBoxSurface("box_0", vec3(1.0f));
	// save a mesh into a file on the disk
	mesh->save("unigine_project/meshes/my_mesh.mesh");
	// create an instance of any class inherited from the Node class (e.g. ObjectMeshStatic)
	ObjectMeshStaticPtr object_mesh = ObjectMeshStatic::create("unigine_project/meshes/my_mesh.mesh");
	// declare a smart pointer for the node
	// and obtain the node pointer from the created NodeDummy
	NodePtr node = object_mesh;
	// export the node into a .node file
	World::saveNode("unigine_project/nodes/my_node.node", node);
	// import the exported node to check the result
	NodePtr imported_node = World::loadNode("unigine_project/nodes/my_node.node");
	// set position of the node
	imported_node->setPosition(Vec3(4.0f, 0.0f, 1.0f));

	return 1;
}

Deleting a Node#

By default each new node's lifetime matches the lifetime of the World (i.e. such node shall be deleted when the world is closed). But you can also choose node's lifetime to be managed:

by the Engine - is this case the node shall be deleted automatically on Engine shutdown.
manually - is this case the node should be deleted manually by the user.

To delete a node you can use the following two methods:

deleteLater() - performs delayed deletion, in this case the object will be deleted during the next swap stage of the main loop (rendering of the object ceases immediately, but it still exists in memory for a while, so you can get it from its parent, for example). This method simplifies object deletion from a secondary thread, so you can call it and forget about the details, letting the Engine take control over the process of deletion, which can be used for future optimizations.
deleteForce() - performs immediate deletion, which might be necessary in some cases. Calling this method for main-loop-dependent objects (e.g., nodes) is safe only when performed from the Main thread.

Source code (C++)

// AppWorldLogic.cpp

#include <UnigineNode.h>
#include <UnigineObjects.h>
#include <UnigineWorld.h>
#include <UnigineEditor.h>
#include <UnigineConsole.h>

using namespace Unigine;
using namespace Math;

int AppWorldLogic::init() {

	// create a mesh
	MeshPtr mesh = Mesh::create();
	mesh->addBoxSurface("box_0", vec3(1.0f));
	// save a mesh into a file on the disk
	mesh->save("unigine_project/meshes/my_mesh.mesh");
	// create an instance of any class inherited from the Node class (e.g. ObjectMeshStatic)
	ObjectMeshStaticPtr object_mesh = ObjectMeshStatic::create("unigine_project/meshes/my_mesh.mesh");
	// declare a smart pointer for the node
	// and obtain the node pointer from the created NodeDummy
	NodePtr node = object_mesh;

	// do something with the node
	// ...

	// delete the node
	node.deleteLater();

	return 1;
}

功能列表:

Name	描述 View: Sort by:
getGeodeticPivot	Returns the current pointer to geodetic pivot of the node.
setVariable	Setter and Getter for value of the single unnamed variable parameter of the node.
getVariable
setWorldScale	Setter and Getter for node scale in the world space.
getWorldScale	Setter and Getter for node scale in the world space.
setWorldPosition	Setter and Getter for node position in the world coordinates.
getWorldPosition
setScale	Setter and Getter for scale of the node.
getScale	Setter and Getter for scale of the node.
setPosition	Setter and Getter for node position.
getPosition	Setter and Getter for node position.
getBodyAngularVelocity	Returns the current angular velocity of the node's physical body in the world space.
getBodyLinearVelocity	Returns the current linear velocity of the node's physical body in the local space.
getObjectBodyRigid	Returns the current rigid body assigned to the node if it is an object node.
getObjectBody	Returns the current physical body assigned to the node if it is an object node.
getWorldBoundSphere	Returns the current bounding sphere of the node in world's coordinate system.
getWorldBoundBox	Returns the current bounding box of the node in world's coordinate system.
getBoundSphere	Returns the current bounding sphere of the node.
getBoundBox	Returns the current bounding box of the node.
setOldWorldTransform	Setter and Getter for old (previous frame) transformation matrix for the node in the world coordinates.
getOldWorldTransform
setWorldTransform	Setter and Getter for transformation matrix of the node in the world coordinates.
getWorldTransform
setTransform	Setter and Getter for transformation matrix of the node in its parent coordinates.
getTransform
getNumProperties	Returns the current total number of properties associated with the node.
getPossessor	Returns the current possessor of the node.
getNumChildren	Returns the current number of children of the node.
getRootNode	Returns the current root node for the node.
setParent	Setter and Getter for parent of the node.
getParent	Setter and Getter for parent of the node.
getNumAncestors	Returns the current number of ancestors of the node.
setName	Setter and Getter for name of the node.
getName	Setter and Getter for name of the node.
setQuery	Setter and Getter for value indicating if occlusion query is used for the node.
isQuery
setClutterInteractionEnabled	Setter and Getter for value indicating if interaction with World Clutters and Mesh Clutters is enabled for the node.
isClutterInteractionEnabled
setGrassInteractionEnabled	Setter and Getter for value indicating if interaction with Grass nodes is enabled for the node.
isGrassInteractionEnabled
setTriggerInteractionEnabled	Setter and Getter for value indicating if interaction with WorldTrigger nodes is enabled for the node.
isTriggerInteractionEnabled
setImmovable	Setter and Getter for value indicating if the node is an immovable (clutter) object, which means it is moved to a separate spatial tree for immovable (static) objects optimizing node management.
isImmovable
setHandled	Setter and Getter for value indicating if the node handle is displayed.
isHandled
setEnabled	Setter and Getter for value indicating if the node and its parent nodes are enabled.
isEnabled
isExtern	Returns the current value indicating if the node is an extern node (its type is one of the following: NODE_EXTERN, OBJECT_EXTERN, WORLD_EXTERN).
isField	Returns the current value indicating if the node is a field node (its type is one of the FIELD_*).
isParticlesField	Returns the current value indicating if the node is a particles field node (its type is one of the PARTICLES_FIELD_*).
isSound	Returns the current value indicating if the node is a sound node (its type is SOUND_*).
isObstacle	Returns the current value indicating if the node is an obstacle node (its type is OBSTACLE_*).
isNavigation	Returns the current value indicating if a given node is a navigation node.
isPhysical	Returns the current value indicating if the node is a physical node (its type is PHYSICAL_*).
isPlayer	Returns the current value indicating if the node is a player node (its type is PLAYER_*).
isObject	Returns the current value indicating if the node is an object node (its type is OBJECT_*).
isDecal	Returns the current value indicating if the node is a decal node (its type is DECAL_*).
isLight	Returns the current value indicating if the node is a light source (its type is LIGHT_*).
isGeodetic	Returns the current value indicating if the node is a geodetic-related node.
isWorld	Returns the current value indicating if the node is a world node (its type is WORLD_*).
isImmovableSupported	Returns the current value indicating if the node can be moved to a separate spatial tree for immovable (static) objects optimizing node management.
isSurfacesCollisionSupported	Returns the current value indicating if collisions with node surfaces are supported.
isSurfacesIntersectionSupported	Returns the current value indicating if intersections with node surfaces are supported.
getTypeName	Returns the current name of the node type.
getType	Returns the current type of the node.
setID	Setter and Getter for ID of the node.
getID	Setter and Getter for ID of the node.
setSaveToWorldEnabled	Setter and Getter for value indicating if saving to *.world file is enabled for the node and all its children (if any).
isSaveToWorldEnabled
isSaveToWorldEnabledSelf	Returns the current value indicating if saving to *.world file is enabled for the node.
setShowInEditorEnabled	Setter and Getter for value indicating if displaying in the World Hierarchy window of the UnigineEditor is enabled for the node.
isShowInEditorEnabled
isShowInEditorEnabledSelf	Returns the current value indicating if displaying in the World Hierarchy window of the UnigineEditor is enabled for the node.
getNumWorldTriggers	Returns the current number of World Triggers inside which the node is located at the moment.
getSpatialBoundSphere	Returns the current bounding sphere with world coordinates that participates in physics calculations, but doesn't take children into account.
getSpatialBoundBox	Returns the current bounding box with world coordinates that participates in physics calculations, but doesn't take children into account.
isLandscapeLayer	Returns the current value indicating if the node is a landscape layer (its type is LANDSCAPE_LAYER_*).
getIWorldTransform	Returns the current inverse transformation matrix of the node for transformations in the world coordinates.
getOldWorldPosition	Returns the current old (previous frame) position of the node in the world coordinates.
setLifetime	Setter and Getter for lifetime management type for the root (either parent or posessor) of the node, or for the node itself (if it is not a child and not possessed by any other node).
getLifetime
getEventNodeSwap	The event triggered when swapping a node via Node.
getEventNodeClone	The event triggered when copying a node via Node.
getEventNodeChangeEnabled	The event triggered when the node's enabled state is changed.
getEventNodeRemove	The event triggered when the node is deleted.
getEventNodeLoad	The event triggered when a node is loaded from a file.
getEventCacheNodeAdd	The event triggered when a node is added to cache.
getEventPropertySurfaceRemove	The event triggered when a property is removed from the object's surface.
getEventPropertySurfaceAdd	The event triggered when a property is assigned to the object's surface.
getEventPropertyNodeSwap	The event triggered when two properties swap their positions in the list of the node's properties.
getEventPropertyChangeEnabled	The event triggered when the node's property enabled state is changed.
getEventPropertyNodeRemove	The event triggered when a property is removed from the list of the node's properties.
getEventPropertyNodeAdd	The event triggered when a new property is assigned to the node.
getEventPropertyNodeSlotsChanged	The event triggered when the number of the node's property slots is changed.
getIDFromFile	Returns the current
getAncestor	Returns a node ancestor by its number.
getChild	Returns a node child by its number.
isChild	Checks if a given node is a child of the node.
setChildIndex	Sets the index for a given child node of the node.
getChildIndex	Returns the index of a given child node of the node.
setData	Sets user data associated with the node.
getData	Returns user data associated with the node.
updateEnabled	Updates node's internal state according to the current "enabled" state.
isEnabledSelf	Returns a value indicating if the node is enabled.
getHierarchy	Retrieves the whole hierarchy of the node and puts it to the hierarchy buffer.
getNode	Returns a node pointer.
isNode	Check the node pointer.
addProperty	Inherits a new property from the one with the given name and adds it to the list of properties associated with the node.
insertProperty	Inserts the property with the specified name at the specified position.
setProperty	Updates the first node property (the one with a 0 index) in the list of properties associated with the node.
setPropertyEnabled	Enables or disables the node property with the specified number.
isPropertyEnabled	Returns a value indicating if the node property with the specified number is enabled.
swapProperty	Swaps two properties with specified numbers in the list of properties associated with the node.
removeProperty	Removes the node property with the specified number.
clearProperties	Clears the list of properties associated with the node.
getProperty	Returns a node property with the specified number if it exists.
getPropertyName	Returns the name of a node property with the specified number.
findProperty	Searches for a property with the specified name among the ones assigned to the node.
hasQueryForce	Returns a value indicating if the Culled By Occlusion Queryoption is force-enabled for the node by the Engine.
setRotation	Sets the node rotation.
getRotation	Returns the node rotation.
setWorldRotation	Sets the node rotation in the world space.
getWorldRotation	Returns the node rotation in the world space.
setTransformWithoutChildren	Sets the transformation matrix for the node in local coordinates (transformations of all node's children are not affected).
getTypeID	Returns the ID of a node type with a given name.
getTypeName	Returns the name of a node type with a given ID.
setVariable	Sets the value of a variable with a given name. If such variable does not exist it will be added with a specified value.
getVariable	Returns the variable with a given name.
setWorldParent	Sets the new parent of the node.
setWorldTransformWithoutChildren	Sets the transformation matrix for the node in world coordinates (transformations of all node's children are not affected).
getBodyWorldVelocity	Returns linear velocity of a point of the node's physical body in the world space.
addChild	Adds a child to the node.
addWorldChild	Adds a child to the node.
clone	Clones the node.
findAncestor	Returns the ID of node's ancestor of a given type.
findChild	Searches for a child node with a given name among the children of the node.
findNode	Searches for a node with a given name among the children of the node.
findNodes	Searches for a node with a given name among the children of the node and puts them to the specified output nodes buffer.
hasVariable	Returns a value indicating if the node has a variable parameter with a given name.
loadWorld	Loads a node state from the Xml.
removeChild	Removes a child node (added by the addChild() method) from the list of children.
removeVariable	Removes a variable parameter with a given name.
removeWorldChild	Removes a child node (added by the addWorldChild() method) from the list of children.
renderVisualizer	Renders a bounding box / sphere of the object.
saveState	Saves a node state to a binary stream.
restoreState	Restores a node state from a binary stream.
saveWorld	Saves the node into the Xml.
swap	Swaps two nodes.
toLocal	Converts a given vector in the world space to the node's local space.
toWorld	Converts a given vector in the local space to the world space.
translate	Translates the node relative to its local coordinate system: the parent node transformation isn't taken into account.
worldTranslate	Translates the node in the world space using the specified vector.
worldLookAt	Reorients the node to "look" at the target point and sets the given up vector: If the node is a Player-related one, it will "look" at the target point along the negative Z axis.
rotate	Rotates the node relative to its local coordinate system: the parent node transformation isn't taken into account.
worldRotate	Rotates the node in the world space.
setDirection	Updates the direction vector of the node and reorients this node: the specified axis of the node becomes oriented along the specified vector in local coordinates.
getDirection	Returns the normalized direction vector pointing along the given node axis in local coordinates (i.e. relative to the node's parent).
setWorldDirection	Updates the direction vector of the node and reorients this node: the specified axis of the node becomes oriented along the specified vector in world coordinates.
getWorldDirection	Returns the normalized direction vector pointing along the given node axis in world coordinates.
getCloneNode	Returns a node cloned from the specified original node.
getCloneProperty	Returns a node property cloned from the specified original property.
setSaveToWorldEnabledRecursive	Sets a value indicating if saving to *.world file is enabled for the node and all its children (if any).
setShowInEditorEnabledRecursive	Sets a value indicating if displaying in the World Hierarchy window of the UnigineEditor is enabled for the node and all its children (if any).
getLifetimeSelf	Returns the lifetime management type set for the node itself.
getHierarchyBoundBox	Returns a bounding box with local coordinates that takes children into account, but doesn't participate in physics calculations.
getHierarchyBoundSphere	Returns a bounding sphere with local coordinates that takes children into account, but doesn't participate in physics calculations.
getHierarchyWorldBoundBox	Returns a bounding box with world coordinates that takes children into account, but doesn't participate in physics calculations.
getHierarchyWorldBoundSphere	Returns a bounding sphere with world coordinates that takes children into account, but doesn't participate in physics calculations.
getHierarchySpatialBoundBox	Returns a bounding box with world coordinates that takes all children and physics into account.
getHierarchySpatialBoundSphere	Returns a bounding sphere with world coordinates that takes all children and physics into account.
updateSpatialTree	Updates node bounds in the spatial tree in the current frame.
updateSpatialTreeDelayed	Mark node bounds in the spatial tree to be updated in the next frame (all bounds will be 100% accurate in this case unlike for the updateSpatialTree() method).
getWorldTrigger	Returns one of the World Triggers inside which the node is located at the moment by its number.
getLostNodePropertyGUID	Returns the GUID of a lost property assigned to the node.
renderBounds	Renders the node bounds.
getIDFromFile	Returns the node ID from the .node or a .world file if the node has been loaded from this file.
applyReplacePaths	Restores the engine's ability to replace baked textures (lightmap, shadow map) inside Node References in runtime.

Node Class

枚举

TYPE#

Name	描述
ANY_TYPE = -1	Any node type.
NODE_BEGIN = 0	Begin of the nodes range.
NODE_DUMMY = 0	Dummy node. See the NodeDummy class.
NODE_LAYER = 1	Layer node. See the NodeLayer class.
NODE_TRIGGER = 2	Dummy node that can fire callbacks on its enabling/disabling or repositioning. See the NodeTrigger class.
NODE_REFERENCE = 3	Node reference that refers to an external NODE file. See the NodeReference class.
NODE_EXTERN = 4	Extern node. See the NodeExtern class.
NODE_ANIMATION_PLAYBACK = 5	Animation playback node. See the NodeAnimationPlayback class.
NODE_END = 5	End of the nodes range.
WORLD_BEGIN = 6	Begin of the world nodes range.
WORLD_SPLINE_GRAPH = 6	World spline graph. See the WorldSplineGraph class.
WORLD_TRIGGER = 7	World trigger. See the WorldTrigger class.
WORLD_CLUTTER = 8	World clutter. See the WorldClutter class.
WORLD_SWITCHER = 9	Node switcher (to switch off parts of the world). See the WorldSwitcher class.
WORLD_OCCLUDER = 10	World occluder. See the WorldOccluder class.
WORLD_OCCLUDER_MESH = 11	World mesh occluder. See the WorldOccluderMesh class.
WORLD_TRANSFORM_PATH = 12	Path defined transformer. See the WorldTransformPath
WORLD_TRANSFORM_BONE = 13	Bone defined transformer. See the WorldTransformBone class.
WORLD_EXPRESSION = 14	Node which allows to execute arbitrary expression. See the WorldExpression class.
WORLD_EXTERN = 15	External world. See the WorldExtern class.
WORLD_END = 15	End of the world nodes range.
GEODETIC_BEGIN = 16	Begin of the geodetic nodes range.
GEODETIC_PIVOT = 16	Geodetic Pivot node. See the GeodeticPivot class.
GEODETIC_END = 16	End of the geodetic nodes range.
FIELD_BEGIN = 17	Begin of the field nodes range.
FIELD_SPACER = 17	Field Spacer node. See the FieldSpacer class.
FIELD_ANIMATION = 18	Field Animation node. See the FieldAnimation class.
FIELD_HEIGHT = 19	Field Height node. See the FieldHeight class.
FIELD_SHORELINE = 20	Field Shoreline node. See the FieldShoreline class.
FIELD_WEATHER = 21	Field Weather node. See the FieldWeather class.
FIELD_END = 21	End of the field nodes range.
PARTICLES_FIELD_BEGIN = 22	Beginning of the particles field range.
PARTICLES_FIELD_SPACER = 22	Particles Field Spacer node. See the ParticlesFieldSpacer class.
PARTICLES_FIELD_DEFLECTOR = 23	Particles Field Deflector node. See the ParticlesFieldDeflector class.
PARTICLES_FIELD_END = 23	End of the particles field nodes range.
LIGHT_BEGIN = 24	Begin of the light nodes range.
LIGHT_VOXEL_PROBE = 24	Voxel probe. See the LightVoxelProbe class.
LIGHT_ENVIRONMENT_PROBE = 25	Environment probe. See the LightEnvironmentProbe class.
LIGHT_PLANAR_PROBE = 26	Planar probe. See the LightPlanarProbe class.
LIGHT_OMNI = 27	Omni-directional light source. See the LightOmni class.
LIGHT_PROJ = 28	Projected light source. See the LightProj class.
LIGHT_WORLD = 29	World light source. See the LightWorld class.
LIGHT_END = 29	End of the light nodes range.
DECAL_BEGIN = 30	Begin of the decal nodes range.
DECAL_PROJ = 30	Projected decal node. See the DecalProj class.
DECAL_ORTHO = 31	Orthographic decal node. See the DecalOrtho class.
DECAL_MESH = 32	Mesh decal node. See the DecalMesh class.
DECAL_END = 32	End of the decal nodes range.
LANDSCAPE_LAYER_BEGIN = 33	Beginning of the landscape layers range.
LANDSCAPE_LAYER_MAP = 33	Landscape Layer Map. See the LandscapeLayerMap class.
LANDSCAPE_LAYER_END = 33	End of the landscape layers range.
OBJECT_BEGIN = 34	Begin of the object nodes range.
OBJECT_DUMMY = 34	Dummy object. See the ObjectDummy class.
OBJECT_DYNAMIC = 35	Dynamic object. See the ObjectDynamic class.
OBJECT_MESH_STATIC = 36	Static mesh object. See the ObjectMeshStatic class.
OBJECT_MESH_CLUSTER = 37	Mesh Cluster object. See the ObjectMeshCluster class.
OBJECT_MESH_CLUTTER = 38	Mesh Clutter object. See the ObjectMeshClutter class.
OBJECT_MESH_SKINNED = 39	Skinned mesh object. See the ObjectMeshSkinned class.
OBJECT_MESH_DYNAMIC = 40	Dynamic mesh object. See the ObjectMeshDynamic class.
OBJECT_MESH_SPLINE_CLUSTER = 41	Mesh Spline Cluster object. See the ObjectMeshSplineCluster class.
OBJECT_LANDSCAPE_TERRAIN = 42	LandscapeTerrain object. See the ObjectLandscapeTerrain class.
OBJECT_TERRAIN_GLOBAL = 43	Terrain global object. See the ObjectTerrainGlobal class.
OBJECT_GRASS = 44	Grass. See the ObjectGrass class.
OBJECT_PARTICLES = 45	Particles object. See the ObjectParticles class.
OBJECT_BILLBOARDS = 46	Billboards object for rendering a high number of billboards. See the ObjectBillboard class.
OBJECT_VOLUME_BOX = 47	Volume box object. See the ObjectVolumeBox class.
OBJECT_VOLUME_SPHERE = 48	Volume sphere object. See the ObjectVolumeSphere class.
OBJECT_VOLUME_OMNI = 49	Volume omni light object. See the ObjectVolumeOmni class.
OBJECT_VOLUME_PROJ = 50	Volume projected light object. See the ObjectVolumeProj class.
OBJECT_GUI = 51	GUI object. See the ObjectGui class.
OBJECT_GUI_MESH = 52	GUI mesh object. See the ObjectGuiMesh class.
OBJECT_WATER_GLOBAL = 53	Water global object. See the ObjectWaterGlobal class.
OBJECT_WATER_MESH = 54	Water mesh object. See the ObjectWaterMesh class.
OBJECT_SKY = 55	Sky object. See the ObjectSky class.
OBJECT_CLOUD_LAYER = 56	Cloud layer object. See the ObjectCloudLayer class.
OBJECT_EXTERN = 57	Extern object. See the ObjectExtern class.
OBJECT_TEXT = 58	Text object. See the ObjectText class.
OBJECT_END = 58	End of the object nodes range.
PLAYER_BEGIN = 59	Begin of the player nodes range.
PLAYER_DUMMY = 59	Dummy player. See the PlayerDummy class.
PLAYER_SPECTATOR = 60	Observing player. See the PlayerSpectator class.
PLAYER_PERSECUTOR = 61	Persecuting player. See the PlayerPersecutor class.
PLAYER_ACTOR = 62	Acting player. See the PlayerActor class.
PLAYER_END = 62	End of the player nodes range.
PHYSICAL_BEGIN = 63	Begin of the physical nodes range.
PHYSICAL_WIND = 63	Physical wind object. See the PhysicalWind class.
PHYSICAL_FORCE = 64	Physical force node that allows to simulate point forces applied to dynamic objects. See the PhysicalForce class.
PHYSICAL_NOISE = 65	Physical noise node that allows to simulate force field. See the PhysicalNoise class.
PHYSICAL_WATER = 66	Physical water object that has no visual representation. See the PhysicalWater class.
PHYSICAL_TRIGGER = 67	Physical trigger. See the PhysicalTrigger class.
PHYSICAL_END = 67	End of the physical nodes range.
NAVIGATION_BEGIN = 68	Begin of the navigation nodes range.
NAVIGATION_SECTOR = 68	Sector within which pathfinding is performed. See the NavigationSector class.
NAVIGATION_MESH = 69	Mesh-based navigation area across which pathfinding is performed. See the NavigationMesh class.
NAVIGATION_END = 69	End of the navigation nodes range.
OBSTACLE_BEGIN = 70	Begin of the obstacle nodes range.
OBSTACLE_BOX = 70	Obstacle in the shape of a box avoided by pathfinding. See the ObstacleBox class.
OBSTACLE_SPHERE = 71	Obstacle in the shape of a sphere avoided by pathfinding. See the ObstacleSphere class.
OBSTACLE_CAPSULE = 72	Obstacle in the shape of a capsule avoided by pathfinding. See the ObstacleCapsule class.
OBSTACLE_END = 72	End of the obstacle nodes range.
SOUND_BEGIN = 73	Begin of the sound nodes range.
SOUND_SOURCE = 73	Sound source. See the SoundSource class.
SOUND_REVERB = 74	Sound reverberation zone. See the SoundReverb class.
SOUND_END = 74	End of the sound nodes range.
NUM_NODES = 75	Counter of node types.
NUM_WORLDS = WORLD_END - WORLD_BEGIN + 1	Counter of world node types.
NUM_GEODETICS = GEODETIC_END - GEODETIC_BEGIN + 1	Counter of geodetic node types.
NUM_FIELDS = FIELD_END - FIELD_BEGIN + 1	Counter of field node types.
NUM_PARTICLES_FIELDS = PARTICLES_FIELD_END - PARTICLES_FIELD_BEGIN + 1	Counter of particles field node types.
NUM_LIGHTS = LIGHT_END - LIGHT_BEGIN + 1	Counter of light node types.
NUM_DECALS = DECAL_END - DECAL_BEGIN + 1	Counter of decal node types.
NUM_OBJECTS = OBJECT_END - OBJECT_BEGIN + 1	Counter of object node types.
NUM_PLAYERS = PLAYER_END - PLAYER_BEGIN + 1	Counter of player node types.
NUM_PHYSICALS = PHYSICAL_END - PHYSICAL_BEGIN + 1	Counter of physical node types.
NUM_NAVIGATIONS = NAVIGATION_END - NAVIGATION_BEGIN + 1	Counter of navigation node types.
NUM_OBSTACLES = OBSTACLE_BEGIN - OBSTACLE_END + 1	Counter of obstacle node types.
NUM_SOUNDS = SOUND_END - SOUND_BEGIN + 1	Counter of sound node types.
DUMMY = 0	Dummy node. See the NodeDummy class.
LAYER = 1	Layer node. See the NodeLayer class.
TRIGGER = 2	Dummy node that can fire callbacks on its enabling/disabling or repositioning. See the NodeTrigger class.
REFERENCE = 3	Node reference that refers to an external NODE file. See the NodeReference class.
EXTERN = 4	Extern node. See the NodeExtern class.

LIFETIME#

Name	描述
LIFETIME_WORLD = 0	Node's lifetime is managed by the world. The node shall be deleted automatically on closing the world.
LIFETIME_ENGINE = 1	Node's lifetime is managed by the Engine. The node shall be deleted automatically on Engine shutdown.
LIFETIME_MANUAL = 2	Node's lifetime is managed by the user. The node should be deleted manually by the user.

Members

Ptr<GeodeticPivot> getGeodeticPivot() const#

Returns the current pointer to geodetic pivot of the node.

Return value

Current geodetic pivot, or NULL if the node is not a child of a geodetic pivot node.

void setVariable ( const Variable & variable ) #

Sets a new value of the single unnamed variable parameter of the node. If this variable does not exist it will be created with a specified value (on requesting the non-existent value 0 will be returned).

Arguments

const Variable & variable - The variable value.

const Variable & getVariable() const#

Returns the current value of the single unnamed variable parameter of the node. If this variable does not exist it will be created with a specified value (on requesting the non-existent value 0 will be returned).

Return value

Current variable value.

void setWorldScale ( const Math::vec3& scale ) #

Sets a new node scale in the world space.

NoticeScaling of nodes should be avoided whenever possible as it requires addidional calculations and may lead to error accumulation.

Arguments

const Math::vec3& scale - The node scale in the world space.

Math::vec3 getWorldScale() const#

Returns the current node scale in the world space.

NoticeScaling of nodes should be avoided whenever possible as it requires addidional calculations and may lead to error accumulation.

Return value

Current node scale in the world space.

void setWorldPosition ( const Math::Vec3& position ) #

Sets a new node position in the world coordinates.

Arguments

const Math::Vec3& position - The node position in the world coordinates.

Math::Vec3 getWorldPosition() const#

Returns the current node position in the world coordinates.

Return value

Current node position in the world coordinates.

void setScale ( const Math::vec3& scale ) #

Sets a new scale of the node.

NoticeScaling of nodes should be avoided whenever possible as it requires addidional calculations and may lead to error accumulation.

Arguments

const Math::vec3& scale - The node scale in the local space.

Math::vec3 getScale() const#

Returns the current scale of the node.

NoticeScaling of nodes should be avoided whenever possible as it requires addidional calculations and may lead to error accumulation.

Return value

Current node scale in the local space.

void setPosition ( const Math::Vec3& position ) #

Sets a new node position.

Arguments

const Math::Vec3& position - The node position in the local space.

Return value

true if occlusion query is used for the node; otherwise false.

void setClutterInteractionEnabled ( bool enabled ) #

Sets a new value indicating if interaction with World Clutters and Mesh Clutters is enabled for the node.

NoticeIt is recommended to disable this option for better performance, when cutting node out of clutters is not necessary. Especially when the world contains a significant number of such nodes.

Arguments

bool enabled - Set true to enable interaction with World Clutters and Mesh Clutters; false - to disable it.

bool isClutterInteractionEnabled() const#

Returns the current value indicating if interaction with World Clutters and Mesh Clutters is enabled for the node.

NoticeIt is recommended to disable this option for better performance, when cutting node out of clutters is not necessary. Especially when the world contains a significant number of such nodes.

Return value

true if interaction with World Clutters and Mesh Clutters is enabled; otherwise false.

void setGrassInteractionEnabled ( bool enabled ) #

Sets a new value indicating if interaction with Grass nodes is enabled for the node.

NoticeIt is recommended to disable this option for better performance, when cutting node out of grass is not necessary. Especially when the world contains a significant number of such nodes.

Arguments

bool enabled - Set true to enable interaction with Grass nodes; false - to disable it.

bool isGrassInteractionEnabled() const#

Returns the current value indicating if interaction with Grass nodes is enabled for the node.

NoticeIt is recommended to disable this option for better performance, when cutting node out of grass is not necessary. Especially when the world contains a significant number of such nodes.

Return value

true if the feature of the clutter (immovable) object for the node; otherwise false.

void setHandled ( bool handled ) #

Sets a new value indicating if the node handle is displayed. This option is valid only for invisible nodes, such as light and sound sources, particle systems and world-managing nodes ( WorldOccluder, triggers, expressions, etc.)

Arguments

bool handled - Set true to enable displaying of the node handle; false - to disable it.

void setID ( int id ) #

Sets a new ID of the node.

Notice

See also engine.world.getNodeByID() function.

Arguments

int id - The ID of the node.

int getID() const#

Returns the current ID of the node.

Notice

Arguments

bool enabled - Set true to enable displaying in the World Hierarchy window of the UnigineEditor for the node; false - to disable it.

bool isShowInEditorEnabled() const#

Returns the current value indicating if displaying in the World Hierarchy window of the UnigineEditor is enabled for the node.

NoticeThe node shall be displayed in the hierarchy only if this option is enabled for all of its ancestors as well.

Notice

Lifetime of each node in the hierarchy is defined by it's root (either parent or posessor). Thus, lifetime management type set for a child node that differs from the one set for the root is ignored.

Arguments

Node::LIFETIME lifetime - The lifetime management type for the root node (see the LIFETIME enum).

Node::LIFETIME getLifetime() const#

Usage Example

Source code (C++)

// implement the PropertyNodeSlotsChanged event handler
void propertynodeslotschanged_event_handler(const Ptr<Node> & node,  int num_slots)
{
	Log::message("\Handling PropertyNodeSlotsChanged event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections propertynodeslotschanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
Node::getEventPropertyNodeSlotsChanged().connect(propertynodeslotschanged_event_connections, propertynodeslotschanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
Node::getEventPropertyNodeSlotsChanged().connect(propertynodeslotschanged_event_connections, [](const Ptr<Node> & node,  int num_slots) { 
		Log::message("\Handling PropertyNodeSlotsChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
propertynodeslotschanged_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection propertynodeslotschanged_event_connection;

// subscribe to the PropertyNodeSlotsChanged event with a handler function keeping the connection
Node::getEventPropertyNodeSlotsChanged().connect(propertynodeslotschanged_event_connection, propertynodeslotschanged_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
propertynodeslotschanged_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
propertynodeslotschanged_event_connection.setEnabled(true);

// ...

// remove subscription to the PropertyNodeSlotsChanged event via the connection
propertynodeslotschanged_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A PropertyNodeSlotsChanged event handler implemented as a class member
	void event_handler(const Ptr<Node> & node,  int num_slots)
	{
		Log::message("\Handling PropertyNodeSlotsChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
Node::getEventPropertyNodeSlotsChanged().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId propertynodeslotschanged_handler_id;

// subscribe to the PropertyNodeSlotsChanged event with a lambda handler function and keeping connection ID
propertynodeslotschanged_handler_id = Node::getEventPropertyNodeSlotsChanged().connect(e_connections, [](const Ptr<Node> & node,  int num_slots) { 
		Log::message("\Handling PropertyNodeSlotsChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
Node::getEventPropertyNodeSlotsChanged().disconnect(propertynodeslotschanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all PropertyNodeSlotsChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
Node::getEventPropertyNodeSlotsChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
Node::getEventPropertyNodeSlotsChanged().setEnabled(true);

If the node was loaded from the *.node file, data is saved directly into the data tag of this file.
If the node is loaded from the *.world file, data is saved into the Node data tag of the *.world file.
If the node is loaded from the *.world file as a NodeReference, data will be saved to the NodeReference data tag of the *.world file.

Arguments

const char * name - String containing a key identifying user data to be stored in the *.node file.
Notice
The "editor_data" key is reserved for the UnigineEditor.
const char * data - New user data. Data can contain an XML formatted string.

const char * getData ( const char * name ) #

Returns user data associated with the node.

If the node was loaded from the *.node file, data from the data tag of this file is returned.
If the node is loaded from the *.world file, data from the Node data tag of the *.world file is returned.
If the node is loaded from the *.world file as a NodeReference, data from the NodeReference data tag of the *.world file is returned.

Arguments

const char * name - String containing a key identifying user data stored in the *.node file.
Notice
The "editor_data" key is reserved for the UnigineEditor.

int insertProperty ( int num, const char * name ) #

Inserts the property with the specified name at the specified position.

Arguments

int num - Position at which a new property is to be inserted, in the range from 0 to the total number of node properties.
const char * name - Name of the property to be inserted.

Return value

int insertProperty ( int num, const UGUID & guid ) #

Inserts the property with the specified GUID at the specified position.

Arguments

int num - Position at which a new property is to be inserted, in the range from 0 to the total number of node properties.
const UGUID & guid - GUID of the property to be inserted.

Return value

int insertProperty ( int num, const Ptr<Property> & property ) #

Inserts the specified property at the specified position.

Arguments

int num - Position at which a new property is to be inserted, in the range from 0 to the total number of node properties.
const Ptr<Property> & property - Property to be added.

Return value

int setProperty ( const char * name ) #

Updates the first node property (the one with a 0 index) in the list of properties associated with the node. A new internal property inherited from the one with the specified name will be set. Such internal properties are saved in a *.world or *.node file.

Arguments

const char * name - Name of the property to be set.

Return value

int setProperty ( const UGUID & guid ) #

Updates the first node property (the one with a 0 index) in the list of properties associated with the node. A new internal property inherited from the one with the specified GUID will be set. Such internal properties are saved in a *.world or *.node file.

Arguments

const UGUID & guid - GUID of the property to be set.

Return value

int setProperty ( const Ptr<Property> & property ) #

Updates the first node property (the one with a 0 index) in the list of properties associated with the node. A new internal property inherited from the one specified will be set. Such internal properties are saved in a *.world or *.node file.

Arguments

const Ptr<Property> & property - Property to be set.

Return value

int setProperty ( int num, const char * name ) #

Updates the node property with the specified number. A new internal property inherited from the one with the specified name will be set. Such internal properties are saved in a *.world or *.node file.

Arguments

int num - Node property number in the range from 0 to the total number of node properties.
const char * name - Name of the property to be set.

Return value

int setProperty ( int num, const UGUID & guid ) #

Updates the node property with the specified number. A new internal property inherited from the one with the specified GUID will be set. Such internal properties are saved in a *.world or *.node file.

Arguments

int num - Node property number in the range from 0 to the total number of node properties.
const UGUID & guid - GUID of the property to be set.

Return value

int setProperty ( int num, const Ptr<Property> & property ) #

Updates the node property with the specified number. A new internal property inherited from the specified one will be set. Such internal properties are saved in a *.world or *.node file.

Arguments

int num - Node property number in the range from 0 to the total number of node properties.
const Ptr<Property> & property - Property to be set.

Return value

void setPropertyEnabled ( int num, bool enable ) #

Enables or disables the node property with the specified number.

Arguments

int num - Node property number in the range from 0 to the total number of node properties.
bool enable - true to enable the specified node property, false to disable it.

bool isPropertyEnabled ( int num ) const#

Returns a value indicating if the node property with the specified number is enabled.

Arguments

int num - Node property number in the range from 0 to the total number of node properties.

Return value

true if the specified property is enabled; otherwise, false.

void swapProperty ( int from_num, int to_num ) #

Swaps two properties with specified numbers in the list of properties associated with the node.

Notice

The order of properties in the list determines the execution sequence of logic of corresponding components (if any).

Arguments

int from_num - Number of the first node property to be swapped, in the range from 0 to the total number of node properties.
int to_num - Number of the second node property to be swapped, in the range from 0 to the total number of node properties.

void removeProperty ( int num ) #

Removes the node property with the specified number.

Arguments

int num - Node property number in the range from 0 to the total number of node properties.

void removeProperty ( const char * name ) #

Removes the node property that has the specified name.

NoticeIf several properties with the same name are associated with the node, only the first one will be removed.

Arguments

const char * name - Name of the node property to be removed.

void removeProperty ( const UGUID & guid ) #

Removes the node property that has the GUID or parent GUID equal to the specified one.

NoticeIf several such properties are associated with the node, only the first one will be removed.

Arguments

const UGUID & guid - GUID of the property to be removed (or GUID of its parent).

void removeProperty ( const Ptr<Property> & property ) #

Removes the specified node property or a node property inherited from it.

NoticeIf several such properties are associated with the node, only the first one will be removed.

Arguments

const Ptr<Property> & property - Node property to be removed.

void clearProperties ( ) #

Clears the list of properties associated with the node.

Ptr<Property> getProperty ( int num ) const#

Returns a node property with the specified number if it exists.

Arguments

int num - Node property number in the range from 0 to the total number of node properties.

Return value

Node property smart pointer, if exists; otherwise, NULL.

const char * getPropertyName ( int num ) const#

Returns the name of a node property with the specified number.

Arguments

int num - Node property number in the range from 0 to the total number of node properties.

Return value

Property name, if exists; otherwise, NULL.

int findProperty ( const char * name ) const#

Searches for a property with the specified name among the ones assigned to the node.

Arguments

const char * name - GUID of a node property to be found.

Return value

Node property number in the range from 0 to the total number of node properties if such a property exists; otherwise -1.

int findProperty ( const UGUID & guid ) const#

Searches for a property with the specified GUID among the ones assigned to the node.

Arguments

const UGUID & guid - GUID of a node property to be found.

Return value

Node property number in the range from 0 to the total number of node properties if such a property exists; otherwise -1.

int findProperty ( const Ptr<Property> & property ) const#

Searches for a specified property among the ones assigned to the node.

Arguments

const Ptr<Property> & property - Node property to be found.

Return value

Node property number in the range from 0 to the total number of node properties if such a property exists; otherwise -1.

void setVariable ( const char * name, const Variable & v ) #

Sets the value of a variable with a given name. If such variable does not exist it will be added with a specified value.

Source code (C++)

NodeDummyPtr container;
if(container->hasVariable("key1")) {
	container->setVariable("key1", Variable(42));
}
Variable value = container->getVariable("key1");
container->removeVariable("key1");

Arguments

const char * name - Variable name.
const Variable & v - Variable value.

Variable getVariable ( const char * name ) const#

Returns the variable with a given name.

Source code (C++)

NodeDummyPtr container;
if(container->hasVariable("key1")) {
	container->setVariable("key1", Variable(42));
}
Variable value = container->getVariable("key1");
container->removeVariable("key1");

Arguments

const char * name - Variable name.

Return value

Variable if it exists; otherwise, variable with 0 value.

void setWorldParent ( const Ptr<Node> & n ) #

Sets the new parent of the node. Transformations of the current node will be done in the world coordinates.

Arguments

const Ptr<Node> & n - New parent node or NULL (0).

void setWorldTransformWithoutChildren ( const Math::Mat4 & transform ) #

Sets the transformation matrix for the node in world coordinates (transformations of all node's children are not affected). This method can be used to change node's transformation relative to its children.

Arguments

const Math::Mat4 & transform - New transformation matrix to be set for the node (world coordinates).

Math::vec3 getBodyWorldVelocity ( const Math::Vec3 & point ) const#

Returns linear velocity of a point of the node's physical body in the world space.

Arguments

const Math::Vec3 & point

Return value

Linear velocity in the world space.

void addChild ( const Ptr<Node> & n ) #

Adds a child to the node. Transformations of the new child will be done in the coordinates of the parent.

Arguments

const Ptr<Node> & n - New child node.

void addWorldChild ( const Ptr<Node> & n ) #

Adds a child to the node. Transformations of the new child will be done in the world coordinates.

Arguments

const Ptr<Node> & n - New child node.

Arguments

const char * name - Name of the node to search for.
Vector<Ptr<Node>> & OUT_nodes - Output buffer to which all found nodes with the specified name will be put.
Notice
This output buffer is to be filled by the Engine as a result of executing the method.
int recursive - 1 if the search is recursive (i.e. performed for children of child nodes); otherwise, 0.

int hasVariable ( const char * name ) #

Returns a value indicating if the node has a variable parameter with a given name.

Source code (C++)

NodeDummyPtr container;
if(container->hasVariable("key1")) {
	container->setVariable("key1", Variable(42));
}
Variable value = container->getVariable("key1");
container->removeVariable("key1");

Arguments

const char * name - Variable name.

Return value

1 if the node has a variable parameter with a given name; otherwise, 0.

int hasVariable ( ) #

Returns a value indicating if the node has a single unnamed variable parameter.

Return value

1 if the node has a single unnamed variable parameter; otherwise, 0.

bool loadWorld ( const Ptr<Xml> & xml ) #

Loads a node state from the Xml.

Arguments

const Ptr<Xml> & xml - Xml smart pointer.

Return value

void removeChild ( const Ptr<Node> & n ) #

Removes a child node (added by the addChild() method) from the list of children.

Arguments

const Ptr<Node> & n - Child node to remove.

void removeVariable ( const char * name ) #

Removes a variable parameter with a given name.

Source code (C++)

NodeDummyPtr container;
if(container->hasVariable("key1")) {
	container->setVariable("key1", Variable(42));
}
Variable value = container->getVariable("key1");
container->removeVariable("key1");

Arguments

const char * name - Variable parameter name.

Return value

void removeWorldChild ( const Ptr<Node> & n ) #

Removes a child node (added by the addWorldChild() method) from the list of children.

Arguments

const Ptr<Node> & n - Child node to remove.

void renderVisualizer ( ) #

Renders a bounding box / sphere of the object.

NoticeYou should enable the engine visualizer by the
						show_visualizer 1 console command.
					

bool saveState ( const Ptr<Stream> & stream ) const#

Saves a node state to a binary stream.

Example using saveState() and restoreState() methods:

Source code (C++)

// initialize a node and set its state
NodeDummyPtr node = NodeDummy::create();
node->setPosition(Vec3(1, 1, 0));

// save state
BlobPtr blob_state = Blob::create();
node->saveState(blob_state);

// change state
node->setPosition(Vec3(0, 0, 0));

// restore state
blob_state->seekSet(0);		// returning the carriage to the start of the blob
node->restoreState(blob_state);

Arguments

const Ptr<Stream> & stream - Stream smart pointer.

Return value

true if node state is successfully saved; otherwise, false.

bool restoreState ( const Ptr<Stream> & stream ) #

Restores a node state from a binary stream.

Example using saveState() and restoreState() methods:

Source code (C++)

// initialize a node and set its state
NodeDummyPtr node = NodeDummy::create();
node->setPosition(Vec3(1, 1, 0));

// save state
BlobPtr blob_state = Blob::create();
node->saveState(blob_state);

// change state
node->setPosition(Vec3(0, 0, 0));

// restore state
blob_state->seekSet(0);		// returning the carriage to the start of the blob
node->restoreState(blob_state);

Arguments

const Ptr<Stream> & stream - Stream smart pointer.

Return value

true if node state is successfully restored; otherwise, false.

bool saveWorld ( const Ptr<Xml> & xml ) const#

Saves the node into the Xml.

Arguments

const Ptr<Xml> & xml - Xml smart pointer.

Return value

true if the node is successfully saved; otherwise, false.

void swap ( const Ptr<Node> & n ) const#

Swaps two nodes.

Arguments

const Ptr<Node> & n - Node to swap.

Math::vec3 toLocal ( const Math::Vec3 & p ) const#

Converts a given vector in the world space to the node's local space.

Arguments

const Math::Vec3 & p - Vector in the world space.

Return value

Vector in the local space.

Math::Vec3 toWorld ( const Math::vec3 & p ) const#

Converts a given vector in the local space to the world space.

Arguments

const Math::vec3 & p - Vector in the local space.

Return value

Vector in the world space.

void translate ( const Math::Vec3 & t ) #

Translates the node relative to its local coordinate system: the parent node transformation isn't taken into account.

Arguments

const Math::Vec3 & t - Translation vector.

void translate ( Math::Scalar x, Math::Scalar y, Math::Scalar z ) #

Translates the node relative to its local coordinate system: the parent node transformation isn't taken into account.

Arguments

Math::Scalar x - Node translation along the X axis, in units.
Math::Scalar y - Node translation along the Y axis, in units.
Math::Scalar z - Node translation along the Z axis, in units.

void worldTranslate ( const Math::Vec3 & t ) #

Translates the node in the world space using the specified vector.

Arguments

const Math::Vec3 & t - Translation vector.

void worldTranslate ( Math::Scalar x, Math::Scalar y, Math::Scalar z ) #

Translates the node in the world space using the values specified for the corresponding axes.

Arguments

Math::Scalar x - Node translation along the X axis, in units.
Math::Scalar y - Node translation along the Y axis, in units.
Math::Scalar z - Node translation along the Z axis, in units.

void worldLookAt ( const Math::Vec3 & target, const Math::vec3 & up ) #

Reorients the node to "look" at the target point and sets the given up vector:

If the node is a Player-related one, it will "look" at the target point along the negative Z axis. The Y axis will be oriented along the specified up vector.
Other nodes will "look" at the target point along the Y axis. The Z axis will be oriented along the specified up vector.

Arguments

const Math::Vec3 & target - Coordinates of the target point in the world space.
const Math::vec3 & up - Up vector of the node in the world space. By default, the up vector is oriented along the Z axis.

void worldLookAt ( const Math::Vec3 & target ) #

Reorients the node to "look" at the target point. The up vector is oriented along the Z axis.

If the node is a Player-related one, it will "look" at the target point along the negative Z axis. The Y axis will be oriented along the world Z axis.
Other nodes will "look" at the target point along the Y axis.

Arguments

const Math::Vec3 & target - Coordinates of the target point in the world space.

void rotate ( const Math::quat & r ) #

Rotates the node relative to its local coordinate system: the parent node transformation isn't taken into account. Rotation is determined by the specified quaternion.

Arguments

const Math::quat & r - Rotation quaternion.

void rotate ( const Math::vec3 & angles ) #

Rotates the node in the local space. Rotation is determined by Euler angles passed as a vec3 vector.

Arguments

const Math::vec3 & angles

void rotate ( float angle_x, float angle_y, float angle_z ) #

Rotates the node in the world space according to specified Euler angles.

Arguments

float angle_x - Pitch angle, in degrees.
float angle_y - Roll angle, in degrees.
float angle_z - Yaw angle, in degrees.

void worldRotate ( const Math::quat & r ) #

Rotates the node in the world space. Rotation is determined by the specified quaternion.

Arguments

const Math::quat & r - Rotation quaternion.

void worldRotate ( const Math::vec3 & angles ) #

Rotates the node in the world space. Rotation is determined by Euler angles passed as a vec3 vector.

Arguments

const Math::vec3 & angles - Vector containing Euler angles (Pitch, Yaw, Roll).

void worldRotate ( float angle_x, float angle_y, float angle_z ) #

Rotates the node in the world space according to specified Euler angles.

Arguments

float angle_x - Pitch angle, in degrees.
float angle_y - Roll angle, in degrees.
float angle_z - Yaw angle, in degrees.

void setDirection ( const Math::vec3 & dir, const Math::vec3 & up, MathLib::AXIS axis = AXIS_NZ ) #

Updates the direction vector of the node and reorients this node: the specified axis of the node becomes oriented along the specified vector in local coordinates. For example, after running the code below, you will get the X axis of the node pointed along the Y axis in local coordinates.

Source code (C++)

// get the node
NodePtr node = World::getNodeByName("material_ball");
// set the X axis to be pointed along the Y axis in local coordinates
node->setDirection(vec3(0.0f,1.0f,0.0f),vec3(0.0f,0.0f,1.0f),Math::AXIS_X);

Arguments

const Math::vec3 & dir - New direction vector in local coordinates. The direction vector always has unit length.
const Math::vec3 & up - New up vector in local coordinates. If you skip this argument, the Z axis (in local coordinates) will be used. Note that the specified up vector is a hint vector only: the node's up vector points in the direction hinted by the specified up vector. The node's up vector matches the specified up vector (up) only if it is perpendicular to the specified direction vector (dir).
MathLib::AXIS axis - Axis along which the direction vector should be pointed. The default is the negative Z axis.

Math::vec3 getDirection ( MathLib::AXIS axis = AXIS_NZ ) const#

Returns the normalized direction vector pointing along the given node axis in local coordinates (i.e. relative to the node's parent). By default, the direction vector pointing along the negative Z axis of the node (in local coordinates) is returned. The direction vector always has a unit length.

Source code (C++)

node->getDirection(node->isPlayer() ? Math::AXIS_NZ : Math::AXIS_Y); // forward direction vector
node->getDirection(node->isPlayer() ? Math::AXIS_Z : Math::AXIS_NY); // backward direction vector
node->getDirection(node->isPlayer() ? Math::AXIS_Y : Math::AXIS_Z); // upward direction vector
node->getDirection(node->isPlayer() ? Math::AXIS_NY : Math::AXIS_NZ); // down direction vector
node->getDirection(Math::AXIS_X); // right direction vector
node->getDirection(Math::AXIS_NX); // left direction vector

Arguments

MathLib::AXIS axis - Axis along which the direction vector points. The default is the negative Z axis.

Return value

Direction vector in local coordinates.

void setWorldDirection ( const Math::vec3 & dir, const Math::vec3 & up, MathLib::AXIS axis = AXIS_NZ ) #

Updates the direction vector of the node and reorients this node: the specified axis of the node becomes oriented along the specified vector in world coordinates. For example, after running the code below, you will get the X axis of the node pointed along the Y axis in world coordinates:

Source code (C++)

// get the node
NodePtr node = World::getNodeByName("material_ball");
// set the X axis to be pointed along the Y axis in world coordinates
node->setWorldDirection(vec3(0.0f,1.0f,0.0f),vec3(0.0f,0.0f,1.0f), Math::AXIS_X);

Arguments

const Math::vec3 & dir - New direction vector in world coordinates. The direction vector always has unit length.
const Math::vec3 & up - New up vector in world coordinates. If you skip this argument, the Z axis (in local coordinates) will be used. Note that the specified up vector is a hint vector only: the node's up vector points in the direction hinted by the specified up vector. The node's up vector matches the specified up vector (up) only if it is perpendicular to the specified direction vector (dir).
MathLib::AXIS axis - Axis along which the direction vector should be pointed. The default is the negative Z axis.

Math::vec3 getWorldDirection ( MathLib::AXIS axis = AXIS_NZ ) const#

Returns the normalized direction vector pointing along the given node axis in world coordinates. By default, the direction vector pointing along the negative Z axis of the node is returned. The direction vector always has a unit length.

Source code (C++)

node->getWorldDirection(node->isPlayer() ? Math::AXIS_NZ : Math::AXIS_Y); // forward direction vector
node->getWorldDirection(node->isPlayer() ? Math::AXIS_Z : Math::AXIS_NY); // backward direction vector
node->getWorldDirection(node->isPlayer() ? Math::AXIS_Y : Math::AXIS_Z); // upward direction vector
node->getWorldDirection(node->isPlayer() ? Math::AXIS_NY : Math::AXIS_NZ); // down direction vector
node->getWorldDirection(Math::AXIS_X); // right direction vector
node->getWorldDirection(Math::AXIS_NX); // left direction vector

Arguments

MathLib::AXIS axis - Axis along which the direction vector points. The default is the negative Z axis.

Return value

Direction vector in world coordinates.

Ptr<Node> getCloneNode ( const Ptr<Node> & original_node ) #

Returns a node cloned from the specified original node.

Notice

This method is intended for use only inside the node clone callback.

Arguments

const Ptr<Node> & original_node - Original node that was cloned.

Return value

Clone of the specified original node if it exists; otherwise the original node itself.

Ptr<Property> getCloneProperty ( const Ptr<Property> & original_property ) #

Returns a node property cloned from the specified original property.

Notice

This method is intended for use only inside the node clone callback.

Arguments

const Ptr<Property> & original_property - Original node property that was cloned.

Return value

Clone of the specified original node property if it exists; otherwise the original node property itself.

void setSaveToWorldEnabledRecursive ( bool enable ) #

Sets a value indicating if saving to *.world file is enabled for the node and all its children (if any).

Arguments

bool enable - true to enable saving to *.world file for the node and all its children (if any); 0 to disable.

void setShowInEditorEnabledRecursive ( bool enable ) #

Sets a value indicating if displaying in the World Hierarchy window of the UnigineEditor is enabled for the node and all its children (if any).

Arguments

bool enable - true to enable displaying in the World Hierarchy window of the UnigineEditor for the node and all its children (if any); 0 to disable.

Node::LIFETIME getLifetimeSelf ( ) const#

Returns the lifetime management type set for the node itself.

Notice

Lifetime of each node in the hierarchy is defined by it's root (either parent or posessor). Setting lifetime management type for a child node different from the one set for the root has no effect.

Return value

Lifetime management type for the node (see the LIFETIME enum).

Math::WorldBoundBox getHierarchyBoundBox ( bool only_enabled_nodes = false ) const#

Returns a bounding box with local coordinates that takes children into account, but doesn't participate in physics calculations. Exclusion of objects from the spatial tree significantly reduces the size of the tree and improves performance due to saving time on bounding box recalculation when transforming nodes.

Arguments

bool only_enabled_nodes - Set true to obtain the result taking into account only the nodes in the hierarchy that are enabled, or false - to take into account all nodes in the hierarchy regardless of their enabled state.

Return value

The bounding box with world coordinates.

Math::WorldBoundSphere getHierarchyBoundSphere ( bool only_enabled_nodes = false ) const#

Returns a bounding sphere with local coordinates that takes children into account, but doesn't participate in physics calculations. Exclusion of objects from the spatial tree significantly reduces the size of the tree and improves performance due to saving time on bounding sphere recalculation when transforming nodes.

Arguments

bool only_enabled_nodes - Set true to obtain the result taking into account only the nodes in the hierarchy that are enabled, or false - to take into account all nodes in the hierarchy regardless of their enabled state.

Return value

The bounding sphere with world coordinates.

Math::WorldBoundBox getHierarchyWorldBoundBox ( bool only_enabled_nodes = false ) const#

Returns a bounding box with world coordinates that takes children into account, but doesn't participate in physics calculations. Exclusion of objects from the spatial tree significantly reduces the size of the tree and improves performance due to saving time on bounding box recalculation when transforming nodes.

Arguments

bool only_enabled_nodes - Set true to obtain the result taking into account only the nodes in the hierarchy that are enabled, or false - to take into account all nodes in the hierarchy regardless of their enabled state.

Return value

The bounding box with world coordinates.

Math::WorldBoundSphere getHierarchyWorldBoundSphere ( bool only_enabled_nodes = false ) const#

Returns a bounding sphere with world coordinates that takes children into account, but doesn't participate in physics calculations. Exclusion of objects from the spatial tree significantly reduces the size of the tree and improves performance due to saving time on bounding sphere recalculation when transforming nodes.

Arguments

bool only_enabled_nodes - Set true to obtain the result taking into account only the nodes in the hierarchy that are enabled, or false - to take into account all nodes in the hierarchy regardless of their enabled state.

Return value

The bounding sphere with world coordinates.

Math::WorldBoundBox getHierarchySpatialBoundBox ( bool only_enabled_nodes = false ) const#

Returns a bounding box with world coordinates that takes all children and physics into account. This bounding box is used by the spatial tree.

Arguments

bool only_enabled_nodes - Set true to obtain the result taking into account only the nodes in the hierarchy that are enabled, or false - to take into account all nodes in the hierarchy regardless of their enabled state.

Return value

The bounding box with world coordinates.

Math::WorldBoundSphere getHierarchySpatialBoundSphere ( bool only_enabled_nodes = false ) const#

Returns a bounding sphere with world coordinates that takes all children and physics into account. This bounding sphere is used by the spatial tree.

Arguments

bool only_enabled_nodes - Set true to obtain the result taking into account only the nodes in the hierarchy that are enabled, or false - to take into account all nodes in the hierarchy regardless of their enabled state.

Return value

The bounding sphere with world coordinates.

virtual void updateSpatialTree ( ) #

Updates node bounds in the spatial tree in the current frame. This method can be used in case you use some custom logic affecting node bounds or position and need to have your changes to be taken into account in the current frame, as well as to process such changes for your custom nodes ( ObjectExtern, NodeExtern) which are otherwise ignored. Calling this method enables you to apply changes for this node fast without complete tree recalculation. But you should be aware that node bounds fast-updated this way might be inaccurate (they can only be expanded, as shrinking will require tree recalculation). In case you need to have 100% accurate bounds in the current frame, call the World::updateSpatial() method. You can also simply tell the spatial tree to update node bounds in the next frame via the updateSpatialTreeDelayed() method.

void updateSpatialTreeDelayed ( ) #

Mark node bounds in the spatial tree to be updated in the next frame (all bounds will be 100% accurate in this case unlike for the updateSpatialTree() method). This method can be used in case you use some custom logic affecting node bounds or position, as well as to process such changes for your custom nodes ( ObjectExtern, NodeExtern) which are otherwise ignored. The changes will only be applied in the next frame, in case you need to have your changes to be taken into account right in the current frame use the World::updateSpatial() method for 100% accurate bounds (slow), or the fast updateSpatialTree() method which only expands node bounds if necessary.

Ptr<WorldTrigger> getWorldTrigger ( int num ) #

Returns one of the World Triggers inside which the node is located at the moment by its number. For any node in the world, you can check whether it is currently inside any World Trigger and access any of such triggers by simply calling this method.

Arguments

int num - Number of the World Trigger in the list of World Triggers inside which the node is located at the moment.

Return value

World Trigger with the specified number inside which the node is located at the moment.

UGUID getLostNodePropertyGUID ( int num ) const#

Returns the GUID of a lost property assigned to the node. If for some reason a property assigned to the specified slot of the node is missing, this method can be used to get it's GUID.

Arguments

int num - Target property slot number.

Return value

Lost property GUID.

void renderBounds ( bool render_node_bound = true, bool render_instance_bound = false ) #

Renders the node bounds. The method is applied for checking the actual size of the CPU-rendered node bounds that may differ from the GPU-rendered mesh size, if the latter has been modified by the shader. For nodes that consist of multiple mesh instances (Clutter, Cluster) rendering of each individual mesh bound is also available.

Arguments

bool render_node_bound - true to enable rendering of the node bounds, false to disable it.
bool render_instance_bound - true to enable bound rendering for each individual mesh instance (applicable for Clutter and Cluster nodes), false to disable it.

int getIDFromFile ( ) const#

Returns the node ID from the *.node or a *.world file if the node has been loaded from this file.

Return value

Node ID from the *.node or a *.world file. For the node created via code, -1 is returned.

void applyReplacePaths ( ) #

Restores the engine's ability to replace baked textures (lightmap, shadow map) inside Node References in runtime. This method is to be applied if hierarchy inside a Node Reference or a path to the baked texture has been modified thus causing rendering of an unsuitable lightmap or a shadow map.

Last update: 2024-08-16

Help improve this article

Was this article helpful?

Report a problem related to this article

(or select a word/phrase and press Ctrl+Enter)

Unigine::Node Class

In This Article:

See Also#

Creating a Node#

Editing a Node and Saving Changes#

Exporting and Importing a Node#

Deleting a Node#

功能列表:

Node Class

枚举

TYPE#

LIFETIME#

Members

Ptr<GeodeticPivot> getGeodeticPivot() const#

Return value

void setVariable ( const Variable & variable ) #

Arguments

const Variable & getVariable() const#

Return value

void setWorldScale ( const Math::vec3& scale ) #

Arguments

Math::vec3 getWorldScale() const#

Return value

void setWorldPosition ( const Math::Vec3& position ) #

Arguments

Math::Vec3 getWorldPosition() const#

Return value

void setScale ( const Math::vec3& scale ) #

Arguments

Math::vec3 getScale() const#

Return value

void setPosition ( const Math::Vec3& position ) #

Arguments

Math::Vec3 getPosition() const#

Return value

Math::vec3 getBodyAngularVelocity() const#

Return value

Math::vec3 getBodyLinearVelocity() const#

Return value

Ptr<BodyRigid> getObjectBodyRigid() const#

Return value

Ptr<Body> getObjectBody() const#

Return value

Math::WorldBoundSphere getWorldBoundSphere() const#

Return value

Math::WorldBoundBox getWorldBoundBox() const#

Return value

Math::BoundSphere getBoundSphere() const#

Return value

Math::BoundBox getBoundBox() const#

Return value

void setOldWorldTransform ( const Math::Mat4& transform ) #

Arguments

Math::Mat4 getOldWorldTransform() const#

Return value

void setWorldTransform ( const Math::Mat4& transform ) #

Arguments

Math::Mat4 getWorldTransform() const#

Return value

void setTransform ( const Math::Mat4& transform ) #

Arguments

Math::Mat4 getTransform() const#

Return value

int getNumProperties() const#

Return value

Ptr<Node> getPossessor() const#

Return value

int getNumChildren() const#

Return value

Ptr<Node> getRootNode() const#

Return value

void setParent ( const Ptr<Node>& parent ) #

Arguments

Ptr<Node> getParent() const#

Return value

int getNumAncestors() const#

Return value

void setName ( const char * name ) #

Arguments

const char * getName() const#