I3T

Appearance

Core ​

Namespaces ​

Name
Core::Builder

Classes ​

Name
classCore::Camera <br>Camera has following outputs 0 -> screen output 1 -> proj * view matrix output 2 -> mul output.
structCore::CameraCoordSystem
classCore::Cycle
classCore::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)
classCore::DataMap <br>In column-major order.
classCore::GraphManager <br>You must manage GraphManager lifecycle.
structCore::HalfspaceSign
classCore::IdGenerator
classCore::ManagedResource <br>Base class for objects that are the actual data managed by a ResourceManager.
classCore::MatrixTracker <br>The main tracking object, responsible for tracking a single chain of sequences.
classCore::Mesh <br>Mesh represents a complete 3D model.
classCore::Model
classCore::ModelResourceFiles <br>A set a of 3D file format files located somewhere in the filesystem.
classCore::Node <br>Base class interface for all boxes.
classCore::NodeTree <br>Container representing a tree of nodes connected together using a particular type of connections.
structCore::Operation <br>Description of each graph node (operation enum, default label, input and output pin names and types)
classCore::Operator <br>Implementation of Node class.
classCore::Pin <br>Pin used for connecting nodes.
classCore::PreorderNodeTreeIterator
classCore::Resource <br>Object holding information about a resource.
classCore::ResourceFiles <br>A collection of file paths in the filesystem that are together required to load a single resource like a model.
classCore::ResourceManager <br>Resource manager for loading resources from the filesystem.
classCore::Screen
structCore::ScreenData
classCore::Sequence <br>Sequence of matrices.
classCore::SequenceTree <br>Iterable node tree container using the SequenceTreeIterator.
classCore::SequenceTreeIterator <br>Preorder iterator over a subtree of sequences and models connected using matrix multiplication connections.
structCore::SetValueResult
structCore::TrackedModelData <br>Data object holding extra information about a currently tracked model.
structCore::TrackedNodeData <br>Tracking data for individual nodes involved in a tracking operation.
classCore::Transform
classCore::TransformChain <br>Iterable object representing a single chain of connected sequence nodes and their transform contents.
classCore::TransformImpl
classCore::TransformImpl< ETransformType::AxisAngle >
classCore::TransformImpl< ETransformType::EulerX >
classCore::TransformImpl< ETransformType::EulerY >
classCore::TransformImpl< ETransformType::EulerZ >
classCore::TransformImpl< ETransformType::Free >
classCore::TransformImpl< ETransformType::Frustum >
classCore::TransformImpl< ETransformType::LookAt > <br>Same as perspective projection node, but all values are locked.
classCore::TransformImpl< ETransformType::Ortho >
classCore::TransformImpl< ETransformType::Perspective >
classCore::TransformImpl< ETransformType::Quat > <br>Quaternion class Quaternion represents the matrix, crated from quaternion.
classCore::TransformImpl< ETransformType::Scale >
classCore::TransformImpl< ETransformType::Translation >
classCore::TransformImpl< ETransformType::Viewport >
structCore::TransformInfo <br>Data container for TransformChainIterator traversal metadata.
structCore::TransformOperation <br>Extends Operation - adds properties to transform nodes.

Types ​

Name
enum classClipRange { MinusOneToOne, OneToMinusOne, ZeroToOne, ZeroToMinusOne}
enum classDepthRange { ZeroToOne}
enum classENodePlugResult { Ok = 0, Err_MismatchedPinTypes, Err_MismatchedPinKind, Err_Loopback, Err_NonexistentPin, Err_Loop, Err_DisabledPin}
enum classEOperatorType { 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, MakeViewport}
enum classETransformType { Free = 0, Translation, EulerX, EulerY, EulerZ, Scale, AxisAngle, Quat, Ortho, Perspective, Frustum, LookAt, Viewport}
enum classEValueState { Editable = 0x0002, EditableSyn = 0x0003, Locked = 0x0000, LockedSyn = 0x0001}<br>Float value editable status: b1, b2 - b1 is editable bit, b2 is synergies bit.
enum classEValueType { Pulse = 0, Float, Vec3, Vec4, Matrix, Quat, MatrixMul, Screen, Ptr}<br>An operator value type = type of the interconnection wire.
enum classResourceType { Model, Shader, Texture}
enum classTrackingDirection { LeftToRight = -1, RightToLeft = 1}
enum classTransformSpace { Model, View, Projection, Screen}
using Ptr< Camera >CameraPtr
using GraphManagergm
typedef std::int64_tID
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
boolcanEditValue(EValueState valueState)
FORCE_INLINE glm::mat4getMatProduct(const std::vector< Ptr< Transform > > & matrices)
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)
boolisViewportValid(const glm::mat4 & mat)
template <typename T ,glm::precision P&gt; <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&gt; <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 PinNamesmatrixIndexNames()
boolvalidateValue(const ValueMask & mask, glm::ivec2 coords, float value)<br>Check single element in the matrix, if it is in the allowed range.
boolvalidateValues(const ValueMask & mask, const glm::mat4 & matrix)<br>Check if all matrix elements are in the allowed range.

