Programming
Fundamentals
Setting Up Development Environment
Usage Examples
UnigineScript
C++
C#
UUSL (Unified UNIGINE Shader Language)
File Formats
Rebuilding the Engine and Tools
GUI
Double Precision Coordinates
API
Containers
Common Functionality
Controls-Related Classes
Engine-Related Classes
Filesystem Functionality
GUI-Related Classes
Math Functionality
Node-Related Classes
Networking Functionality
Pathfinding-Related Classes
Physics-Related Classes
Plugins-Related Classes
CIGI Client Plugin
Rendering-Related Classes

Unigine::Node Class

Header:#include <UnigineNode.h>

In terms of Unigine, all of the objects added into the scene are called nodes. Nodes can be of different types, determining their visual representation and behavior.

The node is created and stored in the world. All changes are saved into the .world file.

The node can be also saved into an external .node file and then imported into the world when necessary. Also it is possible to create a reference to the exported node.

You can associate any string data (written directly into a *.node or a *.world file) or an arbitrary user variable with a node.

See Also

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 the getNode() method.

For example:

  1. Create a box mesh by using the Mesh class.
  2. Use the box mesh to create an instance of the ObjectMeshStatic class. This class is inherited from the Node class.
  3. Get the node from the ObjectMeshStatic instance via the getNode() method.
Source code (C++)
// AppWorldLogic.cpp
			
#include "AppWorldLogic.h"
#include <UnigineNode.h>
#include <UnigineObjects.h>

using namespace Unigine;
using namespace Math;

int AppWorldLogic::init() {

	// create a mesh
	MeshPtr mesh = Mesh::create();
	mesh->addBoxSurface("box_0",vec3(1.0f));
	// 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
	ObjectMeshStaticPtr object_mesh = ObjectMeshStatic::create(mesh);

	// declare a smart pointer for the node
	// and obtain the node pointer from the created ObjectMeshStatic
	NodePtr node = object_mesh->getNode();

	return 1;
}

Now you can operate the ObjectMeshStatic 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.

Notice
The 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, it should be added to UnigineEditor first: you should pass node ownership to the editor by releasing script ownership and call the addNode() method of the Editor class.

For example:

  1. Create a box mesh by using the Mesh class.
  2. 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.
  3. Use the saved .mesh file to create an instance of the ObjectMeshStatic class. This class is inherited from the Node class.
  4. Release script ownership of the ObjectMeshStatic instance.
  5. Get the node from the ObjectMeshStatic instance via the getNode() method.
  6. Add the node to UnigineEditor.
  7. Edit the node and save the world by calling the world_save console command.
Source code (C++)
#include "AppWorldLogic.h"

#include <UnigineNode.h>
#include <UnigineObjects.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");
	// 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");
	// assign a material to the mesh
	object_mesh->setMaterial("mesh_base","*");
	// release script ownership
	object_mesh->release();

	// declare a smart pointer for the node
	// and obtain the node pointer from the created NodeDummy
	NodePtr node = object_mesh->getNode();

	// pass node ownership to the editor by adding the node to it
	Editor::get()->addNode(node);

	// 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::get()->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:

  1. Create a box mesh by using the Mesh class.
  2. 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.
  3. Use the saved .mesh file to create an instance of the ObjectMeshStatic class. This class is inherited from the Node class.
  4. Release script ownership of the ObjectMeshStatic instance.
  5. Get the node from the ObjectMeshStatic instance via the getNode() method and Pass node ownership to the editor by adding it the node to it.
  6. Export the node to an external .node file.
  7. Import the prevoiusly exported node and add it to the editor to check the result.
    Notice
    The node imported via loadNode() is orphan, so you don't need to release script ownership.
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");
	// assign a material to the mesh
	object_mesh->setMaterial("mesh_base", "*");
	// release script ownership
	object_mesh->release();
	// declare a smart pointer for the node
	// and obtain the node pointer from the created NodeDummy
	NodePtr node = object_mesh->getNode();

	// pass node ownership to the editor by adding the node to it
	Editor::get()->addNode(node);

	// export the node into a .node file
	World::get()->saveNode("unigine_project/nodes/my_node.node", node);
	// import the exported node to check the result
	NodePtr imported_node = World::get()->loadNode("unigine_project/nodes/my_node.node");
	// add the imported node to the editor
	//note: an imported node is orphan so you don't need to release script ownership
	Editor::get()->addNode(imported_node);
	// set a position of the node
	imported_node->setPosition(Vec3(4.0f, 0.0f, 1.0f));

	return 1;
}

