vulkanscenegraph/html/_const_visitor_8h_source.html

#pragma once


/* <editor-fold desc="MIT License">


Copyright(c) 2018 Robert Osfield


Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:


The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.


THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


</editor-fold> */


#include <vsg/core/Array.h>

#include <vsg/core/Array2D.h>

#include <vsg/core/Array3D.h>

#include <vsg/core/Mask.h>

#include <vsg/core/Value.h>


namespace vsg

{

    // forward declare core Objects

    class Objects;

    class External;

    class MipmapLayout;


    // forward declare node classes

    class Node;

    class Commands;

    class Group;

    class QuadGroup;

    class LOD;

    class PagedLOD;

    class StateGroup;

    class CullGroup;

    class CullNode;

    class Transform;

    class MatrixTransform;

    class CoordinateFrame;

    class Geometry;

    class VertexDraw;

    class VertexIndexDraw;

    class DepthSorted;

    class Layer;

    class Bin;

    class Switch;

    class Light;

    class AmbientLight;

    class DirectionalLight;

    class PointLight;

    class SpotLight;

    class InstrumentationNode;

    class RegionOfInterest;

    class InstanceNode;

    class InstanceDraw;

    class InstanceDrawIndexed;


    // forward declare text classes

    class Text;

    class TextGroup;

    class TextTechnique;

    class TextLayout;


    // forward declare animation classes

    class Animation;

    class AnimationGroup;

    class AnimationSampler;

    class JointSampler;

    class MorphSampler;

    class TransformSampler;

    class CameraSampler;

    class Joint;


    // forward declare vulkan classes

    class BufferInfo;

    class ImageInfo;

    class ImageView;

    class Image;

    class Compilable;

    class Command;

    class StateCommand;

    class StateSwitch;

    class CommandBuffer;

    class RenderPass;

    class BindDescriptorSet;

    class BindDescriptorSets;

    class BindViewDescriptorSets;

    class Descriptor;

    class DescriptorBuffer;

    class DescriptorImage;

    class DescriptorSet;

    class BindVertexBuffers;

    class BindIndexBuffer;

    class BindComputePipeline;

    class BindGraphicsPipeline;

    class BindRayTracingPipeline;

    class GraphicsPipeline;

    class ComputePipeline;

    class RayTracingPipeline;

    class Draw;

    class DrawIndexed;

    class ShaderStage;

    class GraphicsPipelineState;

    class VertexInputState;

    class InputAssemblyState;

    class TessellationState;

    class ViewportState;

    class RasterizationState;

    class MultisampleState;

    class DepthStencilState;

    class ColorBlendState;

    class DynamicState;

    class ResourceHints;

    class ClearAttachments;

    class ClearColorImage;

    class ClearDepthStencilImage;

    class QueryPool;

    class ResetQueryPool;

    class BeginQuery;

    class EndQuery;

    class WriteTimestamp;

    class CopyQueryPoolResults;


    // forward declare rtx classes

    class DrawMeshTasks;

    class DrawMeshTasksIndirect;

    class DrawMeshTasksIndirectCount;


    // forward declare ui events classes

    class UIEvent;

    class WindowEvent;

    class ExposeWindowEvent;

    class ConfigureWindowEvent;

    class CloseWindowEvent;

    class FocusInEvent;

    class FocusOutEvent;

    class KeyEvent;

    class KeyPressEvent;

    class KeyReleaseEvent;

    class PointerEvent;

    class ButtonPressEvent;

    class ButtonReleaseEvent;

    class MoveEvent;

    class TouchEvent;

    class TouchDownEvent;

    class TouchUpEvent;

    class TouchMoveEvent;

    class ScrollWheelEvent;

    class TerminateEvent;

    class FrameEvent;


    // forward declare util classes

    class ShaderCompileSettings;


    // forward declare viewer classes

    class Camera;

    class CommandGraph;

    class SecondaryCommandGraph;

    class RenderGraph;

    class View;

    class Viewer;

    class ViewMatrix;

    class LookAt;

    class LookDirection;

    class RelativeViewMatrix;

    class TrackingViewMatrix;

    class ProjectionMatrix;

    class Perspective;

    class Orthographic;

    class RelativeProjection;

    class EllipsoidPerspective;


