VulkanSceneGraph/html/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;


     // forward declare nodes classes

     class Node;

     class Commands;

     class Group;

     class QuadGroup;

     class LOD;

     class PagedLOD;

     class StateGroup;

     class CullGroup;

     class CullNode;

     class MatrixTransform;

     class Transform;

     class Geometry;

     class VertexDraw;

     class VertexIndexDraw;

     class DepthSorted;

     class Bin;

     class Switch;

     class Light;

     class AmbientLight;

     class DirectionalLight;

     class PointLight;

     class SpotLight;


     // forward declare vulkan classes

     class Text;

     class TextGroup;

     class TextTechnique;

     class TextLayout;


     // forward declare vulkan classes

     class BufferInfo;

     class Command;

     class StateCommand;

     class StateSwitch;

     class CommandBuffer;

     class RenderPass;

     class BindDescriptorSet;

     class BindDescriptorSets;

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


     // forward declare viewer classes

     class Camera;

     class CommandGraph;

     class RenderGraph;

     class View;

     class Viewer;


     // forward declare general classes

     class FrameStamp;


     class VSG_DECLSPEC Visitor : public Object

     {

     public:

         Visitor();


         Mask traversalMask = MASK_ALL;

         Mask overrideMask = MASK_OFF;


         virtual void apply(Object&);

         virtual void apply(Objects&);

         virtual void apply(External&);

         virtual void apply(Data&);


         // Values

         virtual void apply(stringValue&);

         virtual void apply(boolValue&);

         virtual void apply(intValue&);

         virtual void apply(uintValue&);

         virtual void apply(floatValue&);

         virtual void apply(doubleValue&);

         virtual void apply(vec2Value&);

         virtual void apply(vec4Value&);

         virtual void apply(vec3Value&);

         virtual void apply(dvec2Value&);

         virtual void apply(dvec3Value&);

         virtual void apply(dvec4Value&);

         virtual void apply(bvec2Value&);

         virtual void apply(bvec3Value&);

         virtual void apply(bvec4Value&);

         virtual void apply(ubvec2Value&);

         virtual void apply(ubvec3Value&);

         virtual void apply(ubvec4Value&);

         virtual void apply(svec2Value&);

         virtual void apply(svec3Value&);

         virtual void apply(svec4Value&);

         virtual void apply(usvec2Value&);

         virtual void apply(usvec3Value&);

         virtual void apply(usvec4Value&);

         virtual void apply(ivec2Value&);

         virtual void apply(ivec3Value&);

         virtual void apply(ivec4Value&);

         virtual void apply(uivec2Value&);

         virtual void apply(uivec3Value&);

         virtual void apply(uivec4Value&);


         // Arrays

         virtual void apply(byteArray&);

         virtual void apply(ubyteArray&);

         virtual void apply(shortArray&);

         virtual void apply(ushortArray&);

         virtual void apply(intArray&);

         virtual void apply(uintArray&);

         virtual void apply(floatArray&);

         virtual void apply(doubleArray&);

         virtual void apply(vec2Array&);

         virtual void apply(vec3Array&);

         virtual void apply(vec4Array&);

         virtual void apply(dvec2Array&);

         virtual void apply(dvec3Array&);

         virtual void apply(dvec4Array&);

         virtual void apply(bvec2Array&);

         virtual void apply(bvec3Array&);

         virtual void apply(bvec4Array&);

         virtual void apply(svec2Array&);

         virtual void apply(svec3Array&);

         virtual void apply(svec4Array&);

         virtual void apply(ivec2Array&);

         virtual void apply(ivec3Array&);

         virtual void apply(ivec4Array&);

         virtual void apply(ubvec2Array&);

         virtual void apply(ubvec3Array&);

         virtual void apply(ubvec4Array&);

         virtual void apply(usvec2Array&);

         virtual void apply(usvec3Array&);

         virtual void apply(usvec4Array&);

         virtual void apply(uivec2Array&);

         virtual void apply(uivec3Array&);

         virtual void apply(uivec4Array&);

         virtual void apply(mat4Array&);

         virtual void apply(dmat4Array&);

         virtual void apply(block64Array&);

         virtual void apply(block128Array&);


         // Array2Ds

         virtual void apply(ubyteArray2D&);

         virtual void apply(ushortArray2D&);

         virtual void apply(uintArray2D&);

         virtual void apply(floatArray2D&);

         virtual void apply(doubleArray2D&);

         virtual void apply(vec2Array2D&);

         virtual void apply(vec3Array2D&);

         virtual void apply(vec4Array2D&);

         virtual void apply(dvec2Array2D&);

         virtual void apply(dvec3Array2D&);

         virtual void apply(dvec4Array2D&);

         virtual void apply(bvec2Array2D&);

         virtual void apply(bvec3Array2D&);

         virtual void apply(bvec4Array2D&);

         virtual void apply(svec2Array2D&);

         virtual void apply(svec3Array2D&);

         virtual void apply(svec4Array2D&);

         virtual void apply(ivec2Array2D&);

         virtual void apply(ivec3Array2D&);

         virtual void apply(ivec4Array2D&);

         virtual void apply(ubvec2Array2D&);

         virtual void apply(ubvec3Array2D&);

         virtual void apply(ubvec4Array2D&);

         virtual void apply(usvec2Array2D&);

         virtual void apply(usvec3Array2D&);

         virtual void apply(usvec4Array2D&);

         virtual void apply(uivec2Array2D&);

         virtual void apply(uivec3Array2D&);

         virtual void apply(uivec4Array2D&);

         virtual void apply(block64Array2D&);

         virtual void apply(block128Array2D&);


         // Array3Ds

         virtual void apply(ubyteArray3D&);

         virtual void apply(ushortArray3D&);

         virtual void apply(uintArray3D&);

         virtual void apply(floatArray3D&);

         virtual void apply(doubleArray3D&);

         virtual void apply(vec2Array3D&);

         virtual void apply(vec3Array3D&);

         virtual void apply(vec4Array3D&);

         virtual void apply(dvec2Array3D&);

         virtual void apply(dvec3Array3D&);

         virtual void apply(dvec4Array3D&);

         virtual void apply(ubvec2Array3D&);

         virtual void apply(ubvec3Array3D&);

         virtual void apply(ubvec4Array3D&);

         virtual void apply(block64Array3D&);

         virtual void apply(block128Array3D&);


         // Nodes

         virtual void apply(Node&);

         virtual void apply(Commands&);

         virtual void apply(Group&);

         virtual void apply(QuadGroup&);

         virtual void apply(LOD&);

         virtual void apply(PagedLOD&);

         virtual void apply(StateGroup&);

         virtual void apply(CullGroup&);

         virtual void apply(CullNode&);

         virtual void apply(MatrixTransform&);

         virtual void apply(Transform&);

         virtual void apply(Geometry&);

         virtual void apply(VertexDraw&);

         virtual void apply(VertexIndexDraw&);

         virtual void apply(DepthSorted&);

         virtual void apply(Bin&);

         virtual void apply(Switch&);

         virtual void apply(Light&);

         virtual void apply(AmbientLight&);

         virtual void apply(DirectionalLight&);

         virtual void apply(PointLight&);

         virtual void apply(SpotLight&);


         // text

         virtual void apply(Text&);

         virtual void apply(TextGroup&);

         virtual void apply(TextTechnique&);

         virtual void apply(TextLayout&);


         // Vulkan nodes

         virtual void apply(BufferInfo&);

         virtual void apply(Command&);

         virtual void apply(StateCommand&);

         virtual void apply(StateSwitch&);

         virtual void apply(CommandBuffer&);

         virtual void apply(RenderPass&);

         virtual void apply(BindDescriptorSet&);

         virtual void apply(BindDescriptorSets&);

         virtual void apply(Descriptor&);

         virtual void apply(DescriptorBuffer&);

         virtual void apply(DescriptorImage&);

         virtual void apply(DescriptorSet&);

         virtual void apply(BindVertexBuffers&);

         virtual void apply(BindIndexBuffer&);

         virtual void apply(BindComputePipeline&);

         virtual void apply(BindGraphicsPipeline&);

         virtual void apply(BindRayTracingPipeline&);

         virtual void apply(GraphicsPipeline&);

         virtual void apply(ComputePipeline&);

         virtual void apply(RayTracingPipeline&);

         virtual void apply(GraphicsPipelineState&);

         virtual void apply(ShaderStage&);

         virtual void apply(VertexInputState&);

         virtual void apply(InputAssemblyState&);

         virtual void apply(TessellationState&);

         virtual void apply(ViewportState&);

         virtual void apply(RasterizationState&);

         virtual void apply(MultisampleState&);

         virtual void apply(DepthStencilState&);

         virtual void apply(ColorBlendState&);

         virtual void apply(DynamicState&);

         virtual void apply(ResourceHints&);

         virtual void apply(Draw&);

         virtual void apply(DrawIndexed&);

         virtual void apply(ClearAttachments&);

         virtual void apply(QueryPool&);

         virtual void apply(ResetQueryPool&);

         virtual void apply(BeginQuery&);

         virtual void apply(EndQuery&);

         virtual void apply(WriteTimestamp&);

         virtual void apply(CopyQueryPoolResults&);


         // mesh shading classes

         virtual void apply(DrawMeshTasks&);

         virtual void apply(DrawMeshTasksIndirect&);

         virtual void apply(DrawMeshTasksIndirectCount&);


         // ui events

         virtual void apply(UIEvent&);

         virtual void apply(WindowEvent&);

         virtual void apply(ExposeWindowEvent&);

         virtual void apply(ConfigureWindowEvent&);

         virtual void apply(CloseWindowEvent&);

         virtual void apply(KeyEvent&);

         virtual void apply(KeyPressEvent&);

         virtual void apply(KeyReleaseEvent&);

         virtual void apply(PointerEvent&);

         virtual void apply(ButtonPressEvent&);

         virtual void apply(ButtonReleaseEvent&);

         virtual void apply(MoveEvent&);

         virtual void apply(TouchEvent&);

         virtual void apply(TouchDownEvent&);

         virtual void apply(TouchUpEvent&);

         virtual void apply(TouchMoveEvent&);

         virtual void apply(ScrollWheelEvent&);

         virtual void apply(TerminateEvent&);

         virtual void apply(FrameEvent&);


         // utils

         virtual void apply(AnimationPath&);


         // viewer

         virtual void apply(Camera&);

         virtual void apply(CommandGraph&);

         virtual void apply(RenderGraph&);

         virtual void apply(View&);

         virtual void apply(Viewer&);


         // general classes

         virtual void apply(FrameStamp&);

     };


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

     template<typename T>

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


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

     template<typename T>

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


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

     template<typename T>

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


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

     template<typename T>

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


 } // namespace vsg