Deleting a Node

To delete a node owned by UnigineEditor, pass it to the removeNode() method of the Editor class.

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));
	// create an instance of any class inherited from the Node class (e.g. ObjectMeshStatic)
	ObjectMeshStaticPtr object_mesh = ObjectMeshStatic::create(mesh);
	// assign a material to the mesh
	object_mesh->setMaterial("mesh_base", "*");
	// release script ownership
	object_mesh->release();
	// declare a smart pointer for the node
	// and obtain the node pointer from the created NodeDummy
	NodePtr node = object_mesh->getNode();

	// pass node ownership to the editor by adding the node to it
	Editor::get()->addNode(node);

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

	// delete the node from the editor
	Editor::get()->removeNode(node);
	
	// clear the mesh
	mesh->clear();

	return 1;
}

Node Class

Members


Ptr<Node> getAncestor(int num)

Returns a node ancestor by its number.

Arguments

  • int num - Ancestor ID.

Return value

Ancestor node.

Math::vec3 getAngularVelocity()

Returns the angular velocity of the node's physical body in the local space.

Return value

Angular velocity in the local space.

BoundBox getBoundBox()

Returns the bounding box of the node.

Return value

The bounding box.

BoundSphere getBoundSphere()

Returns the bounding sphere of the node.

Return value

Bounding sphere of the node.

Ptr<Node> getChild(int num)

Returns a node child by its number.

Arguments

  • int num - Child ID.

Return value

Child node.

int isChild(const Ptr<Node> & n)

Checks if a given node is a child of the node.

Arguments

  • const Ptr<Node> & n - Node to check.

Return value

1 if the given node is a child; otherwise, 0.

void setChildIndex(const Ptr<Node> & n, int index)

Sets the index for a given child node of the node.

Arguments

  • const Ptr<Node> & n - Child node.
  • int index - Node index.

int getChildIndex(const Ptr<Node> & n)

Returns the index of a given child node of the node.

Arguments

  • const Ptr<Node> & n - Child node.

Return value

Node index.

void setClutter(int clutter)

Sets a value indicating if the node represents a clutter object.

Arguments

  • int clutter - Positive number to mark the node as a clutter object; otherwise, 0.

int isClutter()

Returns a value indicating if the node is a clutter object.

Return value

1 if the node is a clutter object; otherwise, 0.

void setCollider(int collider)

Updates a value indicating if collision detection is enabled for the node (i.e. the node is a collider object). If it is disabled, the node is removed from the physical scene and does not participate in physical interactions.
Notice
Collision detection tests can be performed using getCollision() methods of the World class.

Arguments

  • int collider - Positive number to enable collision detection, 0 to disable.

int isCollider()

Returns a value indicating if collision detection is enabled for the node.

Return value

1 if collision detection is enabled for the node; otherwise, 0.

void setData(const char * data)

Sets user data associated with the node.
  • 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 * data - New user data. Data can contain an XML formatted string.

const char * getData()

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.

Return value

User string data. Data can be an xml formatted string.

int isDecal()

Returns a value indicating if the node is a decal node (its type is DECAL_*).

Return value

1 if the node is a decal node; otherwise, 0.

void setDirection(const Math::vec3 & dir, const Math::vec3 & up)

Updates the direction vector of the node. By default, a direction vector points along -Z axis. This function changes its direction and reorients the node.

Arguments

  • const Math::vec3 & dir - New direction vector in the local space. The direction vector always has unit length.
  • const Math::vec3 & up - New "up" vector in the local space.

Math::vec3 getDirection()

Returns the normalized direction vector of the node. By default, a direction vector points along the mesh local -Z axis. It always has an unit length.

Return value

Normalized direction vector in the local space.

void setEnabled(int enabled)

Enables or disables the node.

Arguments

  • int enabled - 1 to enable the node, 0 to disable it.

int isEnabled()

Returns a value indicating if the node and its parent nodes are enabled.

Return value

1 if the node and its parent nodes are enabled; otherwise, 0.

int isEnabledSelf()

Returns a value indicating if the node is enabled.

Return value

1 if the node is enabled; otherwise, 0.