Attributes ​

Name
const PinNamesAngleAxisInputNames
const PinNamesAngleAxisToQuatInputNames
const PinNamesClampFloatInputNames
const PinGroupcycleInputs <br>From, to, multiplier, receive (play, pause, stopAndReset, prev, next).
const PinGroupcycleOutputs <br>Output value, emit (play, pause, stopAndReset, prev, next).
const std::array< std::string, 9 >defaultIoNames
const PinNamesemptyNames
const PinNameseulerInputNames
const PinGroupfloatInput
const PinGroupfloatMatrixInput
const PinGroupfloatQuatInput
const PinGroupfloatVector3Input
const PinGroupfloatVectorInput
const PinGroupfourFloatInput
const PinGroupfourVector3Input
const PinGroupfourVectorInput
constexpr TransformMaskg_AllLocked
constexpr TransformMaskg_AllUnlocked
constexpr ValueMaskg_AxisAngleMask
const Operationg_cameraProperties
const Operationg_CycleProperties
constexpr ValueMaskg_FrustumMask
CameraCoordSystemg_i3t <br>The initial I3T specific "world" coordinate system (right handed, view towards -Z)
constexpr ValueMaskg_LookAtMask
const Operationg_modelProperties
CameraCoordSystemg_openGL <br>The standard OpenGL coord system.
constexpr ValueMaskg_OrthoMask
constexpr ValueMaskg_PerspectiveMask
constexpr ValueMaskg_RotateXMask
constexpr ValueMaskg_RotateYMask
constexpr ValueMaskg_RotateZMask
constexpr ValueMaskg_ScaleMask
const Operationg_screen
const Operationg_sequence
const std::vector< TransformOperation >g_transforms <br>All entries must be in the same order as ETransformType enum entries.
constexpr ValueMaskg_TranslateMask
constexpr ValueMaskg_ViewportMask
CameraCoordSystemg_vulkan <br>The standard Vulkan coord system.
IdGeneratorgenerator
IdGeneratorgenerator
constexpr unsignedI3T_CAMERA_OUT_MATRIX
constexpr unsignedI3T_CAMERA_OUT_MUL
constexpr unsignedI3T_CAMERA_OUT_SCREEN
constexpr size_tI3T_CYCLE_IN_FROM
constexpr size_tI3T_CYCLE_IN_NEXT
constexpr size_tI3T_CYCLE_IN_PAUSE
constexpr size_tI3T_CYCLE_IN_PLAY
constexpr size_tI3T_CYCLE_IN_PREV
constexpr size_tI3T_CYCLE_IN_STEP
constexpr size_tI3T_CYCLE_IN_STOP
constexpr size_tI3T_CYCLE_IN_TO
constexpr size_tI3T_CYCLE_OUT_BEGIN
constexpr size_tI3T_CYCLE_OUT_END
constexpr size_tI3T_CYCLE_OUT_NEXT
constexpr size_tI3T_CYCLE_OUT_PAUSE
constexpr size_tI3T_CYCLE_OUT_PLAY
constexpr size_tI3T_CYCLE_OUT_PREV
constexpr size_tI3T_CYCLE_OUT_STOP
constexpr size_tI3T_CYCLE_OUT_VAL
constexpr autoI3T_CYCLE_STEP_DURATION_MINIMUM
constexpr autoI3T_CYCLE_STEP_DURATION_SECONDS
constexpr size_tI3T_DATA0
constexpr size_tI3T_DATA1
constexpr size_tI3T_DATA2
constexpr size_tI3T_INPUT0
constexpr size_tI3T_INPUT1
constexpr size_tI3T_INPUT2
constexpr size_tI3T_MODEL_IN_MUL
constexpr size_tI3T_OUTPUT0
constexpr size_tI3T_OUTPUT1
constexpr size_tI3T_OUTPUT2
constexpr size_tI3T_SCREEN_IN_DISPLAY
constexpr size_tI3T_SCREEN_OUT_ASPECT
constexpr size_tI3T_SCREEN_OUT_HEIGHT
constexpr size_tI3T_SCREEN_OUT_WIDTH
constexpr size_tI3T_SEQ_IN_MAT
constexpr size_tI3T_SEQ_IN_MUL
constexpr size_tI3T_SEQ_MAT
constexpr size_tI3T_SEQ_MOD
constexpr size_tI3T_SEQ_MUL
constexpr size_tI3T_SEQ_OUT_MAT
constexpr size_tI3T_SEQ_OUT_MOD
constexpr size_tI3T_SEQ_OUT_MUL
const PinNameslookAtInputNames
const PinGroupmatrixInput
const PinGroupmatrixMulAndMatrixInput
const PinGroupmatrixMulInput
const PinGroupmatrixVectorInput
const PinNamesmixInputNames
constexpr IDNIL_ID
const std::vector< Operation >operations <br>Table with configuration parameters for OPERATORS.
const PinNamesorthoFrustrumInputNames
const PinNamesPerspectiveInputNames
const PinGrouppulseInput
const PinGroupquatInput
const PinNamesQuatToFloatVecInputNames
const PinGroupscreenInput
const PinGroupsixFloatInput
const PinGroupsixteenFloatInput
const PinGroupthreeFloatInput
const PinGroupthreeVector3Input
const PinNamestr
const PinGrouptwoFloatInput
const PinGrouptwoFloatVector3Input
const PinGrouptwoMatrixInput
const PinGrouptwoQuatFloatInput
const PinGrouptwoQuatInput
const PinGrouptwoVector3FloatInput
const PinGrouptwoVector3Input
const PinGrouptwoVectorFloatInput
const PinGrouptwoVectorInput
const PinGroupvector3FloatInput
const PinGroupvector3Input
const PinGroupvector3QuatInput
const PinGroupvectorInput
const PinGroupvectorMatrixInput
const PinNamesVectors3ToMatrixInputNames
const PinNamesVectorsToMatrixInputNames
const PinNamesviewportInputNames
constexpr int8_tVM_ANY <br>Editable matrix element in ValueMask - it's range of values may be limited - the limit is checked in setValue() methods.
constexpr int8_tVM_MINUS_ONE <br>Fixed matrix element (-1) in ValueMask.
constexpr int8_tVM_ONE <br>Fixed matrix element (+1) in ValueMask.
constexpr int8_tVM_ZERO <br>Fixed matrix element (0) in ValueMask.
const PinNamesxyz
const PinNamesxyzw

