All namespaces containing either **Internal** or **Private** in the name cover private namespaces, which are not recommended to be used in any application, as it is not guaranteed that these interfaces remain stable respectively exist in any future release. Changes in any of these private namespaces can be applied without any (prior) notifications.
If RenderMode is defined for a [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set..."), the RenderMode of the camera replaces the DefaultRenderMode, temporarily during the camera's render pass.
When initializing an asset the default render mode in [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") will be replaced by the values from the asset!
You need to reload the scene explicitly when you change the theme!
If you use more than one camera on a render target, take care to enable swapping only for the last camera (highest sequence number).
| **[Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") Default** | **Asset Verification Enabled** | |
|---|---|---|
| **Asset Version** | X | |
| **File Size** | X | |
| **Time Stamp** | X | |
| **Widget Hash** | X | |
| **Widget Set Version** | X | |
| **[Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") Version** | X | |
| **Solution GUID** | X | |
| **Custom ID** | X | |
| **SceneComposer Version** | X |
| **User Defined** | **SceneComposer** | |
|---|---|---|
| **Asset Version** | X | |
| **File Size** | X | |
| **Time Stamp** | X | |
| **Widget Hash** | X | |
| **Widget Set Version** | X | |
| **[Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") Version** | X | |
| **Solution GUID** | X | |
| **Custom ID** | X | |
| **Scenecomposer Version** | X |
The `GetWidgetSet`-Function is part of the `WidgetMetaInfo.h` file.
When dynamically adding of partitioned assets, the newly added assets should belong to the same original asset that the previous loaded are belonging to.
*CANDERA\_ASSET\_DECOMPRESSION\_CHUNK\_SIZE* is relevant only for [Candera::FileAssetRepository](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_file_asset_repository.html "Class providing methods to read asset from file.").
| Ambient | RGB color that interacts with the ambient attribute of light. |
| Emissive | RGB color that defines the self-lighting of the material. This color is visible, even when Material is unlighted. The emissive color attribute does neither interact with any type of light source nor with other 3D objects. |
| Diffuse | RGBA color that interacts with the diffuse attribute of light. The alpha value of the diffuse color, defines the alpha factor of the entire Material, supposed that alpha blending is enabled (For details see [Candera::RenderMode](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_render_mode.html "The class RenderMode is an Appearance component that encapsulates polygon-level and per-fragment comp...")). |
| Specular | RGB color that interacts with the specular attribute of light. |
| Nearest | Value of the texel that is nearest to the center of the pixel being textured. |
| Linear | The weighted average of the four texels that are closest to the center of the pixel being textured. |
| None | MipMapping disabled |
| Nearest | MipMapping uses nearest mip map level |
| Linear | MipMapping uses bilinear mipmap interpolation of the two nearest mip map levels |
| Repeat | Repeat the texture |
| ClampToEdge | Clamp fetches to the edge of the texture |
| Linear | MipMapping uses bilinear mipmap interpolation of the two nearest mip map levels |
| FrontFaceCulling | Front of the polygon is removed |
| BackFaceCulling | Back of the polygon is removed |
| NoCulling | Front and back of the polygon are rendered |
| ClockWise | Clockwise ordered vertices define the front of the polygon. |
| CounterClockWise | Counterclockwise ordered vertices define the front of the polygon. |
| CompareNever | Never pass the comparison. |
| CompareLess | If source data is less than destination data, the comparison passes. |
| CompareEqual | If source data is equal than destination data, the comparison passes. |
| CompareLessEqual | If source data is less than or equal to destination data, the comparison passes. |
| CompareGreater | If source data is greater than destination data, the comparison passes. |
| CompareNotEqual | If source data is not equal to destination data, the comparison passes. |
| CompareGreaterEqual | If source data is greater than or equal to destination data, the comparison passes. |
| CompareAlways | Always pass the comparison. |
olygons that are coplanar can be made to appear not coplanar by adding a z-bias to each one. This is a technique commonly used to ensure that shadows, decals, or hidden-line images on coplanar surfaces are displayed properly. The depth bias is added before the depth test is performed but does not influence the original depth value written into depth buffer.
| **SetToZero** | **Set the stencil-buffer entry to zero.** |
| Keep | Do not update the entry in the stencil buffer. |
| Replace | Replace the stencil-buffer entry with the reference value. |
| Increment | Increment the stencil-buffer entry, clamping to 2^n where n is the number of bits in the stencil buffer. |
| Decrement | Decrement the stencil-buffer entry, clamping to zero. |
| Invert | Invert the bits in the stencil-buffer entry. |
| IncrementWrap | Increment the stencil-buffer entry, wrapping to zero if the new value exceeds the maximum value |
| DecrementWrap | Decrement the stencil-buffer entry, wrapping to the maximum value if the new value is less than zero. |
| **Node** | **Vertex Shader** | **Fragment Shader** |
|---|---|---|
| Billboard | RefTrans | RefTex |
| Mesh without texture | RefTransLight1 | RefColor |
| Mesh with texture | RefTransLight1 | RefColorTex |
| MorphingMesh without texture | RefTransLight1Morph | RefColor |
| MorphingMesh with texture | RefTransLight1Morph | RefColorTex |
| PointSprite | RefTransPointSprite | RefPointSprite |
| SkyBox | RefTransCubeMap | RefCubeMapTex |
In a class derived from ShaderParamSetter, the methods which calculates the auto-uniforms (e.g. ModelViewProjectionMatrix4), should be invoked in the Activate method.
| **Shader Param Setter** | **Shader Program** |
|---|---|
| TransAnisotropicLightShaderParamSetter | RefTransAnisotropicLight1\_RefAnisotropicLight1SpecularTex |
| TransLightBumpMapShaderParamSetter | RefTransLight1BumpMap\_RefLight1BumpMap |
| TransShaderParamSetter | RefTransLight1\_RefColor |
| TransLightSphereMapShaderParamSetter | RefTransLight1SphereMap\_RefColorTex |
| TransLightShaderParamSetter | RefTransWorldLight1\_RefColor |
In SceneComposer the newly added Node does not appear in the Scene Tree view because it is only added dynamically by the widget. - The used Shader for the generated Billboard in the widget has to be included when generating an asset from the solution - ensure that "Always include in asset" flag is marked at the Shaders properties. - The widget must control memory and VRAM management of its internal dynamic subtree autonomously.
##### Widget Interaction in the Player First, the asset must be exported and loaded in the Player. Then, one of the two existing *SceneGraphDynamicsWidget\_3D* widgets must be selected for the 3D scene. After, **ChangeAppearance**, **CloneOperation** and **AddBillboard** properties can be enabled/disabled (1/0) to obtain different results. #### **Changing Appearance and other 3D Node Attachments** For changing the appearance of a node, the following property of the SceneGraphDynamicsWidget\_3D can be used:In SceneComposer the changed Appearance does not appear in the Appearance panel because it is only changed dynamically by the widget. - The used shader for the generated Billboard in the widget has to be included when generating an asset from the solution - ensure that "Always include in asset" flag is marked at the Shaders properties. - The widget must control memory and VRAM management of dynamically created node attachments autonomously.
#### **Cloning 3D Nodes** For cloning a node, the following property of the SceneGraphDynamicsWidget\_3D can be used:Nodes can be attached to any 3D node.
In SceneComposer the newly added node clone does not appear in the Scene Tree view because it is only added dynamically by the widget. - It is not allowed to modify the scene graph maintained by SceneComposer outside of the subtree owned by the widget! - The widget must control memory and VRAM management of its internal dynamic subtree autonomously.
# 3D Render Order #### Description There are various reasons why sorting of objects to render is required:| [Candera::RenderOrder](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_render_order.html "Defines the order(sequence) in which nodes are rendered. Collaborates with Renderer. Must cover functional correctness (translucent/transparent objects after opaque/solid objects) as well as optimization-related orderings (sorting by state, defining a background bin for rendering without depth checks). Nodes are assigned to bins; all nodes in an "earlier" bin are rendered before all nodes in a "later" bin. Two default bins are defined and must not be deleted. The opaque bin, which is sorted from front to back (DistanceToCameraOrderCriterion), and the transparent bin, which is sorted from back to front (ReverseDistanceToCameraOrderCriterion). If a Node has no specific assignment to a render order bin, it will be automatically assigned by Candera either to opaque or transparent bin, according to its RenderMode::IsAlphaBlendingEnabled setting.") | Defines the sequence of nodes to render per scene and camera. Sorting is done according to following criteria: 1. Rank of render order bins: [Candera::RenderOrder::SetBinRank](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_render_order.html#ac5eef4f1c2868e99327595988dade0c9). 2. Sorting of Nodes within bin (see below). Default bins are 'opaque' and 'transparent'. If no assignment is set, nodes are automatically assigned to opaque or transparent, according to the Node's transparency settings (RenderMode state). |
| Candera::RenderOrderBin | RenderOrder maintains a set of RenderOrderBins. A bin - Contains nodes that have rendering enabled - Candera::RenderOrderBin::SetOrderCriterion: Sorts nodes according to applied [Candera::OrderCriterion](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_order_criterion.html "Abstract class OrderCriterion defines an interface that compares two Nodes according to a specific so...") - Candera::RenderOrderBin::SetRank: defines sequence of bin within render order - Distinction between camera dependent and camera independent bins |
| [Candera::OrderCriterion](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_order_criterion.html "Abstract class OrderCriterion defines an interface that compares two Nodes according to a specific so...") | Nodes within a bin are sorted according to an OrderCriterion. Predefined for **camera dependent bins:** - [Candera::DistanceToCameraOrderCriterion](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_distance_to_camera_order_criterion.html "class DistanceToCameraOrderCriterion compares two Node's distances to the camera. A render order bin ...") (sorting from front to back for opaque bin) - [Candera::ReverseDistanceToCameraOrderCriterion](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_reverse_distance_to_camera_order_criterion.html "class ReverseDistanceToCameraOrderCriterion compares two Node's distances to the camera. A render order bin using ReverseDistanceToCameraOrderCriterion can sort its Nodes from "Back to Front" according to selected distance function. (") (sorting from back to front for transparent bin) Predefined for **camera independent bins, sorted by explicit rank values:** - [Candera::RankOrderCriterion](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_rank_order_criterion.html "class RankOrderCriterion compares two Node's render order ranks, whereas lower render order rank is b...") (lower render order rank is before higher render order rank.) - [Candera::ReverseRankOrderCriterion](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_reverse_rank_order_criterion.html "class ReverseRankOrderCriterion compares two Node's render order ranks, whereas higher render order r...") (higher render order rank is before lower render order rank) - [Candera::RenderStateOrderCriterion](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_render_state_order_criterion.html) (takes in consideration the Node's Shader, Texture and RenderMode, whose changes are considered the most expensive) |
| [Candera::Node](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html "The class Node is an abstract base class for all scene graph nodes. Each Node defines a local coordin...") | A node must be assigned to a bin, and if this bin is sorted by rank, the node must also specify it's rank inside the bin. - [Candera::Node::SetRenderOrderBinAssignment](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html#a1b5049fe6c069246a3d6632217600025): Defines bin assignment. If not set, then auto assignment is processed: Opaque or transparent, according to Node's RenderMode state - [Candera::Node::SetRenderOrderRank](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html#ac5a79fc4766b96fc638cef6ee0073794): Defines render order rank that is utilized if the bin assigned to is sorted by rank |
| [Candera::Scene](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_scene.html "The class Scene represents a top level scene graph node. Multiple Scenes are allowed. A Scene can not be part of any other Scene. To render a Scene, at least one Camera must be part of this Scene and the Camera must have rendering enabled. A Scene can have more than one Camera. Note: Lights added to a Scene apply for that Scene only and do not affect 3D objects in any other Scene.") | Candera::Scene::SetRenderOrder: One RenderOrder is exactly assigned to one Scene. |
| [Candera::Renderer](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_renderer.html "The class Renderer represents the unique Candera render interface to the application. Each render call an base of Candera shall be triggered via the Renderer interface.") | Uses RenderOrder to render Nodes according to its defined sequence. |
- Usage of Candera::RenderStateOrderCriterion does not guarantee best batching algorithm, which should be implemented after benchmarking the target render device's state change costs. - RenderStateOrderCriterion groups the nodes only by their first appearance and texture. Nodes with multi-pass rendering (MultiPassAppearance), or with multiple texture units, most probably will break the batches and cancel some performance gains. - CANDERA\_RENDER\_STATE\_CACHING\_ENABLED should be defined to use Candera's render state caching mechanism.
# Searching for Nodes with SearchTreeTraverser #### Searching for Nodes With [Candera::SearchTreeTraverser](http://dev.doc.cgistudio.at/APILINK/APILINK/class_candera_1_1_search_tree_traverser.html "Search nodes that meet a search criterion within a node tree.") it is possible to find nodes within a given scene tree by certain criteria. The search scene graph traverser is a [Candera::TreeTraverserBase](http://dev.doc.cgistudio.at/APILINK/APILINK/class_candera_1_1_tree_traverser_base.html "Traverses a Node tree depth-first. What is done at each node is customized in the ProcessNode virtual...") implementation that evaluates each node with a given [Candera::SearchCriterion](http://dev.doc.cgistudio.at/APILINK/APILINK/class_candera_1_1_search_criterion.html). Following code snippets illustrate how to use the traverser. #### Creating a plugin that registers a configuration and uses the default configuration editor. First create a [Candera::SearchTreeTraverser](http://dev.doc.cgistudio.at/APILINK/APILINK/class_candera_1_1_search_tree_traverser.html "Search nodes that meet a search criterion within a node tree.") and then set its [Candera::SearchCriterion](http://dev.doc.cgistudio.at/APILINK/APILINK/class_candera_1_1_search_criterion.html). The search criterion validates nodes based on the implemented criterion. In the example below the criterion is a [Candera::ScopeMaskSearchCriterion](http://dev.doc.cgistudio.at/APILINK/APILINK/class_candera_1_1_scope_mask_search_criterion.html). ``` // Create criterion ScopeMaskSearchCriterionAnother call of [Candera::SearchTreeTraverser::GetSearchResult](http://dev.doc.cgistudio.at/APILINK/group___common_base.html#gac868b9574bbdc6bea6f3c9afdd3a6796) would return 0, because we use StopTraversing here. This leads to one result only.
For an easier manipulation of the widget in SceneComposer all the shaders are hardcoded in the source file and then created by the widget at the initialization time.
Alternatively obtain shaders from [Candera::AssetProvider](http://dev.doc.cgistudio.atcgistudio.at/APILINK/class_candera_1_1_asset_provider.html "Abstract class providing methods for retrieving objects.") (e.g. GetAssetProvider()->GetShader("...")) in case the application uses an asset library.
[Candera::Transformable2D::SetPosition](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_transformable2_d.html#a74becbea72134b186c14f5d3bf38f749) sets the absolute position of a node compared to [Candera::Transformable2D::Translate](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_transformable2_d.html#a9a4ed57cd39a872fcb4cfc0f9696ecf1), which adds the given vector to the current position. So setting the position first and then translating the node gives a different behavior than vice versa.
The set of effects supported depends on the feature set of the underlying graphic device unit. This tutorial is based on the reference platform ***iMX6***. Refer to the CanderaPlatformDevice API documentation to learn about the set of 2D effects supported on the platform used.
This simple example is based on a RenderNode with SolidColorBrushBlend effect, so if the example solution is changed, please take care to use only SolidColorBrushBlend on the node to manipulate.
In SceneComposer the manipulated scene graph and the changed properties do not appear because it is only changed dynamically by the widget.
The widget must control memory and VRAM management of its internal dynamic subtree autonomously.
2D effects are part of the device package, therefore in order to create a concrete instance of the effect, the effect must be enabled for the device. Please see chapter **2D Effects** of this tutorial to see how to enable an effect for a certain device.
In SceneComposer the manipulated scene graph and the changed properties do not appear because it is only changed dynamically by the widget.
The widget must control memory and VRAM management of its internal dynamic subtree autonomously.
Don't forget to set a name for the dynamically created nodes.
Default value for row and column span properties is 1.
If a size value is set to -1 the width or height is set to the preferred size of the inner elements.
The grey grid raster in the background is set up manually by solid nodes to illustrate the inner grid borders.
Please note that single cells might still be used for other elements if needed, like in the following example:
A [Candera::GridLayouter](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_grid_layouter.html "GridLayouter arranges its elements in a grid. The amount of rows and columns for the grid must be spe...") with 2 rows and 2 columns is defined. Element in (0,0) has a row and column span of 2, but element at (1,1) is still accessible.
Be sure the order of adding the children groups in the Background group is Top - Bottom - Center otherwise the elements will not be arranged correctly.
Be sure the order of nodes in the groups is Left - Right - Center otherwise the elements will not be arranged correctly.
Only a simplified view is described here, in order to enable the reader to gain a basic knowledge and comprehension of shader programs, their purpose and principles of operation.
Pixels at this stage of the pipeline, are known as fragments, as they might be discarded by the pipeline in subsequent tests and thus never appear as a pixel in color buffer.
| **Stage** | **Description** |
| API | OpenGL ES application programming interface, this is encapsulated by [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]"). |
| Vertex Arrays / Buffer Objects | Buffer in VRAM that stores vertices along with their vertex attributes. Vertex attributes are typically positions, normals, texture coordinates, colors etc. which are stored for every vertex of every primitive. This array is filled and managed by [Candera::VertexBuffer](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_vertex_buffer.html "The VertexBuffer encapsulates the attributes of an uploaded VertexGeometry. It holds the actual handl..."). |
| Vertex Shader | Processes the data stored in vertex buffer, and transforms them to screen coordinates with depth. |
| Primitive Assembly | Assembles the data processed shaded vertices into individual geometric primitives that can be drawn. Such primitives can be triangles, lines or points. The necessary settings here are also set in [Candera::VertexBuffer](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_vertex_buffer.html "The VertexBuffer encapsulates the attributes of an uploaded VertexGeometry. It holds the actual handl..."). |
| Rasterization | Single primitives are converted to a set of two-dimensional fragments (describing the normalized position in the framebuffer). This is the input data to the fragment shader. |
| Texture Memory | Texture memory is the location in VRAM where textures (2D or CubeMaps. In OpenGL ES 2.0, 1D and 3D textures are only supported through extensions) are stored. This memory is filled and managed by [Candera::Texture](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_texture.html "Texture encapsulates a TextureImage and a set of attributes specifying how it is applied to a vertex'..."). |
| Fragment Shader | Fragment shader takes the processed fragments as input, and combines them with the data stored in Texture memory. This stage results in assigning the fragment a color. |
| Per-Fragment Operations | Each fragment is tested, to determine whether it is to be drawn. Blending and dithering operations conclude the pipeline. Various configurations are set, using [Candera::RenderMode](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_render_mode.html "The class RenderMode is an Appearance component that encapsulates polygon-level and per-fragment comp..."). Here Depth-, Stencil-, Scissoring Tests, Blending and Dithering apply. |
| Framebuffer | Includes color, depth-, and stencil buffer to store final render output. |
Uniforms are global variables, and therefore have to be declared outside of function scope.
Varying variables have to have exactly the same name and type in vertex and fragment shader, otherwise linking of them together will fail.
Texturing can also be used in vertex shaders. This can be used to e.g. realize a technique called *Displacement Mapping* where the vectors stored inside a texel are not interpreted as color but as offset being applied to the current vertex position. Consequently, a displacement map can be used e.g. to transform a flat plane to a terrain.
The shaders are passed as *void\** to ensure that platform dependent representations of the shader program can be passed. The parameter DisposerFn hands over lifetime responsibility of shader passed: If it's set to 0 you'll have to take care of the provided *void\** by yourself.
If no instance of the affected classes exist, the corresponding shader parameters will not be set, even if they are enabled in [Candera::GenericShaderParamSetter](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_generic_shader_param_setter.html "GenericShaderParamSetter bundles uniform shader parameters that are calculated by Candera...").
| Uniform Variable | Data Type | GenericShaderParamSetter Flag | Affected Classes | Semantic |
|---|---|---|---|---|
| u\_MMatrix3 | Matrix3 | ModelMatrix3Enabled | [Candera::Node](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html "The class Node is an abstract base class for all scene graph nodes. Each Node defines a local coordin...") | Computes the ModelMatrix3 from the Node's transformation data, used to transform 3-component vectors from model to world space. |
| u\_MVMatrix3 | Matrix3 | ModelViewMatrix3Enabled | [Candera::Node](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html "The class Node is an abstract base class for all scene graph nodes. Each Node defines a local coordin..."), [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set...") | Computes the ModelViewMatrix3 from the Node's transformation data and the currently rendered Camera's ViewMatrix. Used to transform 3-component vectors from model to view space. |
| u\_NormalMMatrix3 | Matrix3 | NormalModelMatrix3Enabled | [Candera::Node](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html "The class Node is an abstract base class for all scene graph nodes. Each Node defines a local coordin...") | Computes the NormalModelMatrix3 from the Node's transformation data, used to transform 3-component directional vectors (especially normals) from model to world space. |
| u\_NormalMMatrix4 | Matrix4 | NormalModelMatrix4Enabled | [Candera::Node](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html "The class Node is an abstract base class for all scene graph nodes. Each Node defines a local coordin...") | Computes the NormalModelMatrix4 (4×4 normal-transform matrix) from the node’s transform and passes it to the shader. |
| u\_NormalMVMatrix3 | Matrix3 | NormalModelViewMatrix3Enabled | [Candera::Node](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html "The class Node is an abstract base class for all scene graph nodes. Each Node defines a local coordin..."), [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set...") | Computes the NormalModelViewMatrix3 from the Node's transformation data and the currently rendered Camera's ViewMatrix. Used to transform 3-component directional vectors (especially normals) from model to view space. |
| u\_MMatrix | Matrix4 | ModelMatrix4Enabled | [Candera::Node](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html "The class Node is an abstract base class for all scene graph nodes. Each Node defines a local coordin...") | Computes the ModelMatrix from the Node's transformation data, used to transform 4-component vectors from model to world space. |
| u\_MVMatrix | Matrix4 | ModelViewMatrix4Enabled | [Candera::Node](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html "The class Node is an abstract base class for all scene graph nodes. Each Node defines a local coordin..."), [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set...") | Computes the ModelViewMatrix4 from the Node's transformation data and the currently rendered Camera's ViewMatrix. Used to transform 4-component vectors from model to view space. |
| u\_PMatrix | Matrix4 | ProjectionMatrix4Enabled | [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set...") | Passes the ProjectionMatrix4 from the active camera to the shader. |
| u\_VPMatrix | Matrix4 | ViewProjectionMatrix4Enabled | [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set...") | Passes the active camera’s the ViewProjectionMatrix4 (View × Projection) to the shader. |
| u\_MVPMatrix | Matrix4 | ModelViewProjectionMatrix4Enabled | [Candera::Node](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_node.html "The class Node is an abstract base class for all scene graph nodes. Each Node defines a local coordin..."), [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set...") | Computes the ModelViewProjectionMatrix4 from the Node's transformation data and the currently rendered Camera's ViewProjectionMatrix. Used to transform 4-component vectors from model to homogeneous screen space. |
| u\_CamDirection | Vector3 | CameraLookAtVectorEnabled, LightActivationEnabled | [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set..."), [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the currently rendered Camera's look-at vector in world space to the shader. Transforms it to object space if LightsCoordinateSpace is set to Object. Can be done explicitly, or inside lighting calculations. |
| u\_CamPosition | Vector3 | CameraPositionEnabled | [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set...") | Passes the currently rendered Camera's position in world space to the shader. |
| u\_Size | Float | - | [Candera::PointSprite](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_point_sprite.html "PointSprite represents a GL point primitive. The size (glPointSize) of the point is calculated by def...") | Passes the size of a [Candera::PointSprite](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_point_sprite.html "PointSprite represents a GL point primitive. The size (glPointSize) of the point is calculated by def...") node to the shader. This is always done, if node is type of [Candera::PointSprite](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_point_sprite.html "PointSprite represents a GL point primitive. The size (glPointSize) of the point is calculated by def..."). |
| u\_Material.ambient | Vector4 | MaterialActivationEnabled | [Candera::Material](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_material.html "The class Material describes the color attributes of an object's surface and is primarily used for li...") | Passes the ambient color component of the node's material (member of Appearance, see [the section on material](https://doc316en.candera.eu/link/448#bkmrk-appearance%3A-material-0).) |
| u\_Material.diffuse | Vector4 | MaterialActivationEnabled | [Candera::Material](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_material.html "The class Material describes the color attributes of an object's surface and is primarily used for li...") | Passes the diffuse color component of the node's material (member of Appearance, see [the section on material](https://doc316en.candera.eu/link/448#bkmrk-appearance%3A-material-0).) |
| u\_Material.emissive | Vector4 | MaterialActivationEnabled | [Candera::Material](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_material.html "The class Material describes the color attributes of an object's surface and is primarily used for li...") | Passes the emissive color component of the node's material (member of Appearance, see [the section on material](https://doc316en.candera.eu/link/448#bkmrk-appearance%3A-material-0).) |
| u\_Material.specular | Vector4 | MaterialActivationEnabled | [Candera::Material](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_material.html "The class Material describes the color attributes of an object's surface and is primarily used for li...") | Passes the specular color component of the node's material (member of Appearance, see [the section on material](https://doc316en.candera.eu/link/448#bkmrk-appearance%3A-material-0).) |
| u\_Material.shininess | Float | MaterialActivationEnabled | [Candera::Material](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_material.html "The class Material describes the color attributes of an object's surface and is primarily used for li...") | Passes the shininess of the node's material (member of Appearance, see [the section on material](https://doc316en.candera.eu/link/448#bkmrk-appearance%3A-material-0).) |
| u\_Texture\[i\] | Integer | TextureActivationEnabled | [Candera::Texture](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_texture.html "Texture encapsulates a TextureImage and a set of attributes specifying how it is applied to a vertex'..."), [Candera::BitmapTextureImage](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_bitmap_texture_image.html "TextureImage encapsulates a VRAM handle which is retrieved when uploading an image to the vram..."), [Candera::ProxyTextureImage](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_proxy_texture_image.html "The class ProxyTextureImage provides a TextureImage interface to an externally maintained image sourc...") | Passes the activated textures handle to the shader if the textures [Candera::TextureImage](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_texture_image.html "Abstract base class for Texture images.A texture image mainly encapsulates a texture handle in VRAM a...") is of type [Candera::BitmapTextureImage](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_bitmap_texture_image.html "TextureImage encapsulates a VRAM handle which is retrieved when uploading an image to the vram...") or Candera::ProxyTextureImage(with TextureTargetType Texture2D). i can be from 1 to 7 or nothing (e.g u\_Texture, u\_Texture1,..). |
| u\_CubeMapTexture\[i\] | Integer | TextureActivationEnabled | [Candera::Texture](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_texture.html "Texture encapsulates a TextureImage and a set of attributes specifying how it is applied to a vertex'..."), [Candera::CubeMapTextureImage](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_cube_map_texture_image.html "CubeMapTextureImage encapsulates a VRAM handle which is retrieved when uploading a cube mapping textu..."), [Candera::ProxyTextureImage](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_proxy_texture_image.html "The class ProxyTextureImage provides a TextureImage interface to an externally maintained image sourc...") | Passes the activated textures handle to the shader if the textures [Candera::TextureImage](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_texture_image.html "Abstract base class for Texture images.A texture image mainly encapsulates a texture handle in VRAM a...") is of type [Candera::CubeMapTextureImage](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_cube_map_texture_image.html "CubeMapTextureImage encapsulates a VRAM handle which is retrieved when uploading a cube mapping textu...") or Candera::ProxyTextureImage(with TextureTargetType TextureCubeMap). i can be from 1 to 7 or nothing (e.g u\_CubeMapTexture, u\_CubeMapTexture1,..). |
| u\_Light\[i\].type | Integer | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes an integer defining the type of light i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].ambient | Vector4 | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the ambient color component of light i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].diffuse | Vector4 | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the diffuse color component of light i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].intensity | float | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the intensity factor applied to the diffuse color of light i to the shader, i can range from 0 to 7. Ignored if the light type is Ambient. |
| u\_Light\[i\].specular | Vector4 | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the specular color component of light i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].position | Vector4 | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the position of a point or spotlight i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].direction | Vector3 | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the direction vector of a directional or spotlight i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].halfplane | Vector3 | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the halfplane vector of a directional, point or spotlight i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].attenuation | Vector4 | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the attenuation weights of a point or spotlight i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].spotCosCutoff | Float | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the cut off angle of a spotlight i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].spotExponent | Float | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the spot exponent of a directional, point or spotlight i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].range | Float | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes the range of a point or spotlight i to the shader, i can range from 0 to 7. |
| u\_Light\[i\].enabled | Bool | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo...") | Passes whether light i is enabled or not to the shader, i can range from 0 to 7. |
| u\_Light\[i\].cameraLookAtVector | Vector3 | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo..."), [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set...") | Computes the look-at vector of the active Camera, and passes it to the shader. Depending on the Light::CoordinateSpace the look-at vector is either in world space or in the object space of the light. |
| u\_MorphWeight | Float Array | - | [Candera::MorphingMesh](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_morphing_mesh.html "MorphingMesh is a Mesh that stores weight values for morphing, and activates them as uniforms at rend...") | Passes the weights of a [Candera::MorphingMesh](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_morphing_mesh.html "MorphingMesh is a Mesh that stores weight values for morphing, and activates them as uniforms at rend...") to the shader. This is always done, if node is type of [Candera::MorphingMesh](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_morphing_mesh.html "MorphingMesh is a Mesh that stores weight values for morphing, and activates them as uniforms at rend..."). |
| u\_CanvasPivot | Vector2 | CanvasActivationEnabled | [Candera::CanvasRenderable](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_canvas_renderable.html "CanvasRenderable is used as base class for renderable canvas objects. The canvas renderable sets up t...") | Passes the position of the pivot of a [Candera::CanvasRenderable](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_canvas_renderable.html "CanvasRenderable is used as base class for renderable canvas objects. The canvas renderable sets up t...") to the shader. |
| u\_CanvasSize | Vector2 | CanvasActivationEnabled | [Candera::CanvasRenderable](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_canvas_renderable.html "CanvasRenderable is used as base class for renderable canvas objects. The canvas renderable sets up t...") | Passes the actual size of a [Candera::CanvasRenderable](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_canvas_renderable.html "CanvasRenderable is used as base class for renderable canvas objects. The canvas renderable sets up t...") to the shader. |
| ub\_Material | Uniform Buffer Object | MaterialActivationEnabled | [Candera::Material](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_material.html "The class Material describes the color attributes of an object's surface and is primarily used for li...") | Passes all of the material parameters from above in a uniform buffer object to the shader. |
| ub\_Lights | Uniform Buffer Object | LightActivationEnabled | [Candera::Light](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_light.html "A Node that represents different kinds of light sources. Light sources are used to determine the colo..."), [Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set...") | Passes all of the light parameters from above in a uniform buffer object to the shader. |
| u\_JointMatrices | Matrix4 | SkinningMeshActivationEnable | [Candera::SkinningMesh](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_skinning_mesh.html) | Passes the Inverse Bind Matrix of a Joint to the shader. |
| **Attribute Name** | **Semantic** |
|---|---|
| PositionAttribute\[i\] | Use this attribute for passing vertex positions (local space). i ranges from 1 to 7 or is nothing (e.g. PositionAttribute, PositionAttribute1,...). |
| PositionTransformedAttribute\[i\] | Use this attribute for passing transformed vertex positions. i ranges from 1 to 7 or is nothing (e.g. PositionTransformedAttribute, PositionTransformedAttribute1,...). |
| NormalAttribute\[i\] | Use this attribute for passing the vertices normals. i ranges from 1 to 7 or is nothing (e.g. NormalAttribute, NormalAttribute1,...). |
| TextureCoordinateAttribute\[i\] | Use this attribute for passing the vertices texture coordinates. i ranges from 1 to 7 or is nothing (e.g. TextureCoordinateAttribute, TextureCoordinateAttribute1,...). |
| ColorAttribute\[i\] | Use this attribute for passing the vertices colors. i ranges from 1 to 7 or is nothing (e.g. ColorAttribute, ColorAttribute1,...). |
| BlendWeightAttribute\[i\] | Use this attribute for passing the vertices blend weight attributes. i ranges from 1 to 7 or is nothing (e.g. BlendWeightAttribute, BlendWeightAttribute1,...). |
| BlendIndexAttribute\[i\] | Use this attribute for passing the vertices blend index attributes. i ranges from 1 to 7 or is nothing (e.g. BlendIndexAttribute, BlendIndexAttribute1,...). |
| PointSizeAttribute\[i\] | Use this attribute for passing the vertices point sizes. i ranges from 1 to 7 or is nothing (e.g. PositionAttribute, PositionAttribute1,...). |
| TangentAttribute\[i\] | Use this attribute for passing the vertices tangents. i ranges from 1 to 7 or is nothing (e.g. TangentAttribute, TangentAttribute1,...). |
| BiNormalAttribute\[i\] | Use this attribute for passing the vertices binormals. i ranges from 1 to 7 or is nothing (e.g. BiNormalAttribute, BiNormalAttribute1,...). |
| TesselationFactorAttribute\[i\] | Use this attribute for passing the vertices tesselation factors. i ranges from 1 to 7 or is nothing (e.g. TesselationFactorAttribute, TesselationFactorAttribute1,...). |
| FogAttribute\[i\] | Use this attribute for passing the vertices fog attributes. i ranges from 1 to 7 or is nothing (e.g. FogAttribute, FogAttribute1,...). |
| DepthAttribute\[i\] | Use this attribute for passing the vertices depth attributes. i ranges from 1 to 7 or is nothing (e.g. DepthAttribute, DepthAttribute1,...). |
| SampleAttribute\[i\] | Use this attribute for passing the vertices sample attributes. i ranges from 1 to 7 or is nothing (e.g. SampleAttribute, SampleAttribute1,...). |
| CustomAttribute\[i\] | Use this attribute for passing your custom data per vertex. i ranges from 1 to 7 or is nothing (e.g. CustomAttribute, CustomAttribute1,...). |
Overlapping Billboards (in screen space) would produce depth-fighting artifacts. Disabling depth test and using render order as well as using depth bias can be used to avoid them.
| **Include File** | **Supports** | **Include In** | **Note** | **Displaces** |
|---|---|---|---|---|
| RefEnvironment.inc | Platform specific defines | All Shaders | Shall be included in each Shader as first statement | Environment.incv, Environment.incf |
| RefLighting.inc | Lighting specific functions, also functions for anisotropic lighting | Shaders that support lighting | Useful helper functions for vertex lighting and pixel lighting | DefaultLighting.incv |
| RefTexturing.inc | Texturing specific functions, e.g. Environment Mapping | Shaders that support certain texture effects | Useful helper functions especially for common texture effects | Texturing.incv |
| RefSkinning.inc | Skinning specific features | Shaders that support skinning | Useful helper functions for skinning | Skinning.incv |
| **Vertex Shaders** | **Supports** | **Combine with Fragment Shaders** | **GenericShaderParamSetter Configuration** | **Note** |
|---|---|---|---|---|
| Core/RefTrans | Transformation, Texture | Core/RefTex, Core/RefUniColor, Core/RefUniColorTex, Core/RefTex2LightMap, Core/RefUniDiffuseMatTex, Effects/RefTexDofBlur, Effects/RefTexDofCombine | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Lighting has no influence. |
| Core/RefTransColor | Transformation, VertexColor, Texture | Core/RefColor, Core/RefColorTex, Core/RefColorTexAlpha, Effects/RefColorTexAlphaOutline | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Lighting has no influence. |
| Core/RefTransLight1 | Transformation, Vertex Lighting with one light source, Texture | Core/RefColor, Core/RefColorTex | SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | If Texture is used, depends on corresponding fragment shader only. |
| Core/RefTransLight2 | Transformation, Vertex Lighting with two light sources. Texture | Core/RefColor, Core/RefColorTex | SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | If Texture is used, depends on corresponding fragment shader only. |
| Core/RefTransLight3 | Transformation, Vertex Lighting with three light sources. Texture | Core/RefColor, Core/RefColorTex | SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | If Texture is used, depends on corresponding fragment shader only. |
| Core/RefTransWorldLight1 | Transformation, Lighting in WorldSpace with 1 Light Texture | Core/RefColor, Core/RefColorTex | SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightsCoordinateSpace(World) | Lighting calculations are processed in world space instead of model space (For details see function Light::SetCoordinateSpace). If Texture is used, depends on corresponding fragment shader only. |
| Effects/RefTransSphereMap | Transformation, Sphere Texture Mapping | Core/RefTex, Core/RefUniColorTex, Core/RefUniDiffuseMatTex | SetModelViewMatrix4Enabled(true) SetNormalModelViewMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Used to process a sphere texture for environment mapping. |
| Effects/RefTransLight1SphereMap | Transformation, Vertex Lighting with one light source, Sphere Texture Mapping | Core/RefColorTex | SetModelViewMatrix4Enabled(true) SetNormalModelViewMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Used to process a sphere texture for environment mapping. |
| Effects/RefTransLight2SphereMap | Transformation, Vertex Lighting with two light sources, Sphere Texture Mapping | Core/RefColorTex | SetModelViewMatrix4Enabled(true) SetNormalModelViewMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Used to process a sphere texture for environment mapping. |
| Effects/RefTransLight3SphereMap | Transformation, Vertex Lighting with three light sources, Sphere Texture Mapping | Core/RefColorTex | SetModelViewMatrix4Enabled(true) SetNormalModelViewMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Used to process a sphere texture for environment mapping. |
| Core/RefTransPointSprite | Transformation of PointSprite | Core/RefPointSprite | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Use with PointSprite. As usual for point sprites, lighting has no influence. |
| Core/RefTransLight1Morph | Transformation, VertexLighting with one lighe source, Morphing Weights | Core/RefColor, Core/RefColorTex | SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Use with MorphingMesh. If Texture is used, depends on corresponding fragment shader only. |
| Effects/RefTransLight1BumpMap | Transformation, Calculation of lighting vectors in tangent space. | Effects/RefLight1BumpMap | SetModelMatrix4Enabled(true) SetNormalModelMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetCameraPositionEnabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightsCoordinateSpace(World) | Used to prepare lighting vectors for bump map shaders. |
| Effects/RefTransLight1ProceduralWood | Transformation, Vertex Lighting with one light source, Passing position to fragment shader for procedural calculations. | Effects/RefProceduralWood | SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | |
| Effects/RefTransAnisotropicLight1Strand | Transformation, passes vertex attributes in world space to fragment shader. Calculates direction of anisotropy, eye vector and light direction. | Effects/RefAnisotropicLight1StrandTex | SetModelViewProjectionMatrix4Enabled(true) SetModelMatrix4Enabled(true) SetNormalModelMatrix3Enabled(true) SetCameraPositionEnabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightsCoordinateSpace(World) | |
| Effects/RefTransAnisotropicLight1 | Transformation, Passes vertex attributes in world space to fragment shader. | Effects/RefAnisotropicLight1SpecularTex | SetModelMatrix4Enabled(true) SetNormalModelMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetCameraPositionEnabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightsCoordinateSpace(World) | |
| Effects/RefTransFur | Transformation, Indexed Multi pass upscaling in direction of normals, Texture | Effects/RefUniColorTexFur | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Lighting has no influence. |
| Effects/RefTransCubeMapReflection | Transformation, Texturing reflection using one CubeMap texture | Core/RefCubeMapTex | SetModelMatrix4Enabled(true) SetNormalModelMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetCameraPositionEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Environment mapping reflections using a CubeMap texture. Lighting is not considered. |
| Effects/RefTransCubeMapRefraction | Transformaion, Texturing refraction using one cubemap texture. | Core/RefCubeMapTex | SetModelMatrix4Enabled(true) SetNormalModelMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetCameraPositionEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Environment mapping refractions using a CubeMap texture. Lighting is not considered. Refraction ratio has to be passed as additional uniform float refractionRatio. |
| Effects/RefTransCubeMapReflectionRefraction | Transformation, Texturing reflection and refraction using one cubemap texture. | Core/RefCubeMapTex2 | SetModelMatrix4Enabled(true) SetNormalModelMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetCameraPositionEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Environment mapping refractions and reflections using a CubeMap texture. Lighting is not considered. Refraction ratio has to be passed as additional uniform float refractionRatio. |
| Core/RefTransCubeMap | Transformation, Texturing using one CubeMap texture, addressed directly by object space vertex coordinates. | Core/RefCubeMapTex | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Direct addressing of CubeMap texture using object space vertex positions. Can be used for e.g. a SkyBox using a CubeMap texture. |
| Effects/RefTransDof | Transformation, Texturing with one texture, First render pass of depth-of-field rendering: Rendering the scene, Scaled depth value passed as varying. | Effects/RefTexDof | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | First pass of depth-of-field rendering has to be applied to every node that is rendered. The resulting image then contains the scene's depth values as alpha value, which is used for further processing. If other effects (e.g. Light, bump mapping etc.) have to be applied on the nodes, then also the corresponding shaders have to be adapted to meet the depth-of-field requirements. Additional uniform u\_depthScale has to be passed to scale the depth values. |
| Effects/RefTransLight1Dof | Transformation, Texturing with one Texture Vertex Lighting with one light source, First render pass of depth-of-field rendering: Rendering the scene, Scaled depth value passed as varying. | Effects/RefColorTexDof | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightsCoordinateSpace(Light::Object); | First pass of depth-of-field rendering has to be applied to every node that is rendered. The resulting image then contains the scene's depth values as alpha value, which is used for further processing. If other effects (e.g. bump mapping etc.) have to be applied on the nodes, then also the corresponding shaders have to be adapted to meet the depth-of-field requirements. Additional uniform u\_depthScale has to be passed to scale the depth values. Supports per vertex lighting. |
| Effects/RefTransFragmentLightDof | Transformation, Texturing with one Texture, Normal and position for per fragment lighting, First render pass of depth-of-field rendering: Rendering the scene, Scaled depth value passed as varying. | Effects/RefTexFragmentLightDof | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightsCoordinateSpace(Light::World); SetModelMatrix4Enabled(true); SetNormalModelMatrix3Enabled(true); | First pass of depth-of-field rendering has to be applied to every node that is rendered. The resulting image then contains the scene's depth values as alpha value, which is used for further processing. If other effects (e.g. bump mapping etc.) have to be applied on the nodes, then also the corresponding shaders have to be adapted to meet the depth-of-field requirements. Additional uniform u\_depthScale has to be passed to scale the depth values. Supports per Fragment lighting. |
| Core/RefTransPos | Transformation, Texture, Vertex position to fragment shader | Core/RefFlatLight1 | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightActivationEnabled(true) | No light calculation, passing vertex position to fragment shader for FlatShading calculations. |
| Effects/RefTransLight1Gooch | Transformation, Assignment of ambient light component, Calculation of varyings needed for computation of specular component in world space. First pass of gooch-shading: Shading. | Effects/RefGoochShading | SetModelMatrix4Enabled(true) SetNormalModelMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetCameraPositionEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightActivationEnabled(true) SetLightsCoordinateSpace(Light::World) | This vertex shader in conjunction with RefGoochShading.fragp realizes the first pass of an implementation of Gooch's rendering technique to simulate the appearance of technical illustrations, often occuring in e.g. manuals or schematic presentations etc. (SIGGRAPH'98 paper "A Non-Photorealistic Lighting Model For Automatic Technical Illustration"). The first pass renders the object using a transition from "cool" to "warm" colors according to the lighting model. While phong shading is normally used to simulate real lighting, this lighting model aims more on preserving details away from the light source. The second pass then draws the silhoutte of the object. For this the object is upscaled and rendered with a fixed color (e.g. black). On [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") side the first and the second pass have to be rendered with different Culling states, such that first pass renders the front of the object, and the second only the back side. |
| Effects/RefTransScale | Transformation, Upscaling in direction of normals, texture coordinates. | Core/RefTex, Core/RefUniColor, Core/RefUniColorTex, Core/RefUniDiffuseMat, Core/RefTex2LightMap | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Lighting has no influence. Used to upscale the vertices inside the vertex shader, using a float scale factor passed as uniform u\_Scale. Is used for silhouette rendering in gooch-shading, but may be also used for other techniques. |
| Core/RefViewportSpace | Texture Adjusting the position of the screen aligned billboard by setting uniform u\_offsetLeft and u\_offsetTop. | Effects/RefTexGaussianBlurX, Effects/RefTexGaussianBlurY, Effects/RefTexDofCombine, Effects/RefBloomThreshold, Effects/RefCombineBloom, Core/RefInterlaceMask | SetModelViewProjectionMatrix4Enabled(false)SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) | Used in subsequent post processing passes in conjuction with a screen-aligned billboard. The billboard should be of size 0.0 to 1.0 with 1.0 being a fullscreen billboard. The position of the billboard on the screen can be adjusted by setting the left and top offset in the range of 0.0 to 1.0. Passes the position and texture coordinate to the fragment shader without any matrix transformation. Therefore the incoming vertex buffer should already be in homogenous screen coordinates. Note: Overlapping Billboards (in screen space) would produce Z-fighting artifacts. Disabling depth test and using render order as well as using depth bias can be used to avoid them. |
| Effects/RefTransLight1Carbon | Transformation, Lighting with one light source, Texture, Line of Sight | Effects/RefCarbon | SetModelMatrix3Enabled(true) SetNormalModelMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightsCoordinateSpace(Light::Object) | Seamless texture utilized as carbon image |
| Effects/RefTransLight1FlopCarPaint | Transformation, Lighting with one light source, Line of Sight, Mixes two color components diffuse and emissive based on camera position | Effects/RefFlopCarPaint | SetModelMatrix3Enabled(true) SetNormalModelMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(false) SetLightsCoordinateSpace(Light::Object) | Mixes two color components (diffuse and emissive) based on the camera position |
| Effects/RefTransLight1MetalFlakesCarPaint | Transformation, Lighting with one light source, Line of Sight, Texture | Effects/RefMetalFlakesCarPaint | SetModelMatrix3Enabled(true) SetNormalModelMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightsCoordinateSpace(Light::Object) | Metal flake effect with one noise texture |
| Effects/RefTransLight1FlopMetalFlakesCarPaint | Transformation, Lighting with one light source, Line of Sight, Texture, Mixes two color components diffuse and emissive based on camera position | Effects/RefFlopMetalFlakesCarPaint | SetModelMatrix3Enabled(true) SetNormalModelMatrix3Enabled(true) SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetLightsCoordinateSpace(Light::Object) | Metal flake effect with one noise texture Mixes two color components (diffuse and emissive) based on the camera position |
| Core/RefCanvasTrans | Applying scale and offset to vertices before transformation, Transformation into world space, Texturing with one texture. | Core/RefTex, Core/RefUniColor, Core/RefUniColorTex, Core/RefTex2LightMap, Core/RefUniDiffuseMatTex | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetCanvasActivationEnabled(true) | Similar to RefTrans, but additionally applies canvas offset and size before multiplying the mvp matrix. |
| Core/RefCanvasTransLight1 | Applying scale and offset to vertices before transformation, Transformation, Texturing with one tetxture, One light source with lighting in model space. | Core/RefColor, Core/RefColorTex | SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetCanvasActivationEnabled(true) SetLightsCoordinateSpace(Light::Object) | Similar to RefTransLight1, but additionally applies canvas offset and size before multiplying the mvp matrix. |
| Core/RefCanvasTransUniDiffuseMat | Applying scale and offset to vertices before transformation, Transformation into world space, Texturing with one texture, Forwarding of material diffuse color to fragment shader. | Core/RefCanvasUniDiffuseMat | SetModelViewProjectionMatrix4Enabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetCanvasActivationEnabled(true) | Similar to RefTrans, but additionally applies canvas offset and size before multiplying the mvp matrix. Additionally it passes material diffuse color to fragment shader. This shader is used to achieve the same effect as a SolidColorBrush in 2D. |
| Effects/RefFxaa | Coordinates in normalized device space. | Effects/RefFxaa | SetModelViewProjectionMatrix4Enabled(false) SetLightActivationEnabled(false) SetMaterialActivationEnabled(false) | Applies the "Fast approximate anti-aliasing" algorithm to its input, which should be a quad using normalized device coordinates. The uniform (u\_Resolution) needs to be set to the width and height of the input texture measured in texels. |
| Effects/Ref | Texture | Effects/RefTexGaussianBlurX, Effects/RefTexGaussianBlurY, Effects/RefTexDofCombine, Effects/RefBloomThreshold, Effects/RefCombineBloom | SetModelViewProjectionMatrix4Enabled(false) SetLightActivationEnabled(false) SetMaterialActivationEnabled(false) SetTextureActivationEnabled(true) | Passes texture coordinates and vertex position to fragment shader without applying a transformation. This is useful for post processing effects when the vertex buffer is just a quad in normalized device coordinates (-1,1). |
| Effects/RefTransGradientLinear | Transformation into world space, Vertex based linear gradient computations. | Effects/RefGradientLinear | SetModelViewProjectionMatrix4Enabled(true) | Vertex Shader for linear gradient computations. |
| Effects/RefTransGradientRadial | Transformation into world space, Passing vertex position to fragment shader. | Effects/RefGradientRadial | SetModelViewProjectionMatrix4Enabled(true) | Vertex Shader for radial gradient computations. |
| Core/RefTransLight1Skin | Skinning | Core/RefColor, Core/RefColorTex | SetModelViewProjectionMatrix4Enabled(true) SetLightActivationEnabled(true) SetMaterialActivationEnabled(true) SetTextureActivationEnabled(true) SetSkinningMeshActivationEnabled(true) | If Texture is used, depends on corresponding fragment shader only. And, use with SkinningMesh. |
| **Fragment Shaders** | **Supports** | **Combine with Vertex Shaders** | **GenericShaderParamSetter Configuration** | **Note** |
|---|---|---|---|---|
| Core/RefColor | Color from varying | Core/RefTransLight\*, Core/RefTransWorldLight\*, Core/RefTransLight1Morph | See configuration of RefTransLight\* or RefTransWorldLight1 | Normaly used for models that support lighting but no texture. varying color (v\_Color) is typically either set by lit material or by vertex color. |
| Core/RefTex | Texture | Core/RefTrans, Effects/RefTransSphereMap, Effects/RefTransScale | See configuration of RefTrans or RefTransSphereMap | Lighting has no influence. |
| Core/RefColorTex | Color from varying, Texture | Core/RefTransLight\*, Core/RefTransWorldLight\*, Core/RefTransColor, Core/RefTransLight1Morph, Core/RefTransLight\*SphereMap | See configuration of RefTransLight\* or RefTransWorldLight1 | Normaly used for models that support lighting and one texture. varying color (v\_Color) is normaly either set by lit material or by vertex color. |
| Core/RefUniColor | Color from uniform | Core/RefTrans, Effects /RefTransScale | See configuration of RefTrans | Useful if certain color is set via uniform (u\_Color) directly. Lighting or vertex colors have no influence. |
| Core/RefUniColorTex | Color from uniform, Texture | Core/RefTrans, Effects/RefTransSphereMap, Effects /RefTransScale | See configuration of RefTrans or RefTransSphereMap | Useful if certain color is set via uniform (u\_Color) directly and blended with one texture. Lighting or vertex colors have no influence. |
| Core/RefUniDiffuseMatTex | Material diffuse color, Texture | Core/RefTrans, Effects/RefTransSphereMap | See configuration of RefTrans or RefTransSphereMap | Final color = materials diffuse color \* texel color. The uniform value of the materials diffuse color is set by [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") automatically if a Material is applied to a Node. Lighting or vertex colors have no influence. |
| Core/RefPointSprite | Pointsprite incl. Texturing | Core/RefTransPointSprite | See configuration of RefTransPointSprite | Used for point sprites only. |
| Core/RefTex2LightMap | Texture, LightMap | Core/RefTrans, Effects /RefTransScale | See configuration of RefTrans | Lightmap Multitexturing: A Lightmap typically defines an illumination texture at unit 1 that is multiplied with texture at unit 0. |
| Effects/RefLight1BumpMap | Per pixel lighting using the normals supplied in u\_Texture1 (normal map). Computed color is combined with the texture in u\_Texture0. | Effects/RefTransLight1BumpMap | See configuration of RefTransLight1BumpMap | Used to display rough surfaces without adding polygon complexity to it. The shader accepts two textures. u\_Texture0 defines the color map used. u\_Texture1 defines a normal map, that stores normals in tangent space to be used for lighting calculations. |
| Effects/RefProceduralWood | Procedural calculation of interpolated rings, which appears like annual rings of wood if the right colors are chosen. | Effects/RefTransLight1ProceduralWood | See configuration of RefTransLight1ProceduralWood | For procedural calculations two color, the orgin of the annual rings and a multiplier that controls the densitiy of the rings can be passed. |
| Effects/RefAnisotropicLight1StrandTex | Per pixel anisotropic lighting, using a strand texture | Effects/RefTransAnisotropicLight1Strand | First texture for color, second for strand. | The strand texture must hold the diffuse and specular light intensity in the R and G channels, respectively. |
| Effects/RefAnisotropicLight1SpecularTex | Per pixel anisotropic lighting | Effects/RefTransAnisotropicLight1 | See configuration of RefTransAnisotropicLight1 | Using alternative anisotropic specular highlights, according to Ward's SIGGRAPH 92 paper "Measuring and Modeling Anisotropic Reflection". Additional calculated specular component is combined with u\_Texture0. Used to display the reflection behavior of multiple surfaces. Uniforms u\_AlphaX and u\_AlphaY model the distribution of the specular highlight. Combined with a texture it can for example be used to simulate metallic surfaces like brushed steel. In the cited paper alphaX and alphaY for several materials can be found. |
| Effects/RefUniColorTexFur | Assignment of product of alpha mask, texture and fixed color. | Effects/RefTransFur | See configuration of RefTransFur | Simulates the appearance of fur if applied with MulitPassRendering. Is also intended to demonstrate multi pass rendering. |
| Core/RefCubeMapTex | Addressing one cube map texture using a single varying vec3. | Effects/RefTransCubeMapReflection, Effects/RefTransCubeMapRefraction, Core/RefTransCubeMap | See configuration of RefTransCubeMapReflection, RefTransCubeMapRefraction, RefTransCubeMap | Cube Map addressing, material colors or lighting are not considered. |
| Core/RefCubeMapTex2 | Mixing two different addressed fragments of a CubeMap using a varying ratio. Addressing is done using two varying vec3. | Effects/RefTransCubeMapReflectionRefraction | See configuration of RefTransCubeMapReflectionRefraction | Cube Map addressing, material colors or lighting are not considered. |
| Core/RefUniDiffuseMat | Material diffuse color | Core/RefTrans | See configuration of RefTrans | Final color = materials diffuse color The uniform value of the materials diffuse color is set by [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") automatically if a Material is applied to a Node. Lighting or vertex colors have no influence. |
| Effects/RefTexDof | Assignment of Texture, First render pass of depth-of-field rendering: Rendering the scene, Depth encoded into alpha channel. | Effects/RefTransDof | See configuration of RefTransDof | First pass of depth-of-field rendering has to be applied to every node that is rendered. The resulting image then contains the scene's depth values as alpha value, which is used for further processing. If other effects (e.g. Light, bump mapping etc.) have to be applied on the nodes, then also the corresponding shaders have to be adapted to meet the depth-of-field requirements. |
| Effects/RefColorTexDof | Color from varying, Assignment of Texture, First render pass of depth-of-field rendering: Rendering the scene, Depth encoded into alpha channel. | Effects/RefTransLight1Dof | See configuration of RefTransLight1Dof | First pass of depth-of-field rendering has to be applied to every node that is rendered. The resulting image then contains the scene's depth values as alpha value, which is used for further processing. If other effects (e.g. bump mapping etc.) have to be applied on the nodes, then also the corresponding shaders have to be adapted to meet the depth-of-field requirements. Support per vertex lighting. |
| Effects/RefTexFragmentLightDof | Per fragment lighting with one light source, Assignment of Texture, First render pass of depth-of-field rendering: Rendering the scene, Depth encoded into alpha channel. | Effects/RefTransFragmentLightDof | See configuration of RefTransFragmentLightDof | First pass of depth-of-field rendering has to be applied to every node that is rendered. The resulting image then contains the scene's depth values as alpha value, which is used for further processing. If other effects (e.g. bump mapping etc.) have to be applied on the nodes, then also the corresponding shaders have to be adapted to meet the depth-of-field requirements. Supports per fragment lighting. |
| Effects/RefTexDofBlur | Assignment of texture, second render pass of depth-of-field: blurring the texture, simulating an optical circle of confusion, caused by lens refraction out of focus. | Core/RefTrans | See configuration of RefTrans | Second pass of depth-of-field rendering: blurring the incoming image. Result is a blurred image of the passed texture. u\_CocScale controls the size of the circle of confusion, and therefore the blur strength. |
| Effects/RefTexDofCombine | Third pass of depth of field: Assignment and blending of two textures, representing the sharp and blurred image. Blend weights result from focus and focus range of the simulated camera lens. | Core/RefViewportSpace, Effects/Ref | See configuration of RefTrans | Third pass of depth rendering: Combines the sharp and the blurred image according to the set focus of the simulated camera lens. u\_Focus controls the distance of the focus plane (where a sharp image would be formed). u\_Range controls the size of the area around the focus plane, where a sharp image would be drawn. |
| Effects/RefTexGaussianBlurX | Assignment of texture, Subsequent pass of post-processing effect: blurring the texture with a Gaussian blur, Gaussian blur step width from unifrom | Core/RefViewportSpace, Effects/Ref | See configuration of RefViewportSpace plus SetUniform("u\_blurFactor",Shader::Float, &blurFactor) | Subsequent pass of post-processing effect: blurring the incoming image horizontally. Result is a blurred image of the passed texture. u\_blurFactor controls the step width of the Gaussian function. u\_blurFactor should always be 1.0/TextureWidth so that every step will correlate with one pixel. |
| Effects/RefTexGaussianBlurY | Assignment of texture, Subsequent pass of post-processing effect: blurring the texture with a Gaussian blur, Gaussian blur step width from unifrom | Core/RefViewportSpace, Effects/Ref | See configuration of RefViewportSpace plus SetUniform("u\_blurFactor",Shader::Float, &blurFactor) | Subsequent pass of post-processing effect: blurring the incoming image vertically. Result is a blurred image of the passed texture. u\_blurFactor controls the step width of the Gaussian function. u\_blurFactor should always be 1.0/TextureHeight so that every step will correlate with one pixel. |
| Core/RefFlatLight1 | Per fragment lighting with one light source for Flat Shading. | Core/RefTransPos | See configuration of RefTransPos | In order to use derivative functions dFdx and dFdy the extension GL\_OES\_standard\_derivatives has to be enabled and supported by driver. |
| Effects/RefGoochShading | Per Fragment calculation of specular component, Mixing cool and warm color using the dot product of light direction and vertex normal as weight, Output: Mixed color + specular and ambient lightcomponent. | Effects/RefTransLight1Gooch | See configuration of RefTransLight1Gooch | This fragment shader in conjunction with RefTransLight1Gooch.vertp realizes the first pass of an implementation of Gooch's rendering technique to simulate the appearance of technical illustrations, often occuring in e.g. manuals or schematic presentations etc. (SIGGRAPH'98 paper "A Non-Photorealistic Lighting Model For Automatic Technical Illustration"). For details please refer to the description of the vertex shader, and to the cited paper. The following unifiorms are needed: u\_CoolColor and u\_CoolColor are 4-component vectors that describe the colors for the cool to warm transition. u\_CoolDiffuseWeight and u\_WarmDiffuseWeight are float values that describe, how the original diffuse color is combined with the warm and cool colors. |
| Effects/RefBloomThreshold | Assignment of texture, Subsequent pass of bloom effect: extracting only the bright parts of the image that should be blurred, brightness threshold from unifrom | Core/RefViewportSpace, Effects/Ref | See configuration of Core/RefViewportSpace | Subsequent pass of post-processing bloom effect: extracting only the bright parts of the incoming texture. Those bright parts are blurred in the next step to generate a bloom effect. |
| Effects/RefCombineBloom | Subsequent pass of bloom effect: Assignment and djustable combination of the original and the bloomed texture | Core/RefViewportSpace, Effects/Ref | See configuration of RefViewportSpace | Subsequent pass of post-processing bloom effect: The incoming texture of the original scene and the incoming texture of the bright, bloomed parts are combined. The blending of the two textures is adjustable by uniforms representing the intensity and saturation of the images. |
| Core/RefInterlaceMask | Uses a texture's color to create a mask through discarding pixels with low transparency. No value is written to the discarded fragments, so also no depth or stencil values. | Core/RefViewportSpace | See configuration of RefViewportSpace | Is especially useful for e.g. Creating stencil masks for stereoscopic 3D. |
| Effects/RefCarbon | Wraps a seamless texture multible times around the object to achieve carbon look. | Effects/RefTransLight1Carbon | See configuration RefTransLight1Carbon | Creates a car paint with typical carbon look. |
| Effects/RefFlopCarPaint | Mixes the two color components together based on the camera position and a user defined bias | Effects/RefTransLight1FlopCarPaint | See configuration RefTransLight1FlopCarPaint | Creates a car paint with shiny, anisotropic two color look. |
| Effects/RefMetalFlakesCarPaint | Adding a noise to the spectral part of the light. Noise can be wrapped around the object multible times. Create the illusion of metal flakes in the car paint. | Effects/RefTransLight1MetalFlakesCarPaint | See configuration RefTransLight1MetalFlakesCarPaint | Creates a car paint with shiny, sparkling look produced by metal flakes within specular highlight |
| Effects/RefFlopMetalFlakesCarPaint | Mixes the two color components together based on the camera position and a user defined bias. Adding a noise to the spectral part of the light. Noise can be wrapped around the object multible times. Create the illusion of metal flakes in the car paint. | Effects/RefTransLight1FlopMetalFlakesCarPaint | See configuration RefTransLight1FlopMetalFlakesCarPaint | Creates a car paint with shiny, sparkling look produced by metal flakes within specular highlight combined with anisotropic two color look. |
| Core/RefCanvasUniDiffuseMat | Assignment of material's diffuse color to fragment color | Core/RefCanvasTransUniDiffuseMat | See configuration RefCanvasTransUniDiffuseMat | This shader is used to achieve the same effect as a SolidColorBrush in 2D. |
| Effects/RefFxaa | Coordinates in normalized device space. | Effects/RefFxaa | See configuration of Effects/RefFxaa | Applies the "Fast approximate anti-aliasing" algorithm to its input, which should be a quad using normalized device coordinates. The uniform (u\_Resolution) needs to be set to the width and height of the input texture measured in texels. |
| Effects/RefGradientLinear | Mixing fragment color according to gradient computations. | Effects/RefTransGradientLinear | See configuration RefTransGradientLinear | Fragment Shader for linear gradient computations. |
| Effects/RefGradientRadial | Assignment of radial gradient color to fragment color. | Effects/RefTransGradientRadial | See configuration RefTransGradientRadial | Fragment Shader for radial gradient computations. |
| Core/RefColorTexAlpha, | Assignment of product of varying color and texture color to fragment color. | Core/RefTransColor | See configuration RefTransColor | This fragment shader shall be used for text or alpha mask rendering. |
| Effects/RefColorTexAlphaOutline | This fragment shader renders an outline of color "u\_outlineColor" and width specified by "u\_outlineWidth" around the contents in the texture "u\_Texture". The input texture is also multiplied by the vertex color. If the "u\_outlineWidth" value is bigger than 10, the contents of the texture need be bigger than 10 too, otherwise artefacts will start to appear with increasing outline width. There is no instancing version of this shader, because it will usually be applied to text rendering which is batched by Canvas rather than the Renderer. | Core/RefTransColor | See configuration RefTransColor Additionally: SetTexelSizeActivationEnabled(true) Custom uniforms: uniform vec4 u\_outlineColor; // Color of outline. uniform float u\_outlineWidth; //Width of outline. | This fragment shader shall be used if a text or an alpha mask shall receive an outline. |
Char data type must not be used for I18N text and always maps to ASCII.
The font will only be available in the finally generated asset, if: - it is either used in any scene (as part of a style which is used in a widget style property for example) - or the "Always include in asset" flag is enabled in the font resource.
The FontFaceName property must be set with a valid [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") path. Keep in mind that, unlike paths generated by the Font dialog where the; the "/" character, the [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") paths use "#" as delimiter.
[Courier](http://dev.doc.cgistudio.at/APILINK/namespace_courier.html) applications can use [Courier::ViewHandler::SetFontStoreProviderCallback](http://dev.doc.cgistudio.at/APILINK/class_courier_1_1_view_handler.html#a7747f74f80b57fd376b13f942d927009) to provide specific settings for the [Candera::AssetFontStore](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_asset_font_store.html "implements a font store for the asset library this is the default font store Candera will use to retr...") in use.
If the code ranges of different style entries overlap, the style entry with the higher number has priority (e.g. font in entry 2 has higher priority than font in entry 1).
CANDERA\_TEXTSHAPER should be set to *"NoShaping"* or *"ComplexScriptLib"* because Harbuzz Text Shaper cannot be used with BitmapFont.
A bitmap font should be used at its native pixel size. However, they are scalable because of the use of bitmaps, but only scaling down is recommended. In case of up scaling, the visual quality will be reduced. Including separate font sizes for bitmap fonts is possible in order to achieve the best looking results.
Choose the appropriate cache for a balance in performance. It is recommended to use either Bitmap or Surface rendering type when static texts are used, while for dynamic texts, GlyphCache is recommended.
Not all BitmapBrush effects have the *Color* property available. Default color for a TextNode2D is white.
For truncation to occur, *Enable Text Layout* property needs to be enabled.
Compare this interface also with the functional steps introduced in chapter [Fonts and Styles](https://doc316en.candera.eu/books/candera/page/fonts-and-styles).
| Scene type | Node name | Widget name |
|---|---|---|
| 2D | [Candera::TextNode2D](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_text_node2_d.html "TextNode2D is a RenderNode that renders text using the attached BitmapBrush effect.") | - |
| 3D | - | TextTextureWidget |
The hinting applies only to **outline** fonts so the bitmap fonts and the stroke fonts will not be affected by this feature.
All modes except GlyphHinter::Monochrome use 256 levels of opacity.
When a layouter is attached, it has to be used as it replaces the default behavior with a complex one. However, the information has to be provided by triggering the layout process otherwise it misses most of the information. This implies that other usages are wrong and lead to undefined or unwanted behavior.
Transformations like scale and rotation are applied after the text has been rendered. This means that you cannot use scaling to produce narrow or wide text, because the visual layout would be altered (right-aligned text will not be aligned any more after scaling). In this case, import a scaled font instead.
[Candera::TextNode2D](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_text_node2_d.html "TextNode2D is a RenderNode that renders text using the attached BitmapBrush effect.") attaches itself to the [Candera::TextRendering::TextValidationGroup](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_text_rendering_1_1_text_validation_group.html) singleton instance per default. To exclude it from the synchronization group it has to be explicitly detached first.
Changing the way of synchronization during runtime should only be done, when the affected text object (e.g. [Candera::TextNode2D](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_text_node2_d.html "TextNode2D is a RenderNode that renders text using the attached BitmapBrush effect.")) has no pending text changes – as this can have unexpected side effects.
| **Id:** | Unique identifier of the translatable text: - *Computed TextId*: An alphanumerical string, which will be exported into a computed hash value as TextId. - *Direct Id*: When the format HEX\_VALUE is used, the hex value is directly exported into the asset without computing a hash value. |
| **Text:** | Text in the master language |
| **Translation hint:** | Hint for the process of translation |
If there is no text configured for a certain language, the *Text Id* will be displayed instead. Using this id, the missing text can easily be identified and found in the Language Table using the search function.
The *Drop* action does not mean that the language will be removed from the solution. The removal of a language can be done from *File > Solution Options* in the *Cultures* tab.
| [Candera::Globalization::Culture](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture.html) | Represents a language, region, and text direction - Locale: ASCII encoded character array, e.g. de\_AT. Use [Candera::Globalization::Culture::GetLocale()](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture.html#aea515e01a7afafe67db6282f7e6dfac4) - Display name: Platform-encoded character array (usually UTF-8), e.g. "German (Austria)". Use [Candera::Globalization::Culture::GetDisplayName()](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture.html#a5381ce8790ea6daca1d6e4e9face34dd) - Text direction: Enum describing text direction for culture. Use [Candera::Globalization::Culture::GetTextDirection()](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture.html#aa7e32e5200cfec29a063ae55e815d370) |
| [Candera::Globalization::CultureManager](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture_manager.html) | Access to cultures and changing of current culture Singleton: [Candera::Globalization::CultureManager::GetInstance()](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture_manager.html#a304b9b82d1ce5e85ce36de1683c87643) Retrieve available cultures: ``` return CultureManager::GetInstance().GetCultureCount(); ``` Get current culture: ``` Culture::SharedPointer culture = CultureManager::GetInstance().GetCurrentCulture(); ``` Get culture name: ``` Culture::SharedPointer culture = CultureManager::GetInstance().GetCulture(index); return culture->GetDisplayName(); ``` Set new culture: ``` Culture::SharedPointer culture = CultureManager::GetInstance().GetCulture(index); FEATSTD_LOG_INFO(" -> Select culture '%s'", culture->GetDisplayName()); rc = CultureManager::GetInstance().SetCurrentCulture(culture->GetLocale()); ``` - [Candera::Globalization::CultureManager::GetCulture(const Char\* locale) const ](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture_manager.html#a11b6e5c19d1d119df057c640cbb6db3a)- Retrieval of specific culture by locale |
| [Candera::Globalization::CultureChangeListener](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture_change_listener.html) | Base class for listeners to culture change events Notification of CultureChangeEvents - Listener has to derive from [Candera::Globalization::CultureChangeListener](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture_change_listener.html) - override [Candera::Globalization::CultureChangeListener::OnCultureChanged(const Culture& culture)](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture_change_listener.html#ad34d13c0afad927f5448437087da15f5) {...} for handler - Registration as listener - [Candera::Globalization::CultureManager::AddCultureChangeListener(CultureChangeListener\* listener)](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_globalization_1_1_culture_manager.html#ac59956a9a17161a614521bd3e83ec23b) - Deregistration of listener - Candera::Globalization::CultureManager::RemoveCultureChangeListener(CultureChangeListener\* listener) |
| [FeatStd::String](http://dev.doc.cgistudio.at/APILINK/class_feat_std_1_1_string.html) and [FeatStd::TextId](http://dev.doc.cgistudio.at/APILINK/class_feat_std_1_1_text_id.html) | Point of access to a text in currently active language Non-translatable String - Will not change with language - Use constructor [FeatStd::String::String(const TChar\*)](http://dev.doc.cgistudio.at/APILINK/class_feat_std_1_1_string.html#a2b5ab81b2f9de953b42677a508146831); Translatable String - Changes with language - Text-Id from string value - Use [FeatStd::TextId::TextId(const Char\* id)](http://dev.doc.cgistudio.at/APILINK/class_feat_std_1_1_text_id.html#a433e7beda4e766070d0d356044f4a3f2) to get the computed hash id from a given character id - Use [FeatStd::String::String(const TextId& id)](http://dev.doc.cgistudio.at/APILINK/class_feat_std_1_1_string.html#a5533f601ec5f8a72649d61fa9bde65ea) to access the text for a given Text-Id ``` FeatStd::String text(FeatStd::TextId("textField_1_3")); ``` - Direct Text-Id: "#\\<HEX\_HASH\_VALUE\\>" - Use FeatStd::String::String(UInt32 id) to access the text for a given <HEX\_HASH\_VALUE> ``` FeatStd::String text(0x13); // for accessing text referenced by a hex-value-id of 13 ``` |
In SceneComposer the animation can be retrieved from AssetProvider only if it was previously loaded in the scene. A better way to access it directly is to define it as a widget property.
The viewport position and size of a [Candera::Camera2D](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera2_d.html "A camera defines the view to the scene. At least one Camera2D has to be added to a 2D scene graph and...") are given in pixels.
| Device | Number of Displays Supported | Types of Layers Supported | Unit Types |
|---|
If you use more than one camera on a render target, take care to enable swapping only for the last camera (highest sequence number).
[Candera::Camera](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera.html "A Camera provides Modelview and Projection matrices. Camera is a Transformable.* The eye point is set...") and [Candera::Camera2D](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_camera2_d.html "A camera defines the view to the scene. At least one Camera2D has to be added to a 2D scene graph and...") clear only the area specified by the viewport.
Software Layers are not supported on all devices! Software Layers are supported on iMX6. An example solution for this concept can be seen in *cgi\_studio\_player/content/Tutorials/07\_RenderTargetsCameras* solution.
For a correct behaviour of the scene editor the composition camera has to be placed in a separate scene.
The software layers are delimited by a 1 px border. If needed, this border can be disabled using the "BorderEnabled" property.
| Source | Destination | Constant Alpha | Blend Mode | Formula | Output |
|---|---|---|---|---|---|
| 0.5 | SoftwareLayerBlendModeStandard | SRC \* SRC.A + DST \* (1 - SRC.A) | |||
| SoftwareLayerBlendModePreMultiplied | SRC + DST \* (1 - SRC.A) | ||||
| SoftwareLayerBlendModeConstantAlpha | SRC \* CNS.A + DST \* (1 - CNS.A) | ||||
| SoftwareLayerBlendModeSimultaneousAlpha | SRC \* SRC.A \* CNS.A + DST \* (1 - SRC.A \* CNS.A) | ||||
| SoftwareLayerBlendModeSimultaneousPreMultiplied | SRC \* CNS.A + DST \* (1 - SRC.A \* CNS.A) | ||||
| SoftwareLayerBlendModeOff | SRC |
| Object | Scope Mask |
|---|---|
| Sphere | 1 |
| Pyramid | 2 |
| Cube | All |
| Camera 1 | 1 |
| Camera 2 | All |
For the convenience, we will assume that the last context activated by the application is Context Resource Pool 1.
| **Index** | **MultiContext flag** | **Upload scope mask** | **Uploaded in CRP 0** | **Uploaded in CRP 1** | ||||||
|---|---|---|---|---|---|---|---|---|---|---|
| **1** | **2** | **All** | **Cube** | **Sphere** | **Pyramid** | **Cube** | **Sphere** | **Pyramid** | ||
| **1** | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/jCcok.png) |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |
| **2** |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  |
| **3** |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  |  |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  |  |  |
| **4** | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |
| **5** | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  |
| **6** | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) | [](https://doc316en.candera.eu/uploads/images/gallery/2023-02/cancel.png) |  |  |  |
The Layer property must be correctly set for Candera::SoftwareLayer render targets (DisplayRenderTarget3D and DisplayRenderTarget2D). The layers must have different values, with the lowest value for the lowest layer.
**Rules to configure multiple cameras attached to a render target** - Camera 2D: Clear Color Buffer = false; Enable Swapping = true - Camera 3D: Clear Color Buffer = true; Enable Swapping = false
A camera can belong to multiple groups, but its state is unique, meaning that enabling the camera in one group will enable it in all groups and also in the Render Target panel where it is associated to a render target. If a group is disabled or enabled, all the cameras inside it will be disabled or enabled. If one or many from those cameras are members of another group, the second group will be enabled or disabled too.
For specific devices the prefix "Device" is used in the beginning of class identifiers. Simply exchange it with the according device name.
[Candera::ProxyTextureImage](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_proxy_texture_image.html "The class ProxyTextureImage provides a TextureImage interface to an externally maintained image sourc...") can be used with textures of type GL\_TEXTURE\_2D or GL\_TEXTURE\_CUBE\_MAP. For other types, e.g. 3D textures, activation and other steps have to be done using own implementations along with node listeners.
MSAA for offscreen render targets is only available on devices that support OpenGL ES 3.0 or higher. Even more, the number of supported samples differs from one device to another, some may not support more than 4x MSAA, which is the minimum defined by the OpenGL ES 3.0 standard. Using sample values higher than supported might lead to undefined behaviours or errors. It is recommended to check the device documentation for the number of supported samples.
To get this mechanism running ensure that the camera always clears the stencil buffer to 0 every frame.
The GraphicDeviceUnit has to be initialized accordingly to support stencil buffers.
| Vertex shader | RefTransLight1BumpMap |
| Fragment shader | RefLight1BumpMap |
| Vertex shader | RefTransLight1ProceduralWood |
| Fragment shader | RefProceduralWood |
| Vertex shader | RefTransAnisotropicLight1 |
| Fragment shader | RefAnisotropicLight1SpecularTex |
A nice fur effect is obtained with at least 10 render passes.
| Vertex shader | RefTransFur |
| Fragment shader | RefUniColorTexFur |
Lighting and material has no influence on the fur effect.
| Appearance | Vertex shader | Fragment shader |
|---|---|---|
| m\_goochAppearance1 | RefTransLight1Gooch | RefGoochShading |
| m\_goochAppearance2 | RefTransScale | RefUniColor |
The Billboards should be rendered such that they cover the whole screen
Remember to set a [Candera::RenderOrder](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_render_order.html "Defines the order(sequence) in which nodes are rendered. Collaborates with Renderer. Must cover functional correctness (translucent/transparent objects after opaque/solid objects) as well as optimization-related orderings (sorting by state, defining a background bin for rendering without depth checks). Nodes are assigned to bins; all nodes in an "earlier" bin are rendered before all nodes in a "later" bin. Two default bins are defined and must not be deleted. The opaque bin, which is sorted from front to back (DistanceToCameraOrderCriterion), and the transparent bin, which is sorted from back to front (ReverseDistanceToCameraOrderCriterion). If a Node has no specific assignment to a render order bin, it will be automatically assigned by Candera either to opaque or transparent bin, according to its RenderMode::IsAlphaBlendingEnabled setting.") object for each scene.
The billboard from the Combine Scene uses two textures. When you set the textures be sure that the *texture unit* value is set to "0" for the texture corresponding to the camera 1. Analogous, the other texture will have the *texture unit* value set to "1".
The Billboards should be rendered such that they cover the whole screen
Remember to set a [Candera::RenderOrder](http://dev.doc.cgistudio.at/APILINK/class_candera_1_1_render_order.html "Defines the order(sequence) in which nodes are rendered. Collaborates with Renderer. Must cover functional correctness (translucent/transparent objects after opaque/solid objects) as well as optimization-related orderings (sorting by state, defining a background bin for rendering without depth checks). Nodes are assigned to bins; all nodes in an "earlier" bin are rendered before all nodes in a "later" bin. Two default bins are defined and must not be deleted. The opaque bin, which is sorted from front to back (DistanceToCameraOrderCriterion), and the transparent bin, which is sorted from back to front (ReverseDistanceToCameraOrderCriterion). If a Node has no specific assignment to a render order bin, it will be automatically assigned by Candera either to opaque or transparent bin, according to its RenderMode::IsAlphaBlendingEnabled setting.") object for each scene.
The billboard from the Combine Scene uses two textures. When you set the textures be sure that the *texture unit* value is set to "0" for the texture corresponding to the camera 1. Analogous, the other texture will have the *texture unit* value set to "1".
Ensure that this effect is supported by the device platform in use.
Ensure that this effect is supported by the device platform in use.
Ensure that this effect is supported by the device platform in use.
Ensure that this effect is supported by the device platform in use.
Ensure that this effect is supported by the device platform in use.
Ensure that this effect is supported by the device platform in use.
If the Player is started via SceneComposer plugin notification, it will be automatically started with the -l option.
| FEATSTD\_MONITOR\_TYPE | Enables or disables [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") Monitor component and [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") performance monitoring instrumentation macros. By default, [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") is configured to not include instrumentation on graphics engine level. | On / Off |
| FEATSTD\_MONITOR\_TCPIP\_ADDRESS FEATSTD\_MONITOR\_TCPIP\_PORT | If FEATSTD\_MONITOR\_TYPE is set to FEATSTD\_COM\_TYPE\_TCPIP , TCP/IP online connection to be established with Analyzer can be configured. Default: - localhost (127.0.0.1) - 13047 | TCP/IP Address and Port |
| FEATSTD\_MONITOR\_SERIALPORT\_ADDRESS FEATSTD\_MONITOR\_SERIALPORT\_BAUDRATE | If FEATSTD\_MONITOR\_TYPE is set to FEATSTD\_COM\_TYPE\_SERIALPORT , Serial port online connection to be established with Analyzer can be configured. Default: - empty - Baud: 9600 | Serial COM Port and Baudrate |
| CANDERA\_PERFORMANCE\_RECORDER\_DISABLED | Enables or disables [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") performance instrumentations. Default: Off | On / Off |
**Tip:** [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") Logging is also very useful to test individual parts of your code like if-cases or loops via:
``` Candera.LogInfo(message) ``` # Id Handling This chapter explains how to get access to other nodes via the id of their attached script. Therefore, create a new Scene Composer solution using the "3D Getting started" template, which includes a 3D model of a car. To start it's important to know that there are two functions that are fundamental to get access to other nodes:
**Tip:** Also check the Sample Solution for further information and scripts.
# Communication between Children #### How to find siblings This chapter explains how to get access to sibling nodes via the id of their attached script. Because there is yet no direct way to get the ids of sibling nodes you have to use a workaround. The recommended way is to use a script on a root node which tells its child nodes the ids or even the scripts of their siblings. The diagram beneath shows the car node in the center. Its script "CarRootController" finds the door scripts of its childnodes and pass them in form of an array to the scripts of its child nodes. Now each door node has access to the other door nodes.
**Tip:** Don't forget to add the new function to the public table! (see next step)
Next we need a public boolean which tells the script that the door should get opened. Afterwards this public value 'openDoor' will get modified by another door script. ``` return { Init = Init, Update = Update, GetName = GetName, openDoor = false, } ``` Now switch to the **Update-Function** to add following lines of code: ``` local function Update(self, id) if self.openDoor == true then -- get the current x- and z-rotation of the door and change the y-rotation to a proper value local pitch, yaw, roll = Candera.GetRotation(id) Candera.SetRotation(id, pitch, yaw, -30) -- now iterate over the array with the other door scripts stored in the public variable doorScripts --and change their openDoor boolean to true so they can get opened for i, otherDoorScript in ipairs(self.doorScripts) do otherDoorScript.openDoor = true end end end ``` However yet the public array doorScripts will be nil as a root node has to find all door scripts and save them to the public array of each script. Therefore add a new array called doorScripts to the public table... ``` return { Init = Init, Update = Update, GetName = GetName, openDoor = false, doorScripts ={} } ```Lua uses 'nil' as a kind non-value, to represent the absence of a useful value.
#### Root Script ... and switch to the CarRootController script to the **Init-Function** . To find the door scripts iterate over the array childIds, get the script of each id and store it to a array. Therefore add a local array called "doorScripts" to your CarRootController script. When all the door scripts are found iterate over the doorScripts array and store the local array of door scripts to the doorScripts array of each script: ``` for i, childId in ipairs(childIds) do local script = Candera.IdToScriptComponent[childId] if script and script.GetName() == "door" then table.insert(doorScripts, script) end end for i, doorScript in ipairs(doorScripts) do doorScript.doorScripts = doorScripts end ```Don't forget to set the openDoor value in the properties panel to true at least for one door script to test if the other doors will get opened.
**Tip:** don't forget to add the callback functions **OnDisable()** and **OnEnable()** to the public table so they can get called by [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]").
If you start the execution of the script system and disable the CarRootController script during runtime also the wheels should stop rotating. Furthermore if you enable the CarRootController again, the wheels start rotating and the steering lock switches. # Set Priority of Lua-Scripts #### Script Priority Another useful feature of Lua-Scripting is the priority. It defines in which order the scripts get called (f.e. the Update or the Init). To test this feature in its simplest way create four cubes and equip them with the same script called "SimpleLogInfo". ``` local function Init(self, id) Candera.LogInfo(self.logString) end return { Init = Init, logString = "logString" } ``` This script allows to enter an output string in the public table which will get written in the CanderaLogging panel. Now apply the script to each of the cubes and enter a proper log info to the public value "logString" in the Properties panel. The next step is to assign a priority value to each instance of the script:
**Tip:** for ordering script execution you can also use call-back functions. F.e. LateUpdate(self, id) is called every render frame after all Update callbacks.
# Tutorial for Asynchronous Asset-Loading # Asynchronous Asset-Loading #### Description This tutorial describes Asynchronous Asset-Loading and provides short examples on how to load a bitmap. #### Asynchronous Asset-Loading Asset Loading, especially reading from the asset repositories, can be a time consuming task, which blocks the CPU from further processing. This can even slow down rendering in certain cases. To improve this, asset loading requests can now be submitted as asynchronous jobs. These jobs can be done either in parallel on a separate thread, or interleaved with the rendering in smaller chunks. Whenever an asset is available, the main thread can retrieve it and add it to the render loop. #### How to activate this in the application For a [Courier](http://dev.doc.cgistudio.at/APILINK/namespace_courier.html) based application, the AsyncLoadReqMsg message can be used to load Views. For a [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]") based application, Async version of the asset loader methods can be used (see AsyncAssetProviderProxy and new ContentLoader methods). #### Number of threads for asynchronous asset loading To load the assets asynchronously in one single thread, the interface "AsyncAssetProviderProxy" can be used. It is available from any AssetProvider implementation via the AssetProvider::AsyncProxy() method. Using a second thread for async loading can be achieved by checking the CANDERA\_ASSETLOADER\_WORKER\_THREAD\_ENABLED in Cmake. AsyncRequests will be dispatched on the worker thread as soon as possible. For multithreaded async asset loading, the CMake flag CANDERA\_ASSETLOADER\_WORKER\_THREAD\_ENABLED specifies if the asynchronous asset load requests are handled on a dedicated thread or on the caller one. #### Upload Upload can be done asynchronously too, as ContentLoader::BuildSceneContextAsync can also upload to VRAM (depending on a parameter value). In this case, the single threaded variant must be used. #### Examples In the AsyncAssetProviderProxy, each Get\* (GetScene) function schedules a Get\* (GetSceneById) call on the AssetProvider that created the Proxy. In the case that CANDERA\_ASSETLOADER\_WROKER\_THREAD\_ENABLED flag is enabled in CMAKE, the AssetProvider::Get\* call will be dispatched on a separate thread and the result will be available as soon as the worker thread completes the dispatch. In the case that the above mentioned CMake option is disabled, one or more calls to DispatchNext() need to be performed on the current thread to assure that the request is dispatched. It is advised to call the DispatchNext() routine periodically during the Update part of the render loop of the application to ensure all asynchronous asset load requests are dispatched in a controlled and limited time. One option to call DispatchNext would be to introduce it in the LateUpdate part of the UpdateSystem provided by [Candera](http://dev.doc.cgistudio.at/APILINK/namespace_candera.html "[DataBinding_RefTypeSample]"). ``` AssetProvider* assetProvider = ContentLoader::GetInstance().GetAssetProvider(); if (assetProvider != 0) { UpdateSystem* updateSystem = EntityComponentSystem::EntitySystem::Get
