This page has been translated automatically.
UnigineEditor
Interface Overview
Assets Workflow
Settings and Preferences
Adjusting Node Parameters
Setting Up Materials
Setting Up Properties
Landscape Tool
Using Editor Tools for Specific Tasks
FAQ
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
Warning! This version of documentation is OUTDATED, as it describes an older SDK version! Please switch to the documentation for the latest SDK version.
Warning! This version of documentation describes an old SDK version which is no longer supported! Please upgrade to the latest SDK version.

Unigine::NodeExtern Class

Header:#include <UnigineNodes.h>
Inherits:Node

NodeExtern is a custom user-defined node created via API. The NodeExtern class is a wrapper for implementation of a custom node class inherited from the NodeExternBase class.

A NodeExtern node is created when the engine loads an instance of the custom node class. It can also be created directly by using the class constructor with a custom node class ID as an argument. In both cases, the NodeExtern node wraps the custom node class inherited from the NodeExternBase.

A custom user-defined node is created as follows:

Notice
The custom user-defined node can be implemented on the C++ side only. So you should implement the custom node class in C++ and then use it on the C++ or UnigineScript side.
  1. Inherit a custom node class from NodeExternBase:
    Source code (C++)
    #include <UnigineNodes.h>
    
    using namespace Unigine;
    
    // inherit a custom class from NodeExternBase
    class MyNode : public NodeExternBase
    {
    };
  2. Implement logic of the custom node and register the class via NodeExternBase::addClassID():
    Notice
    The custom node class isn't a node, as the NodeExternBase class isn't inherited from the Node class.
    Source code (C++)
    #include <UnigineNodes.h>
    #include <UnigineEngine.h>
    #include "AppSystemLogic.h"
    #include "AppWorldLogic.h"
    #include "AppEditorLogic.h"
    
    using namespace Unigine;
    
    // inherit a custom class from NodeExternBase
    class MyNode : public NodeExternBase
    {
    public:
    
    	// constructors
    	MyNode(){}
    	MyNode(void *node) : NodeExternBase(node){}
    	// destructor
    	virtual ~MyNode(){}
    
    	// unique class ID
    	virtual int getClassID() {return 1;}
    
    	// set world transformation of the node
    	void setWorldTransform(const UNIGINE_MAT4 &transform) {getNode()->setWorldTransform(transform);}
    
    	// other methods
    	// ...
    };
    
    int main(int argc,char *argv[]) {
    
    	// register the MyNode class
    	NodeExternBase::addClassID<MyNode>(1);
    
    	Unigine::EnginePtr engine(UNIGINE_VERSION,argc,argv);
    
    	AppSystemLogic system_logic;
    	AppWorldLogic world_logic;
    	AppEditorLogic editor_logic;
    
    	engine->main(&system_logic,&world_logic,&editor_logic);
    
    	return 0;
    }
    If required, the custom node class can be exported to UnigineScript.
  3. Create a custom node in one of the following ways:
    Source code (C++)
    // create a MyNode pointer directly: a NodeExtern node will be created as well
    MyNode *my_node_0 = new MyNode();
    // obtain the NodeExtern node
    my_node_0->getNodeExtern();
    
    // create a NodeExtern instance by MyNode's class ID
    NodeExternPtr my_node_1 = NodeExtern::create(1);
    // obtain the MyNode pointer if required
    MyNode *my_node_2 = (MyNode*)my_node_1->getNodeExtern();
    If the class has been exported to UnigineScript, you can perform the same on the UnigineScript side:
    Source code (UnigineScript)
    // create a MyNode pointer directly: a NodeExtern node will be created as well
    MyNode my_node_0 = new MyNode();
    // obtain the NodeExtern node
    my_node_0.getNodeExtern();
    
    // create a NodeExtern instance by MyNode's class ID
    NodeExtern my_node_1 = new NodeExtern(1);
    // obtain MyNode if required
    MyNode my_node_2 = class_cast("MyNode", node.getNodeExtern());

See Also

  • The NodeExternBase class for the complete usage example of the NodeExtern and NodeExternBase classes.

NodeExtern Class

Members


static NodeExternPtr create(int class_id)

Constructor. Creates a custom user-defined node. An instance of the custom node class will be created as well.

Arguments

  • int class_id - Unique class ID.

Ptr<NodeExtern> cast(const Ptr<Node> & node)

Casts a NodeExtern out of the Node instance.

Arguments

  • const Ptr<Node> & node - Pointer to Node.

Return value

Pointer to NodeExtern.

int getClassID()

Returns the class ID of the node.

Return value

Class ID if the node exists; otherwise, 0.

NodeExternBase * getNodeExtern()

Returns the pointer to the custom node class.
Source code (C++)
// create a NodeExtern instance by MyNode's class ID
NodeExternPtr my_node_1 = NodeExtern::create(1);
// get the MyNode pointer
MyNode *my_node_2 = (MyNode*)my_node_1->getNodeExtern();

Return value

Pointer to the custom node class.

int type()

Returns the type of the node.

Return value

NodeExtern type identifier.
Last update: 2018-08-10
Build: ()