int isExtern()

Returns a value indicating if the node is an extern node (its type is one of the following: NODE_EXTERN, OBJECT_EXTERN, WORLD_EXTERN).

Return value

1 if the node is an extern node; otherwise, 0.

int isField()

Returns a value indicating if the node is a field node (its type is one of the FIELD_*).

Return value

1 if the node is a field node; otherwise, 0.

void setFolded(int folded)

Shows or minimizes node children in the node tree hierarchy.

Arguments

  • int folded - Positive number to minimize node children; 0 to expand node hierarchy.

int isFolded()

Returns a value indicating if node children are displayed or minimized in the node tree hierarchy.

Return value

Positive number if node children are hidden in the node tree; otherwise, 0.

int isGeodetic()

Returns a value indicating if the node is a geodetic-related node.

Return value

1 if the node is a geodetic-related node; otherwise, 0.

Ptr<GeodeticPivot> getGeodeticPivot()

Returns a pointer to geodetic pivot of the node.

Return value

Geodetic pivot smart pointer, or NULL if the node is not a child of a geodetic pivot node.

void setHandled(int handled)

Disables or shows the node handle. This option is valid only for invisible nodes, such as light and sound sources, particle systems and world-managing nodes (WorldSector, WorldPortal, WorldOccluder, triggers, expressions, etc.)

Arguments

  • int handled - Positive value to show the handle, 0 to hide it.

int isHandled()

Returns a 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 (WorldSector, WorldPortal, WorldOccluder, triggers, expressions, etc.)

Return value

1 if the handle is shown; otherwise, 0.

void deleteHierarchy(const Ptr<Node> & node)

Deletes the whole hierarchy of the given node.

Arguments

  • const Ptr<Node> & node - Node, the hierarchy of which is to be deleted.

void getHierarchy(Vector< Ptr<Node> > & hierarchy)

Retrieves the whole hierarchy of the node and puts it to the hierarchy buffer.

Arguments

  • Vector< Ptr<Node> > & hierarchy - Hierarchy buffer.

int setID(int id)

Sets a unique ID for the node.

Arguments

  • int id - Node ID.

Return value

1 if the ID is set successfully; otherwise, 0.

int getID()

Returns the ID of the node.
Notice
See also engine.world.getNode() function.

Return value

Node ID.

Math::Mat4 getIWorldTransform()

Returns the inverse transformation matrix of the node for transformations in the world coordinates.

Return value

Inverse transformation matrix.

void setLatest(int latest)

Sets a flag that forces a node to be updated the last of all, after states of all other nodes were updated. For example, a post update flag is useful to draw nodes strictly in front of the camera (after a Player has updated its transformations). By default, this flag is set to 0.

Arguments

  • int latest - Positive value to update a node last of all; otherwise, 0.

int isLatest()

Checks if a node is forced to be updated the last of all, after states of all other nodes were updated. For example, a post update flag is useful to draw nodes strictly in front of the camera (after a Player has updated its transformations). By default, this flag is set to 0.

Return value

1 if the node is updated last of all; otherwise, 0

int isLight()

Returns a value indicating if the node is a light source (its type is LIGHT_*).

Return value

1 if the node is a light source; otherwise, 0.

Math::vec3 getLinearVelocity()

Returns the linear velocity of the node's physical body in the local space.

Return value

Linear velocity in the local space.

void setName(const char * name)

Sets a name for the node.

Arguments

  • const char * name - New name of the node.

const char * getName()

Returns the name of the node.

Return value

Name of the node.

int isNavigation()

Returns a value indicating if a given node is a navigation node.

Return value

Returns 1 if the given node is a navigation node; otherwise, 0.

Ptr<Node> getNode()

Returns a node pointer.

Return value

Node pointer.

Ptr<Node> getNode(int id)

Returns a node pointer.

Arguments

  • int id - Node identifier.

Return value

Node pointer.

int isNode(const Ptr<Node> & node)

Check the node pointer.

Arguments

  • const Ptr<Node> & node - Node pointer.

Return value

Returns 1 if the node is valid; otherwise, 0.

int isNode(int id)

Check the node pointer.

Arguments

  • int id - Node pointer.

Return value

Returns 1 if the node is valid; otherwise, 0.

int getNumAncestors()

Returns the number of ancestors of the node.

Return value

Number of ancestors.

