Unigine::WorldSplineGraph Class

Coordinates of the "up" vector are additionally stored for each point of the segment. You can specify this vector to define orientation of geometry or objects, that can be stretched or tiled along the segments of the spline graph. By default this vector is parallel to the Z axis. The "up" vector does not affect the form of the spline segment.

It is possible to obtain an interpolated value for any point belonging to a segment, this can be used for various purposes (e.g. to change road profile). Interpolated "up" vector can be calculated as follows (pseudocode):

Source code (C++)

vec3 lerpUpVector(vec3 start_up, vec3 end_up, float t) const
{
	float angle = acos(dot(start_up, end_up)) * RAD2DEG;
	vec3 rotation_axis = cross(start_up, end_up);

	return rotateAxisAngle(rotation_axis, angle * t) * start_up;
}

A world spline graph consists of segments and has a list of source nodes (currently ObjectMeshStatic, ObjectMeshSkinned, and DecalProj) that can be placed at points and along the segments of the spline graph. Each point and segment can have a single or a set of source nodes assigned. An arbitrary number of WorldSplineGraph nodes can be added to the scene.

WorldSplineGraph has the following features:

Points of the spline graph are managed via the SplinePoint class.
Segments of the spline graph are managed via the SplineSegment class.
3 modes are supported:
- stretching: source nodes are stretched along the spline segment.
- tiling: source nodes are duplicated along the spline segment.
- adaptive - represents a combination of the first two: source nodes are duplicated along the spline segment, but the length of each node (stretching) is determined by the curvature of the corresponding part of the segment. Thus, long nodes are placed along the straight parts of segments, while short ones - along the curved parts, providing a reasonable balance between the plausible look and performance.
Forward axis selection for stretching/tiling source nodes.

功能列表:

Name	说明/描述 View: Sort by:
*create*	Default constructor.
getNumSplineSegments	Returns the current total number of spline segments in the world spline graph.
getNumSplinePoints	Returns the current total number of spline points in the world spline graph.
isCurved	Returns the current value indicating if the world spline graph is curved.
getEventRebuildingFinished	The event triggered after the world spline graph is rebuilt.
getEventSegmentRemoved	The event triggered when a segment of the world spline graph is removed.
getEventSegmentChanged	The event triggered when a segment of the world spline graph is modified.
getEventSegmentAdded	The event triggered when a segment is added to the world spline graph.
getEventPointRemoved	The event triggered when a point of the world spline graph is removed.
getEventPointChanged	The event triggered when a point of the world spline graph is modified.
getEventPointAdded	The event triggered when a point is added to the world spline graph.
setSplineGraphName	Sets the name of the world spline graph.
getSplineGraphName	Returns the name of the world spline graph.
loadSegmentNodes	Loads source nodes assigned to the specified spline segment immediately.
clear	Clears the world spline graph.
makeCurved	Curves the world spline graph using its geodetic pivot.
makeFlat	Flattens the world spline graph using its geodetic pivot.
load	Loads a spline graph from the specified XML-file.
save	Saves a spline graph to the specified XML-file.
type	Returns the type of the node.
getSegmentNodeMesh	Gets a mesh used by a node with the specified index, placed along the specified spline segment, and puts it to the specified target Mesh instance.
getPointNodeMesh	Exports a mesh with the specified index placed as the specified spline point to the specified target mesh.
createSplinePoint	Creates a new spline point with the specified parameters and attaches it to the world spline graph.
removeSplinePoint	Removes the specified spline point from the world spline graph.
getSplinePoints	Returns the list of all points of the world spline graph and puts them to the specified vector of SplinePoint elements.
createSplineSegment	Creates a new spline segment with the specified parameters and attaches it to the world spline graph.
removeSplineSegment	Removes the specified spline segment from the world spline graph.
getSplineSegments	Returns the list of all segments of the world spline graph and puts them to the specified vector of SplineSegment elements.
rebuild	Rebuilds the world spline graph.
isRebuilding	Returns a value indicating if the world spline graph is currently being rebuilt.
splitSplineSegment	Splits the specified spline segment into two parts by inserting a new point placed at the parametrically specified point on the T (times axis) in the [0.
breakSplinePoint	Breaks the specified spline point shared by several spline segments into a set of separate ones, so that each of the segments gets its own point.
weldSplinePoints	Joins all spline points specified in the list into a single one, so that this point is shared by all spline segments having the specified points as starting or ending ones.
isLinked	Returns a value indicating if the specified spline point is linked to any spline segment.

WorldSplineGraph Class

Members

getNumSplineSegments() const#

Returns the current total number of spline segments in the world spline graph.

Return value

Current

getNumSplinePoints() const#

Returns the current total number of spline points in the world spline graph.

Return value

Current

isCurved() const#

Returns the current value indicating if the world spline graph is curved.

Return value

Current

Event<const Ptr<WorldSplineGraph> &> getEventRebuildingFinished() const#

event triggered after the world spline graph is rebuilt. The world spline graph uses a deferred rebuild. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Notice

For more details see the Event Handling article.

The event handler signature is as follows: myhandler(const Ptr<WorldSplineGraph> & spline_graph)

Usage Example

Source code (C++)

// implement the RebuildingFinished event handler
void rebuildingfinished_event_handler(const Ptr<WorldSplineGraph> & spline_graph)
{
	Log::message("\Handling RebuildingFinished 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 rebuildingfinished_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventRebuildingFinished().connect(rebuildingfinished_event_connections, rebuildingfinished_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventRebuildingFinished().connect(rebuildingfinished_event_connections, [](const Ptr<WorldSplineGraph> & spline_graph) { 
		Log::message("\Handling RebuildingFinished event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
rebuildingfinished_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 rebuildingfinished_event_connection;

// subscribe to the RebuildingFinished event with a handler function keeping the connection
publisher->getEventRebuildingFinished().connect(rebuildingfinished_event_connection, rebuildingfinished_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the RebuildingFinished event via the connection
rebuildingfinished_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 RebuildingFinished event handler implemented as a class member
	void event_handler(const Ptr<WorldSplineGraph> & spline_graph)
	{
		Log::message("\Handling RebuildingFinished event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

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

// ...

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

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the RebuildingFinished event with a handler function
publisher->getEventRebuildingFinished().connect(rebuildingfinished_event_handler);


// remove subscription to the RebuildingFinished event later by the handler function
publisher->getEventRebuildingFinished().disconnect(rebuildingfinished_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

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

// subscribe to the RebuildingFinished event with a lambda handler function and keeping connection ID
rebuildingfinished_handler_id = publisher->getEventRebuildingFinished().connect([](const Ptr<WorldSplineGraph> & spline_graph) { 
		Log::message("\Handling RebuildingFinished event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventRebuildingFinished().disconnect(rebuildingfinished_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all RebuildingFinished events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventRebuildingFinished().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventRebuildingFinished().setEnabled(true);

Return value

Event reference.

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplineSegment> &> getEventSegmentRemoved() const#

event triggered when a segment of the world spline graph is removed. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Notice

For more details see the Event Handling article.

The event handler signature is as follows: myhandler(const Ptr<WorldSplineGraph> & spline_graph, const Ptr<SplineSegment> & segment)

Usage Example

Source code (C++)

// implement the SegmentRemoved event handler
void segmentremoved_event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment)
{
	Log::message("\Handling SegmentRemoved 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 segmentremoved_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventSegmentRemoved().connect(segmentremoved_event_connections, segmentremoved_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventSegmentRemoved().connect(segmentremoved_event_connections, [](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment) { 
		Log::message("\Handling SegmentRemoved event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
segmentremoved_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 segmentremoved_event_connection;

// subscribe to the SegmentRemoved event with a handler function keeping the connection
publisher->getEventSegmentRemoved().connect(segmentremoved_event_connection, segmentremoved_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the SegmentRemoved event via the connection
segmentremoved_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 SegmentRemoved event handler implemented as a class member
	void event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment)
	{
		Log::message("\Handling SegmentRemoved event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

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

// ...

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

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the SegmentRemoved event with a handler function
publisher->getEventSegmentRemoved().connect(segmentremoved_event_handler);


// remove subscription to the SegmentRemoved event later by the handler function
publisher->getEventSegmentRemoved().disconnect(segmentremoved_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

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

// subscribe to the SegmentRemoved event with a lambda handler function and keeping connection ID
segmentremoved_handler_id = publisher->getEventSegmentRemoved().connect([](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment) { 
		Log::message("\Handling SegmentRemoved event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventSegmentRemoved().disconnect(segmentremoved_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all SegmentRemoved events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventSegmentRemoved().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventSegmentRemoved().setEnabled(true);

Return value

Event reference.

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplineSegment> &> getEventSegmentChanged() const#

event triggered when a segment of the world spline graph is modified. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Notice

For more details see the Event Handling article.

The event handler signature is as follows: myhandler(const Ptr<WorldSplineGraph> & spline_graph, const Ptr<SplineSegment> & segment)

Usage Example

Source code (C++)

// implement the SegmentChanged event handler
void segmentchanged_event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment)
{
	Log::message("\Handling SegmentChanged 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 segmentchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventSegmentChanged().connect(segmentchanged_event_connections, segmentchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventSegmentChanged().connect(segmentchanged_event_connections, [](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment) { 
		Log::message("\Handling SegmentChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
segmentchanged_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 segmentchanged_event_connection;

// subscribe to the SegmentChanged event with a handler function keeping the connection
publisher->getEventSegmentChanged().connect(segmentchanged_event_connection, segmentchanged_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the SegmentChanged event via the connection
segmentchanged_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 SegmentChanged event handler implemented as a class member
	void event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment)
	{
		Log::message("\Handling SegmentChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

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

// ...

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

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the SegmentChanged event with a handler function
publisher->getEventSegmentChanged().connect(segmentchanged_event_handler);


// remove subscription to the SegmentChanged event later by the handler function
publisher->getEventSegmentChanged().disconnect(segmentchanged_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

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

// subscribe to the SegmentChanged event with a lambda handler function and keeping connection ID
segmentchanged_handler_id = publisher->getEventSegmentChanged().connect([](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment) { 
		Log::message("\Handling SegmentChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventSegmentChanged().disconnect(segmentchanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all SegmentChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventSegmentChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventSegmentChanged().setEnabled(true);

Return value

Event reference.

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplineSegment> &> getEventSegmentAdded() const#

event triggered when a segment is added to the world spline graph. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Notice

For more details see the Event Handling article.

The event handler signature is as follows: myhandler(const Ptr<WorldSplineGraph> & spline_graph, const Ptr<SplineSegment> & segment)

Usage Example

Source code (C++)

// implement the SegmentAdded event handler
void segmentadded_event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment)
{
	Log::message("\Handling SegmentAdded 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 segmentadded_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventSegmentAdded().connect(segmentadded_event_connections, segmentadded_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventSegmentAdded().connect(segmentadded_event_connections, [](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment) { 
		Log::message("\Handling SegmentAdded event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
segmentadded_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 segmentadded_event_connection;

// subscribe to the SegmentAdded event with a handler function keeping the connection
publisher->getEventSegmentAdded().connect(segmentadded_event_connection, segmentadded_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the SegmentAdded event via the connection
segmentadded_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 SegmentAdded event handler implemented as a class member
	void event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment)
	{
		Log::message("\Handling SegmentAdded event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

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

// ...

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

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the SegmentAdded event with a handler function
publisher->getEventSegmentAdded().connect(segmentadded_event_handler);


// remove subscription to the SegmentAdded event later by the handler function
publisher->getEventSegmentAdded().disconnect(segmentadded_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

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

// subscribe to the SegmentAdded event with a lambda handler function and keeping connection ID
segmentadded_handler_id = publisher->getEventSegmentAdded().connect([](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplineSegment> & segment) { 
		Log::message("\Handling SegmentAdded event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventSegmentAdded().disconnect(segmentadded_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all SegmentAdded events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventSegmentAdded().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventSegmentAdded().setEnabled(true);

Return value

Event reference.

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplinePoint> &> getEventPointRemoved() const#

event triggered when a point of the world spline graph is removed. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Notice

For more details see the Event Handling article.

The event handler signature is as follows: myhandler(const Ptr<WorldSplineGraph> & spline_graph, const Ptr<SplinePoint> & point)

Usage Example

Source code (C++)

// implement the PointRemoved event handler
void pointremoved_event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point)
{
	Log::message("\Handling PointRemoved 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 pointremoved_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventPointRemoved().connect(pointremoved_event_connections, pointremoved_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventPointRemoved().connect(pointremoved_event_connections, [](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point) { 
		Log::message("\Handling PointRemoved event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
pointremoved_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 pointremoved_event_connection;

// subscribe to the PointRemoved event with a handler function keeping the connection
publisher->getEventPointRemoved().connect(pointremoved_event_connection, pointremoved_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the PointRemoved event via the connection
pointremoved_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 PointRemoved event handler implemented as a class member
	void event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point)
	{
		Log::message("\Handling PointRemoved event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

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

// ...

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

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the PointRemoved event with a handler function
publisher->getEventPointRemoved().connect(pointremoved_event_handler);


// remove subscription to the PointRemoved event later by the handler function
publisher->getEventPointRemoved().disconnect(pointremoved_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

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

// subscribe to the PointRemoved event with a lambda handler function and keeping connection ID
pointremoved_handler_id = publisher->getEventPointRemoved().connect([](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point) { 
		Log::message("\Handling PointRemoved event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventPointRemoved().disconnect(pointremoved_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all PointRemoved events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventPointRemoved().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventPointRemoved().setEnabled(true);

Return value

Event reference.

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplinePoint> &> getEventPointChanged() const#

event triggered when a point of the world spline graph is modified. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Notice

For more details see the Event Handling article.

The event handler signature is as follows: myhandler(const Ptr<WorldSplineGraph> & spline_graph, const Ptr<SplinePoint> & point)

Usage Example

Source code (C++)

// implement the PointChanged event handler
void pointchanged_event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point)
{
	Log::message("\Handling PointChanged 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 pointchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventPointChanged().connect(pointchanged_event_connections, pointchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventPointChanged().connect(pointchanged_event_connections, [](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point) { 
		Log::message("\Handling PointChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
pointchanged_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 pointchanged_event_connection;

// subscribe to the PointChanged event with a handler function keeping the connection
publisher->getEventPointChanged().connect(pointchanged_event_connection, pointchanged_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the PointChanged event via the connection
pointchanged_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 PointChanged event handler implemented as a class member
	void event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point)
	{
		Log::message("\Handling PointChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

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

// ...

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

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the PointChanged event with a handler function
publisher->getEventPointChanged().connect(pointchanged_event_handler);


// remove subscription to the PointChanged event later by the handler function
publisher->getEventPointChanged().disconnect(pointchanged_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

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

// subscribe to the PointChanged event with a lambda handler function and keeping connection ID
pointchanged_handler_id = publisher->getEventPointChanged().connect([](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point) { 
		Log::message("\Handling PointChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventPointChanged().disconnect(pointchanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all PointChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventPointChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventPointChanged().setEnabled(true);

Return value

Event reference.

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplinePoint> &> getEventPointAdded() const#

event triggered when a point is added to the world spline graph. You can subscribe to events via connect() and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).

Notice

For more details see the Event Handling article.

The event handler signature is as follows: myhandler(const Ptr<WorldSplineGraph> & spline_graph, const Ptr<SplinePoint> & point)

Usage Example

Source code (C++)

// implement the PointAdded event handler
void pointadded_event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point)
{
	Log::message("\Handling PointAdded 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 pointadded_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventPointAdded().connect(pointadded_event_connections, pointadded_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventPointAdded().connect(pointadded_event_connections, [](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point) { 
		Log::message("\Handling PointAdded event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
pointadded_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 pointadded_event_connection;

// subscribe to the PointAdded event with a handler function keeping the connection
publisher->getEventPointAdded().connect(pointadded_event_connection, pointadded_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the PointAdded event via the connection
pointadded_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 PointAdded event handler implemented as a class member
	void event_handler(const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point)
	{
		Log::message("\Handling PointAdded event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

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

// ...

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

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the PointAdded event with a handler function
publisher->getEventPointAdded().connect(pointadded_event_handler);


// remove subscription to the PointAdded event later by the handler function
publisher->getEventPointAdded().disconnect(pointadded_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

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

// subscribe to the PointAdded event with a lambda handler function and keeping connection ID
pointadded_handler_id = publisher->getEventPointAdded().connect([](const Ptr<WorldSplineGraph> & spline_graph,  const Ptr<SplinePoint> & point) { 
		Log::message("\Handling PointAdded event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventPointAdded().disconnect(pointadded_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all PointAdded events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventPointAdded().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventPointAdded().setEnabled(true);

Return value

Event reference.

static WorldSplineGraphPtr create ( ) #

Default constructor. Creates an empty world spline graph.

static WorldSplineGraphPtr create ( const char * name ) #

Constructor. Creates an empty world spline graph with a given name.

Arguments

const char * name - World spline graph name.

int getNumSplinePoints ( ) const#

Returns the total number of spline points in the world spline graph.

Return value

Number of spline points.

int getNumSplineSegments ( ) const#

Returns the total number of spline segments in the world spline graph.

Return value

Number of segments.

void setSplineGraphName ( const char * name, bool force_load = 0 ) #

Sets the name of the world spline graph.

Arguments

const char * name - World spline graph name.
bool force_load - Force flag.
- If 1 is specified, the world spline graph will immediately loaded from a file.
- If 0 is specified, only the world spline graph name will be updated.

const char * getSplineGraphName ( ) const#

Returns the name of the world spline graph.

Return value

World spline graph name.

void loadSegmentNodes ( int segment_index = -1 ) #

Loads source nodes assigned to the specified spline segment immediately.

Arguments

int segment_index - Segment index. If no segment index is specified, the method loads source nodes assigned to all segments.

void clear ( ) #

Clears the world spline graph.

bool isCurved ( ) const#

Returns a value indicating if the world spline graph is curved.

Return value

true if the world spline graph is curved; otherwise, false.

void makeCurved ( ) #

Curves the world spline graph using its geodetic pivot. The spline file is saved upon completion of the curving operation.

Notice

The world spline graph must be a child of a Geodetic Pivot node.

void makeFlat ( ) #

Flattens the world spline graph using its geodetic pivot. The spline file is saved upon completion of the flattening operation.

Notice

The world spline graph must be a child of a Geodetic Pivot node.

bool load ( const char * name ) #

Loads a spline graph from the specified XML-file.

Arguments

const char * name - Name of the XML-file to load the spline graph from.

Return value

true if the spline graph was successfully loaded; otherwise, false.

bool save ( const char * name ) #

Saves a spline graph to the specified XML-file.

Arguments

const char * name - Name of the XML-file to save the spline graph to.

Return value

true if the spline graph was successfully saved; otherwise, false.

static int type ( ) #

Returns the type of the node.

Return value

WorldSplineGraph type identifier.

void getSegmentNodeMesh ( const Ptr<Mesh> & mesh, const Ptr<SplineSegment> & segment, int node_index, bool bake_transform = 0 ) #

Gets a mesh used by a node with the specified index, placed along the specified spline segment, and puts it to the specified target Mesh instance.

Arguments

const Ptr<Mesh> & mesh - Target mesh instance to which the obtained mesh is to be put.
const Ptr<SplineSegment> & segment - Spline segment for which the mesh is to be returned.
int node_index - Number of the node instance placed along the spline segment.
bool bake_transform - true to use baked mesh transformation, false - to use default (the mesh will be placed at the origin). The default value is false.

void getPointNodeMesh ( const Ptr<Mesh> & mesh, const Ptr<SplinePoint> & point, int node_index, bool bake_transform = false ) #

Exports a mesh with the specified index placed as the specified spline point to the specified target mesh.

NoticeDue to the nature of the mesh, there will be visual artifacts connected with the float precision, in case an exported node is located very far from the origin (around 10,000 m and further). In this case we advise exporting it without baking transformation.

Arguments

const Ptr<Mesh> & mesh - Target mesh to store the desired mesh placed at the specified spline point.
const Ptr<SplinePoint> & point - Spline point for which a mesh is to be retrieved.
int node_index - Number of the desired node in a row of nodes placed at the specified point, in the range from 0 to the total number of nodes placed at the point.
Notice
The node must be an ObjectMeshStatic or an ObjectMeshSkinned, otherwise an error occurs.
bool bake_transform - Bake Transform flag: true - to export the mesh preserving the current coordinates (can be useful when splitting large WorldSplineGraph objects to keep relative positions of meshes); or false - to reset the position of the exported mesh to origin (0,0,0) with zero-rotation.

Ptr<SplinePoint> createSplinePoint ( const Math::Vec3 & position ) #

Creates a new spline point with the specified parameters and attaches it to the world spline graph.

Arguments

const Math::Vec3 & position - Position coordinates for the new splint point.

Return value

New spline point.

void removeSplinePoint ( const Ptr<SplinePoint> & point, bool merge = 0 ) #

Removes the specified spline point from the world spline graph. You can set the merge flag to merge spline segments sharing this point as their start and end points.

NoticeSegment merging is available only when the point to be removed is shared by two segments, otherwise the merge flag is ignored and all segments sharing this point are also removed.

Arguments

const Ptr<SplinePoint> & point - Spline point to be removed.
bool merge - true to merge spline segments sharing this point as their start and end points, false to remove all segments sharing this point. The default value is false.

void getSplinePoints ( Vector<Ptr<SplinePoint>> & OUT_points ) const#

Returns the list of all points of the world spline graph and puts them to the specified vector of SplinePoint elements.

Arguments

Vector<Ptr<SplinePoint>> & OUT_points - Vector to store the list of all points of the world spline graph.
Notice
This output buffer is to be filled by the Engine as a result of executing the method.

Ptr<SplineSegment> createSplineSegment ( const Ptr<SplinePoint> & start_point, const Math::vec3 & start_tangent, const Math::vec3 & start_up, const Ptr<SplinePoint> & end_point, const Math::vec3 & end_tangent, const Math::vec3 & end_up ) #

Creates a new spline segment with the specified parameters and attaches it to the world spline graph.

Arguments

const Ptr<SplinePoint> & start_point - Start point of the spline segment.
const Math::vec3 & start_tangent - Tangent coordinates for the start point of the spline segment.
const Math::vec3 & start_up - Coordinates of the "up" vector for the start point of the spline segment.
const Ptr<SplinePoint> & end_point - End point of the segment.
const Math::vec3 & end_tangent - Tangent coordinates for the end point of the spline segment.
const Math::vec3 & end_up - Coordinates of the "up" vector for the end point of the spline segment.

Return value

New spline segment connecting two specified points.

void removeSplineSegment ( const Ptr<SplineSegment> & segment, bool with_points = 0 ) #

Removes the specified spline segment from the world spline graph. You can set the with_points flag to remove the segment together with its start and end points.

Arguments

const Ptr<SplineSegment> & segment - Spline segment to be removed.
bool with_points - true to remove the segment with its start and end points, false to keep points. The default value is false.

void getSplineSegments ( Vector<Ptr<SplineSegment>> & OUT_segments ) const#

Returns the list of all segments of the world spline graph and puts them to the specified vector of SplineSegment elements.

Arguments

Vector<Ptr<SplineSegment>> & OUT_segments - Vector to store the list of all segments of the world spline graph.
Notice
This output buffer is to be filled by the Engine as a result of executing the method.

void rebuild ( int try_force = 0 ) #

Rebuilds the world spline graph. This method is to be called after making any changes to spline segments (mode, etc.), point positions, tangents, or "up" vectors, as well as after changing source node assignments and/or other parameters (UV tiling, gap, etc.)

Arguments

int try_force - Forced rebuild flag: set 1 to try and force rebuild the world spline graph.

int isRebuilding ( ) const#

Returns a value indicating if the world spline graph is currently being rebuilt. The world spline graph uses a deferred rebuild.

Return value

1 if the world spline graph is currently being rebuilt; otherwise 0.

void splitSplineSegment ( const Ptr<SplineSegment> & segment, float new_point_t ) #

Splits the specified spline segment into two parts by inserting a new point placed at the parametrically specified point on the T (times axis) in the [0.0f, 1.0f] range from the segment's start point.

Arguments

const Ptr<SplineSegment> & segment - Spline segment to be split.
float new_point_t - Coordinate of the splitting point of the segment along the horizontal T (times) axis in the range [0.0f, 1.0f].

void breakSplinePoint ( const Ptr<SplinePoint> & point ) #

Breaks the specified spline point shared by several spline segments into a set of separate ones, so that each of the segments gets its own point.

Arguments

const Ptr<SplinePoint> & point - Spline point to be broken.
Notice
The point must be shared by a least 2 segments.

void weldSplinePoints ( Vector<Ptr<SplinePoint>> & OUT_points ) #

Joins all spline points specified in the list into a single one, so that this point is shared by all spline segments having the specified points as starting or ending ones.

Arguments

Vector<Ptr<SplinePoint>> & OUT_points - List of spline points to be joined into a single one.
Notice
This output buffer is to be filled by the Engine as a result of executing the method.

bool isLinked ( const Ptr<SplinePoint> & point ) const#

Returns a value indicating if the specified spline point is linked to any spline segment.

Arguments

const Ptr<SplinePoint> & point - Spline point to be checked.

Return value

1 if the specified spline point is linked to any spline segment; otherwise, 0.

Last update: 2024-03-20

Help improve this article

Was this article helpful?

Report a problem related to this article

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

Header:	#include <UnigineWorlds.h>
Inherits from:	Node

Unigine::WorldSplineGraph Class

In This Article:

See Also#

功能列表:

WorldSplineGraph Class

Members

getNumSplineSegments() const#

Return value

getNumSplinePoints() const#

Return value

isCurved() const#

Return value

Event<const Ptr<WorldSplineGraph> &> getEventRebuildingFinished() const#

Return value

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplineSegment> &> getEventSegmentRemoved() const#

Return value

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplineSegment> &> getEventSegmentChanged() const#

Return value

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplineSegment> &> getEventSegmentAdded() const#

Return value

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplinePoint> &> getEventPointRemoved() const#

Return value

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplinePoint> &> getEventPointChanged() const#

Return value

Event<const Ptr<WorldSplineGraph> &, const Ptr<SplinePoint> &> getEventPointAdded() const#

Return value

static WorldSplineGraphPtr create ( ) #

static WorldSplineGraphPtr create ( const char * name ) #

Arguments

int getNumSplinePoints ( ) const#

Return value

int getNumSplineSegments ( ) const#

Return value

void setSplineGraphName ( const char * name, bool force_load = 0 ) #

Arguments

const char * getSplineGraphName ( ) const#

Return value

void loadSegmentNodes ( int segment_index = -1 ) #

Arguments

void clear ( ) #

bool isCurved ( ) const#

Return value

void makeCurved ( ) #

void makeFlat ( ) #

bool load ( const char * name ) #

Arguments

Return value

bool save ( const char * name ) #

Arguments

Return value

static int type ( ) #

Return value

void getSegmentNodeMesh ( const Ptr<Mesh> & mesh, const Ptr<SplineSegment> & segment, int node_index, bool bake_transform = 0 ) #

Arguments

void getPointNodeMesh ( const Ptr<Mesh> & mesh, const Ptr<SplinePoint> & point, int node_index, bool bake_transform = false ) #

Arguments

Ptr<SplinePoint> createSplinePoint ( const Math::Vec3 & position ) #

Arguments

Return value

void removeSplinePoint ( const Ptr<SplinePoint> & point, bool merge = 0 ) #

Arguments

void getSplinePoints ( Vector<Ptr<SplinePoint>> & OUT_points ) const#

Arguments

Ptr<SplineSegment> createSplineSegment ( const Ptr<SplinePoint> & start_point, const Math::vec3 & start_tangent, const Math::vec3 & start_up, const Ptr<SplinePoint> & end_point, const Math::vec3 & end_tangent, const Math::vec3 & end_up ) #

Arguments

Return value

void removeSplineSegment ( const Ptr<SplineSegment> & segment, bool with_points = 0 ) #

Arguments

void getSplineSegments ( Vector<Ptr<SplineSegment>> & OUT_segments ) const#

Arguments

void rebuild ( int try_force = 0 ) #

Arguments

int isRebuilding ( ) const#

Return value

void splitSplineSegment ( const Ptr<SplineSegment> & segment, float new_point_t ) #

Arguments

void breakSplinePoint ( const Ptr<SplinePoint> & point ) #

Arguments

void weldSplinePoints ( Vector<Ptr<SplinePoint>> & OUT_points ) #

Arguments