vsg::AmbientLight
AmbientLight represents an ambient light source.
Definition: Light.h:41

vsg::AnimationPath
Definition: AnimationPath.h:27

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:90

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:93

vsg::BindIndexBuffer
BindIndexBuffer command encapsulates vkBindIndexBuffer 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 vkBindVertexBuffers call and associated settings.
Definition: BindVertexBuffers.h:25

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

vsg::ButtonPressEvent
ButtonPressEvent represent a button press event.
Definition: PointerEvent.h:54

vsg::ButtonReleaseEvent
ButtonReleaseEvent represent a button release event.
Definition: PointerEvent.h:71

vsg::Camera
Definition: Camera.h:27

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

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

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

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

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

vsg::Command
Command base class from encapsualting vkCmd* calls and associated settings.
Definition: Command.h:25

vsg::Commands
Definition: Commands.h:29

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

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

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:104

vsg::DepthSorted
Definition: DepthSorted.h:27

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

vsg::DescriptorBuffer
Definition: DescriptorBuffer.h:24

vsg::DescriptorImage
Definition: DescriptorImage.h:24

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

vsg::Descriptor
Definition: Descriptor.h:28

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

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

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::DrawMeshTasks
Definition: DrawMeshTasks.h:22

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

vsg::DynamicState
DynamicState encapsulates to VkPipelineDynamicStateCreateInfo settings passed when setting up Graphic...
Definition: DynamicState.h:22

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::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::GraphicsPipelineState
Definition: GraphicsPipeline.h:29

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

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