int getNumChildren()

Returns the number of children of the node.

Return value

Number of child nodes.

int isObject()

Returns a value indicating if the node is an object node (its type is OBJECT_*).

Return value

1 if the node is an object node; otherwise, 0.

Ptr<Body> getObjectBody()

Returns a physical body assigned to the node if it is an object node.

Return value

Body assigned to the object node; otherwise, NULL (0).

Ptr<BodyRigid> getObjectBodyRigid()

Returns a rigid body assigned to the node if it is an object node.

Return value

Rigid body assigned to the object node; otherwise, NULL (0).

int isObstacle()

Returns a value indicating if the node is an obstacle node (its type is OBSTACLE_*).

Return value

Returns 1 if the given node is an obstacle node; otherwise, 0.

void setOldWorldTransform(const Math::Mat4 & transform)

Sets old transformation matrix for the node in the world coordinates.

Arguments

  • const Math::Mat4 & transform - Old transformation matrix to be set.

Math::Mat4 getOldWorldTransform()

Returns old transformation matrix for the node in the world coordinates.

Return value

Old transformation matrix.

int isOwner()

Returns the owner flag. If the pointer is the owner, on its deletion the node also will be deleted. Use grab() and release() functions to change ownership

Return value

Owner flag.

void setParent(const Ptr<Node> & parent)

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

Arguments

  • const Ptr<Node> & parent - New parent node.

Ptr<Node> getParent()

Returns the parent of the node.

Return value

Parent node or NULL (0), if the node has no parent.

int isPhysical()

Returns a value indicating if the node is a physical node (its type is PHYSICAL_*).

Return value

1 if the node is a physical node; otherwise, 0.

int isPlayer()

Returns a value indicating if the node is a player node (its type is PLAYER_*).

Return value

1 if the node is a player node; otherwise, 0.

void setPosition(const Math::Vec3 & pos)

Sets the node position.

Arguments

  • const Math::Vec3 & pos - Node position in the local space

Math::Vec3 getPosition()

Returns the node position.

Return value

Node position in the local space

Ptr<Node> getPossessor()

Returns a possessor of the node. The following nodes can be possessors:
  • NodeReference
  • WorldCluster
  • WorldClutter
  • WorldLayer
This function can only be applied to a root node inside a node reference.

Return value

Node posessor, if it exists; otherwise, NULL.

int setProperty(const char * name)

Associates a given property with the whole node.

Arguments

  • const char * name - Property name.

Return value

1 if the property is set successfully; otherwise, 0.

Ptr<Property> getProperty()

Returns a property associated with the node.

Return value

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

const char * getPropertyName()

Returns the name of a property associated with the node.

Return value

Property name, if exists; otherwise, NULL.

void setQuery(int query)

Updates a value indicating if occlusion query is used for the node.

Arguments

  • int query - Positive number to use occlusion query, 0 not to use.

int isQuery()

Returns a value indicating if occlusion query is used for the node. The default is 0 (not used).

Return value

1 if occlusion query is used; otherwise, 0.

Ptr<Node> getRootNode()

Returns the root node for the node.

Return value

Root node the root node for the node.

void setRotation(const Math::quat & rot, int identity = 0)

Sets the node rotation.

Arguments

  • const Math::quat & rot - Node rotation in the local space.
  • int identity - 1 to enable scaling of the node, 0 to disable it.

Math::quat getRotation()

Returns the node rotation.

Return value

Node rotation in the local space.

void setScale(const Math::vec3 & s)

Sets the scale of the node.

Arguments

  • const Math::vec3 & s - Node scale in the local space.

Math::vec3 getScale()

Returns the scale of the node.

Return value

Node scale in the local space.

int isShadow()

Returns a value indicating if the node was a shadow caster in the previous frame and, therefore, is updated.

Return value

1 if the node was a shadow caster; otherwise, 0.

int isSound()

Returns a value indicating if the node is a sound node (its type is SOUND_*).

Return value

1 if the node is a sound node; otherwise, 0.

void setSpatial(int spatial)

Updates a value indicating if sectors and portals are used for node visibility determination.

Arguments

  • int spatial - Positive value to consider sectors and portals; otherwise, 0.

int isSpatial()

Returns a value indicating if sectors and portals are used for node visibility determination.

Return value

Returns 1 if sectors and portals are considered; otherwise, 0.