Types Documentation ​

enum ClipRange ​

EnumeratorValueDescription
MinusOneToOne
OneToMinusOne
ZeroToOne
ZeroToMinusOne

enum DepthRange ​

EnumeratorValueDescription
ZeroToOne

enum ENodePlugResult ​

EnumeratorValueDescription
Ok0
Err_MismatchedPinTypes
Err_MismatchedPinKind
Err_Loopback
Err_NonexistentPinSame nodes.
Err_Loop
Err_DisabledPin

enum EOperatorType ​

EnumeratorValueDescription
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
MakeViewport

enum ETransformType ​

EnumeratorValueDescription
Free0
Translation
EulerX
EulerY
EulerZ
Scale
AxisAngle
Quat
Ortho
Perspective
Frustum
LookAt
Viewport

enum EValueState ​

EnumeratorValueDescription
Editable0x000210
EditableSyn0x000311
Locked0x000000
LockedSyn0x000101

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 ​

EnumeratorValueDescription
Pulse0
Floatstandard data type
Vec3
Vec4
Matrix
Quat
MatrixMulconnection of sequences in the scene graph - represents a matrix multiplication - stores a matrix
Screenprojection 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 ​

EnumeratorValueDescription
Model
Shader
Texture

enum TrackingDirection ​

EnumeratorValueDescription
LeftToRight-1
RightToLeft1

enum TransformSpace ​

EnumeratorValueDescription
Model
View
Projection
Screen

using CameraPtr ​

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

using gm ​

cpp
using Core::gm = typedef GraphManager;

typedef ID ​

cpp
typedef std::int64_t Core::ID;

using Matrices ​

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

using PinGroup ​

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

using PinNames ​

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

using TransformMask ​

cpp
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>;

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
)

function getMatProduct ​

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

function getOperationProps ​

cpp
FORCE_INLINE const Operation * getOperationProps(
    EOperatorType type
)

function getTransformDefaults ​

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

function getTransformMap ​

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

function getTransformOperation ​

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

function getTransformOperation ​

cpp
FORCE_INLINE const TransformOperation & getTransformOperation(
    ETransformType type
)

function isViewportValid ​

cpp
bool isViewportValid(
    const glm::mat4 & mat
)

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
)

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
)

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()

function validateValue ​

cpp
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
)

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"};

variable AngleAxisToQuatInputNames ​

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

