Core

File with operations table.

Namespaces

Name
Core::Builder

Classes

	Name
class	Core::Camera <br>Camera has following outputs 0 -> screen output 1 -> proj * view matrix output 2 -> mul output.
class	Core::Cycle
class	Core::Data <br>Representation of the interconnection wire value (Shared piece of memory - union of all data types passed along the wire) and of the value stored in the defaultValues map (such as fovy for Perspective)
class	Core::DataMap <br>In column-major order.
class	Core::GraphManager <br>You must manage GraphManager lifecycle.
struct	Core::HalfspaceSign
class	Core::IdGenerator
class	Core::IModelProxy
class	Core::ManagedResource <br>Base class for objects that are the actual data managed by a ResourceManager.
class	Core::MatrixTracker
class	Core::Mesh <br>Mesh represents a complete 3D model.
class	Core::Model
class	Core::ModelResourceFiles <br>A set a of 3D file format files located somewhere in the filesystem.
class	Core::Node <br>Base class interface for all boxes.
struct	Core::Operation <br>Description of each graph node (operation enum, default label, input and output pin names and types)
class	Core::Operator <br>Implementation of Node class.
class	Core::Pin <br>Pin used for connecting nodes.
class	Core::Resource <br>Object holding information about a resource.
class	Core::ResourceFiles <br>A collection of file paths in the filesystem that are together required to load a single resource like a model.
class	Core::ResourceManager <br>Resource manager for loading resources from the filesystem.
class	Core::Sequence <br>Sequence of matrices.
class	Core::SequenceTree
struct	Core::TrackingResult
class	Core::Transform
class	Core::TransformImpl
class	Core::TransformImpl< ETransformType::AxisAngle >
class	Core::TransformImpl< ETransformType::EulerX >
class	Core::TransformImpl< ETransformType::EulerY >
class	Core::TransformImpl< ETransformType::EulerZ >
class	Core::TransformImpl< ETransformType::Free >
class	Core::TransformImpl< ETransformType::Frustum >
class	Core::TransformImpl< ETransformType::LookAt > <br>Same as perspective projection node, but all values are locked.
class	Core::TransformImpl< ETransformType::Ortho >
class	Core::TransformImpl< ETransformType::Perspective >
class	Core::TransformImpl< ETransformType::Quat > <br>Quaternion class Quaternion represents the matrix, crated from quaternion.
class	Core::TransformImpl< ETransformType::Scale >
class	Core::TransformImpl< ETransformType::Translation >
struct	Core::TransformInfo <br>Cannot outlive the sequence.
struct	Core::TransformOperation <br>Extends Operation - adds properties to transform nodes.
struct	Core::ValueSetResult

Types

	Name
enum class	ENodePlugResult { Ok = 0, Err_MismatchedPinTypes, Err_MismatchedPinKind, Err_Loopback, Err_NonexistentPin, Err_Loop, Err_DisabledPin}
enum class	EOperatorType { Inversion, Transpose, Determinant, MatrixMulMatrix, MatrixAddMatrix, MatrixMulVector, VectorMulMatrix, MatrixMulFloat, VectorDotVector, VectorAddVector, VectorSubVector, VectorMulFloat, VectorPerspectiveDivision, NormalizeVector, MixVector, Vector3CrossVector3, Vector3DotVector3, Vector3AddVector3, Vector3SubVector3, Vector3MulFloat, NormalizeVector3, Vector3Length, ShowVector3, MixVector3, ConjQuat, FloatVecToQuat, AngleAxisToQuat, VecVecToQuat, QuatToFloatVec, QuatToAngleAxis, QuatToEuler, EulerToQuat, QuatInverse, QuatSlerp, QuatLongWaySlerp, QuatLerp, FloatMulQuat, QuatMulQuat, QuatVecConjQuat, QuatLength, ClampFloat, FloatMulFloat, FloatDivFloat, FloatAddFloat, FloatPowFloat, MixFloat, FloatSinCos, ASinACos, Signum, MatrixToVectors, Vectors3ToMatrix, VectorsToMatrix, MatrixToFloats, FloatsToMatrix, MatrixToTR, TRToMatrix, MatrixToQuat, QuatToMatrix, VectorToFloats, FloatsToVector, Vector3ToFloats, FloatsToVector3, VectorToVector3, Vector3ToVector, QuatToFloats, FloatsToQuat, NormalizeQuat, FloatToFloat, Vector3ToVector3, Vector4ToVector4, MatrixToMatrix, QuatToQuat, PulseToPulse, MakeTranslation, MakeEulerX, MakeEulerY, MakeEulerZ, MakeScale, MakeAxisAngle, MakeOrtho, MakePerspective, MakeFrustum, MakeLookAt, Screen}
enum class	ETransformType { Free = 0, Translation, EulerX, EulerY, EulerZ, Scale, AxisAngle, Quat, Ortho, Perspective, Frustum, LookAt}
enum class	EValueState { Editable = 0x0002, EditableSyn = 0x0003, Locked = 0x0000, LockedSyn = 0x0001}<br>Float value editable status: b1, b2 - b1 is editable bit, b2 is synergies bit.
enum class	EValueType { Pulse = 0, Float, Vec3, Vec4, Matrix, Quat, MatrixMul, Screen, Ptr}<br>An operator value type = type of the interconnection wire.
enum class	ResourceType { Model, Shader, Texture}
enum class	TrackingDirection { LeftToRight = -1, RightToLeft = 1}
using Ptr< Camera >	CameraPtr
using GraphManager	gm
typedef std::int64_t	ID
using std::vector< Ptr< Transform > >	Matrices
using std::vector< EValueType >	PinGroup
using std::vector< std::string >	PinNames
using std::bitset< 16 >	TransformMask <br>ROW ORDER flags, if the mat4x4 values are editable (i.e., each single value may be changed by the mouse drag or not)
using std::array< int8_t, 16 >	ValueMask <br>Array of possible value codes for each matrix element: -1, 0, 1, ANY.

Functions

	Name
bool	canEditValue(EValueState valueState)
FORCE_INLINE glm::mat4	getMatProduct(const std::vector< Ptr< Transform >> & matrices)
Ptr< Sequence >	getNonemptyChildSequence(Ptr< Sequence > startSequence, Ptr< Sequence > parentSequence)
Ptr< Sequence >	getNonemptyParentSequence(Ptr< Sequence > sequence)
FORCE_INLINE const Operation *	getOperationProps(EOperatorType type)
FORCE_INLINE const TransformOperation::ValueMap &	getTransformDefaults(const std::string & keyWord)
FORCE_INLINE const TransformMask &	getTransformMap(const std::string & keyWord)
std::optional< TransformOperation * >	getTransformOperation(const std::string & keyWord)
FORCE_INLINE const TransformOperation &	getTransformOperation(ETransformType type)
template <typename T ,glm::precision P> <br>GLM_FUNC_DECL glm::tquat< T, P >	longWaySlerp(glm::tquat< T, P > const & x, glm::tquat< T, P > const & y, T a)<br>PF: Long way version of Spherical linear interpolation of two quaternions.
template <typename T ,glm::precision P> <br>GLM_FUNC_QUALIFIER glm::tquat< T, P >	longWaySlerp(glm::tquat< T, P > const & x, glm::tquat< T, P > const & y, T a)<br>PF: Long way version of Spherical linear interpolation of two quaternions.
const PinNames	matrixIndexNames()
void	setActivePart(Ptr< Node > node, float value)
bool	validateValue(const ValueMask & mask, glm::ivec2 coords, float value)<br>Check single element in the matrix, if it is in the allowed range.
bool	validateValues(const ValueMask & mask, const glm::mat4 & matrix)<br>Check if all matrix elements are in the allowed range.

