Base class for binding runtimes.
Actions are small operations that Kanzi executes when the trigger event that contains that action occurs
and the trigger conditions are met. Action is the base class for actions. For example, if you want to perform
a simple operation, such as set a value of a property, you can use a trigger with the SetPropertyAction
action.
Base abstraction class for Action classes.
See: Action, ApplyAction.
An Activity is a part of application UI that is responsible for a task.
For example, a media player application can have Activity nodes, such as radio, music player, and AUX.
However, an Activity can also be a smaller task, such as an Activity for the popup volume indicator that appears only when the user changes the volume in a media player.
An Activity can be visual, but does not have to be.
For example, an Activity that is visual can instantiate a prefab to show a popup window, while an Activity that is not visual can be music playback which plays music in the background regardless of other Activity nodes.
An Activity is a part of application UI that is responsible for a task.
For example, a media player application can have Activity nodes, such as radio, music player, and AUX.
However, an Activity can also be a smaller task, such as an Activity for the popup volume indicator that appears only when the user changes the volume in a media player.
An Activity can be visual, but does not have to be.
For example, an Activity that is visual can instantiate a prefab to show a popup window, while an Activity that is not visual can be music playback which plays music in the background regardless of other Activity nodes.
ActivityCodeBehind is code that is associated with a particular Activity node, and has access to the properties of that Activity node.
You can use this to:
Animation binding processor executes an animation and calculates the value for use in expression bindings.
The processor itself is not executed unless an operation code within binding operation codes refers to it by index.
Use the Animation Player to play back an animation timeline that you set using the
TimelineProperty property in that Animation Player. Kanzi resolves paths to animated nodes
relative to the node where you attach an Animation Player.
A Resource wrapper class for animations.
Currently only supports loading of float keyframe animations.
Base abstraction for Actions for DataTrigger, such as ForwardingApplyAction and ApplyActivationAction.
An ApplyAction applies the changes described in the Action on apply(), and reverts them on unapply().
An ApplyActivationAction keeps an Activity node activated for as long as the condition is met in
a DataTrigger that contains this action. When the trigger condition is no longer met, Kanzi rolls back the state of
the Activity node to the state before the action was applied. Use the ApplyActivationAction only with a DataTrigger.
An ApplyPropertyAction sets a property to the requested value for as long as the condition is met in
the DataTrigger that sets off this action. When the trigger condition is no longer met, Kanzi rolls back the value
of that property to the value before the action was applied, or to the value set while Kanzi was
applying an ApplyPropertyAction. Use the ApplyPropertyAction only with a DataTrigger.
Binding is the simplest form of binding. It performs a copy from source to target without caching the
value. To learn more about bindings, see
AbstractBinding.
Binding processor
Font implementation for bitmap fonts. Supported bitmap fonts consist of a plain text fnt definition file
and one or more bitmaps containing the pre-rendered glyphs at a certain size.
Image is the basic runtime primitive to load, hold, and convert image data in memory.
Each image has width, height, pixel format, image data in memory, and can contain mipmap images.
Use the Blit Render Pass to blit one or more textures to the screen of the current rendering context using
a material. After the blit operation, a Blit Render Pass passes the control to its descendants and then
further to its siblings and parent.
Use BlurEffect2D to apply a Gaussian blur post-processing effect to 2D nodes.
Use a brush to fill a Node2D.
Use the Button 2D node to create a 2D UI control that the user can interact
with through clicking, tapping, or pressing a key.
Use the Button 3D node to create a 3D UI control that the user can interact
with through clicking, tapping, or pressing a key.
Callback processor.
Use a Camera to define the view transform to use to render a 3D Scene.
Use a Clear Render Pass to clear the color, depth, and stencil buffers of the current render context
before passing the control to the descendants of this render pass.
Click input manipulator recognizes the click and tap gestures from the incoming touch events.
The click manipulator generates the messages required to implement the logic for UI elements
that users can click or tap. For example, use the input manipulator to create a button.
ClickManipulatorComponent installs a ClickManipulator to a node. Use ClickManipulatorComponent to
enable nodes to react to click and touch input events and to control
the behavior of the installed ClickManipulator.
Code Behind is a workflow where you associate code with an instance of a node instead of a type.
In Code Behind you write code that you want to associate with the view or controller parts of the model-view-controller pattern.
Color brush class.
Color with 4 floating point components: red, green, blue and alpha (r, g, b, a).
\ingroup Math
Command class defines property and message types used in implementation of commands.
Texture brush class.
Use the Composition Target Render Pass to set one to four composition targets and render all descendant render passes
to the composition targets that the Composition Target Render Pass created. If you set multiple composition targets,
rendering can write to all specified buffers at the same time.
See MultipleCompositionTargets “Using multiple composition targets”.
After Kanzi renders the descendant render passes of a Composition Target Render Pass, the Composition Target
Render Pass restores the earlier composition settings.
Condition for triggers.
Contains property types of Constraints.
Texture brush class.
Use the Content Layout 2D node to present content in a 2D UI control as a single item.
You can use the Content Layout 2D node to create a control that adapts to the size of its content,
or a control where the content adapts to the size of the control.
The measured dimensions of the Content Layout 3D are determined
by the combined maximum dimensions of its items.
Use the Cubemap Render Pass to create a cubemap texture that represents the scene from some location.
You can use the result of the Cubemap Render Pass as a cubemap texture. For example, use the Cubemap
Render Pass to create dynamic reflections of the environment on the surface of 3D nodes.
DataContext acts as a container for data.
A type of Exclusive Activity Host node, that uses a list of Activity nodes provided by setting a list DataObject, from a DataSource, to the ActivitySourceProperty property.
A child Activity node of a Data-Driven Exclusive Activity Host uses the prefab set in the ActivityTemplateProperty.
A type of Exclusive Activity Host node, that uses a list of Activity nodes provided by setting a list DataObject, from a DataSource, to the ActivitySourceProperty property.
A child Activity node of a Data-Driven Exclusive Activity Host uses the prefab set in the ActivityTemplateProperty.
DataObject is the base class for data.
All data within the data source is described as a tree of data objects.
The base class provides support for the hierarchy as the derived classes provide support for different value types.
Use data sources to separate the user interface from the application data and to remove the dependencies between a
Kanzi Studio project and the application code which define the Kanzi application. Kanzi allows you to define the
format and structure of your data source by defining a Kanzi Engine data source plugin.
Use a DataTrigger to apply an action to either set a property value of a target node or activate an Activity node. A DataTrigger keeps that action applied for as long as the condition in that DataTrigger is met. When the condition in that DataTrigger is no longer met, Kanzi reverts the changes that it applied using that DataTrigger. Note that in a DataTrigger you can use only ApplyAction actions: ApplyActivationAction and ApplyPropertyAction.
Base class for the DataTrigger class. The DataTriggerComponent class defines the inclusion of ApplyAction class.
DefaultLogger is a container for an arbitrary number of other loggers.
DispatchMessageAction dispatches a message of specified type to a specified target.
Use the Dock Layout 2D node to place nodes relative to each other along the sides of a Dock Layout 2D node.
To set the side along which you want to place a node in a Dock Layout 2D node, use the
DockLayoutConcept::SideProperty property.
Use the Dock Layout 3D node to place nodes relative to each other along the sides of a Dock Layout 3D node.
To set the side along which you want to place a node in a Dock Layout 3D node, use the
DockLayoutConcept::SideProperty property.
Domain binds Kanzi subsystems and objects together.
Drag-and-drop input manipulator recognizes the drag-and-drop gesture from incoming touch events. It generates messages required to
implement the logic for objects which react to the drag-and-drop gesture. For example, use the drag-and-drop input manipulator to
move objects in an application.
Use the Draw Objects Render Pass to render only nodes in a Scene node provided by an object
source you set in this render pass. The Draw Objects Render Pass renders objects from the
object source you set in the ObjectSourceProperty property with the Camera node that the
Scene node uses. The Camera node that a Draw Objects Render Pass uses must be in the same
Scene node as the objects that the Draw Objects Render Pass renders.
Use the Draw Objects With %Material Render Pass to render nodes provided by an object source using a material.
Editor information for metadata.
Use EffectStack2D to apply multiple post-processing effects to 2D nodes.
Empty Node 2D can be used to group other 2D nodes.
Use an EmptyNode3D to group 3D nodes.
Error type used extnesively by this crate.
An Activity Host that displays Activity nodes one at a time.
An Activity Host that displays Activity nodes one at a time.
Expression binding processor.
Use trigger conditions to set which conditions must be met for a Trigger to set off. For example, you can define
conditions to set off a trigger when the user navigates to a specific Page node, enable the user to click a button
only when that button is visible, or enable the user to scroll a Scroll View node only when a specific Page node is
active.
Use a FloatValueAccumulator to increase the value of a float property type or a property field over time.
Flow Layout 2D arranges 2D items along a line and continues to the next line when it
runs out of space.
Flow Layout 3D arranges 3D items along a line and continues to the next line when it
runs out of space.
Focus Manager enables you to set and change the key focus between attached nodes. Each domain can have
only one instance of a Focus Manager.
%FocusNavigationManipulator converts key gestures into focus chain navigation actions to move the focus between
focusable nodes.
Specifies focus scope types.
Specifies the focus states of a node.
A font family resource contains font files.
FontFile is the base class for different font file resource implementations.
ForwardingAction is the base class for the action classes that read and send arguments, such as
SetPropertyAction or DispatchMessageAction.
Framebuffer attachment state.
GPUResource is a resource that must be deployed to the GPU.
GatherLightsRenderPass is a class for generating light properties for rendering nodes.
GatherNearestLightsRenderPass is an implementation of light gathering.
GraphicsFormat specifies format of graphics data used for example in textures and vertex attributes.
See: For a 3D grid component, see GridLayout3D.
See: For a 2D grid component, see GridLayout2D.
Use the Grid List %Box 2D node to create scrollable lists of 2D items arranged in a grid.
Use the Grid List %Box 3D node to create scrollable lists of 3D items arranged in a grid.
Image2D node.
The base class for the Kanzi input manipulators. Use the input manipulators to recognize gestures,
such as click or pinch, or hardware key gestures from incoming events. Kanzi has specialized subclasses
to handle touch gestures and hardware key gestures. Kanzi converts and handles mouse events as touch
gestures.
Use the Instantiator node to replicate the appearance of a 3D node, or a tree of 3D nodes, that
the Instantiator node targets.
Instruction binding processor is the top-level class for all instruction-like binding processors.
Use an IntValueAccumulator to increase the value of an integer property type over time.
Kanzi uses C++
std::string internally, and its internal representation differs from the Rust
String type. Rust strings represent a sequence of UTF-8 code points, while C++ strings are
an array of
c_char.
KeyManipulator class is a key input manipulator that detects key gestures. Kanzi recognizes a
key gesture when it receives an event with a key code and an optional key modifier. When Kanzi
recognizes a key gesture, an input manipulator:
The KeyManipulatorComponent node component installs a KeyManipulator to the attached node, and configures
the key gesture of the manipulator.
Keyboard declares the messages dispatched to the nodes when Kanzi handles a hardware key event.
The key events handled by Kanzi are the press and release events. These key events are converted into
KeyDownMessage and KeyUpMessage, that includes the translated logical key value and the key modifiers.
Key modifiers are special keys that modify the logical key meaning when pressed together with that
logical key.
Deprecated: In Kanzi 3.8. To handle key messages, use KeyManipulator.
Expression operation.
Legacy Render Pass is phased out in favor of specialized render passes that perform
individual operations, which are combined in a Legacy Render Pass into a single render pass.
Level of detail selector node is a 3D node that changes the appearance of its child nodes based on
the viewing distance.
Light node is a source of light for a 3D scene.
List %Box Item Container for 2D List %Box nodes. Wrapper component for storing item object nodes.
List %Box Item Container for 3D List %Box nodes. Wrapper component for storing item object nodes.
Long-press input manipulator recognizes the long-press gesture from the incoming touch events. It generates the required messages to
implement logic for nodes that react to the long-press gesture. For example, use the long-press input manipulator to open a context menu.
LongPressManipulatorComponent installs a LongPressManipulator to a node. Use LongPressManipulatorComponent to
enable nodes to react to long press and touch input events and to control the behavior of the installed
LongPressManipulator.
MainLoopScheduler implements the Kanzi application main loop in form of a customizable sequence of stages, each consisting of a sequence of tasks,
where a task is any callable, including functions, function objects, and lambdas.
Use MaskEffect2D to apply a mask to 2D nodes.
A material is an instance of a material type (ShaderProgram) that contains the property values for the material type properties.
These values can be overridden in the nodes that use the material.
Freeform shader brush.
Use the %Material Setup Render Pass to set properties to a material for further render operations using that material.
Matrix with 3x3 elements.
Matrix with 4x4 elements.
Mesh stores the geometry data for rendering Model3D nodes. A mesh has one or more clusters. Each cluster has
material and primitives. Primitives are typically triangles stored as vertex data and index data.
MessageArguments is the base class for arguments passed in messages. An instance of
MessageArguments together with an
instance of
MessageType forms a Kanzi message. In Kanzi when you dispatch a message, you dispatch a message of certain
type and arguments.
Message handler trigger.
An instance of a
MessageType represents a single message type in the Kanzi message system.
A message type exists throughout the lifetime of an application.
Metaclass provides type inspection mechanism for Kanzi classes.
Node for rendering meshes in 3D space.
Timeline for animating morph weights.
This action invokes the FocusManager::tryMoveFocus() method.
Multi-click input manipulator recognizes multi-click and multi-tap gestures from incoming touch events. It generates the messages required to
implement the logic for nodes that change the state when users multi-click or multi-tap the node. For example, use the multi-click input
manipulator to zoom in and out a map.
MultiClickManipulatorComponent installs a MultiClickManipulator to a node. Use MultiClickManipulatorComponent to
enable nodes to react to multi-click and multi-touch input events and to control
the behavior of the installed MultiClickManipulator.
The named interval profiler.
The %NavigationManipulator supports these navigation directions and default keyboard keys for them:
The NavigationManipulatorComponent node component installs a NavigationManipulator to a node, and configures the navigation key gestures of the manipulator.
A nine-patch image is a 3x3 grid of images. The center image is framed by the other images which all stretch according to the layout size.
Base class for Kanzi nodes.
Node2D is the base class of 2D nodes.
Base class for all 3D nodes.
NodeComponent is the base class for all node components.
Node component is an isolated piece of logic which can be attached to any node
in order to add additional functionality to it. Examples of node component could be
Trigger which performs specific actions when certain conditions are met or AnimationPlayer
which animates specific properties of the node it is attached to and its child nodes.
Use node effects to apply post-processing effects to 2D nodes.
Use node effect prefabs to create node effects that define post-processing effects for 2D nodes.
Use the Node List Render Pass to filter and hold a list of nodes that you want to render using other render passes.
Null brush class.
Object represents a strong reference to an instance of C++
kanzi::Object.
Structure for object source.
On Attached Trigger.
Invokes associated actions on setting of a property type, specified by SourcePropertyTypeProperty, on a source node, specified by SourceNodeProperty.
By default, invocation is performed also when setting to identical values. This behavior can be changed with IgnoreIdenticalValueProperty.
Use OutlineEffect2D to apply an outline to the content of 2D nodes.
Use Page nodes to create the structure of an application user interface. For example, you can create different parts of the user interface, such as Home, Media Browser, Navigation, or Settings screens, each in their own hierarchy of Page nodes.
Use a PageHost node to group Page and PageHost nodes, and to manage navigation requests and transitions in a tree of Page nodes under a PageHost node.
Transition collection is used to define transitions within a Page Host.
Pan input manipulator recognizes a pan gesture from the incoming touch events. It generates
messages for different phases of the pan gesture. You can use these messages to implement the
logic to move nodes, to pan or to flick scrollable content. For example, you can use the pan
input manipulator to scroll a map.
PanManipulatorComponent installs a PanManipulator to a node. Use PanManipulatorComponent to
enable nodes to react to pan events and to control the behavior of the installed PanManipulator.
An Activity Host that can display multiple Activity nodes at a time.
An Activity Host that can display multiple Activity nodes at a time.
Kanzi animation system consists of animations and timelines:
Pinch input manipulator recognizes the pinch gesture from the incoming touch events. It
generates the required messages to implement the logic for objects which react to the pinch
gesture. For example, use the pinch input manipulator to zoom in or zoom out a map using the
pinch gesture.
Use the Pipeline State Render Pass to set for its child render passes the depth
and stencil testing, transparency, and culling. This render pass sets the rendering
state before passing the control to its descendants. After the descendant render passes
of a Pipeline State Render Pass execute, Kanzi restores the rendering state.
If a Pipeline State Render Pass does not have any descendants, Kanzi does not apply
the rendering state you set in that render pass.
Portal node.
A prefab template contains information that is required to create a tree of Node instances.
A prefab template node contains information that is required to create node instances: the metaclass of the node,
the (initial) property values of the node, information about the bindings and node components of the node,
and the list of of child nodes.
Prefab view 2D node.
Use Prefab view 2D to switch 2D nodes at runtime.
Prefab view 3D node.
Use Prefab view 3D to switch 3D nodes at runtime.
Progressive rendering viewport 2D is a viewport which splits rendering its scene
across multiple frames. Progressive rendering viewport is useful when it is required
to render complex scene which can take significant amount of time when rendered normally
and thus increasing frame time. Progressive rendering viewport renders parts of the scene
frame by frame thus decreasing time required to render the scene per frame.
The Kanzi animation system consists of animations, which define how to animate properties, and
timelines, which map animations to time and to the objects that you want to animate.
Use Property Driven Animation Player when you want to use a property type to control a
keyframe animation.
Property Driven Animation Player applies an animation with the time taken from a specific
property in the node, to which you attach the player, every time that property changes.
Kanzi animation system consists of animations and timelines:
Use a Property Target Easing Interpolator when you want to create a smooth transition between the current value of
a property and a value that you set dynamically. In a Property Target Easing Interpolator you can set the easing
curve, easing mode, and the duration of the transition. When you set a property value without a Property Target
Easing Interpolator, Kanzi applies the value to that property immediately. For example, when you
use the Object::setProperty() function, Kanzi applies the value immediately.
Use a Property Target Interpolator when you want to dynamically set the target value
of a property and want to interpolate the current value to the target value over time.
With a Property Target Interpolator you can automatically animate the change of a
property value to achieve a smooth transition. Without a Property Target Interpolator
Kanzi immediately applies a new value to a property. For example, when you
use the Object::setProperty() function, Kanzi immediately applies a new value.
An instance of a
PropertyType represents a single property type in the Kanzi property system.
A property type exists throughout the lifetime of an application, including the property types
that you create during the runtime of an application.
Runs a binary operation for each value in a range in sequence.
Range binding processor is a binding processor for accessing properties from property objects in ranges.
RenderPass is the base class for Kanzi render passes.
Use render pass prefabs to create render pass trees that define how Kanzi renders 3D content in your project.
Use the Render Pass View to instantiate a RenderPassPrefab.
Renderbuffers provide the images that can be rendered to by attaching them to the framebuffer as color or depth stencil images.
Unlike textures, you cannot access renderbuffers using the samplers from shaders. When you direct rendering to a framebuffer,
the depth and stencil tests require either renderbuffer or texture attached to the framebuffer.
Represents the base class for all resources.
This base class contains information related to the type of the resource and the
loading status of the resource data. The actual resource data is specific to the sub-classes.
Resource binding processor creates a resource reference that is used to resolve a string into a resource.
The resource binding processor is associated with a resolve instruction in the expression binding, where
the binding uses string input to resolve a binding into a resource value.
When the resolved resource changes, Kanzi updates the binding.
A resource dictionary is a container that maps resource IDs to resources. A node can
refer to resources by setting resource IDs to resource ID properties. You can set a resource
dictionary to the node or to any of its parent nodes to define which resources the node uses.
You can use a resource dictionary to group similar resources to logical entity, such as themes or locales,
and change a resource dictionary of a node to change multiple resources at the same time.
A resource dictionary selector is a type of a resource dictionary that redirects resource queries to its only nested dictionary.
This type of dictionary is used internally by Screen to implement switching of locales and themes in theme groups.
You can use Screen::setLocale to set the current locale and Screen::activateTheme to activate a theme in a theme group.
Use the
ResourceManager to access and use resources in kzb files. The resource manager maintains
kzb files and provides mechanisms to load resources from kzb files.
A structure that describes the scale, rotation and translation transformation in 2D space.
Rotation is stored as angle in radians.
Stage for ticking animations.
Stage for handling input events.
Stage for laying out the nodes.
Stage for presenting the nodes.
Stage for rendering the nodes.
Stage for executing your application code.
Includes:
Scene is a 3D node that is the root node for other 3D nodes.
The screen represents the metrics of the target device and acts as the root node for the whole node tree.
Use the Scroll View 2D node to create an input plane to enable user input from gestures.
For example, you can use the scroll message with its parameters generated by a Scroll View
node to move a map plane or rotate a mesh.
Use the Scroll View 3D node to create an input plane to enable user input from gestures.
For example, you can use the scroll message with its parameters generated by a Scroll View
node to move a map plane or rotate a mesh.
SetPropertyAction sets the value of a property of a target node based on:
ShaderProgram defines programmable vertex and fragment operations done by the GPU for a draw call.
Use ShadowEffect2D to apply drop- and inner-shadow post-processing effects to 2D nodes.
Use the Slider 2D node as a building block for a 2D UI control that lets
the application user change a numerical value using a visual indicator between a minimum and a maximum value.
Use the Slider 3D node as a building block for a 3D UI control that lets
the application user change a numerical value using a visual indicator between a minimum and a maximum value.
Spline is a piecewise polynomial curve that defines a path in a 3-dimensional space.
Stack Layout 2D arranges its items on a line along the axis you specify in the DirectionProperty. The default value of the DirectionProperty is x axis.
Stack Layout 3D arranges its items on a line along the axis you specify in the DirectionProperty. The default value of the DirectionProperty is x axis.
Contains property types of Standard material.
Contains property types for the Kanzi Physically Based Rendering (PBR) shaders. Use the PBR
materials to create assets that behave realistically in many lighting conditions. These
properties represent physical properties on a material and are therefore intuitive when
being set.
Many properties have a standard and detail variation that you can use to apply material
properties in layers. The detail maps use DetailTextureTilingProperty and
DetailTextureOffsetProperty to tile differently than the standard map and are typically
used to provide fine detail.
The Occlusion, Metallic, and Roughness maps are designed to read from different color
channels. Therefore it is possible to provide a single texture for all three.
State manager for managing states of nodes or application.
Style applying properties, node components and bindings to nodes.
Surfaces provide images for Framebuffers where to render to.
You can use
TaskDispatcher to schedule execution of callbacks to the UI thread.
You can access Kanzi UI objects only on the thread that you create them on.
You can wrap code that accesses UI objects with tasks and submit them from any thread to the
TaskDispatcher.
The UI thread will execute these tasks during its main loop.
Text Block 2D displays a small amount of text in 2D.
To render a Text Block 3D node Kanzi:
TextBox2D provides the required overrides to handle 2D rendering and gesture handling
for the 2D text input.
TextBox3D provides the required overrides to handle 3D rendering and gesture handling
for the 3D text input.
The text input manipulator handles key gestures used with TextBox nodes to move the cursor, select text,
and delete text, and provides the basics of text editing capabilities in Kanzi. For example, you can enable
the application user to:
Text resource.
Textures provide images that can be used with image nodes, texture brushes and materials for
use in 3D rendering or material brushes.
Texture brush class.
ThreadObject represents a weak reference to a Kanzi object.
The Kanzi animation system consists of animations and timelines: animations define how the values of specific type
change in time, and timelines map the animations to properties of objects you want to animate.
A Resource wrapper class for animation timelines.
Use the TimerTrigger to execute actions at the time interval that you set with the IntervalProperty.
To Source bindings are one-way bindings that have an extra source to which to write the result value.
To Source binding is the opposite of a regular one-way binding. To Source binding updates the source property
whenever the target property changes.
Use the Toggle Button 2D node to create a 2D UI control that the user can interact with
through clicking, tapping, or pressing a keyboard key, and that has multiple toggle states.
Use the Toggle Button 3D node to create a 3D UI control that the user can interact with
through clicking, tapping, or pressing a keyboard key, and that has multiple toggle states.
Toggle Button Group 2D allows users of your application to select only one option from a set of
options that are mutually exclusive. Toggle Buttons in a Toggle Button Group behave like radio
buttons, where only one Toggle Button can be active at a time. Use the CurrentButtonIndexProperty
property to check which Toggle Button in the Toggle Button Group is selected.
Toggle Button Group 3D allows users of your application to select only one option from a set of
options that are mutually exclusive. Toggle Buttons in a Toggle Button Group behave like radio
buttons, where only one Toggle Button can be active at a time. Use the CurrentButtonIndexProperty
property to check which Toggle Button in the Toggle Button Group is selected.
Trajectory defines a series of points following a geometrical path. For example,
use a trajectory as align paths for 3d objects or animation paths.
You can create trajectory as a spline, circle or line trajectory.
%Trajectory Layout 2D arranges its items along a trajectory.
%Trajectory Layout 3D arranges its items along a trajectory.
Use the %Trajectory List %Box 3D node to create scrollable lists of items arranged along a Trajectory.
Trigger is the base class for defining events, conditions and actions for content-driven logic programming.
Use the TrySetFocusAction action to transfer focus to any focusable item in a node tree.
Two-way binding causes changes to either the source value or the target value to automatically update the other.
ValueAccumulatorBase is the base class for the Value Accumulator implementations for
different data types. It defines the common property and message types
for different Value Accumulators.
Union container for manipulating an object from a heterogeneous set of types in a uniform manner.
Vector with 2 floating point components: (x, y).
Vector with 3 floating point components: (x, y, z).
Vector with 4 floating point components: (x, y, z, w).
Use a Viewport 2D to set the size of a render target surface onto which content is projected.
Viewport 2D is a 2D node that can project a 3D scene through a camera. Viewport 2D is a special
node because it can render both 2D nodes, such as Image, Page, Button 2D, and a Scene,
which is a 3D node.
Use the Viewport 3D node to render 2D nodes in 3D space.
Represents a weak reference to an instance of C++
kanzi::Object.
Can be passed to functions accepting
&Object (or its derivatives), yet, if the object is
stale, the functions will return an error
STALE_OBJECT instead.
Use the WriteLogAction class to attach logging functionality to a trigger. When
a trigger that has a WriteLogAction attached is set off, the action is executed
and it writes the string that you set in the LogTextProperty to the Kanzi Studio
Log window in the log category KZ_LOG_CATEGORY_GENERIC.