    // forward declare general classes

    class FrameStamp;

    class Instrumentation;


    class VSG_DECLSPEC ConstVisitor : public Object

    {

    public:

        ConstVisitor();


        ConstVisitor(const ConstVisitor& rhs, const CopyOp& copyop = {}) :

            Object(rhs, copyop),

            traversalMask(rhs.traversalMask),

            overrideMask(rhs.overrideMask) {}


        Mask traversalMask = MASK_ALL;

        Mask overrideMask = MASK_OFF;


        virtual Instrumentation* getInstrumentation() { return nullptr; }


        virtual void apply(const Object&);

        virtual void apply(const Objects&);

        virtual void apply(const External&);

        virtual void apply(const Data&);

        virtual void apply(const MipmapLayout&);


        // Values

        virtual void apply(const stringValue&);

        virtual void apply(const wstringValue&);

        virtual void apply(const boolValue&);

        virtual void apply(const intValue&);

        virtual void apply(const uintValue&);

        virtual void apply(const floatValue&);

        virtual void apply(const doubleValue&);

        virtual void apply(const vec2Value&);

        virtual void apply(const vec3Value&);

        virtual void apply(const vec4Value&);

        virtual void apply(const dvec2Value&);

        virtual void apply(const dvec3Value&);

        virtual void apply(const dvec4Value&);

        virtual void apply(const bvec2Value&);

        virtual void apply(const bvec3Value&);

        virtual void apply(const bvec4Value&);

        virtual void apply(const ubvec2Value&);

        virtual void apply(const ubvec3Value&);

        virtual void apply(const ubvec4Value&);

        virtual void apply(const svec2Value&);

        virtual void apply(const svec3Value&);

        virtual void apply(const svec4Value&);

        virtual void apply(const usvec2Value&);

        virtual void apply(const usvec3Value&);

        virtual void apply(const usvec4Value&);

        virtual void apply(const ivec2Value&);

        virtual void apply(const ivec3Value&);

        virtual void apply(const ivec4Value&);

        virtual void apply(const uivec2Value&);

        virtual void apply(const uivec3Value&);

        virtual void apply(const uivec4Value&);

        virtual void apply(const mat2Value&);

        virtual void apply(const dmat2Value&);

        virtual void apply(const mat3Value&);

        virtual void apply(const dmat3Value&);

        virtual void apply(const mat4Value&);

        virtual void apply(const dmat4Value&);


        // Arrays

        virtual void apply(const stringArray&);

        virtual void apply(const byteArray&);

        virtual void apply(const ubyteArray&);

        virtual void apply(const shortArray&);

        virtual void apply(const ushortArray&);

        virtual void apply(const intArray&);

        virtual void apply(const uintArray&);

        virtual void apply(const floatArray&);

        virtual void apply(const doubleArray&);

        virtual void apply(const vec2Array&);

        virtual void apply(const vec3Array&);

        virtual void apply(const vec4Array&);

        virtual void apply(const dvec2Array&);

        virtual void apply(const dvec3Array&);

        virtual void apply(const dvec4Array&);

        virtual void apply(const bvec2Array&);

        virtual void apply(const bvec3Array&);

        virtual void apply(const bvec4Array&);

        virtual void apply(const svec2Array&);

        virtual void apply(const svec3Array&);

        virtual void apply(const svec4Array&);

        virtual void apply(const ivec2Array&);

        virtual void apply(const ivec3Array&);

        virtual void apply(const ivec4Array&);

        virtual void apply(const ubvec2Array&);

        virtual void apply(const ubvec3Array&);

        virtual void apply(const ubvec4Array&);

        virtual void apply(const usvec2Array&);

        virtual void apply(const usvec3Array&);

        virtual void apply(const usvec4Array&);

        virtual void apply(const uivec2Array&);

        virtual void apply(const uivec3Array&);

        virtual void apply(const uivec4Array&);

        virtual void apply(const mat4Array&);

        virtual void apply(const dmat4Array&);

        virtual void apply(const block64Array&);

        virtual void apply(const block128Array&);


        // Array2Ds

        virtual void apply(const byteArray2D&);

        virtual void apply(const ubyteArray2D&);

        virtual void apply(const shortArray2D&);

        virtual void apply(const ushortArray2D&);