void setTransform(const Math::Mat4 & transform)

Sets the transformation matrix for the node in its parent coordinates.

Arguments

  • const Math::Mat4 & transform - New transformation matrix.

Math::Mat4 getTransform()

Returns the transformation matrix of the node in its parent coordinates.

Return value

Transformation matrix.

int getType()

Returns a type of the node.

Return value

Node type identifier.

int getTypeId(const char * type)

Returns the ID of a node type with a given name.

Arguments

  • const char * type - Node type name.

Return value

Node type ID, if such type exists; otherwise, -1.

const char * getTypeName()

Returns a name of the node type.

Return value

Node type name.

const char * getTypeName(int type)

Returns the name of a node type with a given ID.

Arguments

  • int type - Node type ID.

Return value

Node type name.

int isVisible()

Returns a value indicating if the node was shown in the viewport in the previous frame and, therefore, is updated.

Return value

1 if the node was visible; otherwise, 0.

int isWorld()

Returns a value indicating if the node is a world node (its type is WORLD_*).

Return value

1 if the node is a world node; otherwise, 0.

Math::vec3 getWorldBack()

Returns the normalized "back" vector of the node. This vector always has a unit length.

Return value

Normalized "back" vector in the world space.

UNIGINE_BOUND_BOX getWorldBoundBox()

Returns the world bounding box of the node.

Return value

World bounding box.

UNIGINE_BOUND_SPHERE getWorldBoundSphere()

Returns the world bounding sphere of the node.

Return value

World bounding sphere.

void setWorldDirection(const Math::vec3 & dir, const Math::vec3 & up)

Sets the direction vector of the node. By default, a direction vector points along -Z axis. This function changes its direction and reorients the node.

Arguments

  • const Math::vec3 & dir - New direction vector in the world space. The direction vector always has a unit length.
  • const Math::vec3 & up - New up vector in the world space.

Math::vec3 getWorldDirection()

Returns the normalized direction vector of the node. By default, a direction vector points along the mesh local -Z axis and is returned in world space coordinates. It always has a unit length.

Return value

Normalized direction vector in the world space.

Math::vec3 getWorldDown()

Returns the normalized "down" vector of the node. This vector always has a unit length.

Return value

Normalized "down" vector in the world space.

Math::vec3 getWorldForward()

Returns the normalized "forward" vector of the node. This vector always has a unit length.

Return value

Normalized "forward" vector in the world space.

Math::vec3 getWorldLeft()

Returns the normalized "left" vector of the node. This vector always has a unit length.

Return value

Normalized "left" vector in the world space.

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.

void setWorldPosition(const Math::Vec3 & pos)

Sets the node position in the world coordinates.

Arguments

  • const Math::Vec3 & pos

Math::Vec3 getWorldPosition()

Returns the node position in the world coordinates.

Return value

Node position in the world space.

Math::vec3 getWorldRight()

Returns the normalized "right" vector of the node. This vector always has a unit length.

Return value

Normalized "right" vector in the world space.

void setWorldRotation(const Math::quat & rot, int identity = 0)

Sets the node rotation in the world space.

Arguments

  • const Math::quat & rot - Node rotation in the world space.
  • int identity - 1 to enable scaling of the node, 0 to disable it.

Math::quat getWorldRotation()

Returns the node rotation in the world space.

Return value

Node rotation in the world space.

void setWorldScale(const Math::vec3 & s)

Sets the node scale in the world space.

Arguments

  • const Math::vec3 & s - Node scale in the world space.

Math::vec3 getWorldScale()

Returns the node scale in the world space.

Return value

Node scale in the world space.

Ptr<WorldSector> getWorldSector()

Returns a sector, in which the node is located.

Return value

World sector.

void setWorldTransform(const Math::Mat4 & transform)

Sets the transformation matrix for the node in the world coordinates.

Arguments

  • const Math::Mat4 & transform - Transformation matrix.

Math::Mat4 getWorldTransform()

Returns the transformation matrix of the node in the world coordinates.

Return value

Transformation matrix.

Math::vec3 getWorldUp()

Returns the normalized "up" vector of the node. This vector always has a unit length.

Return value

Normalized "up" vector in the world space.

Math::vec3 getWorldVelocity(const Math::Vec3 & point)

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.

Ptr<Node> clone()

Clones the current node.

Return value

