diff --git a/include/vsg/all.h b/include/vsg/all.h index 27bf34ff77..8bd1541227 100644 --- a/include/vsg/all.h +++ b/include/vsg/all.h @@ -30,6 +30,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI #include #include #include +#include #include #include #include diff --git a/include/vsg/animation/Animation.h b/include/vsg/animation/Animation.h index f1eb5564ec..2d81407b46 100644 --- a/include/vsg/animation/Animation.h +++ b/include/vsg/animation/Animation.h @@ -94,6 +94,10 @@ namespace vsg } void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& sampler : samplers) visitor.tryReplacePointer(sampler); + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/animation/AnimationGroup.h b/include/vsg/animation/AnimationGroup.h index 6d4ce7d56f..ee583ec16f 100644 --- a/include/vsg/animation/AnimationGroup.h +++ b/include/vsg/animation/AnimationGroup.h @@ -45,6 +45,11 @@ namespace vsg { for (auto& child : children) child->accept(visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& animation : animations) visitor.tryReplacePointer(animation); + for (auto& child : children) visitor.tryReplacePointer(child); + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/animation/Joint.h b/include/vsg/animation/Joint.h index 608f4fec9c..eda51cb472 100644 --- a/include/vsg/animation/Joint.h +++ b/include/vsg/animation/Joint.h @@ -49,6 +49,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& child : children) visitor.tryReplacePointer(child); + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/commands/Commands.h b/include/vsg/commands/Commands.h index d87eed3a0d..6fbcb0ecd4 100644 --- a/include/vsg/commands/Commands.h +++ b/include/vsg/commands/Commands.h @@ -39,6 +39,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& child : children) visitor.tryReplacePointer(child); + } int compare(const Object& rhs) const override; diff --git a/include/vsg/core/Array.h b/include/vsg/core/Array.h index ec70eb4280..02342f52a3 100644 --- a/include/vsg/core/Array.h +++ b/include/vsg/core/Array.h @@ -150,6 +150,7 @@ namespace vsg // implementation provided by Visitor.h void accept(Visitor& visitor) override; void accept(ConstVisitor& visitor) const override; + std::optional> accept(ReplacementVisitor& visitor) override; void read(Input& input) override { diff --git a/include/vsg/core/Array2D.h b/include/vsg/core/Array2D.h index 1460faff43..67164bdd74 100644 --- a/include/vsg/core/Array2D.h +++ b/include/vsg/core/Array2D.h @@ -128,6 +128,7 @@ namespace vsg // implementation provided by Visitor.h void accept(Visitor& visitor) override; void accept(ConstVisitor& visitor) const override; + std::optional> accept(ReplacementVisitor& visitor) override; void read(Input& input) override { diff --git a/include/vsg/core/Array3D.h b/include/vsg/core/Array3D.h index aa3c911c1b..97bdcbb4a7 100644 --- a/include/vsg/core/Array3D.h +++ b/include/vsg/core/Array3D.h @@ -134,6 +134,7 @@ namespace vsg // implementation provided by Visitor.h void accept(Visitor& visitor) override; void accept(ConstVisitor& visitor) const override; + std::optional> accept(ReplacementVisitor& visitor) override; void read(Input& input) override { diff --git a/include/vsg/core/External.h b/include/vsg/core/External.h index d015261eaa..25cc83120d 100644 --- a/include/vsg/core/External.h +++ b/include/vsg/core/External.h @@ -46,6 +46,13 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal&) const override {} + void traverse(ReplacementVisitor& visitor) override + { + for (auto& [path, object] : entries) + { + if (object) visitor.tryReplacePointer(object); + } + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/core/Inherit.h b/include/vsg/core/Inherit.h index 1278a5f17e..dff839e177 100644 --- a/include/vsg/core/Inherit.h +++ b/include/vsg/core/Inherit.h @@ -14,6 +14,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI #include #include +#include #include #include #include @@ -69,6 +70,7 @@ namespace vsg void accept(Visitor& visitor) override { visitor.apply(static_cast(*this)); } void accept(ConstVisitor& visitor) const override { visitor.apply(static_cast(*this)); } + std::optional> accept(ReplacementVisitor& visitor) override { return visitor.apply(static_cast(*this)); } void accept(RecordTraversal& visitor) const override { visitor.apply(static_cast(*this)); } }; diff --git a/include/vsg/core/Object.h b/include/vsg/core/Object.h index 02f678a4e7..c15931d2e5 100644 --- a/include/vsg/core/Object.h +++ b/include/vsg/core/Object.h @@ -14,6 +14,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI #include #include +#include #include #include #include @@ -29,6 +30,7 @@ namespace vsg class Auxiliary; class Visitor; class ConstVisitor; + class ReplacementVisitor; class RecordTraversal; class Input; class Output; @@ -112,6 +114,9 @@ namespace vsg virtual void accept(ConstVisitor& visitor) const; virtual void traverse(ConstVisitor&) const {} + virtual std::optional> accept(ReplacementVisitor& visitor); + virtual void traverse(ReplacementVisitor&) {}; + virtual void accept(RecordTraversal& visitor) const; virtual void traverse(RecordTraversal&) const {} diff --git a/include/vsg/core/Objects.h b/include/vsg/core/Objects.h index 5618bd94fd..49a9c8952e 100644 --- a/include/vsg/core/Objects.h +++ b/include/vsg/core/Objects.h @@ -35,6 +35,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& child : children) visitor.tryReplacePointer(child); + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/core/ReplacementVisitor.h b/include/vsg/core/ReplacementVisitor.h new file mode 100644 index 0000000000..a2dacdb105 --- /dev/null +++ b/include/vsg/core/ReplacementVisitor.h @@ -0,0 +1,529 @@ +#pragma once + +/* + +Copyright(c) 2018-2026 Robert Osfield, Chris Djali + +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. + + */ + +#include +#include +#include +#include +#include + +#include + +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 TransformSampler; + class CameraSampler; + class MorphSampler; + class JointSampler; + 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 ReplacementVisitor : public Object + { + public: + ReplacementVisitor(); + + ReplacementVisitor(const ReplacementVisitor& 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; } + + template + std::optional> acceptChecked(T& object) + { + std::optional> replacement = object.accept(*this); + if (!replacement.has_value()) + return std::nullopt; + if (replacement.value() == nullptr) + return nullptr; + if (replacement.value()->is_compatible(typeid(T))) + return ref_ptr(static_cast(replacement.value().get())); + return std::nullopt; + } + + template + bool tryReplacePointer(ref_ptr& ptr) + { + std::optional> newPtr = acceptChecked(*ptr); + if (newPtr.has_value()) + { + ptr = newPtr.value(); + return true; + } + return false; + } + + virtual std::optional> apply(Object&); + virtual std::optional> apply(Objects&); + virtual std::optional> apply(External&); + virtual std::optional> apply(Data&); + virtual std::optional> apply(MipmapLayout&); + + // Values + virtual std::optional> apply(stringValue&); + virtual std::optional> apply(wstringValue&); + virtual std::optional> apply(boolValue&); + virtual std::optional> apply(intValue&); + virtual std::optional> apply(uintValue&); + virtual std::optional> apply(floatValue&); + virtual std::optional> apply(doubleValue&); + virtual std::optional> apply(vec2Value&); + virtual std::optional> apply(vec3Value&); + virtual std::optional> apply(vec4Value&); + virtual std::optional> apply(dvec2Value&); + virtual std::optional> apply(dvec3Value&); + virtual std::optional> apply(dvec4Value&); + virtual std::optional> apply(bvec2Value&); + virtual std::optional> apply(bvec3Value&); + virtual std::optional> apply(bvec4Value&); + virtual std::optional> apply(ubvec2Value&); + virtual std::optional> apply(ubvec3Value&); + virtual std::optional> apply(ubvec4Value&); + virtual std::optional> apply(svec2Value&); + virtual std::optional> apply(svec3Value&); + virtual std::optional> apply(svec4Value&); + virtual std::optional> apply(usvec2Value&); + virtual std::optional> apply(usvec3Value&); + virtual std::optional> apply(usvec4Value&); + virtual std::optional> apply(ivec2Value&); + virtual std::optional> apply(ivec3Value&); + virtual std::optional> apply(ivec4Value&); + virtual std::optional> apply(uivec2Value&); + virtual std::optional> apply(uivec3Value&); + virtual std::optional> apply(uivec4Value&); + virtual std::optional> apply(mat2Value&); + virtual std::optional> apply(dmat2Value&); + virtual std::optional> apply(mat3Value&); + virtual std::optional> apply(dmat3Value&); + virtual std::optional> apply(mat4Value&); + virtual std::optional> apply(dmat4Value&); + + // Arrays + virtual std::optional> apply(stringArray&); + virtual std::optional> apply(byteArray&); + virtual std::optional> apply(ubyteArray&); + virtual std::optional> apply(shortArray&); + virtual std::optional> apply(ushortArray&); + virtual std::optional> apply(intArray&); + virtual std::optional> apply(uintArray&); + virtual std::optional> apply(floatArray&); + virtual std::optional> apply(doubleArray&); + virtual std::optional> apply(vec2Array&); + virtual std::optional> apply(vec3Array&); + virtual std::optional> apply(vec4Array&); + virtual std::optional> apply(dvec2Array&); + virtual std::optional> apply(dvec3Array&); + virtual std::optional> apply(dvec4Array&); + virtual std::optional> apply(bvec2Array&); + virtual std::optional> apply(bvec3Array&); + virtual std::optional> apply(bvec4Array&); + virtual std::optional> apply(svec2Array&); + virtual std::optional> apply(svec3Array&); + virtual std::optional> apply(svec4Array&); + virtual std::optional> apply(ivec2Array&); + virtual std::optional> apply(ivec3Array&); + virtual std::optional> apply(ivec4Array&); + virtual std::optional> apply(ubvec2Array&); + virtual std::optional> apply(ubvec3Array&); + virtual std::optional> apply(ubvec4Array&); + virtual std::optional> apply(usvec2Array&); + virtual std::optional> apply(usvec3Array&); + virtual std::optional> apply(usvec4Array&); + virtual std::optional> apply(uivec2Array&); + virtual std::optional> apply(uivec3Array&); + virtual std::optional> apply(uivec4Array&); + virtual std::optional> apply(mat4Array&); + virtual std::optional> apply(dmat4Array&); + virtual std::optional> apply(block64Array&); + virtual std::optional> apply(block128Array&); + + // Array2Ds + virtual std::optional> apply(byteArray2D&); + virtual std::optional> apply(ubyteArray2D&); + virtual std::optional> apply(shortArray2D&); + virtual std::optional> apply(ushortArray2D&); + virtual std::optional> apply(intArray2D&); + virtual std::optional> apply(uintArray2D&); + virtual std::optional> apply(floatArray2D&); + virtual std::optional> apply(doubleArray2D&); + virtual std::optional> apply(vec2Array2D&); + virtual std::optional> apply(vec3Array2D&); + virtual std::optional> apply(vec4Array2D&); + virtual std::optional> apply(dvec2Array2D&); + virtual std::optional> apply(dvec3Array2D&); + virtual std::optional> apply(dvec4Array2D&); + virtual std::optional> apply(bvec2Array2D&); + virtual std::optional> apply(bvec3Array2D&); + virtual std::optional> apply(bvec4Array2D&); + virtual std::optional> apply(svec2Array2D&); + virtual std::optional> apply(svec3Array2D&); + virtual std::optional> apply(svec4Array2D&); + virtual std::optional> apply(ivec2Array2D&); + virtual std::optional> apply(ivec3Array2D&); + virtual std::optional> apply(ivec4Array2D&); + virtual std::optional> apply(ubvec2Array2D&); + virtual std::optional> apply(ubvec3Array2D&); + virtual std::optional> apply(ubvec4Array2D&); + virtual std::optional> apply(usvec2Array2D&); + virtual std::optional> apply(usvec3Array2D&); + virtual std::optional> apply(usvec4Array2D&); + virtual std::optional> apply(uivec2Array2D&); + virtual std::optional> apply(uivec3Array2D&); + virtual std::optional> apply(uivec4Array2D&); + virtual std::optional> apply(block64Array2D&); + virtual std::optional> apply(block128Array2D&); + + // Array3Ds + virtual std::optional> apply(byteArray3D&); + virtual std::optional> apply(ubyteArray3D&); + virtual std::optional> apply(shortArray3D&); + virtual std::optional> apply(ushortArray3D&); + virtual std::optional> apply(intArray3D&); + virtual std::optional> apply(uintArray3D&); + virtual std::optional> apply(floatArray3D&); + virtual std::optional> apply(doubleArray3D&); + virtual std::optional> apply(vec2Array3D&); + virtual std::optional> apply(vec3Array3D&); + virtual std::optional> apply(vec4Array3D&); + virtual std::optional> apply(dvec2Array3D&); + virtual std::optional> apply(dvec3Array3D&); + virtual std::optional> apply(dvec4Array3D&); + virtual std::optional> apply(ubvec2Array3D&); + virtual std::optional> apply(ubvec3Array3D&); + virtual std::optional> apply(ubvec4Array3D&); + virtual std::optional> apply(block64Array3D&); + virtual std::optional> apply(block128Array3D&); + + // Nodes + virtual std::optional> apply(Node&); + virtual std::optional> apply(Compilable&); + virtual std::optional> apply(Commands&); + virtual std::optional> apply(Group&); + virtual std::optional> apply(QuadGroup&); + virtual std::optional> apply(LOD&); + virtual std::optional> apply(PagedLOD&); + virtual std::optional> apply(StateGroup&); + virtual std::optional> apply(CullGroup&); + virtual std::optional> apply(CullNode&); + virtual std::optional> apply(Transform&); + virtual std::optional> apply(MatrixTransform&); + virtual std::optional> apply(CoordinateFrame&); + virtual std::optional> apply(Geometry&); + virtual std::optional> apply(VertexDraw&); + virtual std::optional> apply(VertexIndexDraw&); + virtual std::optional> apply(DepthSorted&); + virtual std::optional> apply(Layer&); + virtual std::optional> apply(Bin&); + virtual std::optional> apply(Switch&); + virtual std::optional> apply(Light&); + virtual std::optional> apply(AmbientLight&); + virtual std::optional> apply(DirectionalLight&); + virtual std::optional> apply(PointLight&); + virtual std::optional> apply(SpotLight&); + virtual std::optional> apply(InstrumentationNode&); + virtual std::optional> apply(RegionOfInterest&); + virtual std::optional> apply(InstanceNode&); + virtual std::optional> apply(InstanceDraw&); + virtual std::optional> apply(InstanceDrawIndexed&); + + // text + virtual std::optional> apply(Text&); + virtual std::optional> apply(TextGroup&); + virtual std::optional> apply(TextTechnique&); + virtual std::optional> apply(TextLayout&); + + // animation + virtual std::optional> apply(Animation&); + virtual std::optional> apply(AnimationGroup&); + virtual std::optional> apply(AnimationSampler&); + virtual std::optional> apply(JointSampler&); + virtual std::optional> apply(MorphSampler&); + virtual std::optional> apply(TransformSampler&); + virtual std::optional> apply(CameraSampler&); + virtual std::optional> apply(Joint&); + + // Vulkan nodes + virtual std::optional> apply(BufferInfo&); + virtual std::optional> apply(ImageInfo&); + virtual std::optional> apply(ImageView&); + virtual std::optional> apply(Image&); + virtual std::optional> apply(Command&); + virtual std::optional> apply(StateCommand&); + virtual std::optional> apply(StateSwitch&); + virtual std::optional> apply(CommandBuffer&); + virtual std::optional> apply(RenderPass&); + virtual std::optional> apply(BindDescriptorSet&); + virtual std::optional> apply(BindDescriptorSets&); + virtual std::optional> apply(BindViewDescriptorSets&); + virtual std::optional> apply(Descriptor&); + virtual std::optional> apply(DescriptorBuffer&); + virtual std::optional> apply(DescriptorImage&); + virtual std::optional> apply(DescriptorSet&); + virtual std::optional> apply(BindVertexBuffers&); + virtual std::optional> apply(BindIndexBuffer&); + virtual std::optional> apply(BindComputePipeline&); + virtual std::optional> apply(BindGraphicsPipeline&); + virtual std::optional> apply(BindRayTracingPipeline&); + virtual std::optional> apply(GraphicsPipeline&); + virtual std::optional> apply(ComputePipeline&); + virtual std::optional> apply(RayTracingPipeline&); + virtual std::optional> apply(GraphicsPipelineState&); + virtual std::optional> apply(ShaderStage&); + virtual std::optional> apply(VertexInputState&); + virtual std::optional> apply(InputAssemblyState&); + virtual std::optional> apply(TessellationState&); + virtual std::optional> apply(ViewportState&); + virtual std::optional> apply(RasterizationState&); + virtual std::optional> apply(MultisampleState&); + virtual std::optional> apply(DepthStencilState&); + virtual std::optional> apply(ColorBlendState&); + virtual std::optional> apply(DynamicState&); + virtual std::optional> apply(ResourceHints&); + virtual std::optional> apply(Draw&); + virtual std::optional> apply(DrawIndexed&); + virtual std::optional> apply(ClearAttachments&); + virtual std::optional> apply(ClearColorImage&); + virtual std::optional> apply(ClearDepthStencilImage&); + virtual std::optional> apply(QueryPool&); + virtual std::optional> apply(ResetQueryPool&); + virtual std::optional> apply(BeginQuery&); + virtual std::optional> apply(EndQuery&); + virtual std::optional> apply(WriteTimestamp&); + virtual std::optional> apply(CopyQueryPoolResults&); + + // mesh shading classes + virtual std::optional> apply(DrawMeshTasks&); + virtual std::optional> apply(DrawMeshTasksIndirect&); + virtual std::optional> apply(DrawMeshTasksIndirectCount&); + + // ui events + virtual std::optional> apply(UIEvent&); + virtual std::optional> apply(WindowEvent&); + virtual std::optional> apply(ExposeWindowEvent&); + virtual std::optional> apply(ConfigureWindowEvent&); + virtual std::optional> apply(CloseWindowEvent&); + virtual std::optional> apply(FocusInEvent&); + virtual std::optional> apply(FocusOutEvent&); + virtual std::optional> apply(KeyEvent&); + virtual std::optional> apply(KeyPressEvent&); + virtual std::optional> apply(KeyReleaseEvent&); + virtual std::optional> apply(PointerEvent&); + virtual std::optional> apply(ButtonPressEvent&); + virtual std::optional> apply(ButtonReleaseEvent&); + virtual std::optional> apply(MoveEvent&); + virtual std::optional> apply(TouchEvent&); + virtual std::optional> apply(TouchDownEvent&); + virtual std::optional> apply(TouchUpEvent&); + virtual std::optional> apply(TouchMoveEvent&); + virtual std::optional> apply(ScrollWheelEvent&); + virtual std::optional> apply(TerminateEvent&); + virtual std::optional> apply(FrameEvent&); + + // utils + virtual std::optional> apply(ShaderCompileSettings&); + + // app + virtual std::optional> apply(Camera&); + virtual std::optional> apply(CommandGraph&); + virtual std::optional> apply(SecondaryCommandGraph&); + virtual std::optional> apply(RenderGraph&); + virtual std::optional> apply(View&); + virtual std::optional> apply(Viewer&); + virtual std::optional> apply(ViewMatrix&); + virtual std::optional> apply(LookAt&); + virtual std::optional> apply(LookDirection&); + virtual std::optional> apply(RelativeViewMatrix&); + virtual std::optional> apply(TrackingViewMatrix&); + virtual std::optional> apply(ProjectionMatrix&); + virtual std::optional> apply(Perspective&); + virtual std::optional> apply(Orthographic&); + virtual std::optional> apply(RelativeProjection&); + virtual std::optional> apply(EllipsoidPerspective&); + + // general classes + virtual std::optional> apply(FrameStamp&); + + bool is_compatible(const std::type_info& type) const noexcept override { return typeid(ReplacementVisitor) == type || Object::is_compatible(type); } + }; + + // provide Value<>::accept() implementation + template + std::optional> Value::accept(ReplacementVisitor& visitor) { return visitor.apply(*this); } + + // provide Array<>::accept() implementation + template + std::optional> Array::accept(ReplacementVisitor& visitor) { return visitor.apply(*this); } + + // provide Array2D<>::accept() implementation + template + std::optional> Array2D::accept(ReplacementVisitor& visitor) { return visitor.apply(*this); } + + // provide Array3D<>::accept() implementation + template + std::optional> Array3D::accept(ReplacementVisitor& visitor) { return visitor.apply(*this); } + +} // namespace vsg diff --git a/include/vsg/core/Value.h b/include/vsg/core/Value.h index a5c02bd704..b91558dd6e 100644 --- a/include/vsg/core/Value.h +++ b/include/vsg/core/Value.h @@ -80,6 +80,7 @@ namespace vsg // implementation provided by Visitor.h void accept(Visitor& visitor) override; void accept(ConstVisitor& visitor) const override; + std::optional> accept(ReplacementVisitor& visitor) override; void read(Input& input) override { diff --git a/include/vsg/nodes/CullNode.h b/include/vsg/nodes/CullNode.h index ff851f288b..10d39e23e2 100644 --- a/include/vsg/nodes/CullNode.h +++ b/include/vsg/nodes/CullNode.h @@ -38,6 +38,7 @@ namespace vsg void traverse(Visitor& visitor) override { child->accept(visitor); } void traverse(ConstVisitor& visitor) const override { child->accept(visitor); } void traverse(RecordTraversal& visitor) const override { child->accept(visitor); } + void traverse(ReplacementVisitor& visitor) override { visitor.tryReplacePointer(child); } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/nodes/DepthSorted.h b/include/vsg/nodes/DepthSorted.h index 8e50c93134..3e4c3f8929 100644 --- a/include/vsg/nodes/DepthSorted.h +++ b/include/vsg/nodes/DepthSorted.h @@ -41,6 +41,7 @@ namespace vsg void traverse(Visitor& visitor) override { child->accept(visitor); } void traverse(ConstVisitor& visitor) const override { child->accept(visitor); } void traverse(RecordTraversal& visitor) const override { child->accept(visitor); } + void traverse(ReplacementVisitor& visitor) override { visitor.tryReplacePointer(child); } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/nodes/Group.h b/include/vsg/nodes/Group.h index ff1e625974..c5698485df 100644 --- a/include/vsg/nodes/Group.h +++ b/include/vsg/nodes/Group.h @@ -54,6 +54,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& child : children) visitor.tryReplacePointer(child); + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/nodes/InstanceNode.h b/include/vsg/nodes/InstanceNode.h index 5399defda8..c1ac8a32ee 100644 --- a/include/vsg/nodes/InstanceNode.h +++ b/include/vsg/nodes/InstanceNode.h @@ -69,6 +69,7 @@ namespace vsg void traverse(Visitor& visitor) override { child->accept(visitor); } void traverse(ConstVisitor& visitor) const override { child->accept(visitor); } void traverse(RecordTraversal& visitor) const override { child->accept(visitor); } + void traverse(ReplacementVisitor& visitor) override { visitor.tryReplacePointer(child); } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/nodes/InstrumentationNode.h b/include/vsg/nodes/InstrumentationNode.h index f336637f7c..18674f54f5 100644 --- a/include/vsg/nodes/InstrumentationNode.h +++ b/include/vsg/nodes/InstrumentationNode.h @@ -45,6 +45,7 @@ namespace vsg void traverse(Visitor& visitor) override; void traverse(ConstVisitor& visitor) const override; void traverse(RecordTraversal& visitor) const override; + void traverse(ReplacementVisitor& visitor) override; void read(Input& input) override; void write(Output& output) const override; @@ -60,6 +61,7 @@ namespace vsg SourceLocation _sl_Visitor; SourceLocation _sl_ConstVisitor; SourceLocation _sl_RecordTraversal; + SourceLocation _sl_ReplacementVisitor; }; VSG_type_name(vsg::InstrumentationNode); diff --git a/include/vsg/nodes/LOD.h b/include/vsg/nodes/LOD.h index c7274da216..28ccc58f99 100644 --- a/include/vsg/nodes/LOD.h +++ b/include/vsg/nodes/LOD.h @@ -61,6 +61,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& [ratio, node] : children) { visitor.tryReplacePointer(node); } + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/nodes/Layer.h b/include/vsg/nodes/Layer.h index 2de68f7885..9ca9972868 100644 --- a/include/vsg/nodes/Layer.h +++ b/include/vsg/nodes/Layer.h @@ -47,6 +47,10 @@ namespace vsg { if ((visitor.traversalMask & (visitor.overrideMask | mask)) != MASK_OFF) child->accept(visitor); } + void traverse(ReplacementVisitor& visitor) override + { + if ((visitor.traversalMask & (visitor.overrideMask | mask)) != MASK_OFF) { visitor.tryReplacePointer(child); } + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/nodes/PagedLOD.h b/include/vsg/nodes/PagedLOD.h index 5c929fe5eb..70ca9791f8 100644 --- a/include/vsg/nodes/PagedLOD.h +++ b/include/vsg/nodes/PagedLOD.h @@ -73,6 +73,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& [ratio, node] : children) { visitor.tryReplacePointer(node); } + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/nodes/QuadGroup.h b/include/vsg/nodes/QuadGroup.h index f4836c00d1..453db826cd 100644 --- a/include/vsg/nodes/QuadGroup.h +++ b/include/vsg/nodes/QuadGroup.h @@ -47,6 +47,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& child : children) visitor.tryReplacePointer(child); + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/nodes/StateGroup.h b/include/vsg/nodes/StateGroup.h index 2f1f9044b4..5ff2f6a1d3 100644 --- a/include/vsg/nodes/StateGroup.h +++ b/include/vsg/nodes/StateGroup.h @@ -76,6 +76,11 @@ namespace vsg { for (auto& child : children) child->accept(visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& sc : stateCommands) visitor.tryReplacePointer(sc); + for (auto& child : children) visitor.tryReplacePointer(child); + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/nodes/Switch.h b/include/vsg/nodes/Switch.h index 009f4c0743..afd94efd7c 100644 --- a/include/vsg/nodes/Switch.h +++ b/include/vsg/nodes/Switch.h @@ -64,6 +64,13 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& [mask, node] : children) + { + if ((visitor.traversalMask & (visitor.overrideMask | mask)) != MASK_OFF) { visitor.tryReplacePointer(node); } + } + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/nodes/TileDatabase.h b/include/vsg/nodes/TileDatabase.h index 2e80d22c48..24616e226a 100644 --- a/include/vsg/nodes/TileDatabase.h +++ b/include/vsg/nodes/TileDatabase.h @@ -98,6 +98,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + if (child) visitor.tryReplacePointer(child); + } // read/write of TileReader settings void read(Input& input) override; diff --git a/include/vsg/state/BindDescriptorSet.h b/include/vsg/state/BindDescriptorSet.h index 9f975c1148..845a829248 100644 --- a/include/vsg/state/BindDescriptorSet.h +++ b/include/vsg/state/BindDescriptorSet.h @@ -64,6 +64,19 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + bool dirty = false; + dirty |= visitor.tryReplacePointer(layout); + for (auto& ds : descriptorSets) + { + dirty |= visitor.tryReplacePointer(ds); + } + if (dirty) + { + _vulkanData.clear(); + } + } void read(Input& input) override; void write(Output& output) const override; @@ -141,6 +154,15 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + bool dirty = visitor.tryReplacePointer(layout); + dirty |= visitor.tryReplacePointer(descriptorSet); + if (dirty) + { + _vulkanData.clear(); + } + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/state/DescriptorSet.h b/include/vsg/state/DescriptorSet.h index 7ea4c69c2a..70270773a4 100644 --- a/include/vsg/state/DescriptorSet.h +++ b/include/vsg/state/DescriptorSet.h @@ -56,6 +56,11 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + if (setLayout) visitor.tryReplacePointer(setLayout); + for (auto& descriptor : descriptors) visitor.tryReplacePointer(descriptor); + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/state/StateSwitch.h b/include/vsg/state/StateSwitch.h index df8dd3b812..f33b2d514d 100644 --- a/include/vsg/state/StateSwitch.h +++ b/include/vsg/state/StateSwitch.h @@ -49,6 +49,13 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + for (auto& [mask, stateCommand] : children) + { + if ((visitor.traversalMask & (visitor.overrideMask | mask)) != MASK_OFF) visitor.tryReplacePointer(stateCommand); + } + } ref_ptr clone(const CopyOp& copyop = {}) const override { return StateSwitch::create(*this, copyop); } int compare(const Object& rhs_object) const override; diff --git a/include/vsg/state/ViewDependentState.h b/include/vsg/state/ViewDependentState.h index ded1e84ca7..168bd567f6 100644 --- a/include/vsg/state/ViewDependentState.h +++ b/include/vsg/state/ViewDependentState.h @@ -78,6 +78,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + if (layout) visitor.tryReplacePointer(layout); + } void read(Input& input) override; void write(Output& output) const override; @@ -117,6 +121,11 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& rt) const override; + void traverse(ReplacementVisitor& visitor) override + { + visitor.tryReplacePointer(descriptorSet); + if (preRenderCommandGraph) visitor.tryReplacePointer(preRenderCommandGraph); + } // containers filled in by RecordTraversal std::vector> ambientLights; diff --git a/include/vsg/text/CpuLayoutTechnique.h b/include/vsg/text/CpuLayoutTechnique.h index 5e500668f8..bc46762e83 100644 --- a/include/vsg/text/CpuLayoutTechnique.h +++ b/include/vsg/text/CpuLayoutTechnique.h @@ -35,6 +35,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + if (scenegraph) visitor.tryReplacePointer(scenegraph); + } void setup(Text* text, uint32_t minimumAllocation = 0, ref_ptr options = {}) override; void setup(TextGroup* textGroup, uint32_t minimumAllocation = 0, ref_ptr options = {}) override; diff --git a/include/vsg/text/GpuLayoutTechnique.h b/include/vsg/text/GpuLayoutTechnique.h index ed8ad66c37..1004f96eac 100644 --- a/include/vsg/text/GpuLayoutTechnique.h +++ b/include/vsg/text/GpuLayoutTechnique.h @@ -47,6 +47,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + if (scenegraph) visitor.tryReplacePointer(scenegraph); + } void setup(Text* text, uint32_t minimumAllocation = 0, ref_ptr options = {}) override; void setup(TextGroup* textGroup, uint32_t minimumAllocation = 0, ref_ptr options = {}) override; diff --git a/include/vsg/text/Text.h b/include/vsg/text/Text.h index 27b0184be9..dd42997681 100644 --- a/include/vsg/text/Text.h +++ b/include/vsg/text/Text.h @@ -38,6 +38,10 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + if (technique) visitor.tryReplacePointer(technique); + } void read(Input& input) override; void write(Output& output) const override; diff --git a/include/vsg/text/TextGroup.h b/include/vsg/text/TextGroup.h index d29dcf72d0..e8e1181676 100644 --- a/include/vsg/text/TextGroup.h +++ b/include/vsg/text/TextGroup.h @@ -39,6 +39,11 @@ namespace vsg { if (technique) technique->accept(visitor); } + void traverse(ReplacementVisitor& visitor) override + { + if (technique) visitor.tryReplacePointer(technique); + for (auto& child : children) visitor.tryReplacePointer(child); + } int compare(const Object& rhs) const override; diff --git a/include/vsg/utils/GraphicsPipelineConfigurator.h b/include/vsg/utils/GraphicsPipelineConfigurator.h index cde9b24f55..89a24bdda5 100644 --- a/include/vsg/utils/GraphicsPipelineConfigurator.h +++ b/include/vsg/utils/GraphicsPipelineConfigurator.h @@ -101,6 +101,7 @@ namespace vsg void traverse(Visitor& visitor) override; void traverse(ConstVisitor& visitor) const override; + void traverse(ReplacementVisitor& visitor) override; // inputs to setup of GraphicsPipeline, the default sets are taken from any provided by ShaderSet::defaultGraphicsPipelineStates GraphicsPipelineStates pipelineStates; diff --git a/include/vsg/utils/SharedObjects.h b/include/vsg/utils/SharedObjects.h index 23f3dd76d6..3db06eeaa4 100644 --- a/include/vsg/utils/SharedObjects.h +++ b/include/vsg/utils/SharedObjects.h @@ -94,6 +94,7 @@ namespace vsg void traverse(Visitor& visitor) override; void traverse(ConstVisitor& visitor) const override; + void traverse(ReplacementVisitor& visitor) override; int compare(const Object& rhs_object) const override; }; diff --git a/src/vsg/CMakeLists.txt b/src/vsg/CMakeLists.txt index f4125a189a..1f6142758c 100644 --- a/src/vsg/CMakeLists.txt +++ b/src/vsg/CMakeLists.txt @@ -20,6 +20,7 @@ set(SOURCES core/MemorySlots.cpp core/Object.cpp core/Objects.cpp + core/ReplacementVisitor.cpp core/Visitor.cpp core/Version.cpp diff --git a/src/vsg/core/Object.cpp b/src/vsg/core/Object.cpp index 8b39dedfb0..5aacb22d94 100644 --- a/src/vsg/core/Object.cpp +++ b/src/vsg/core/Object.cpp @@ -14,6 +14,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI #include #include #include +#include #include #include @@ -131,6 +132,11 @@ void Object::accept(ConstVisitor& visitor) const visitor.apply(*this); } +std::optional> Object::accept(ReplacementVisitor& visitor) +{ + return visitor.apply(*this); +} + void Object::accept(RecordTraversal& visitor) const { visitor.apply(*this); diff --git a/src/vsg/core/ReplacementVisitor.cpp b/src/vsg/core/ReplacementVisitor.cpp new file mode 100644 index 0000000000..068dc7d350 --- /dev/null +++ b/src/vsg/core/ReplacementVisitor.cpp @@ -0,0 +1,1141 @@ +/* + +Copyright(c) 2018-2026 Robert Osfield, Chris Djali + +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. + + */ + +#include + +using namespace vsg; + +ReplacementVisitor::ReplacementVisitor() +{ +} + +std::optional> ReplacementVisitor::apply(Object&) +{ + return std::nullopt; +} + +std::optional> ReplacementVisitor::apply(Objects& value) +{ + return apply(static_cast(value)); +} + +std::optional> ReplacementVisitor::apply(External& value) +{ + return apply(static_cast(value)); +} + +std::optional> ReplacementVisitor::apply(Data& value) +{ + return apply(static_cast(value)); +} + +std::optional> ReplacementVisitor::apply(MipmapLayout& value) +{ + return apply(static_cast(value)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// Values +// +std::optional> ReplacementVisitor::apply(stringValue& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(wstringValue& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(boolValue& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(intValue& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uintValue& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(floatValue& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(doubleValue& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec2Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec3Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec4Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec2Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec3Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec4Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(bvec2Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(bvec3Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(bvec4Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec2Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec3Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec4Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(svec2Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(svec3Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(svec4Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(usvec2Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(usvec3Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(usvec4Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ivec2Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ivec3Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ivec4Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uivec2Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uivec3Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uivec4Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(mat2Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dmat2Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(mat3Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dmat3Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(mat4Value& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dmat4Value& value) +{ + return apply(static_cast(value)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// Arrays +// +std::optional> ReplacementVisitor::apply(stringArray& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(byteArray& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubyteArray& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(shortArray& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ushortArray& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(intArray& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uintArray& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(floatArray& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(doubleArray& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec2Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec3Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec4Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec2Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec3Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec4Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(bvec2Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(bvec3Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(bvec4Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(svec2Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(svec3Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(svec4Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ivec2Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ivec3Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ivec4Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec2Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec3Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec4Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(usvec2Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(usvec3Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(usvec4Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uivec2Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uivec3Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uivec4Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(mat4Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dmat4Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(block64Array& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(block128Array& value) +{ + return apply(static_cast(value)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// Array2Ds +// +std::optional> ReplacementVisitor::apply(byteArray2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubyteArray2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(shortArray2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ushortArray2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(intArray2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uintArray2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(floatArray2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(doubleArray2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec2Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec3Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec4Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec2Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec3Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec4Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(bvec2Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(bvec3Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(bvec4Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(svec2Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(svec3Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(svec4Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ivec2Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ivec3Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ivec4Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec2Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec3Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec4Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(usvec2Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(usvec3Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(usvec4Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uivec2Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uivec3Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uivec4Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(block64Array2D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(block128Array2D& value) +{ + return apply(static_cast(value)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// Array3Ds +// +std::optional> ReplacementVisitor::apply(byteArray3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubyteArray3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(shortArray3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ushortArray3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(intArray3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(uintArray3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(floatArray3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(doubleArray3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec2Array3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec3Array3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(vec4Array3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec2Array3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec3Array3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(dvec4Array3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec2Array3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec3Array3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ubvec4Array3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(block64Array3D& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(block128Array3D& value) +{ + return apply(static_cast(value)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// Nodes +// +std::optional> ReplacementVisitor::apply(Node& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Compilable& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Commands& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Group& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(QuadGroup& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(LOD& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(PagedLOD& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(StateGroup& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(CullGroup& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(CullNode& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Transform& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(MatrixTransform& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(CoordinateFrame& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Geometry& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(VertexDraw& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(VertexIndexDraw& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(DepthSorted& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Layer& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Bin& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Switch& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Light& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(AmbientLight& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(DirectionalLight& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(PointLight& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(SpotLight& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(InstrumentationNode& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(RegionOfInterest& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(InstanceNode& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(InstanceDraw& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(InstanceDrawIndexed& value) +{ + return apply(static_cast(value)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// Text Objects +// +std::optional> ReplacementVisitor::apply(Text& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(TextGroup& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(TextTechnique& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(TextLayout& value) +{ + return apply(static_cast(value)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// Animation Objects/Nodes +// +std::optional> ReplacementVisitor::apply(Animation& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(AnimationGroup& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(AnimationSampler& sampler) +{ + return apply(static_cast(sampler)); +} +std::optional> ReplacementVisitor::apply(JointSampler& sampler) +{ + return apply(static_cast(sampler)); +} +std::optional> ReplacementVisitor::apply(MorphSampler& sampler) +{ + return apply(static_cast(sampler)); +} +std::optional> ReplacementVisitor::apply(TransformSampler& sampler) +{ + return apply(static_cast(sampler)); +} +std::optional> ReplacementVisitor::apply(CameraSampler& sampler) +{ + return apply(static_cast(sampler)); +} +std::optional> ReplacementVisitor::apply(Joint& value) +{ + return apply(static_cast(value)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// Vulkan Objects +// +std::optional> ReplacementVisitor::apply(BufferInfo& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ImageInfo& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ImageView& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Image& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Command& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(StateCommand& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(StateSwitch& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(CommandBuffer& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(RenderPass& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(BindDescriptorSet& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(BindDescriptorSets& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(BindViewDescriptorSets& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Descriptor& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(DescriptorBuffer& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(DescriptorImage& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(DescriptorSet& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(BindVertexBuffers& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(BindIndexBuffer& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(BindComputePipeline& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(BindGraphicsPipeline& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(BindRayTracingPipeline& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(GraphicsPipeline& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ComputePipeline& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(RayTracingPipeline& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(GraphicsPipelineState& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ShaderStage& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(VertexInputState& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(InputAssemblyState& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(TessellationState& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ViewportState& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(RasterizationState& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(MultisampleState& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(DepthStencilState& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ColorBlendState& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(DynamicState& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ResourceHints& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Draw& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(DrawIndexed& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ClearAttachments& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ClearColorImage& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ClearDepthStencilImage& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(QueryPool& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ResetQueryPool& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(BeginQuery& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(EndQuery& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(WriteTimestamp& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(CopyQueryPoolResults& value) +{ + return apply(static_cast(value)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// Mesh shading +// +std::optional> ReplacementVisitor::apply(DrawMeshTasks& dmt) +{ + return apply(static_cast(dmt)); +} +std::optional> ReplacementVisitor::apply(DrawMeshTasksIndirect& dmti) +{ + return apply(static_cast(dmti)); +} +std::optional> ReplacementVisitor::apply(DrawMeshTasksIndirectCount& dmtic) +{ + return apply(static_cast(dmtic)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// UI Events +// +std::optional> ReplacementVisitor::apply(UIEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(WindowEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(ExposeWindowEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(ConfigureWindowEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(CloseWindowEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(FocusInEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(FocusOutEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(KeyEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(KeyPressEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(KeyReleaseEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(PointerEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(ButtonPressEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(ButtonReleaseEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(MoveEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(TouchEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(TouchDownEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(TouchUpEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(TouchMoveEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(ScrollWheelEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(TerminateEvent& event) +{ + return apply(static_cast(event)); +} +std::optional> ReplacementVisitor::apply(FrameEvent& event) +{ + return apply(static_cast(event)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// util classes +// +std::optional> ReplacementVisitor::apply(ShaderCompileSettings& shaderCompileSettings) +{ + return apply(static_cast(shaderCompileSettings)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// Viewer classes +// +std::optional> ReplacementVisitor::apply(Camera& camera) +{ + return apply(static_cast(camera)); +} +std::optional> ReplacementVisitor::apply(CommandGraph& cg) +{ + return apply(static_cast(cg)); +} +std::optional> ReplacementVisitor::apply(SecondaryCommandGraph& cg) +{ + return apply(static_cast(cg)); +} +std::optional> ReplacementVisitor::apply(RenderGraph& rg) +{ + return apply(static_cast(rg)); +} +std::optional> ReplacementVisitor::apply(View& view) +{ + return apply(static_cast(view)); +} +std::optional> ReplacementVisitor::apply(Viewer& viewer) +{ + return apply(static_cast(viewer)); +} +std::optional> ReplacementVisitor::apply(ViewMatrix& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(LookAt& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(LookDirection& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(RelativeViewMatrix& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(TrackingViewMatrix& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(ProjectionMatrix& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Perspective& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(Orthographic& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(RelativeProjection& value) +{ + return apply(static_cast(value)); +} +std::optional> ReplacementVisitor::apply(EllipsoidPerspective& value) +{ + return apply(static_cast(value)); +} + +//////////////////////////////////////////////////////////////////////////////// +// +// General classes +// +std::optional> ReplacementVisitor::apply(FrameStamp& fs) +{ + return apply(static_cast(fs)); +} diff --git a/src/vsg/nodes/InstrumentationNode.cpp b/src/vsg/nodes/InstrumentationNode.cpp index 3c69d158e9..e545a9b47a 100644 --- a/src/vsg/nodes/InstrumentationNode.cpp +++ b/src/vsg/nodes/InstrumentationNode.cpp @@ -20,9 +20,10 @@ InstrumentationNode::InstrumentationNode() : _level(1), _color(255, 255, 255, 255), _name("InstrumentationNode"), - _sl_Visitor{_name.c_str(), "InstrumentationNode::traverse(Visitor& rt)", __FILE__, 42, _color, _level}, - _sl_ConstVisitor{_name.c_str(), "InstrumentationNode::traverse(Visitor& rt)", __FILE__, 48, _color, _level}, - _sl_RecordTraversal{_name.c_str(), "InstrumentationNode::traverse(Visitor& rt)", __FILE__, 54, _color, _level} + _sl_Visitor{_name.c_str(), "InstrumentationNode::traverse(Visitor& rt)", __FILE__, 67, _color, _level}, + _sl_ConstVisitor{_name.c_str(), "InstrumentationNode::traverse(Visitor& rt)", __FILE__, 73, _color, _level}, + _sl_RecordTraversal{_name.c_str(), "InstrumentationNode::traverse(Visitor& rt)", __FILE__, 79, _color, _level}, + _sl_ReplacementVisitor{_name.c_str(), "InstrumentationNode::traverse(Visitor& rt)", __FILE__, 86, _color, _level} { } @@ -33,7 +34,8 @@ InstrumentationNode::InstrumentationNode(const InstrumentationNode& rhs, const C _name(rhs._name), _sl_Visitor{rhs._sl_Visitor}, _sl_ConstVisitor{rhs._sl_ConstVisitor}, - _sl_RecordTraversal{rhs._sl_RecordTraversal} + _sl_RecordTraversal{rhs._sl_RecordTraversal}, + _sl_ReplacementVisitor{rhs._sl_ReplacementVisitor} { _sl_Visitor.name = _name.c_str(); _sl_ConstVisitor.name = _name.c_str(); @@ -79,6 +81,13 @@ void InstrumentationNode::traverse(RecordTraversal& rt) const child->accept(rt); } + +void InstrumentationNode::traverse(ReplacementVisitor& visitor) +{ + CpuInstrumentation cpuInst(visitor.getInstrumentation(), &_sl_ReplacementVisitor, child.get()); + visitor.tryReplacePointer(child); +} + void InstrumentationNode::setColor(uint_color color) { _color = color; diff --git a/src/vsg/state/ViewDependentState.cpp b/src/vsg/state/ViewDependentState.cpp index 0d194f9fbc..3c7a334e21 100644 --- a/src/vsg/state/ViewDependentState.cpp +++ b/src/vsg/state/ViewDependentState.cpp @@ -54,6 +54,21 @@ namespace vsg void traverse(Visitor& visitor) override { t_traverse(*this, visitor); } void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); } void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); } + void traverse(ReplacementVisitor& visitor) override + { + if (auto ref_node = node.ref_ptr()) + { + std::optional> newPtr = visitor.acceptChecked(*ref_node); + if (newPtr.has_value()) + { + node = newPtr.value(); + } + // newPtr will go out of scope here, so if visitor doesn't keep the replacement alive by other means, + // e.g. a map from replaced objects to their replacements so the same replacement is returned when an + // object is visited via multiple paths in the scenegraph, then node will become stale and no longer + // be lockable. + } + } }; VSG_type_name(TraverseChildrenOfNode); diff --git a/src/vsg/utils/GraphicsPipelineConfigurator.cpp b/src/vsg/utils/GraphicsPipelineConfigurator.cpp index 0a5a698272..8bf12763d7 100644 --- a/src/vsg/utils/GraphicsPipelineConfigurator.cpp +++ b/src/vsg/utils/GraphicsPipelineConfigurator.cpp @@ -421,6 +421,14 @@ void GraphicsPipelineConfigurator::traverse(ConstVisitor& visitor) const if (descriptorConfigurator) descriptorConfigurator->accept(visitor); } +void GraphicsPipelineConfigurator::traverse(ReplacementVisitor& visitor) +{ + for (auto& ps : pipelineStates) visitor.tryReplacePointer(ps); + if (shaderSet) visitor.tryReplacePointer(shaderSet); + if (shaderHints) visitor.tryReplacePointer(shaderHints); + if (descriptorConfigurator) visitor.tryReplacePointer(descriptorConfigurator); +} + void GraphicsPipelineConfigurator::reset() { pipelineStates.clear(); diff --git a/src/vsg/utils/SharedObjects.cpp b/src/vsg/utils/SharedObjects.cpp index 9d455d7e0d..d0d9567f0a 100644 --- a/src/vsg/utils/SharedObjects.cpp +++ b/src/vsg/utils/SharedObjects.cpp @@ -214,6 +214,10 @@ void LoadedObject::traverse(ConstVisitor& visitor) const { if (object) object->accept(visitor); } +void LoadedObject::traverse(ReplacementVisitor& visitor) +{ + if (object) visitor.tryReplacePointer(object); +} int LoadedObject::compare(const Object& rhs_object) const {