        virtual void apply(const intArray2D&);

        virtual void apply(const uintArray2D&);

        virtual void apply(const floatArray2D&);

        virtual void apply(const doubleArray2D&);

        virtual void apply(const vec2Array2D&);

        virtual void apply(const vec3Array2D&);

        virtual void apply(const vec4Array2D&);

        virtual void apply(const dvec2Array2D&);

        virtual void apply(const dvec3Array2D&);

        virtual void apply(const dvec4Array2D&);

        virtual void apply(const bvec2Array2D&);

        virtual void apply(const bvec3Array2D&);

        virtual void apply(const bvec4Array2D&);

        virtual void apply(const svec2Array2D&);

        virtual void apply(const svec3Array2D&);

        virtual void apply(const svec4Array2D&);

        virtual void apply(const ivec2Array2D&);

        virtual void apply(const ivec3Array2D&);

        virtual void apply(const ivec4Array2D&);

        virtual void apply(const ubvec2Array2D&);

        virtual void apply(const ubvec3Array2D&);

        virtual void apply(const ubvec4Array2D&);

        virtual void apply(const usvec2Array2D&);

        virtual void apply(const usvec3Array2D&);

        virtual void apply(const usvec4Array2D&);

        virtual void apply(const uivec2Array2D&);

        virtual void apply(const uivec3Array2D&);

        virtual void apply(const uivec4Array2D&);

        virtual void apply(const block64Array2D&);

        virtual void apply(const block128Array2D&);


        // Array3Ds

        virtual void apply(const byteArray3D&);

        virtual void apply(const ubyteArray3D&);

        virtual void apply(const shortArray3D&);

        virtual void apply(const ushortArray3D&);

        virtual void apply(const intArray3D&);

        virtual void apply(const uintArray3D&);

        virtual void apply(const floatArray3D&);

        virtual void apply(const doubleArray3D&);

        virtual void apply(const vec2Array3D&);

        virtual void apply(const vec3Array3D&);

        virtual void apply(const vec4Array3D&);

        virtual void apply(const dvec2Array3D&);

        virtual void apply(const dvec3Array3D&);

        virtual void apply(const dvec4Array3D&);

        virtual void apply(const ubvec2Array3D&);

        virtual void apply(const ubvec3Array3D&);

        virtual void apply(const ubvec4Array3D&);

        virtual void apply(const block64Array3D&);

        virtual void apply(const block128Array3D&);


        // Nodes

        virtual void apply(const Node&);

        virtual void apply(const Compilable&);

        virtual void apply(const Commands&);

        virtual void apply(const Group&);

        virtual void apply(const QuadGroup&);

        virtual void apply(const LOD&);

        virtual void apply(const PagedLOD&);

        virtual void apply(const StateGroup&);

        virtual void apply(const CullGroup&);

        virtual void apply(const CullNode&);

        virtual void apply(const Transform&);

        virtual void apply(const MatrixTransform&);

        virtual void apply(const CoordinateFrame&);

        virtual void apply(const Geometry&);

        virtual void apply(const VertexDraw&);

        virtual void apply(const VertexIndexDraw&);

        virtual void apply(const DepthSorted&);

        virtual void apply(const Layer&);

        virtual void apply(const Bin&);

        virtual void apply(const Switch&);

        virtual void apply(const Light&);

        virtual void apply(const AmbientLight&);

        virtual void apply(const DirectionalLight&);

        virtual void apply(const PointLight&);

        virtual void apply(const SpotLight&);

        virtual void apply(const InstrumentationNode&);

        virtual void apply(const RegionOfInterest&);

        virtual void apply(const InstanceNode&);

        virtual void apply(const InstanceDraw&);

        virtual void apply(const InstanceDrawIndexed&);


        // text

        virtual void apply(const Text&);

        virtual void apply(const TextGroup&);

        virtual void apply(const TextTechnique&);

        virtual void apply(const TextLayout&);


        // animation

        virtual void apply(const Animation&);

        virtual void apply(const AnimationGroup&);

        virtual void apply(const AnimationSampler&);

        virtual void apply(const JointSampler&);

        virtual void apply(const MorphSampler&);

        virtual void apply(const TransformSampler&);

        virtual void apply(const CameraSampler&);