Cloned node.

int findAncestor(int type)

Returns the ID of node's ancestor of a given type.

Arguments

  • int type - Ancestor type identifier. One of the NODE_* pre-defined variables.

Return value

Ancestor ID if it exists; otherwise -1.

int findAncestor(const char * name)

Returns the ID of node's ancestor with a given name.

Arguments

  • const char * name - Ancestor name.

Return value

Ancestor ID if it exists; otherwise -1.

int findChild(const char * name)

Searches for a child node with a given name among the children of the node.

Arguments

  • const char * name - Name of the child node.

Return value

Child node number, if it is found; otherwise, -1.

Ptr<Node> findNode(const char * name, int recursive = 0)

Searches for a node with a given name among the children of the node.

Arguments

  • const char * name - Name of the child node.
  • int recursive - 1 if the search is recursive (i.e. performed for children of child nodes); otherwise, 0.

Return value

Child node, if it is found; otherwise, NULL.

void grab()

Grabs the node (sets the owner flag to 1). The node should not be handled by the engine after this function is called.

int loadWorld(const Ptr<Xml> & xml)

Loads a node state from the Xml.

Arguments

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

Return value

1 if the node state is loaded successfully; otherwise, 0.

void release()

Releases the node (sets the owner flag to 0). The node should be handled by the engine after this function is called.

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 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.
Notice
You should enable the engine visualizer by the show_visualizer 1 console command.

int restoreState(const Ptr<Stream> & stream)

Restores a node state from the stream.
Warning
This function is deprecated and will be removed in the next release.

Arguments

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

Return value

1 if node state is successfully restored; otherwise, 0.

void rotate(const Math::quat & r)

Rotates the node. Rotation is determined by the specified quaternion.

Arguments

  • const Math::quat & r - Rotation quaternion.

int saveState(const Ptr<Stream> & stream)

Saves a node state into the stream.
Warning
This function is deprecated and will be removed in the next release.

Arguments

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

Return value

1 if node state is successfully saved; otherwise, 0.

int saveWorld(const Ptr<Xml> & xml)

Saves a node state into the Xml.

Arguments

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

Return value

1 if the node state is saved successfully; otherwise, 0.

void scale(const Math::vec3 & s)

Scales the node.

Arguments

  • const Math::vec3 & s - Scale vector.

void swap(const Ptr<Node> & n)

Swaps two nodes.

Arguments

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

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

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)

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.

Arguments

  • const Math::Vec3 & t - Translation vector.

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

Sets viewing matrix of the node.

Arguments

  • const Math::Vec3 & target - Coordinates of the target point in the world space.
  • const Math::vec3 & up - Coordinates of the "up" vector in the world space.

void worldLookAt(const Math::Vec3 & target)

Reorients the node to "look" at the target point of the node. Direction vector of the node will point to the target point.

Arguments

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

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 worldScale(const Math::vec3 & s)

Scales the node in the world space.

Arguments

  • const Math::vec3 & s - Scale vector.

void worldTranslate(const Math::Vec3 & t)

Translates the node in the world space.

Arguments

  • const Math::Vec3 & t - Translation vector.

int DECAL_BEGIN

Description

Begin of the decal nodes range.

int DECAL_END

Description

End of the decal nodes range.

int DECAL_MESH

Description

Mesh decal node. See the DecalMesh class.

int DECAL_ORTHO

Description

Orthographic decal node. See the DecalOrtho class.

int DECAL_PROJ

Description

Projected decal node. See the DecalProj class.

int DUMMY

Description

Dummy node. See the NodeDummy class.

int EXTERN

Description

Extern node.

int FIELD_ANIMATION

Description

Field Animation node. See the FieldAnimation class.

int FIELD_BEGIN

Description

Begin of the field nodes range.

int FIELD_END

Description

End of the field nodes range.

int FIELD_HEIGHT

Description

Field Height node. See the FieldHeight class.

int FIELD_SHORELINE

Description

Field Shoreline node. See the FieldShoreline class.

int FIELD_SPACER

Description

Field Spacer node. See the FieldSpacer class.

int FIELD_WEATHER

Description

Field Weather node. See the FieldWeather class.

int GEODETIC_BEGIN

Description

Begin of the geodetic nodes range.

int GEODETIC_END

Description

End of the geodetic nodes range.

int GEODETIC_PIVOT