Attributes

	Name
const PinNames	AngleAxisInputNames
const PinNames	AngleAxisToQuatInputNames
const PinNames	ClampFloatInputNames
const PinGroup	cycleInputs <br>From, to, multiplier, receive (play, pause, stopAndReset, prev, next).
const PinGroup	cycleOutputs <br>Output value, emit (play, pause, stopAndReset, prev, next).
const std::array< std::string, 9 >	defaultIoNames
const PinNames	emptyNames
const PinNames	eulerInputNames
const PinGroup	floatInput
const PinGroup	floatMatrixInput
const PinGroup	floatQuatInput
const PinGroup	floatVector3Input
const PinGroup	floatVectorInput
const PinGroup	fourFloatInput
const PinGroup	fourVector3Input
const PinGroup	fourVectorInput
constexpr TransformMask	g_AllLocked
constexpr TransformMask	g_AllUnlocked
constexpr ValueMask	g_AxisAngleMask
const Operation	g_cameraProperties
const Operation	g_CycleProperties
constexpr ValueMask	g_FrustumMask
constexpr ValueMask	g_LookAtMask
const Operation	g_modelProperties
constexpr ValueMask	g_OrthoMask
constexpr ValueMask	g_PerspectiveMask
constexpr ValueMask	g_RotateXMask
constexpr ValueMask	g_RotateYMask
constexpr ValueMask	g_RotateZMask
constexpr ValueMask	g_ScaleMask
const Operation	g_sequence
const std::vector< TransformOperation >	g_transforms <br>All entries must be in the same order as ETransformType enum entries.
constexpr ValueMask	g_TranslateMask
IdGenerator	generator
IdGenerator	generator
constexpr unsigned	I3T_CAMERA_OUT_MATRIX
constexpr unsigned	I3T_CAMERA_OUT_MUL
constexpr unsigned	I3T_CAMERA_OUT_SCREEN
constexpr size_t	I3T_CYCLE_IN_FROM
constexpr size_t	I3T_CYCLE_IN_NEXT
constexpr size_t	I3T_CYCLE_IN_PAUSE
constexpr size_t	I3T_CYCLE_IN_PLAY
constexpr size_t	I3T_CYCLE_IN_PREV
constexpr size_t	I3T_CYCLE_IN_STEP
constexpr size_t	I3T_CYCLE_IN_STOP
constexpr size_t	I3T_CYCLE_IN_TO
constexpr size_t	I3T_CYCLE_OUT_BEGIN
constexpr size_t	I3T_CYCLE_OUT_END
constexpr size_t	I3T_CYCLE_OUT_NEXT
constexpr size_t	I3T_CYCLE_OUT_PAUSE
constexpr size_t	I3T_CYCLE_OUT_PLAY
constexpr size_t	I3T_CYCLE_OUT_PREV
constexpr size_t	I3T_CYCLE_OUT_STOP
constexpr size_t	I3T_CYCLE_OUT_VAL
constexpr auto	I3T_CYCLE_STEP_DURATION_MINIMUM
constexpr auto	I3T_CYCLE_STEP_DURATION_SECONDS
constexpr size_t	I3T_DATA0
constexpr size_t	I3T_DATA1
constexpr size_t	I3T_DATA2
constexpr size_t	I3T_INPUT0
constexpr size_t	I3T_INPUT1
constexpr size_t	I3T_INPUT2
constexpr size_t	I3T_OUTPUT0
constexpr size_t	I3T_OUTPUT1
constexpr size_t	I3T_OUTPUT2
constexpr size_t	I3T_SEQ_IN_MAT
constexpr size_t	I3T_SEQ_IN_MUL
constexpr size_t	I3T_SEQ_MAT
constexpr size_t	I3T_SEQ_MOD
constexpr size_t	I3T_SEQ_MUL
constexpr size_t	I3T_SEQ_OUT_MAT
constexpr size_t	I3T_SEQ_OUT_MOD
constexpr size_t	I3T_SEQ_OUT_MUL
const PinNames	lookAtInputNames
const PinGroup	matrixInput
const PinGroup	matrixMulAndMatrixInput
const PinGroup	matrixMulInput
const PinGroup	matrixVectorInput
const PinNames	mixInputNames
constexpr ID	NIL_ID
const std::vector< Operation >	operations <br>Table with configuration parameters for OPERATORS.
const PinNames	orthoFrustrumInputNames
const PinNames	PerspectiveInputNames
const PinGroup	pulseInput
const PinGroup	quatInput
const PinNames	QuatToFloatVecInputNames
const PinGroup	screenFloatInput
const PinGroup	screenInput
const PinGroup	sixFloatInput
const PinGroup	sixteenFloatInput
const PinGroup	threeFloatInput
const PinGroup	threeVector3Input
const PinNames	tr
const PinGroup	twoFloatInput
const PinGroup	twoFloatVector3Input
const PinGroup	twoMatrixInput
const PinGroup	twoQuatFloatInput
const PinGroup	twoQuatInput
const PinGroup	twoVector3FloatInput
const PinGroup	twoVector3Input
const PinGroup	twoVectorFloatInput
const PinGroup	twoVectorInput
const PinGroup	vector3FloatInput
const PinGroup	vector3Input
const PinGroup	vector3QuatInput
const PinGroup	vectorInput
const PinGroup	vectorMatrixInput
const PinNames	Vectors3ToMatrixInputNames
const PinNames	VectorsToMatrixInputNames
constexpr int8_t	VM_ANY <br>Editable matrix element in ValueMask - it's range of values may be limited - the limit is checked in setValue() methods.
constexpr int8_t	VM_MINUS_ONE <br>Fixed matrix element (-1) in ValueMask.
constexpr int8_t	VM_ONE <br>Fixed matrix element (+1) in ValueMask.
constexpr int8_t	VM_ZERO <br>Fixed matrix element (0) in ValueMask.
const PinNames	xyz
const PinNames	xyzw

Types Documentation

enum ENodePlugResult

Enumerator	Value	Description
Ok	0
Err_MismatchedPinTypes
Err_MismatchedPinKind
Err_Loopback
Err_NonexistentPin		Same nodes.
Err_Loop
Err_DisabledPin

enum EOperatorType