        virtual void apply(const Joint&);


        // Vulkan nodes

        virtual void apply(const BufferInfo&);

        virtual void apply(const ImageInfo&);

        virtual void apply(const ImageView&);

        virtual void apply(const Image&);

        virtual void apply(const Command&);

        virtual void apply(const StateCommand&);

        virtual void apply(const StateSwitch&);

        virtual void apply(const CommandBuffer&);

        virtual void apply(const RenderPass&);

        virtual void apply(const BindDescriptorSet&);

        virtual void apply(const BindDescriptorSets&);

        virtual void apply(const BindViewDescriptorSets&);

        virtual void apply(const Descriptor&);

        virtual void apply(const DescriptorBuffer&);

        virtual void apply(const DescriptorImage&);

        virtual void apply(const DescriptorSet&);

        virtual void apply(const BindVertexBuffers&);

        virtual void apply(const BindIndexBuffer&);

        virtual void apply(const BindComputePipeline&);

        virtual void apply(const BindGraphicsPipeline&);

        virtual void apply(const BindRayTracingPipeline&);

        virtual void apply(const GraphicsPipeline&);

        virtual void apply(const ComputePipeline&);

        virtual void apply(const RayTracingPipeline&);

        virtual void apply(const GraphicsPipelineState&);

        virtual void apply(const ShaderStage&);

        virtual void apply(const VertexInputState&);

        virtual void apply(const InputAssemblyState&);

        virtual void apply(const TessellationState&);

        virtual void apply(const ViewportState&);

        virtual void apply(const RasterizationState&);

        virtual void apply(const MultisampleState&);

        virtual void apply(const DepthStencilState&);

        virtual void apply(const ColorBlendState&);

        virtual void apply(const DynamicState&);

        virtual void apply(const ResourceHints&);

        virtual void apply(const Draw&);

        virtual void apply(const DrawIndexed&);

        virtual void apply(const ClearAttachments&);

        virtual void apply(const ClearColorImage&);

        virtual void apply(const ClearDepthStencilImage&);

        virtual void apply(const QueryPool&);

        virtual void apply(const ResetQueryPool&);

        virtual void apply(const BeginQuery&);

        virtual void apply(const EndQuery&);

        virtual void apply(const WriteTimestamp&);

        virtual void apply(const CopyQueryPoolResults&);


        // mesh shading classes

        virtual void apply(const DrawMeshTasks&);

        virtual void apply(const DrawMeshTasksIndirect&);

        virtual void apply(const DrawMeshTasksIndirectCount&);


        // ui events

        virtual void apply(const UIEvent&);

        virtual void apply(const WindowEvent&);

        virtual void apply(const ExposeWindowEvent&);

        virtual void apply(const ConfigureWindowEvent&);

        virtual void apply(const CloseWindowEvent&);

        virtual void apply(const FocusInEvent&);

        virtual void apply(const FocusOutEvent&);

        virtual void apply(const KeyEvent&);

        virtual void apply(const KeyPressEvent&);

        virtual void apply(const KeyReleaseEvent&);

        virtual void apply(const PointerEvent&);

        virtual void apply(const ButtonPressEvent&);

        virtual void apply(const ButtonReleaseEvent&);

        virtual void apply(const MoveEvent&);

        virtual void apply(const TouchEvent&);

        virtual void apply(const TouchDownEvent&);

        virtual void apply(const TouchUpEvent&);

        virtual void apply(const TouchMoveEvent&);

        virtual void apply(const ScrollWheelEvent&);

        virtual void apply(const TerminateEvent&);

        virtual void apply(const FrameEvent&);


        // utils

        virtual void apply(const ShaderCompileSettings&);


        // viewer

        virtual void apply(const Camera&);

        virtual void apply(const CommandGraph&);

        virtual void apply(const SecondaryCommandGraph&);

        virtual void apply(const RenderGraph&);

        virtual void apply(const View&);

        virtual void apply(const Viewer&);

        virtual void apply(const ViewMatrix&);

        virtual void apply(const LookAt&);

        virtual void apply(const LookDirection&);

        virtual void apply(const RelativeViewMatrix&);

        virtual void apply(const TrackingViewMatrix&);

        virtual void apply(const ProjectionMatrix&);

        virtual void apply(const Perspective&);