vsg::InputAssemblyState
InputAssemblyState encapsulates to VkPipelineInputAssemblyStateCreateInfo settings passed when settin...
Definition: InputAssemblyState.h:22

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

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

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

vsg::LOD
Definition: LOD.h:33

vsg::Light
Definition: Light.h:25

vsg::MatrixTransform
Definition: MatrixTransform.h:24

vsg::MoveEvent
MoveEvent represent a button move event.
Definition: PointerEvent.h:88

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

vsg::Node
Definition: Node.h:24

vsg::Object
Definition: Object.h:42

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

vsg::PagedLOD
Definition: PagedLOD.h:36

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

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

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 to VkPipelineRasterizationStateCreateInfo settings passed when settin...
Definition: RasterizationState.h:22

vsg::RayTracingPipeline
Definition: RayTracingPipeline.h:26

vsg::RenderGraph
Definition: RenderGraph.h:28

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:22

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

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

vsg::SpotLight
SpotLight represents a local point light source which intensity varies as a spot light.
Definition: Light.h:81

vsg::StateCommand
Definition: StateCommand.h:23

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 a application terminate event.
Definition: ApplicationEvent.h:24

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

vsg::TextGroup
Definition: TextGroup.h:27

vsg::TextLayout
Definition: TextLayout.h:35

vsg::TextTechnique
Definition: TextTechnique.h:25

vsg::Text
Definition: Text.h:30

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

vsg::TouchEvent
TouchEvent is a base class 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::Transform
Transform node is a pure virtual base class for positioning/scaling/rotation subgraphs.
Definition: Transform.h:22

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

vsg::Value
Definition: Value.h:39

vsg::VertexDraw
Definition: VertexDraw.h:25

vsg::VertexIndexDraw
Definition: VertexIndexDraw.h:25

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

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

vsg::Viewer
Definition: Viewer.h:31

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

vsg::Visitor
Definition: Visitor.h:140

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