Enumerator	Value	Description
Inversion
Transpose
Determinant
MatrixMulMatrix
MatrixAddMatrix
MatrixMulVector
VectorMulMatrix
MatrixMulFloat
VectorDotVector
VectorAddVector
VectorSubVector
VectorMulFloat
VectorPerspectiveDivision
NormalizeVector
MixVector
Vector3CrossVector3
Vector3DotVector3
Vector3AddVector3
Vector3SubVector3
Vector3MulFloat
NormalizeVector3
Vector3Length
ShowVector3
MixVector3
ConjQuat
FloatVecToQuat
AngleAxisToQuat
VecVecToQuat
QuatToFloatVec
QuatToAngleAxis
QuatToEuler
EulerToQuat
QuatInverse
QuatSlerp
QuatLongWaySlerp
QuatLerp
FloatMulQuat
QuatMulQuat
QuatVecConjQuat
QuatLength
ClampFloat
FloatMulFloat
FloatDivFloat
FloatAddFloat
FloatPowFloat
MixFloat
FloatSinCos
ASinACos
Signum
MatrixToVectors
Vectors3ToMatrix
VectorsToMatrix
MatrixToFloats
FloatsToMatrix
MatrixToTR
TRToMatrix
MatrixToQuat
QuatToMatrix
VectorToFloats
FloatsToVector
Vector3ToFloats
FloatsToVector3
VectorToVector3
Vector3ToVector
QuatToFloats
FloatsToQuat
NormalizeQuat
FloatToFloat
Vector3ToVector3
Vector4ToVector4
MatrixToMatrix
QuatToQuat
PulseToPulse
MakeTranslation
MakeEulerX
MakeEulerY
MakeEulerZ
MakeScale
MakeAxisAngle
MakeOrtho
MakePerspective
MakeFrustum
MakeLookAt
Screen

enum ETransformType

Enumerator	Value	Description
Free	0
Translation
EulerX
EulerY
EulerZ
Scale
AxisAngle
Quat
Ortho
Perspective
Frustum
LookAt

enum EValueState

Enumerator	Value	Description
Editable	0x0002	10
EditableSyn	0x0003	11
Locked	0x0000	00
LockedSyn	0x0001	01

Float value editable status: b1, b2 - b1 is editable bit, b2 is synergies bit.

Todo: PF:- proc tohle neni po bitech? SynergiesBit = 0x0001, ///< 001 EditableBit = 0x0002, ///< 010 PossibleNextBit = 0x0004, ///< 100 ...

enum EValueType

Enumerator	Value	Description
Pulse	0
Float		standard data type
Vec3
Vec4
Matrix
Quat
MatrixMul		connection of sequences in the scene graph - represents a matrix multiplication - stores a matrix
Screen		projection and camera view transformation
Ptr

An operator value type = type of the interconnection wire.

The string names are defined in Operations.h, defaultIoNames

enum ResourceType

Enumerator	Value	Description
Model
Shader
Texture

enum TrackingDirection

Enumerator	Value	Description
LeftToRight	-1
RightToLeft	1

using CameraPtr

cpp

using Core::CameraPtr = typedef Ptr<Camera>;

using Core::CameraPtr = typedef Ptr<Camera>;

using gm

cpp

using Core::gm = typedef GraphManager;

using Core::gm = typedef GraphManager;

typedef ID

cpp

typedef std::int64_t Core::ID;

typedef std::int64_t Core::ID;

using Matrices

cpp

using Core::Matrices = typedef std::vector<Ptr<Transform> >;

using Core::Matrices = typedef std::vector<Ptr<Transform> >;

using PinGroup

cpp

using Core::PinGroup = typedef std::vector<EValueType>;

using Core::PinGroup = typedef std::vector<EValueType>;

using PinNames

cpp

using Core::PinNames = typedef std::vector<std::string>;

using Core::PinNames = typedef std::vector<std::string>;

using TransformMask

cpp

using Core::TransformMask = typedef std::bitset<16>;

using Core::TransformMask = typedef std::bitset<16>;

ROW ORDER flags, if the mat4x4 values are editable (i.e., each single value may be changed by the mouse drag or not)

using ValueMask

cpp

using Core::ValueMask = typedef std::array<int8_t, 16>;

using Core::ValueMask = typedef std::array<int8_t, 16>;

Array of possible value codes for each matrix element: -1, 0, 1, ANY.

Note: These definitions are in the ROW order - are flipped to COLUMN order in validateValue()

These arrays are defined for all Transform variants in TransformImpl.cpp

Functions Documentation

function canEditValue

cpp

inline bool canEditValue(
    EValueState valueState
)

inline bool canEditValue(
    EValueState valueState
)

function getMatProduct

cpp

FORCE_INLINE glm::mat4 getMatProduct(
    const std::vector< Ptr< Transform >> & matrices
)

FORCE_INLINE glm::mat4 getMatProduct(
    const std::vector< Ptr< Transform >> & matrices
)

function getNonemptyChildSequence

cpp

Ptr< Sequence > getNonemptyChildSequence(
    Ptr< Sequence > startSequence,
    Ptr< Sequence > parentSequence
)

Ptr< Sequence > getNonemptyChildSequence(
    Ptr< Sequence > startSequence,
    Ptr< Sequence > parentSequence
)

Return: Nonempty child sequence of parentSequence or nullptr if there is no such sequence.

Precondition: parentSequence is direct or indirect parent of startSequence.

function getNonemptyParentSequence

cpp

Ptr< Sequence > getNonemptyParentSequence(
    Ptr< Sequence > sequence
)

Ptr< Sequence > getNonemptyParentSequence(
    Ptr< Sequence > sequence
)

Return: nullptr if there is no nonempty sequence in the parent chain.

function getOperationProps

cpp

FORCE_INLINE const Operation * getOperationProps(
    EOperatorType type
)

FORCE_INLINE const Operation * getOperationProps(
    EOperatorType type
)

function getTransformDefaults

cpp

FORCE_INLINE const TransformOperation::ValueMap & getTransformDefaults(
    const std::string & keyWord
)

FORCE_INLINE const TransformOperation::ValueMap & getTransformDefaults(
    const std::string & keyWord
)

function getTransformMap

cpp

FORCE_INLINE const TransformMask & getTransformMap(
    const std::string & keyWord
)

FORCE_INLINE const TransformMask & getTransformMap(
    const std::string & keyWord
)

function getTransformOperation

cpp

std::optional< TransformOperation * > getTransformOperation(
    const std::string & keyWord
)

std::optional< TransformOperation * > getTransformOperation(
    const std::string & keyWord
)

function getTransformOperation

cpp

FORCE_INLINE const TransformOperation & getTransformOperation(
    ETransformType type
)

FORCE_INLINE const TransformOperation & getTransformOperation(
    ETransformType type
)

function longWaySlerp

cpp

template <typename T ,
glm::precision P>
GLM_FUNC_DECL glm::tquat< T, P > longWaySlerp(
    glm::tquat< T, P > const & x,
    glm::tquat< T, P > const & y,
    T a
)

template <typename T ,
glm::precision P>
GLM_FUNC_DECL glm::tquat< T, P > longWaySlerp(
    glm::tquat< T, P > const & x,
    glm::tquat< T, P > const & y,
    T a
)

PF: Long way version of Spherical linear interpolation of two quaternions.

Parameters:

x A quaternion
y A quaternion
a Interpolation factor. The interpolation is defined beyond the range [0, 1].

Template Parameters:

T Value type used to build the quaternion. Supported: half, float or double.