        virtual void apply(const Orthographic&);

        virtual void apply(const RelativeProjection&);

        virtual void apply(const EllipsoidPerspective&);


        // general classes

        virtual void apply(const FrameStamp&);


        bool is_compatible(const std::type_info& type) const noexcept override { return typeid(ConstVisitor) == type || Object::is_compatible(type); }

    };


    // provide Value<>::accept() implementation

    template<typename T>

    void Value<T>::accept(ConstVisitor& visitor) const { visitor.apply(*this); }


    // provide Array<>::accept() implementation

    template<typename T>

    void Array<T>::accept(ConstVisitor& visitor) const { visitor.apply(*this); }


    // provide Array2D<>::accept() implementation

    template<typename T>

    void Array2D<T>::accept(ConstVisitor& visitor) const { visitor.apply(*this); }


    // provide Array3D<>::accept() implementation

    template<typename T>

    void Array3D<T>::accept(ConstVisitor& visitor) const { visitor.apply(*this); }


} // namespace vsg

vsg::AmbientLight
AmbientLight represents an ambient light source.
Definition AmbientLight.h:24

vsg::AnimationGroup
AnimationGroup node provides a list of child nodes and a list of animations to animate them.
Definition AnimationGroup.h:24

vsg::Animation
Animation class that controls a single animation made up of one more samplers.
Definition Animation.h:44

vsg::AnimationSampler
Base class for animation samplers that sample animation data and set associated scene graph objects.
Definition Animation.h:24

vsg::BeginQuery
BeginQuery command encapsulates vkCmdBeginQuery call and associated functionality.
Definition BeginQuery.h:22

vsg::Bin
Definition Bin.h:24

vsg::BindComputePipeline
BindComputePipeline state command encapsulates the vkCmdBindPipeline call for a ComputePipeline.
Definition ComputePipeline.h:65

vsg::BindDescriptorSet
Definition BindDescriptorSet.h:92

vsg::BindDescriptorSets
BindDescriptorSets state command encapsulates vkCmdBindDescriptorSets call and associated settings fo...
Definition BindDescriptorSet.h:25

vsg::BindGraphicsPipeline
BindGraphicsPipeline state command encapsulates the vkCmdBindPipeline call for a GraphicsPipeline.
Definition GraphicsPipeline.h:111

vsg::BindIndexBuffer
BindIndexBuffer command encapsulates vkCmdBindIndexBuffer call and associated settings.
Definition BindIndexBuffer.h:28

vsg::BindRayTracingPipeline
BindRayTracingPipeline state command encapsulates vkCmdBindPipeline for a RayTracingPipeline.
Definition RayTracingPipeline.h:85

vsg::BindVertexBuffers
BindVertexBuffers command encapsulates vkCmdBindVertexBuffers call and associated settings.
Definition BindVertexBuffers.h:25

vsg::BindViewDescriptorSets
Definition ViewDependentState.h:54

vsg::BufferInfo
BufferInfo encapsulates the settings that map to VkDescriptorBufferInfo.
Definition BufferInfo.h:27

vsg::ButtonPressEvent
ButtonPressEvent represents a button press event.
Definition PointerEvent.h:55

vsg::ButtonReleaseEvent
ButtonReleaseEvent represents a button release event.
Definition PointerEvent.h:72

vsg::Camera
Definition Camera.h:27

vsg::CameraSampler
Animation sampler for sampling position, rotation and scale keyframes for setting camera view and pro...
Definition CameraSampler.h:111

vsg::ClearAttachments
ClearAttachments command encapsulates vkCmdClearAttachments functionality and associated settings.
Definition ClearAttachments.h:22

vsg::ClearColorImage
ClearColorImage command encapsulates vkCmdClearColorImage functionality and associated settings.
Definition ClearImage.h:23

vsg::ClearDepthStencilImage
ClearDepthStencilImage command encapsulates vkCmdClearDepthStencilImage functionality and associated ...
Definition ClearImage.h:38

vsg::CloseWindowEvent
CloseWindowEvent represents a window close event.
Definition WindowEvent.h:87

vsg::ColorBlendState
ColorBlendState encapsulates VkPipelineColorBlendStateCreateInfo settings passed when setting up Grap...
Definition ColorBlendState.h:22