Description

Geodetic Pivot node. See the GeodeticPivot class.

int LAYER

Description

Node layer containing parent layer and all its child nodes. See the NodeLayer class.

int LIGHT_BEGIN

Description

Begin of the light nodes range.

int LIGHT_END

Description

End of the light nodes range.

int LIGHT_ENVIRONMENT_PROBE

Description

Environment probe. See the LightEnvironmentProbe class.

int LIGHT_OMNI

Description

Omni-directional light source. See the LightOmni class.

int LIGHT_PROJ

Description

Projected light source. See the LightProj class.

int LIGHT_WORLD

Description

World light source. See the LightWorld class.

int NAVIGATION_BEGIN

Description

Begin of the navigation nodes range.

int NAVIGATION_END

Description

End of the navigation nodes range.

int NAVIGATION_MESH

Description

Mesh-based navigation area across which pathfinding is performed. See the NavigationMesh class.

int NAVIGATION_SECTOR

Description

Sector within which pathfinding is performed. See the NavigationSector class.

int NODE_DUMMY

Description

Dummy node. See the NodeDummy class.

int NODE_EXTERN

Description

Extern node. See the NodeExtern class.

int NODE_LAYER

Description

Layer node. See the NodeLayer class.

int NODE_PIVOT

Description

Pivot node. See the NodePivot class.

int NODE_REFERENCE

Description

Node reference. See the NodeReference class.

int NODE_TRIGGER

Description

Node trigger. See the NodeTrigger class.

int NUM_DECALS

Description

Counter of decal node types.

int NUM_FIELDS

Description

Counter of field node types.

int NUM_GEODETICS

Description

Counter of geodetic node types.

int NUM_LIGHTS

Description

Counter of light node types.

int NUM_NAVIGATIONS

Description

Counter of navigation node types.

int NUM_NODES

Description

Counter of node types.

int NUM_OBJECTS

Description

Counter of object node types.

int NUM_OBSTACLES

Description

Counter of obstacle node types.

int NUM_PHYSICALS

Description

Counter of physical node types.

int NUM_PLAYERS

Description

Counter of player node types.

int NUM_SOUNDS

Description

Counter of sound node types.

int NUM_WORLDS

Description

Counter of world node types.

int OBJECT_BEGIN

Description

Begin of the object nodes range.

int OBJECT_BILLBOARDS

Description

Billboards object for rendering a high number of billboards. See the ObjectBillboard class.

int OBJECT_CLOUD_LAYER

Description

Cloud layer object. See the ObjectCloudLayer class.

int OBJECT_DUMMY

Description

Dummy object. See the ObjectDummy class.

int OBJECT_DYNAMIC

Description

Dynamic object. See the ObjectDynamic class.

int OBJECT_END

Description

End of the object nodes range.

int OBJECT_EXTERN

Description

Extern object. See the ObjectExtern class.

int OBJECT_GRASS

Description

Grass. See the ObjectGrass class.

int OBJECT_GUI

Description

GUI object. See the ObjectGui class.

int OBJECT_GUI_MESH

Description

GUI mesh object. See the ObjectGuiMesh class.

int OBJECT_MESH_CLUSTER

Description

Mesh Cluster object. See the ObjectMeshCluster class.

int OBJECT_MESH_CLUTTER

Description

Mesh Clutter object. See the ObjectMeshClutter class.

int OBJECT_MESH_DYNAMIC

Description

Dynamic mesh object. See the ObjectMeshDynamic class.

int OBJECT_MESH_SKINNED

Description

Skinned mesh object. See the ObjectMeshSkinned class.

int OBJECT_MESH_STATIC

Description

Static mesh object. See the ObjectMeshStatic class.

int OBJECT_PARTICLES

Description

Particles object. See the ObjectParticles class.

int OBJECT_SKY

Description

Sky object. See the ObjectSky class.

int OBJECT_TERRAIN

Description

Terrain object. See the ObjectTerrain class.

int OBJECT_TERRAIN_GLOBAL

Description

Terrain global object. See the ObjectTerrainGlobal class.

int OBJECT_TEXT

Description

Text object. See the ObjectText class.

int OBJECT_VOLUME_BOX

Description

Volume box object. See the ObjectVolumeBox class.

int OBJECT_VOLUME_OMNI

Description

Volume omni light object. See the ObjectVolumeOmni class.