See: gtc_quaternion

The interpolation always take the long path and the rotation is performed at constant speed.

function longWaySlerp

cpp

template <typename T ,
glm::precision P>
GLM_FUNC_QUALIFIER glm::tquat< T, P > longWaySlerp(
    glm::tquat< T, P > const & x,
    glm::tquat< T, P > const & y,
    T a
)

template <typename T ,
glm::precision P>
GLM_FUNC_QUALIFIER glm::tquat< T, P > longWaySlerp(
    glm::tquat< T, P > const & x,
    glm::tquat< T, P > const & y,
    T a
)

PF: Long way version of Spherical linear interpolation of two quaternions.

Parameters:

x A quaternion
y A quaternion
a Interpolation factor. The interpolation is defined beyond the range [0, 1].

Template Parameters:

T Value type used to build the quaternion. Supported: half, float or double.

See: gtc_quaternion

The interpolation always take the long path and the rotation is performed at constant speed.

function matrixIndexNames

cpp

static const PinNames matrixIndexNames()

static const PinNames matrixIndexNames()

function setActivePart

cpp

void setActivePart(
    Ptr< Node > node,
    float value
)

void setActivePart(
    Ptr< Node > node,
    float value
)

function validateValue

cpp

bool validateValue(
    const ValueMask & mask,
    glm::ivec2 coords,
    float value
)

bool validateValue(
    const ValueMask & mask,
    glm::ivec2 coords,
    float value
)

Check single element in the matrix, if it is in the allowed range.

Parameters:

mask code of possible values (in the ROW order!) -1, 0, 1, ANY
coords {x, y} x is column and y is row.
value single value from the matrix to be validated against the mask

Return: true for an allowed value on given position in the matrix

Possible range is defined by constants in the ValueMask array. Editable values have the value VM_ANY, fixed values have VW_MINUS_ONE, VM_ZERO, or WM_ONE

function validateValues

cpp

bool validateValues(
    const ValueMask & mask,
    const glm::mat4 & matrix
)

bool validateValues(
    const ValueMask & mask,
    const glm::mat4 & matrix
)

Check if all matrix elements are in the allowed range.

Parameters:

mask code of possible values (in the ROW order!) -1, 0, 1, ANY
matrix matrix to be validated against the mask

Return: true for a valid matrix

Fixed elements are not changed. Editable elements (ANY) must be further tested outside.

column order

Attributes Documentation

variable AngleAxisInputNames

cpp

static const PinNames AngleAxisInputNames = {"angle", "axis"};

static const PinNames AngleAxisInputNames = {"angle", "axis"};

variable AngleAxisToQuatInputNames

cpp

static const PinNames AngleAxisToQuatInputNames = {"angle", "angle / 2", "vec3"};

static const PinNames AngleAxisToQuatInputNames = {"angle", "angle / 2", "vec3"};

variable ClampFloatInputNames

cpp

static const PinNames ClampFloatInputNames = {"val", "min", "max"};

static const PinNames ClampFloatInputNames = {"val", "min", "max"};

variable cycleInputs

cpp

static const PinGroup cycleInputs = {
    EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Pulse,
    EValueType::Pulse, EValueType::Pulse, EValueType::Pulse, EValueType::Pulse,
};

static const PinGroup cycleInputs = {
    EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Pulse,
    EValueType::Pulse, EValueType::Pulse, EValueType::Pulse, EValueType::Pulse,
};

From, to, multiplier, receive (play, pause, stopAndReset, prev, next).

variable cycleOutputs

cpp

static const PinGroup cycleOutputs = {
    EValueType::Float, EValueType::Pulse, EValueType::Pulse, EValueType::Pulse,
    EValueType::Pulse, EValueType::Pulse, EValueType::Pulse, EValueType::Pulse,
};

static const PinGroup cycleOutputs = {
    EValueType::Float, EValueType::Pulse, EValueType::Pulse, EValueType::Pulse,
    EValueType::Pulse, EValueType::Pulse, EValueType::Pulse, EValueType::Pulse,
};

Output value, emit (play, pause, stopAndReset, prev, next).

variable defaultIoNames

cpp

static const std::array< std::string, 9 > defaultIoNames = {
    "pulse",  
    "float",  
    "vec3",   
    "vec4",   
    "matrix", 
    "quat",   
    "MatMul", 
    "screen", 
    "pointer" 
};

static const std::array< std::string, 9 > defaultIoNames = {
    "pulse",  
    "float",  
    "vec3",   
    "vec4",   
    "matrix", 
    "quat",   
    "MatMul", 
    "screen", 
    "pointer" 
};

variable emptyNames

cpp

static const PinNames emptyNames = {};

static const PinNames emptyNames = {};

variable eulerInputNames

cpp

static const PinNames eulerInputNames = {"angle"};

static const PinNames eulerInputNames = {"angle"};

variable floatInput

cpp

static const PinGroup floatInput = {EValueType::Float};

static const PinGroup floatInput = {EValueType::Float};

variable floatMatrixInput

cpp

static const PinGroup floatMatrixInput = {EValueType::Float, EValueType::Matrix};

static const PinGroup floatMatrixInput = {EValueType::Float, EValueType::Matrix};

variable floatQuatInput

cpp

static const PinGroup floatQuatInput = {EValueType::Float, EValueType::Quat};

static const PinGroup floatQuatInput = {EValueType::Float, EValueType::Quat};

variable floatVector3Input

cpp

static const PinGroup floatVector3Input = {EValueType::Float, EValueType::Vec3};

static const PinGroup floatVector3Input = {EValueType::Float, EValueType::Vec3};

variable floatVectorInput

cpp

static const PinGroup floatVectorInput = {EValueType::Float, EValueType::Vec4};

static const PinGroup floatVectorInput = {EValueType::Float, EValueType::Vec4};

variable fourFloatInput

cpp

static const PinGroup fourFloatInput = {EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Float};

static const PinGroup fourFloatInput = {EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Float};

variable fourVector3Input

cpp

static const PinGroup fourVector3Input = {EValueType::Vec3, EValueType::Vec3, EValueType::Vec3, EValueType::Vec3};

static const PinGroup fourVector3Input = {EValueType::Vec3, EValueType::Vec3, EValueType::Vec3, EValueType::Vec3};

variable fourVectorInput

cpp

static const PinGroup fourVectorInput = {EValueType::Vec4, EValueType::Vec4, EValueType::Vec4, EValueType::Vec4};

static const PinGroup fourVectorInput = {EValueType::Vec4, EValueType::Vec4, EValueType::Vec4, EValueType::Vec4};

variable g_AllLocked

cpp

constexpr TransformMask g_AllLocked = 0b0000000000000000;

constexpr TransformMask g_AllLocked = 0b0000000000000000;

variable g_AllUnlocked

cpp

constexpr TransformMask g_AllUnlocked = 0b1111111111111111;

constexpr TransformMask g_AllUnlocked = 0b1111111111111111;

variable g_AxisAngleMask

cpp