vsg::CommandBuffer
CommandBuffer encapsulates VkCommandBuffer.
Definition CommandBuffer.h:30

vsg::CommandGraph
CommandGraph is a group node that sits at the top of the scene graph and manages the recording of its...
Definition CommandGraph.h:28

vsg::Command
Command base class for encapsulating vkCmd* calls and associated settings.
Definition Command.h:23

vsg::Commands
Definition Commands.h:29

vsg::Compilable
Base class for encapsulating nodes that have Vulkan objects associated with them that will need compi...
Definition Compilable.h:23

vsg::ComputePipeline
ComputePipeline encapsulates compute VkPipeline and the VkComputePipelineCreateInfo settings used to ...
Definition ComputePipeline.h:24

vsg::ConfigureWindowEvent
ConfigureWindowEvent represents a window configure event - such as changes to the size of the window.
Definition WindowEvent.h:64

vsg::ConstVisitor
Definition ConstVisitor.h:179

vsg::CoordinateFrame
CoordinateFrame provides support for astronomically large coordinates.
Definition CoordinateFrame.h:22

vsg::CopyOp
Definition Object.h:42

vsg::CopyQueryPoolResults
CopyQueryPoolResults commands encapsulates vkCmdCopyQueryPoolResults and associated settings.
Definition CopyQueryPoolResults.h:23

vsg::CullGroup
CullNode that enables view frustum culling on a list of children.
Definition CullGroup.h:23

vsg::CullNode
Definition CullNode.h:25

vsg::Data
Definition Data.h:115

vsg::DepthSorted
Definition DepthSorted.h:27

vsg::DepthStencilState
DepthStencilState encapsulates VkPipelineDepthStencilStateCreateInfo settings passed when setting up ...
Definition DepthStencilState.h:22

vsg::DescriptorBuffer
Definition DescriptorBuffer.h:24

vsg::Descriptor
Definition Descriptor.h:26

vsg::DescriptorImage
Definition DescriptorImage.h:24

vsg::DescriptorSet
DescriptorSet encapsulates VkDescriptorSet and VkDescriptorSetAllocateInfo settings used to describe ...
Definition DescriptorSet.h:26

vsg::DirectionalLight
DirectionalLight represents a directional light source - used for light sources that are treated as i...
Definition DirectionalLight.h:24

vsg::Draw
Draw command encapsulates vkCmdDraw call and associated settings.
Definition Draw.h:24

vsg::DrawIndexed
DrawIndexed command encapsulates vkCmdDrawIndexed call and associated settings.
Definition DrawIndexed.h:24

vsg::DrawMeshTasks
Definition DrawMeshTasks.h:22

vsg::DrawMeshTasksIndirectCount
DrawMeshTasksIndirectCount command encapsulates vkCmdDrawMeshTasksIndirectCountEXT call and associate...
Definition DrawMeshTasksIndirectCount.h:23

vsg::DrawMeshTasksIndirect
DrawMeshTasksIndirect command encapsulates vkCmdDrawMeshTasksIndirectEXT call and associated paramete...
Definition DrawMeshTasksIndirect.h:23

vsg::DynamicState
Definition DynamicState.h:23

vsg::EllipsoidPerspective
Definition ProjectionMatrix.h:190

vsg::EndQuery
encapsulation of vkCmdEndQuery
Definition EndQuery.h:22

vsg::ExposeWindowEvent
ExposeWindowEvent represents a window expose event.
Definition WindowEvent.h:41

vsg::External
Definition External.h:31

vsg::FocusInEvent
FocusInEvent represents a window acquiring focus event.
Definition WindowEvent.h:98

vsg::FocusOutEvent
FocusOutEvent represents a window losing focus event.
Definition WindowEvent.h:109

vsg::FrameEvent
Definition ApplicationEvent.h:37

vsg::FrameStamp
FrameStamp represents the time and frame count of a specific frame.
Definition FrameStamp.h:22

vsg::Geometry
Definition Geometry.h:30

vsg::GraphicsPipeline
GraphicsPipeline encapsulates graphics VkPipeline and the VkGraphicsPipelineCreateInfo settings used ...
Definition GraphicsPipeline.h:57

vsg::GraphicsPipelineState
Definition GraphicsPipeline.h:29