variable ClampFloatInputNames ​

cpp
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,
};

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,
};

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" 
};

variable emptyNames ​

cpp
static const PinNames emptyNames = {};

variable eulerInputNames ​

cpp
static const PinNames eulerInputNames = {"angle"};

variable floatInput ​

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

variable floatMatrixInput ​

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

variable floatQuatInput ​

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

variable floatVector3Input ​

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

variable floatVectorInput ​

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

variable fourFloatInput ​

cpp
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};

variable fourVectorInput ​

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

variable g_AllLocked ​

cpp
constexpr TransformMask g_AllLocked = 0b0000000000000000;

variable g_AllUnlocked ​

cpp
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,
};

variable g_cameraProperties ​

cpp
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"},
    
};

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,
};

variable g_i3t ​

cpp
CameraCoordSystem g_i3t = CameraCoordSystem();

The initial I3T specific "world" coordinate system (right handed, view towards -Z)

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,
};

variable g_modelProperties ​

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

variable g_openGL ​

cpp
CameraCoordSystem g_openGL = CameraCoordSystem{ClipRange::MinusOneToOne, DepthRange::ZeroToOne, true};

The standard OpenGL coord system.

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,
};

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,
};

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,
};

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,
};

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,
};

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,
};

variable g_screen ​

cpp
const Operation g_screen = {
    "Screen", "screen",      screenInput,   {EValueType::Float, EValueType::Float, EValueType::Float},
    NO_TAG,   DEFAULT_NAMES, DEFAULT_NAMES, false,
    true};

variable g_sequence ​

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

variable g_transforms ​

cpp
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,
};

variable g_ViewportMask ​