constexpr ValueMask g_AxisAngleMask = {
    VM_ANY, VM_ANY, VM_ANY, VM_ZERO, VM_ANY,  VM_ANY,  VM_ANY,  VM_ZERO,
    VM_ANY, VM_ANY, VM_ANY, VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

constexpr ValueMask g_AxisAngleMask = {
    VM_ANY, VM_ANY, VM_ANY, VM_ZERO, VM_ANY,  VM_ANY,  VM_ANY,  VM_ZERO,
    VM_ANY, VM_ANY, VM_ANY, VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

variable g_cameraProperties

cpp

const Operation g_cameraProperties = {
    "Camera", "camera", {}, {EValueType::Screen, EValueType::Matrix, EValueType::MatrixMul}};

const Operation g_cameraProperties = {
    "Camera", "camera", {}, {EValueType::Screen, EValueType::Matrix, EValueType::MatrixMul}};

variable g_CycleProperties

cpp

static const Operation g_CycleProperties = {
	"Cycle", "cycle", cycleInputs, cycleOutputs,
    NO_TAG,
	{"from", "to", "step", "play", "pause", "stop", "prev", "next"},
	
    {"value", "", "pause", "stop", "prev", "next", "begin", "end"},
    
};

static const Operation g_CycleProperties = {
	"Cycle", "cycle", cycleInputs, cycleOutputs,
    NO_TAG,
	{"from", "to", "step", "play", "pause", "stop", "prev", "next"},
	
    {"value", "", "pause", "stop", "prev", "next", "begin", "end"},
    
};

variable g_FrustumMask

cpp

constexpr ValueMask g_FrustumMask = {
    VM_ANY,  VM_ZERO, VM_ANY, VM_ZERO, VM_ZERO, VM_ANY,  VM_ANY,       VM_ZERO,
    VM_ZERO, VM_ZERO, VM_ANY, VM_ANY,  VM_ZERO, VM_ZERO, VM_MINUS_ONE, VM_ZERO,
};

constexpr ValueMask g_FrustumMask = {
    VM_ANY,  VM_ZERO, VM_ANY, VM_ZERO, VM_ZERO, VM_ANY,  VM_ANY,       VM_ZERO,
    VM_ZERO, VM_ZERO, VM_ANY, VM_ANY,  VM_ZERO, VM_ZERO, VM_MINUS_ONE, VM_ZERO,
};

variable g_LookAtMask

cpp

constexpr ValueMask g_LookAtMask = {
    
    VM_ANY, VM_ANY, VM_ANY, VM_ANY, VM_ANY,  VM_ANY,  VM_ANY,  VM_ANY,
    VM_ANY, VM_ANY, VM_ANY, VM_ANY, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

constexpr ValueMask g_LookAtMask = {
    
    VM_ANY, VM_ANY, VM_ANY, VM_ANY, VM_ANY,  VM_ANY,  VM_ANY,  VM_ANY,
    VM_ANY, VM_ANY, VM_ANY, VM_ANY, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

variable g_modelProperties

cpp

static const Operation g_modelProperties = {
    "Model",
    "model",
    matrixMulInput,
    {},
};

static const Operation g_modelProperties = {
    "Model",
    "model",
    matrixMulInput,
    {},
};

variable g_OrthoMask

cpp

constexpr ValueMask g_OrthoMask = {
    VM_ANY,  VM_ZERO, VM_ZERO, VM_ANY, VM_ZERO, VM_ANY,  VM_ZERO, VM_ANY,
    VM_ZERO, VM_ZERO, VM_ANY,  VM_ANY, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

constexpr ValueMask g_OrthoMask = {
    VM_ANY,  VM_ZERO, VM_ZERO, VM_ANY, VM_ZERO, VM_ANY,  VM_ZERO, VM_ANY,
    VM_ZERO, VM_ZERO, VM_ANY,  VM_ANY, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

variable g_PerspectiveMask

cpp

constexpr ValueMask g_PerspectiveMask = {
    
    VM_ANY,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ANY,  VM_ZERO,      VM_ZERO,
    VM_ZERO, VM_ZERO, VM_ANY,  VM_ANY,  VM_ZERO, VM_ZERO, VM_MINUS_ONE, VM_ZERO,
};

constexpr ValueMask g_PerspectiveMask = {
    
    VM_ANY,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ANY,  VM_ZERO,      VM_ZERO,
    VM_ZERO, VM_ZERO, VM_ANY,  VM_ANY,  VM_ZERO, VM_ZERO, VM_MINUS_ONE, VM_ZERO,
};

variable g_RotateXMask

cpp

constexpr ValueMask g_RotateXMask = {
    VM_ONE,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ANY,  VM_ANY,  VM_ZERO,
    VM_ZERO, VM_ANY,  VM_ANY,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

constexpr ValueMask g_RotateXMask = {
    VM_ONE,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ANY,  VM_ANY,  VM_ZERO,
    VM_ZERO, VM_ANY,  VM_ANY,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

variable g_RotateYMask

cpp

constexpr ValueMask g_RotateYMask = {
    VM_ANY, VM_ZERO, VM_ANY, VM_ZERO, VM_ZERO, VM_ONE,  VM_ZERO, VM_ZERO,
    VM_ANY, VM_ZERO, VM_ANY, VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

constexpr ValueMask g_RotateYMask = {
    VM_ANY, VM_ZERO, VM_ANY, VM_ZERO, VM_ZERO, VM_ONE,  VM_ZERO, VM_ZERO,
    VM_ANY, VM_ZERO, VM_ANY, VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

variable g_RotateZMask

cpp

constexpr ValueMask g_RotateZMask = {
    VM_ANY,  VM_ANY,  VM_ZERO, VM_ZERO, VM_ANY,  VM_ANY,  VM_ZERO, VM_ZERO,
    VM_ZERO, VM_ZERO, VM_ONE,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

constexpr ValueMask g_RotateZMask = {
    VM_ANY,  VM_ANY,  VM_ZERO, VM_ZERO, VM_ANY,  VM_ANY,  VM_ZERO, VM_ZERO,
    VM_ZERO, VM_ZERO, VM_ONE,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

variable g_ScaleMask

cpp

constexpr ValueMask g_ScaleMask = {
    VM_ANY,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ANY,  VM_ZERO, VM_ZERO,
    VM_ZERO, VM_ZERO, VM_ANY,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

constexpr ValueMask g_ScaleMask = {
    VM_ANY,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ANY,  VM_ZERO, VM_ZERO,
    VM_ZERO, VM_ZERO, VM_ANY,  VM_ZERO, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

variable g_sequence

cpp

const Operation g_sequence = {
    "Sequence", "sequence", matrixMulAndMatrixInput, {EValueType::MatrixMul, EValueType::Matrix, EValueType::Matrix}};

const Operation g_sequence = {
    "Sequence", "sequence", matrixMulAndMatrixInput, {EValueType::MatrixMul, EValueType::Matrix, EValueType::Matrix}};

variable g_transforms

cpp

static const std::vector< TransformOperation > g_transforms;

static const std::vector< TransformOperation > g_transforms;

All entries must be in the same order as ETransformType enum entries.

variable g_TranslateMask

cpp

constexpr ValueMask g_TranslateMask = {
    
    VM_ONE,  VM_ZERO, VM_ZERO, VM_ANY, VM_ZERO, VM_ONE,  VM_ZERO, VM_ANY,
    VM_ZERO, VM_ZERO, VM_ONE,  VM_ANY, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

constexpr ValueMask g_TranslateMask = {
    
    VM_ONE,  VM_ZERO, VM_ZERO, VM_ANY, VM_ZERO, VM_ONE,  VM_ZERO, VM_ANY,
    VM_ZERO, VM_ZERO, VM_ONE,  VM_ANY, VM_ZERO, VM_ZERO, VM_ZERO, VM_ONE,
};

variable generator

cpp

static IdGenerator generator;

static IdGenerator generator;

variable generator

cpp

static IdGenerator generator;

static IdGenerator generator;

variable I3T_CAMERA_OUT_MATRIX

cpp

constexpr unsigned I3T_CAMERA_OUT_MATRIX = 1;

constexpr unsigned I3T_CAMERA_OUT_MATRIX = 1;

variable I3T_CAMERA_OUT_MUL

cpp

constexpr unsigned I3T_CAMERA_OUT_MUL = 2;

constexpr unsigned I3T_CAMERA_OUT_MUL = 2;

variable I3T_CAMERA_OUT_SCREEN

cpp

constexpr unsigned I3T_CAMERA_OUT_SCREEN = 0;

constexpr unsigned I3T_CAMERA_OUT_SCREEN = 0;

variable I3T_CYCLE_IN_FROM

cpp

constexpr size_t I3T_CYCLE_IN_FROM = 0;

constexpr size_t I3T_CYCLE_IN_FROM = 0;

variable I3T_CYCLE_IN_NEXT

cpp

constexpr size_t I3T_CYCLE_IN_NEXT = 7;

constexpr size_t I3T_CYCLE_IN_NEXT = 7;

variable I3T_CYCLE_IN_PAUSE

cpp

constexpr size_t I3T_CYCLE_IN_PAUSE = 4;

constexpr size_t I3T_CYCLE_IN_PAUSE = 4;

variable I3T_CYCLE_IN_PLAY

cpp

constexpr size_t I3T_CYCLE_IN_PLAY = 3;

constexpr size_t I3T_CYCLE_IN_PLAY = 3;

variable I3T_CYCLE_IN_PREV

cpp

constexpr size_t I3T_CYCLE_IN_PREV = 6;

constexpr size_t I3T_CYCLE_IN_PREV = 6;

variable I3T_CYCLE_IN_STEP

cpp

constexpr size_t I3T_CYCLE_IN_STEP = 2;

constexpr size_t I3T_CYCLE_IN_STEP = 2;

variable I3T_CYCLE_IN_STOP

cpp

constexpr size_t I3T_CYCLE_IN_STOP = 5;

constexpr size_t I3T_CYCLE_IN_STOP = 5;

variable I3T_CYCLE_IN_TO

cpp

constexpr size_t I3T_CYCLE_IN_TO = 1;

constexpr size_t I3T_CYCLE_IN_TO = 1;

variable I3T_CYCLE_OUT_BEGIN

cpp

constexpr size_t I3T_CYCLE_OUT_BEGIN = 6;

constexpr size_t I3T_CYCLE_OUT_BEGIN = 6;

variable I3T_CYCLE_OUT_END

cpp

constexpr size_t I3T_CYCLE_OUT_END = 7;

constexpr size_t I3T_CYCLE_OUT_END = 7;

variable I3T_CYCLE_OUT_NEXT

cpp

constexpr size_t I3T_CYCLE_OUT_NEXT = 5;

constexpr size_t I3T_CYCLE_OUT_NEXT = 5;

variable I3T_CYCLE_OUT_PAUSE

cpp

constexpr size_t I3T_CYCLE_OUT_PAUSE = 2;

constexpr size_t I3T_CYCLE_OUT_PAUSE = 2;

variable I3T_CYCLE_OUT_PLAY

cpp

constexpr size_t I3T_CYCLE_OUT_PLAY = 1;

constexpr size_t I3T_CYCLE_OUT_PLAY = 1;

variable I3T_CYCLE_OUT_PREV

cpp

constexpr size_t I3T_CYCLE_OUT_PREV = 4;

constexpr size_t I3T_CYCLE_OUT_PREV = 4;

variable I3T_CYCLE_OUT_STOP

cpp

constexpr size_t I3T_CYCLE_OUT_STOP = 3;

constexpr size_t I3T_CYCLE_OUT_STOP = 3;

variable I3T_CYCLE_OUT_VAL

cpp

constexpr size_t I3T_CYCLE_OUT_VAL = 0;

constexpr size_t I3T_CYCLE_OUT_VAL = 0;

variable I3T_CYCLE_STEP_DURATION_MINIMUM

cpp

constexpr auto I3T_CYCLE_STEP_DURATION_MINIMUM = 0.01f;

constexpr auto I3T_CYCLE_STEP_DURATION_MINIMUM = 0.01f;

variable I3T_CYCLE_STEP_DURATION_SECONDS

cpp

constexpr auto I3T_CYCLE_STEP_DURATION_SECONDS = 0.5f;

constexpr auto I3T_CYCLE_STEP_DURATION_SECONDS = 0.5f;

variable I3T_DATA0

cpp

constexpr size_t I3T_DATA0 = 0;

constexpr size_t I3T_DATA0 = 0;

variable I3T_DATA1

cpp

constexpr size_t I3T_DATA1 = 1;

constexpr size_t I3T_DATA1 = 1;

variable I3T_DATA2

cpp

constexpr size_t I3T_DATA2 = 2;

constexpr size_t I3T_DATA2 = 2;

variable I3T_INPUT0

cpp

constexpr size_t I3T_INPUT0 = 0;

constexpr size_t I3T_INPUT0 = 0;

variable I3T_INPUT1

cpp

constexpr size_t I3T_INPUT1 = 1;

constexpr size_t I3T_INPUT1 = 1;

variable I3T_INPUT2

cpp

constexpr size_t I3T_INPUT2 = 2;

constexpr size_t I3T_INPUT2 = 2;

variable I3T_OUTPUT0

cpp

constexpr size_t I3T_OUTPUT0 = 0;

constexpr size_t I3T_OUTPUT0 = 0;

variable I3T_OUTPUT1

cpp

constexpr size_t I3T_OUTPUT1 = 1;

constexpr size_t I3T_OUTPUT1 = 1;

variable I3T_OUTPUT2

cpp

constexpr size_t I3T_OUTPUT2 = 2;

constexpr size_t I3T_OUTPUT2 = 2;

variable I3T_SEQ_IN_MAT

cpp

constexpr size_t I3T_SEQ_IN_MAT = 1;

constexpr size_t I3T_SEQ_IN_MAT = 1;

variable I3T_SEQ_IN_MUL

cpp

constexpr size_t I3T_SEQ_IN_MUL = 0;

constexpr size_t I3T_SEQ_IN_MUL = 0;

variable I3T_SEQ_MAT

cpp

constexpr size_t I3T_SEQ_MAT = 1;

constexpr size_t I3T_SEQ_MAT = 1;

variable I3T_SEQ_MOD

cpp

constexpr size_t I3T_SEQ_MOD = 2;

constexpr size_t I3T_SEQ_MOD = 2;

variable I3T_SEQ_MUL

cpp

constexpr size_t I3T_SEQ_MUL = 0;

constexpr size_t I3T_SEQ_MUL = 0;

variable I3T_SEQ_OUT_MAT

cpp

constexpr size_t I3T_SEQ_OUT_MAT = 1;

constexpr size_t I3T_SEQ_OUT_MAT = 1;

variable I3T_SEQ_OUT_MOD

cpp

constexpr size_t I3T_SEQ_OUT_MOD = 2;

constexpr size_t I3T_SEQ_OUT_MOD = 2;

variable I3T_SEQ_OUT_MUL

cpp

constexpr size_t I3T_SEQ_OUT_MUL = 0;

constexpr size_t I3T_SEQ_OUT_MUL = 0;

variable lookAtInputNames

cpp

static const PinNames lookAtInputNames = {"eye", "center", "up"};

static const PinNames lookAtInputNames = {"eye", "center", "up"};

variable matrixInput

cpp

static const PinGroup matrixInput = {EValueType::Matrix};

static const PinGroup matrixInput = {EValueType::Matrix};

variable matrixMulAndMatrixInput

cpp

static const PinGroup matrixMulAndMatrixInput = {EValueType::MatrixMul, EValueType::Matrix};

static const PinGroup matrixMulAndMatrixInput = {EValueType::MatrixMul, EValueType::Matrix};

variable matrixMulInput

cpp

static const PinGroup matrixMulInput = {EValueType::MatrixMul};

static const PinGroup matrixMulInput = {EValueType::MatrixMul};

variable matrixVectorInput

cpp

static const PinGroup matrixVectorInput = {EValueType::Matrix, EValueType::Vec4};

static const PinGroup matrixVectorInput = {EValueType::Matrix, EValueType::Vec4};

variable mixInputNames

cpp

static const PinNames mixInputNames = {"from", "to", "t"};

static const PinNames mixInputNames = {"from", "to", "t"};

variable NIL_ID

cpp

constexpr ID NIL_ID = 0;

constexpr ID NIL_ID = 0;

variable operations

cpp

static const std::vector< Operation > operations;

static const std::vector< Operation > operations;

Table with configuration parameters for OPERATORS.

Must be in the same order as in EOperatorType!!!

variable orthoFrustrumInputNames

cpp

static const PinNames orthoFrustrumInputNames = {"left", "right", "bottom", "top", "near", "far"};

static const PinNames orthoFrustrumInputNames = {"left", "right", "bottom", "top", "near", "far"};

variable PerspectiveInputNames

cpp

static const PinNames PerspectiveInputNames = {"fovy", "aspect", "near", "far"};

static const PinNames PerspectiveInputNames = {"fovy", "aspect", "near", "far"};

variable pulseInput

cpp

static const PinGroup pulseInput = {EValueType::Pulse};

static const PinGroup pulseInput = {EValueType::Pulse};

variable quatInput

cpp

static const PinGroup quatInput = {EValueType::Quat};

static const PinGroup quatInput = {EValueType::Quat};

variable QuatToFloatVecInputNames

cpp

static const PinNames QuatToFloatVecInputNames = {"w", "(x,y,z)"};

static const PinNames QuatToFloatVecInputNames = {"w", "(x,y,z)"};

variable screenFloatInput

cpp

static const PinGroup screenFloatInput = {EValueType::Screen, EValueType::Float};

static const PinGroup screenFloatInput = {EValueType::Screen, EValueType::Float};

variable screenInput

cpp

static const PinGroup screenInput = {EValueType::Screen};

static const PinGroup screenInput = {EValueType::Screen};

variable sixFloatInput

cpp

static const PinGroup sixFloatInput = {EValueType::Float, EValueType::Float, EValueType::Float,
                                       EValueType::Float, EValueType::Float, EValueType::Float};

static const PinGroup sixFloatInput = {EValueType::Float, EValueType::Float, EValueType::Float,
                                       EValueType::Float, EValueType::Float, EValueType::Float};

variable sixteenFloatInput

cpp

static const PinGroup sixteenFloatInput = {EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Float,
                                           EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Float,
                                           EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Float,
                                           EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Float};

static const PinGroup sixteenFloatInput = {EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Float,
                                           EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Float,
                                           EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Float,
                                           EValueType::Float, EValueType::Float, EValueType::Float, EValueType::Float};

variable threeFloatInput

cpp

static const PinGroup threeFloatInput = {EValueType::Float, EValueType::Float, EValueType::Float};

static const PinGroup threeFloatInput = {EValueType::Float, EValueType::Float, EValueType::Float};

variable threeVector3Input

cpp

static const PinGroup threeVector3Input = {EValueType::Vec3, EValueType::Vec3, EValueType::Vec3};

static const PinGroup threeVector3Input = {EValueType::Vec3, EValueType::Vec3, EValueType::Vec3};

variable tr

cpp

static const PinNames tr = {"T", "R"};

static const PinNames tr = {"T", "R"};

variable twoFloatInput

cpp

static const PinGroup twoFloatInput = {EValueType::Float, EValueType::Float};

static const PinGroup twoFloatInput = {EValueType::Float, EValueType::Float};

variable twoFloatVector3Input

cpp

static const PinGroup twoFloatVector3Input = {EValueType::Float, EValueType::Float, EValueType::Vec3};

static const PinGroup twoFloatVector3Input = {EValueType::Float, EValueType::Float, EValueType::Vec3};

variable twoMatrixInput

cpp

static const PinGroup twoMatrixInput = {EValueType::Matrix, EValueType::Matrix};

static const PinGroup twoMatrixInput = {EValueType::Matrix, EValueType::Matrix};

variable twoQuatFloatInput

cpp

static const PinGroup twoQuatFloatInput = {EValueType::Quat, EValueType::Quat, EValueType::Float};

static const PinGroup twoQuatFloatInput = {EValueType::Quat, EValueType::Quat, EValueType::Float};

variable twoQuatInput

cpp

static const PinGroup twoQuatInput = {EValueType::Quat, EValueType::Quat};

static const PinGroup twoQuatInput = {EValueType::Quat, EValueType::Quat};

variable twoVector3FloatInput

cpp

static const PinGroup twoVector3FloatInput = {EValueType::Vec3, EValueType::Vec3, EValueType::Float};

static const PinGroup twoVector3FloatInput = {EValueType::Vec3, EValueType::Vec3, EValueType::Float};

variable twoVector3Input

cpp

static const PinGroup twoVector3Input = {EValueType::Vec3, EValueType::Vec3};

static const PinGroup twoVector3Input = {EValueType::Vec3, EValueType::Vec3};

variable twoVectorFloatInput

cpp

static const PinGroup twoVectorFloatInput = {EValueType::Vec4, EValueType::Vec4, EValueType::Float};

static const PinGroup twoVectorFloatInput = {EValueType::Vec4, EValueType::Vec4, EValueType::Float};

variable twoVectorInput

cpp

static const PinGroup twoVectorInput = {EValueType::Vec4, EValueType::Vec4};

static const PinGroup twoVectorInput = {EValueType::Vec4, EValueType::Vec4};

variable vector3FloatInput

cpp

static const PinGroup vector3FloatInput = {EValueType::Vec3, EValueType::Float};

static const PinGroup vector3FloatInput = {EValueType::Vec3, EValueType::Float};

variable vector3Input

cpp

static const PinGroup vector3Input = {EValueType::Vec3};

static const PinGroup vector3Input = {EValueType::Vec3};

variable vector3QuatInput

cpp

static const PinGroup vector3QuatInput = {EValueType::Vec3, EValueType::Quat};

static const PinGroup vector3QuatInput = {EValueType::Vec3, EValueType::Quat};

variable vectorInput

cpp

static const PinGroup vectorInput = {EValueType::Vec4};

static const PinGroup vectorInput = {EValueType::Vec4};

variable vectorMatrixInput

cpp

static const PinGroup vectorMatrixInput = {EValueType::Vec4, EValueType::Matrix};

static const PinGroup vectorMatrixInput = {EValueType::Vec4, EValueType::Matrix};

variable Vectors3ToMatrixInputNames

cpp

static const PinNames Vectors3ToMatrixInputNames = {"vec3 X", "vec3 Y", "vec3 Z", "vec3 T"};

static const PinNames Vectors3ToMatrixInputNames = {"vec3 X", "vec3 Y", "vec3 Z", "vec3 T"};

variable VectorsToMatrixInputNames

cpp

static const PinNames VectorsToMatrixInputNames = {"vec4 X", "vec4 Y", "vec4 Z", "vec4 T"};

static const PinNames VectorsToMatrixInputNames = {"vec4 X", "vec4 Y", "vec4 Z", "vec4 T"};

variable VM_ANY

cpp

constexpr int8_t VM_ANY = 2;

constexpr int8_t VM_ANY = 2;

Editable matrix element in ValueMask - it's range of values may be limited - the limit is checked in setValue() methods.

variable VM_MINUS_ONE

cpp

constexpr int8_t VM_MINUS_ONE = -1;

constexpr int8_t VM_MINUS_ONE = -1;

Fixed matrix element (-1) in ValueMask.

variable VM_ONE

cpp

constexpr int8_t VM_ONE = 1;

constexpr int8_t VM_ONE = 1;

Fixed matrix element (+1) in ValueMask.

variable VM_ZERO

cpp

constexpr int8_t VM_ZERO = 0;

constexpr int8_t VM_ZERO = 0;

Fixed matrix element (0) in ValueMask.

variable xyz

cpp

static const PinNames xyz = {"x", "y", "z"};

static const PinNames xyz = {"x", "y", "z"};

variable xyzw

cpp

static const PinNames xyzw = {"x", "y", "z", "w"};

static const PinNames xyzw = {"x", "y", "z", "w"};

Updated on 2024-03-16 at 19:15:01 +0000

Core ​

Namespaces ​

Classes ​

Types ​

Functions ​

Attributes ​

Types Documentation ​

enum ENodePlugResult ​

enum EOperatorType ​

enum ETransformType ​

enum EValueState ​

enum EValueType ​

enum ResourceType ​

enum TrackingDirection ​

using CameraPtr ​

using gm ​

typedef ID ​

using Matrices ​

using PinGroup ​

using PinNames ​

using TransformMask ​

using ValueMask ​

Functions Documentation ​

function canEditValue ​

function getMatProduct ​

function getNonemptyChildSequence ​

function getNonemptyParentSequence ​

function getOperationProps ​

function getTransformDefaults ​

function getTransformMap ​

function getTransformOperation ​

function getTransformOperation ​

function longWaySlerp ​

function longWaySlerp ​

function matrixIndexNames ​

function setActivePart ​

function validateValue ​

function validateValues ​

Attributes Documentation ​

variable AngleAxisInputNames ​

variable AngleAxisToQuatInputNames ​

variable ClampFloatInputNames ​

variable cycleInputs ​

variable cycleOutputs ​

variable defaultIoNames ​

variable emptyNames ​

variable eulerInputNames ​

variable floatInput ​

variable floatMatrixInput ​

variable floatQuatInput ​

variable floatVector3Input ​

variable floatVectorInput ​

variable fourFloatInput ​

variable fourVector3Input ​

variable fourVectorInput ​

variable g_AllLocked ​

variable g_AllUnlocked ​

variable g_AxisAngleMask ​

variable g_cameraProperties ​

variable g_CycleProperties ​

variable g_FrustumMask ​

variable g_LookAtMask ​

variable g_modelProperties ​

variable g_OrthoMask ​

variable g_PerspectiveMask ​

variable g_RotateXMask ​

variable g_RotateYMask ​

variable g_RotateZMask ​

variable g_ScaleMask ​

variable g_sequence ​

variable g_transforms ​

variable g_TranslateMask ​

variable generator ​

variable generator ​

variable I3T_CAMERA_OUT_MATRIX ​

variable I3T_CAMERA_OUT_MUL ​

variable I3T_CAMERA_OUT_SCREEN ​

variable I3T_CYCLE_IN_FROM ​

variable I3T_CYCLE_IN_NEXT ​

variable I3T_CYCLE_IN_PAUSE ​

Core

Namespaces

Classes

Types

Functions

Attributes

Types Documentation

enum ENodePlugResult

enum EOperatorType

enum ETransformType

enum EValueState

enum EValueType

enum ResourceType

enum TrackingDirection

using CameraPtr

using gm

typedef ID

using Matrices

using PinGroup

using PinNames

using TransformMask

using ValueMask

Functions Documentation

function canEditValue

function getMatProduct

function getNonemptyChildSequence

function getNonemptyParentSequence

function getOperationProps

function getTransformDefaults

function getTransformMap

function getTransformOperation

function getTransformOperation

function longWaySlerp

function longWaySlerp

function matrixIndexNames

function setActivePart

function validateValue

function validateValues

Attributes Documentation

variable AngleAxisInputNames

variable AngleAxisToQuatInputNames

variable ClampFloatInputNames

variable cycleInputs

variable cycleOutputs

variable defaultIoNames

variable emptyNames

variable eulerInputNames

variable floatInput

variable floatMatrixInput

variable floatQuatInput

variable floatVector3Input

variable floatVectorInput

variable fourFloatInput

variable fourVector3Input

variable fourVectorInput

variable g_AllLocked

variable g_AllUnlocked

variable g_AxisAngleMask

variable g_cameraProperties

variable g_CycleProperties

variable g_FrustumMask

variable g_LookAtMask

variable g_modelProperties

variable g_OrthoMask

variable g_PerspectiveMask

variable g_RotateXMask

variable g_RotateYMask

variable g_RotateZMask

variable g_ScaleMask

variable g_sequence

variable g_transforms

variable g_TranslateMask

variable generator

variable generator

variable I3T_CAMERA_OUT_MATRIX

variable I3T_CAMERA_OUT_MUL

variable I3T_CAMERA_OUT_SCREEN

variable I3T_CYCLE_IN_FROM

variable I3T_CYCLE_IN_NEXT

variable I3T_CYCLE_IN_PAUSE