vsg::Group
Group node provides a list of children.
Definition Group.h:24

vsg::Image
Image class encapsulates VkImage and VkImageCreateInfo settings used to set it up.
Definition Image.h:25

vsg::ImageInfo
ImageInfo class provides the VkDescriptorImageInfo settings used when setting up vsg::/vkDescriptorIm...
Definition ImageInfo.h:23

vsg::ImageView
ImageView class encapsulates VkImageView and VkImageViewCreateInfo settings used to set it up.
Definition ImageView.h:25

vsg::InputAssemblyState
InputAssemblyState encapsulates VkPipelineInputAssemblyStateCreateInfo settings passed when setting u...
Definition InputAssemblyState.h:22

vsg::InstanceDraw
Definition InstanceDraw.h:25

vsg::InstanceDrawIndexed
Definition InstanceDrawIndexed.h:25

vsg::InstanceNode
Definition InstanceNode.h:34

vsg::Instrumentation
base class for Instrumentation implementations
Definition Instrumentation.h:51

vsg::InstrumentationNode
InstrumentationNode enables instrumentation of a subgraph.
Definition InstrumentationNode.h:24

vsg::Joint
Definition Joint.h:22

vsg::JointSampler
Animation sampler for accumulating vsg::Joint hierarchies and assigned accumulated transform matrices...
Definition JointSampler.h:23

vsg::KeyEvent
KeyEvent is a base class for key events.
Definition KeyEvent.h:286

vsg::KeyPressEvent
KeyPressEvent represents a key press event.
Definition KeyEvent.h:309

vsg::KeyReleaseEvent
KeyReleaseEvent represents a key release event.
Definition KeyEvent.h:320

vsg::LOD
Definition LOD.h:33

vsg::Layer
Layer node is used to control which bin to place the subgraph in and what sort value to assign.
Definition Layer.h:23

vsg::Light
Definition Light.h:26

vsg::LookAt
LookAt is a ViewMatrix that implements the gluLookAt model for specifying the view matrix.
Definition ViewMatrix.h:54

vsg::LookDirection
LookDirection is a ViewMatrix that uses a position and rotation to set the view matrix.
Definition ViewMatrix.h:108

vsg::MatrixTransform
Definition MatrixTransform.h:24

vsg::MipmapLayout
Definition MipmapLayout.h:24

vsg::MorphSampler
Animation sampler for morphing geometry, implementation not yet completed.
Definition MorphSampler.h:48

vsg::MoveEvent
MoveEvent represents a pointer move event.
Definition PointerEvent.h:89

vsg::MultisampleState
MultisampleState encapsulates VkPipelineMultisampleStateCreateInfo settings passed when setting up Gr...
Definition MultisampleState.h:22

vsg::Node
Definition Node.h:24

vsg::Objects
Simple container class that has a list of vsg::Object as children.
Definition Objects.h:25

vsg::Orthographic
Orthographic is a ProjectionMatrix that implements the glOrtho model for setting the projection matri...
Definition ProjectionMatrix.h:102

vsg::PagedLOD
Definition PagedLOD.h:36

vsg::Perspective
Perspective is a ProjectionMatrix that implements the gluPerspective model for setting the projection...
Definition ProjectionMatrix.h:50

vsg::PointLight
PointLight represents a local point light source where all light radiants event from the light positi...
Definition PointLight.h:24

vsg::PointerEvent
PointerEvent is a base class for mouse pointer events.
Definition PointerEvent.h:34

vsg::ProjectionMatrix
ProjectionMatrix is a base class for specifying the Camera projection matrix and its inverse.
Definition ProjectionMatrix.h:24

vsg::QuadGroup
Definition QuadGroup.h:29

vsg::QueryPool
QueryPool encapsulates the VkQueryPool and the VkQueryPoolCreateInfo settings used to set it up.
Definition QueryPool.h:23

vsg::RasterizationState
RasterizationState encapsulates VkPipelineRasterizationStateCreateInfo settings passed when setting u...
Definition RasterizationState.h:22

vsg::RayTracingPipeline
Definition RayTracingPipeline.h:26

vsg::RegionOfInterest
RegionOfInterest node is inform applications/algorithms extents that should take account of.
Definition RegionOfInterest.h:23

