Unigine::Curve2d Class

Curve2d Class

Enums

REPEAT_MODE#

Members

getHash() const#

Return value

getNumKeys() const#

Return value

void setRepeatModeStart ( ) #

Arguments

• start - The repeat mode for the beginning of the curve (defines behavior before the first key point), one of the REPEAT_MODE_* values.

getRepeatModeStart() const#

Return value

void setRepeatModeEnd ( ) #

Arguments

• end - The repeat mode for the end of the curve (defines behavior after the last key point), one of the REPEAT_MODE_* values.

getRepeatModeEnd() const#

Return value

Event<> getEventChanged() const#

// implement the Changed event handler
void changed_event_handler()
{
	Log::message("\Handling Changed 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 changed_event_connections;

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

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventChanged().connect(changed_event_connections, []() { 
		Log::message("\Handling Changed event (lambda).\n");
	}
);

// ...

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

// subscribe to the Changed event with a handler function keeping the connection
publisher->getEventChanged().connect(changed_event_connection, changed_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventChanged().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 Changed event with a handler function
publisher->getEventChanged().connect(changed_event_handler);


// remove subscription to the Changed event later by the handler function
publisher->getEventChanged().disconnect(changed_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 changed_handler_id;

// subscribe to the Changed event with a lambda handler function and keeping connection ID
changed_handler_id = publisher->getEventChanged().connect([]() { 
		Log::message("\Handling Changed event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventChanged().disconnect(changed_handler_id);


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

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

// ... actions to be performed

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

Return value

Curve2d ( ) #

Curve2d ( const Ptr<Curve2d> & curve ) #

Arguments

• const Ptr<Curve2d> & curve - Source curve.

void clear ( ) #

void copy ( const Ptr<Curve2d> & curve ) #

Arguments

• const Ptr<Curve2d> & curve - Source curve.

int addKey ( const Math::vec2 & point ) #

Arguments

• const Math::vec2 & point - Coordinates of the new key point to be added.

Return value

int addKey ( const Math::vec2 & point, const Math::vec2 & left_tangent, const Math::vec2 & right_tangent ) #

Arguments

• const Math::vec2 & point - Coordinates of the new key point to be added.
• const Math::vec2 & left_tangent - Coordinates of the left tangent at the key point.
• const Math::vec2 & right_tangent - Coordinates of the right tangent at the key point.

Return value

void removeKey ( int index ) #

Arguments

• int index - Key point number, in the range from 0 to the total number of key points in the curve.

int moveKey ( int index, const Math::vec2 & point ) #

Arguments

• int index - Key point number, in the range from 0 to the total number of key points in the curve.
• const Math::vec2 & point - New coordinates of the key point.

Return value

void sortKeys ( ) #

void setKeyPoint ( int index, const Math::vec2 & point ) #

Arguments

• int index - Key point number, in the range from 0 to the total number of key points in the curve.
• const Math::vec2 & point - New coordinates to be set for the specified point.

void setKeyLeftTangent ( int index, const Math::vec2 & point ) #

Arguments

• int index - Key point number, in the range from 0 to the total number of key points in the curve.
• const Math::vec2 & point - New coordinates of the left tangent at the specified key point to be set.

void setKeyRightTangent ( int index, const Math::vec2 & point ) #

Arguments

• int index - Key point number, in the range from 0 to the total number of key points in the curve.
• const Math::vec2 & point - New coordinates of the right tangent at the specified key point to be set.

Math::vec2 getKeyPoint ( int index ) #

Arguments

• int index - Key point number, in the range from 0 to the total number of key points in the curve.

Return value

Math::vec2 getKeyLeftTangent ( int index ) #

Arguments

• int index - Key point number, in the range from 0 to the total number of key points in the curve.

Return value

Math::vec2 getKeyRightTangent ( int index ) #

Arguments

• int index - Key point number, in the range from 0 to the total number of key points in the curve.

Return value

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

Example using saveState() and restoreState() methods:

// initialize a node and set its state
Curve2dPtr curve = Curve2d::create();
curve->addKey(vec2(1, 0));
curve->addKey(vec2(2, 1));
curve->addKey(vec2(4, 3));

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

// change state
curve->removeKey(1);

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

Arguments

• const Ptr<Stream> & stream - Stream to which the curve data will be saved.

Return value

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

Example using saveState() and restoreState() methods:

// initialize a node and set its state
Curve2dPtr curve = Curve2d::create();
curve->addKey(vec2(1, 0));
curve->addKey(vec2(2, 1));
curve->addKey(vec2(4, 3));

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

// change state
curve->removeKey(1);

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

Arguments

• const Ptr<Stream> & stream - Stream in which the saved curve parameter data is stored.

Return value

bool save ( const Ptr<Json> & json ) const#

Arguments

• const Ptr<Json> & json - Json class instance to which the curve data will be saved.

Return value

bool load ( const Ptr<Json> & json ) #

Arguments

• const Ptr<Json> & json - Json class instance in which the curve data is stored.

Return value

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

Arguments

• const Ptr<Xml> & xml - Xml class instance to which the curve data will be saved.

Return value

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

Arguments

• const Ptr<Xml> & xml - Xml class instance in which the curve data is stored.

Return value

float evaluate ( float time ) const#

Arguments

• float time - The time within the curve you want to evaluate (horizontal axis in the curve graph).

Return value