int OBJECT_VOLUME_PROJ

Description

Volume projected light object. See the ObjectVolumeProj class.

int OBJECT_VOLUME_SPHERE

Description

Volume sphere object. See the ObjectVolumeSphere class.

int OBJECT_WATER_GLOBAL

Description

Water global object. See the ObjectWaterGlobal class.

int OBJECT_WATER_MESH

Description

Water mesh object. See the ObjectWaterMesh class.

int OBSTACLE_BEGIN

Description

Begin of the obstacle nodes range.

int OBSTACLE_BOX

Description

Obstacle in the shape of a box avoided by pathfinding. See the ObstacleBox class.

int OBSTACLE_CAPSULE

Description

Obstacle in the shape of a capsule avoided by pathfinding. See the ObstacleCapsule class.

int OBSTACLE_END

Description

End of the obstacle nodes range.

int OBSTACLE_SPHERE

Description

Obstacle in the shape of a sphere avoided by pathfinding. See the ObstacleSphere class.

int PHYSICAL_BEGIN

Description

Begin of the physical nodes range.

int PHYSICAL_END

Description

End of the physical nodes range.

int PHYSICAL_FORCE

Description

Physical force node that allows to simulate point forces applied to dynamic objects. See the PhysicalForce class.

int PHYSICAL_NOISE

Description

Physical noise node that allows to simulate force field. See the PhysicalNoise class.

int PHYSICAL_TRIGGER

Description

Physical trigger. See the PhysicalTrigger class.

int PHYSICAL_WATER

Description

Physical water object that has no visual representation. See the PhysicalWater class.

int PHYSICAL_WIND

Description

Physical wind object. See the PhysicalWind class.

int PIVOT

Description

Node that helps to control rotation and transformation of its children. See the NodePivot class.

int PLAYER_ACTOR

Description

Acting player. See the PlayerActor class.

int PLAYER_BEGIN

Description

Begin of the player nodes range.

int PLAYER_DUMMY

Description

Dummy player. See the PlayerDummy class.

int PLAYER_END

Description

End of the player nodes range.

int PLAYER_PERSECUTOR

Description

Persecuting player. See the PlayerPersecutor class.

int PLAYER_SPECTATOR

Description

Observing player. See the PlayerSpectator class.

int REFERENCE

Description

Node that references an external NODE file. See the NodeReference class.

int SOUND_BEGIN

Description

Begin of the sound nodes range.

int SOUND_END

Description

End of the sound nodes range.

int SOUND_REVERB

Description

Sound reverberation zone. See the SoundReverb class.

int SOUND_SOURCE

Description

Sound source. See the SoundSource class.

int TRIGGER

Description

Dummy node that can fire callbacks on its enabling/disabling or repositioning. See the NodeTrigger class.

int WORLD_BEGIN

Description

Begin of the world nodes range.

int WORLD_CLUSTER

Description

Node cluster. See the WorldCluster class.

int WORLD_CLUTTER

Description

World clutter. See the WorldClutter class.

int WORLD_END

Description

End of the world nodes range.

int WORLD_EXPRESSION

Description

Node which allows to execute arbitrary expression. See the WorldExpression class.

int WORLD_EXTERN

Description

External world. See the WorldExtern class.

int WORLD_LAYER

Description

World layer. See the WorldLayer class.

int WORLD_OCCLUDER

Description

World occluder. See the WorldOccluder class.

int WORLD_OCCLUDER_MESH

Description

World mesh occluder. See the WorldOccluderMesh class.

int WORLD_OCCLUDER_TERRAIN

Description

World terrain occluder. See the WorldOccluderMesh class.

int WORLD_PORTAL

Description

World portal. See the WorldPortal class.

int WORLD_SECTOR

Description

World sector. See the WorldSector class.

int WORLD_SPLINE_GRAPH

Description

World spline graph. See the WorldSplineGraph class.

int WORLD_SWITCHER

Description

Node switcher (to switch off parts of the world). See the WorldSwitcher class.

int WORLD_TRANSFORM_BONE

Description

Bone defined transformer. See the WorldTransformBone class.

int WORLD_TRANSFORM_PATH

Description

Path defined transformer. See the WorldTransformPath

int WORLD_TRIGGER

Description

World trigger. See the WorldTrigger class.
Last update: 2017-10-20