vsg::RelativeProjection
RelativeProjection is a ProjectionMatrix that decorates another ProjectionMatrix and pre-multiplies i...
Definition ProjectionMatrix.h:162

vsg::RelativeViewMatrix
RelativeViewMatrix is a ViewMatrix that decorates another ViewMatrix and pre-multiplies its transform...
Definition ViewMatrix.h:136

vsg::RenderGraph
Definition RenderGraph.h:29

vsg::RenderPass
RenderPass encapsulation of VkRenderPass.
Definition RenderPass.h:86

vsg::ResetQueryPool
ResetQueryPool command encapsulates vkCmdResetQueryPool functionality.
Definition ResetQueryPool.h:23

vsg::ResourceHints
ResourceHints provides settings that help preallocation of Vulkan resources and memory.
Definition ResourceHints.h:35

vsg::ScrollWheelEvent
ScrollWheelEvent represents a scroll wheel event.
Definition ScrollWheelEvent.h:22

vsg::SecondaryCommandGraph
SecondaryCommandGraph is a specialization of CommandGraph that provides Vulkan secondary command buff...
Definition SecondaryCommandGraph.h:25

vsg::ShaderCompileSettings
Definition ShaderModule.h:28

vsg::ShaderStage
ShaderStage encapsulates VkPipelineShaderStageCreateInfo settings passed when setting up GraphicsPipe...
Definition ShaderStage.h:24

vsg::SpotLight
SpotLight represents a local point light source whose intensity varies as a spot light.
Definition SpotLight.h:24

vsg::StateCommand
Definition StateCommand.h:24

vsg::StateGroup
Definition StateGroup.h:32

vsg::StateSwitch
Definition StateSwitch.h:22

vsg::Switch
Switch node for toggling on/off recording of children.
Definition Switch.h:25

vsg::TerminateEvent
TerminateEvent represents an application termination event.
Definition ApplicationEvent.h:24

vsg::TessellationState
TessellationState encapsulates VkPipelineTessellationStateCreateInfo settings passed when setting up ...
Definition TessellationState.h:22

vsg::TextGroup
Definition TextGroup.h:27

vsg::Text
Definition Text.h:30

vsg::TextLayout
Definition TextLayout.h:35

vsg::TextTechnique
Definition TextTechnique.h:25

vsg::TouchDownEvent
TouchDownEvent represents a touch down event.
Definition TouchEvent.h:45

vsg::TouchEvent
TouchEvent is a base class for touch events.
Definition TouchEvent.h:24

vsg::TouchMoveEvent
TouchMoveEvent represents a touch move event.
Definition TouchEvent.h:67

vsg::TouchUpEvent
TouchUpEvent represents a touch up event.
Definition TouchEvent.h:56

vsg::TrackingViewMatrix
Definition ViewMatrix.h:156

vsg::Transform
Transform node is a pure virtual base class for positioning/scaling/rotating subgraphs.
Definition Transform.h:22

vsg::TransformSampler
Animation sampler for sampling position, rotation and scale keyframes for setting transforms/joints.
Definition TransformSampler.h:70

vsg::UIEvent
UIEvent is a base class for user interface events.
Definition UIEvent.h:28

vsg::VertexDraw
Definition VertexDraw.h:25

vsg::VertexIndexDraw
Definition VertexIndexDraw.h:25

vsg::VertexInputState
VertexInputState encapsulates VkPipelineVertexInputStateCreateInfo settings passed when setting up Gr...
Definition VertexInputState.h:22

vsg::View
View is a Group class that pairs a Camera that defines the view with a subgraph that defines the scen...
Definition View.h:36

vsg::ViewMatrix
ViewMatrix is a base class for specifying the Camera view matrix and its inverse.
Definition ViewMatrix.h:23

vsg::Viewer
Definition Viewer.h:33

vsg::ViewportState
ViewportState encapsulates VkPipelineViewportStateCreateInfo settings passed when setting up Graphics...
Definition ViewportState.h:24

vsg::WindowEvent
WindowEvent is the base class for events related to a window.
Definition WindowEvent.h:24

vsg::WriteTimestamp
WriteTimestamp command encapsulates vkCmdWriteTimestamp call and settings passed to it.
Definition WriteTimestamp.h:22