cpp
constexpr ValueMask g_ViewportMask = {
    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_vulkan ​

cpp
CameraCoordSystem g_vulkan = CameraCoordSystem{ClipRange::ZeroToOne, DepthRange::ZeroToOne, false};

The standard Vulkan coord system.

variable generator ​

cpp
static IdGenerator generator;

variable generator ​

cpp
static IdGenerator generator;

variable I3T_CAMERA_OUT_MATRIX ​

cpp
constexpr unsigned I3T_CAMERA_OUT_MATRIX = 1;

variable I3T_CAMERA_OUT_MUL ​

cpp
constexpr unsigned I3T_CAMERA_OUT_MUL = 2;

variable I3T_CAMERA_OUT_SCREEN ​

cpp
constexpr unsigned I3T_CAMERA_OUT_SCREEN = 0;

variable I3T_CYCLE_IN_FROM ​

cpp
constexpr size_t I3T_CYCLE_IN_FROM = 0;

variable I3T_CYCLE_IN_NEXT ​

cpp
constexpr size_t I3T_CYCLE_IN_NEXT = 7;

variable I3T_CYCLE_IN_PAUSE ​

cpp
constexpr size_t I3T_CYCLE_IN_PAUSE = 4;

variable I3T_CYCLE_IN_PLAY ​

cpp
constexpr size_t I3T_CYCLE_IN_PLAY = 3;

variable I3T_CYCLE_IN_PREV ​

cpp
constexpr size_t I3T_CYCLE_IN_PREV = 6;

variable I3T_CYCLE_IN_STEP ​

cpp
constexpr size_t I3T_CYCLE_IN_STEP = 2;

variable I3T_CYCLE_IN_STOP ​

cpp
constexpr size_t I3T_CYCLE_IN_STOP = 5;

variable I3T_CYCLE_IN_TO ​

cpp
constexpr size_t I3T_CYCLE_IN_TO = 1;

variable I3T_CYCLE_OUT_BEGIN ​

cpp
constexpr size_t I3T_CYCLE_OUT_BEGIN = 6;

variable I3T_CYCLE_OUT_END ​

cpp
constexpr size_t I3T_CYCLE_OUT_END = 7;

variable I3T_CYCLE_OUT_NEXT ​

cpp
constexpr size_t I3T_CYCLE_OUT_NEXT = 5;

variable I3T_CYCLE_OUT_PAUSE ​

cpp
constexpr size_t I3T_CYCLE_OUT_PAUSE = 2;

variable I3T_CYCLE_OUT_PLAY ​

cpp
constexpr size_t I3T_CYCLE_OUT_PLAY = 1;

variable I3T_CYCLE_OUT_PREV ​

cpp
constexpr size_t I3T_CYCLE_OUT_PREV = 4;

variable I3T_CYCLE_OUT_STOP ​

cpp
constexpr size_t I3T_CYCLE_OUT_STOP = 3;

variable I3T_CYCLE_OUT_VAL ​

cpp
constexpr size_t I3T_CYCLE_OUT_VAL = 0;

variable I3T_CYCLE_STEP_DURATION_MINIMUM ​

cpp
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;

variable I3T_DATA0 ​

cpp
constexpr size_t I3T_DATA0 = 0;

variable I3T_DATA1 ​

cpp
constexpr size_t I3T_DATA1 = 1;

variable I3T_DATA2 ​

cpp
constexpr size_t I3T_DATA2 = 2;

variable I3T_INPUT0 ​

cpp
constexpr size_t I3T_INPUT0 = 0;

variable I3T_INPUT1 ​

cpp
constexpr size_t I3T_INPUT1 = 1;

variable I3T_INPUT2 ​

cpp
constexpr size_t I3T_INPUT2 = 2;

variable I3T_MODEL_IN_MUL ​

cpp
constexpr size_t I3T_MODEL_IN_MUL = 0;

variable I3T_OUTPUT0 ​

cpp
constexpr size_t I3T_OUTPUT0 = 0;

variable I3T_OUTPUT1 ​

cpp
constexpr size_t I3T_OUTPUT1 = 1;

variable I3T_OUTPUT2 ​

cpp
constexpr size_t I3T_OUTPUT2 = 2;

variable I3T_SCREEN_IN_DISPLAY ​

cpp
constexpr size_t I3T_SCREEN_IN_DISPLAY = 0;

variable I3T_SCREEN_OUT_ASPECT ​

cpp
constexpr size_t I3T_SCREEN_OUT_ASPECT = 2;

variable I3T_SCREEN_OUT_HEIGHT ​

cpp
constexpr size_t I3T_SCREEN_OUT_HEIGHT = 1;

variable I3T_SCREEN_OUT_WIDTH ​

cpp
constexpr size_t I3T_SCREEN_OUT_WIDTH = 0;

variable I3T_SEQ_IN_MAT ​

cpp
constexpr size_t I3T_SEQ_IN_MAT = 1;

variable I3T_SEQ_IN_MUL ​

cpp
constexpr size_t I3T_SEQ_IN_MUL = 0;

variable I3T_SEQ_MAT ​

cpp
constexpr size_t I3T_SEQ_MAT = 1;

variable I3T_SEQ_MOD ​

cpp
constexpr size_t I3T_SEQ_MOD = 2;

variable I3T_SEQ_MUL ​

cpp
constexpr size_t I3T_SEQ_MUL = 0;

variable I3T_SEQ_OUT_MAT ​

cpp
constexpr size_t I3T_SEQ_OUT_MAT = 1;

variable I3T_SEQ_OUT_MOD ​

cpp
constexpr size_t I3T_SEQ_OUT_MOD = 2;

variable I3T_SEQ_OUT_MUL ​

cpp
constexpr size_t I3T_SEQ_OUT_MUL = 0;

variable lookAtInputNames ​

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

variable matrixInput ​

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

variable matrixMulAndMatrixInput ​

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

variable matrixMulInput ​

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

variable matrixVectorInput ​

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

variable mixInputNames ​

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

variable NIL_ID ​

cpp
constexpr ID NIL_ID = 0;

variable operations ​

cpp
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"};

variable PerspectiveInputNames ​

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

variable pulseInput ​

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

variable quatInput ​

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

variable QuatToFloatVecInputNames ​

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

variable screenInput ​

cpp
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};

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};

variable threeFloatInput ​

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

variable threeVector3Input ​

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

variable tr ​

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

variable twoFloatInput ​

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

variable twoFloatVector3Input ​

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

variable twoMatrixInput ​

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

variable twoQuatFloatInput ​

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

variable twoQuatInput ​

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

variable twoVector3FloatInput ​

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

variable twoVector3Input ​

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

variable twoVectorFloatInput ​

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

variable twoVectorInput ​

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

variable vector3FloatInput ​

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

variable vector3Input ​

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

variable vector3QuatInput ​

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

variable vectorInput ​

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

variable vectorMatrixInput ​

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

variable Vectors3ToMatrixInputNames ​

cpp
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"};

variable viewportInputNames ​

cpp
static const PinNames viewportInputNames = {"x", "y", "width", "height", "near", "far"};

variable VM_ANY ​

cpp
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;

Fixed matrix element (-1) in ValueMask.

variable VM_ONE ​

cpp
constexpr int8_t VM_ONE = 1;

Fixed matrix element (+1) in ValueMask.

variable VM_ZERO ​

cpp
constexpr int8_t VM_ZERO = 0;

Fixed matrix element (0) in ValueMask.

variable xyz ​

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

variable xyzw ​

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

Updated on 2026-09-11 at 21:24:26 +0000