Shadows

include/vsg/app/CommandGraph.h

@@ -26,6 +26,7 @@ namespace vsg
     class VSG_DECLSPEC CommandGraph : public Inherit<Group, CommandGraph>
     {
     public:
+        CommandGraph();
         CommandGraph(ref_ptr<Device> in_device, int family);
         explicit CommandGraph(ref_ptr<Window> in_window, ref_ptr<Node> child = {});
 

include/vsg/app/View.h

@@ -15,21 +15,23 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include <vsg/app/Camera.h>
 #include <vsg/app/Window.h>
 #include <vsg/nodes/Group.h>
-#include <vsg/state/ViewDependentState.h>
 
 namespace vsg
 {
 
+    // forward declare
+    class ViewDependentState;
+
     /// View is a Group class that pairs a Camera that defines the view with a subgraph that defines the scene that is being viewed/rendered
     class VSG_DECLSPEC View : public Inherit<Group, View>
     {
     public:
-        View();
+        View(bool activeViewDependentState = true);
 
         // share the specified view's children, viewID, mask and camera ViewportState
         View(const View& view);
 
-        explicit View(ref_ptr<Camera> in_camera, ref_ptr<Node> in_scenegraph = {});
+        explicit View(ref_ptr<Camera> in_camera, ref_ptr<Node> in_scenegraph = {}, bool activeViewDependentState = true);
 
         template<class N, class V>
         static void t_accept(N& node, V& visitor)

include/vsg/app/WindowResizeHandler.h

@@ -23,22 +23,22 @@ namespace vsg
 
     /// Utility class for updating a scene graph when a View's camera ViewportState has been updated so that associated GraphicsPipelines in the
     /// scene graph can be recompiled and correctly reflect the new ViewportState.
-    class VSG_DECLSPEC UpdateGraphicsPipelines : public vsg::Inherit<vsg::Visitor, UpdateGraphicsPipelines>
+    class VSG_DECLSPEC UpdateGraphicsPipelines : public Inherit<Visitor, UpdateGraphicsPipelines>
     {
     public:
         UpdateGraphicsPipelines();
 
-        vsg::ref_ptr<vsg::Context> context;
-        std::set<std::pair<const vsg::Object*, uint32_t>> visited;
+        ref_ptr<Context> context;
+        std::set<std::pair<const Object*, uint32_t>> visited;
 
         bool visit(const Object* object, uint32_t index);
 
-        void apply(vsg::Object& object) override;
-        void apply(vsg::BindGraphicsPipeline& bindPipeline) override;
-        void apply(vsg::StateGroup& sg) override;
-        void apply(vsg::View& view) override;
+        void apply(Object& object) override;
+        void apply(BindGraphicsPipeline& bindPipeline) override;
+        void apply(StateGroup& sg) override;
+        void apply(View& view) override;
     };
-    VSG_type_name(vsg::UpdateGraphicsPipelines);
+    VSG_type_name(UpdateGraphicsPipelines);
 
     /// WindowResizeHandler class for updating viewport/scissor and attachments to fit with new window dimensions.
     class VSG_DECLSPEC WindowResizeHandler : public Inherit<Visitor, WindowResizeHandler>
@@ -70,6 +70,6 @@ namespace vsg
         void apply(ClearAttachments& clearAttachments) override;
         void apply(View& view) override;
     };
-    VSG_type_name(vsg::WindowResizeHandler);
+    VSG_type_name(WindowResizeHandler);
 
 } // namespace vsg

include/vsg/maths/transform.h

@@ -156,7 +156,7 @@ namespace vsg
         return t_mat4<T>(2.0 / (right - left), 0.0, 0.0, 0.0,
                          0.0, 2.0 / (bottom - top), 0.0, 0.0,
                          0.0, 0.0, 1.0 / (zFar - zNear), 0.0,
-                         -(right + left) / (right - left), -(bottom + top) / (bottom - top), zFar / (zFar - zNear), 1.0);
+                         -(right + left) / (right - left), -(bottom + top) / (bottom - top), 0.5 - (zNear + zFar) / (2.0 * (zFar - zNear)), 1.0);
     }
 
     template<typename T>

include/vsg/nodes/Light.h

@@ -27,6 +27,7 @@ namespace vsg
         std::string name;
         vec3 color = vec3(1.0f, 1.0f, 1.0f);
         float intensity = 1.0f;
+        uint32_t shadowMaps = 0;
 
         void read(Input& input) override;
         void write(Output& output) const override;

include/vsg/state/ResourceHints.h

@@ -12,6 +12,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 </editor-fold> */
 
+#include <vsg/maths/vec2.h>
 #include <vsg/vk/DescriptorPool.h>
 
 namespace vsg
@@ -32,6 +33,10 @@ namespace vsg
         VkDeviceSize minimumBufferSize = 16 * 1024 * 1024;
         VkDeviceSize minimumDeviceMemorySize = 16 * 1024 * 1024;
 
+        uivec2 numLightsRange = {8, 1024};
+        uivec2 numShadowMapsRange = {0, 64};
+        uivec2 shadowMapSize = {2048, 2028};
+
         void read(Input& input) override;
         void write(Output& output) const override;
 

include/vsg/state/Sampler.h

@@ -17,6 +17,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 namespace vsg
 {
+    // forward declare
     class Context;
 
     /// Sampler encapsulates the VkSampler and the VkSamplerCreateInfo settings used to set it up.

include/vsg/state/ViewDependentState.h

@@ -12,9 +12,14 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 </editor-fold> */
 
+#include <vsg/app/CommandGraph.h>
+#include <vsg/app/RenderGraph.h>
+#include <vsg/io/Logger.h>
 #include <vsg/nodes/Light.h>
+#include <vsg/nodes/Switch.h>
 #include <vsg/state/BindDescriptorSet.h>
 #include <vsg/state/DescriptorBuffer.h>
+#include <vsg/state/DescriptorImage.h>
 
 namespace vsg
 {
@@ -86,6 +91,9 @@ namespace vsg
     };
     VSG_type_name(vsg::BindViewDescriptorSets);
 
+    // forward declare
+    class ResourceRequirements;
+
     /// ViewDependentState to manage lighting, clip planes and texture projection
     /// By default assigned to the vsg::View, for standard usage you don't need to create or modify the ViewDependentState
     /// If you wish to override the standard lighting support provided by ViewDependentState you can subclass it.
@@ -96,38 +104,65 @@ namespace vsg
     class VSG_DECLSPEC ViewDependentState : public Inherit<Object, ViewDependentState>
     {
     public:
-        ViewDependentState(uint32_t maxNumberLights = 64, uint32_t maxViewports = 1);
+        ViewDependentState(View* view, bool in_active);
 
         template<class N, class V>
         static void t_traverse(N& node, V& visitor)
         {
             node.descriptorSet->accept(visitor);
+            if (node.preRenderCommandGraph) node.preRenderCommandGraph->accept(visitor);
         }
 
         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;
 
         // containers filled in by RecordTraversal
         std::vector<std::pair<dmat4, const AmbientLight*>> ambientLights;
         std::vector<std::pair<dmat4, const DirectionalLight*>> directionalLights;
         std::vector<std::pair<dmat4, const PointLight*>> pointLights;
         std::vector<std::pair<dmat4, const SpotLight*>> spotLights;
 
-        virtual void compile(Context& context);
+        virtual void init(ResourceRequirements& requirements);
+
         virtual void clear();
-        virtual void pack();
         virtual void bindDescriptorSets(CommandBuffer& commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet);
 
+        virtual void compile(Context& context);
+
+        View* view = nullptr;
+        bool active = true;
+
         ref_ptr<vec4Array> lightData;
         ref_ptr<BufferInfo> lightDataBufferInfo;
 
         ref_ptr<vec4Array> viewportData;
         ref_ptr<BufferInfo> viewportDataBufferInfo;
 
+        ref_ptr<Image> shadowDepthImage;
+        ref_ptr<DescriptorImage> shadowMapImages;
+
         ref_ptr<DescriptorSetLayout> descriptorSetLayout;
         ref_ptr<DescriptorBuffer> descriptor;
         ref_ptr<DescriptorSet> descriptorSet;
 
+        // shadow map hints
+        double maxShadowDistance = 1e8;
+        double shadowMapBias = 0.005;
+        double lambda = 0.5;
+
+        // Shadow backend.
+        ref_ptr<CommandGraph> preRenderCommandGraph;
+        ref_ptr<Switch> preRenderSwitch;
+
+        struct ShadowMap
+        {
+            ref_ptr<RenderGraph> renderGraph;
+            ref_ptr<View> view;
+        };
+
+        mutable std::vector<ShadowMap> shadowMaps;
+
     protected:
         ~ViewDependentState();
     };

include/vsg/utils/AnimationPath.h

@@ -67,7 +67,9 @@ namespace vsg
 
         ref_ptr<Object> object;
         ref_ptr<AnimationPath> path;
+
         KeySymbol resetKey = KEY_Space;
+
         clock::time_point startPoint;
         double time = 0.0;
 
@@ -85,4 +87,37 @@ namespace vsg
     };
     VSG_type_name(vsg::AnimationPathHandler);
 
+    /// RecordAnimationPathHandler event handler records the camera
+    class VSG_DECLSPEC RecordAnimationPathHandler : public Inherit<Visitor, RecordAnimationPathHandler>
+    {
+    public:
+        explicit RecordAnimationPathHandler(ref_ptr<Object> in_object, const Path& in_filename = "saved_animation.vsgt", ref_ptr<Options> in_options = {});
+
+        ref_ptr<Object> object;
+        Path filename;
+        ref_ptr<Options> options;
+
+        ref_ptr<AnimationPath> path;
+        KeySymbol toggleRecordingKey = KEY_r;
+        KeySymbol togglePlaybackKey = KEY_p;
+
+        bool recording = false;
+        bool playing = false;
+        clock::time_point startPoint;
+        double time = 0.0;
+
+        bool printFrameStatsToConsole = false;
+        clock::time_point statsStartPoint;
+        double frameCount = 0.0;
+
+        void apply(Camera& camera) override;
+        void apply(MatrixTransform& transform) override;
+
+        void apply(KeyPressEvent& keyPress) override;
+        void apply(FrameEvent& frame) override;
+
+    protected:
+    };
+    VSG_type_name(vsg::RecordAnimationPathHandler);
+
 } // namespace vsg

include/vsg/utils/GraphicsPipelineConfigurator.h

@@ -52,15 +52,11 @@ namespace vsg
         bool assignDescriptor(const std::string& name, ref_ptr<Data> data = {}, uint32_t dstArrayElement = 0);
         bool assignDescriptor(const std::string& name, const BufferInfoList& bufferInfoList, uint32_t dstArrayElement = 0);
 
-        [[deprecated("use enableDescriptor(..)")]]
-        bool enableUniform(const std::string& name) { return enableDescriptor(name); }
+        [[deprecated("use enableDescriptor(..)")]] bool enableUniform(const std::string& name) { return enableDescriptor(name); }
 
-        [[deprecated("use assignDescriptor(..)")]]
-        bool assignUniform(const std::string& name, ref_ptr<Data> data = {}, uint32_t dstArrayElement = 0) { return assignDescriptor(name, data, dstArrayElement); }
-
-        [[deprecated("use assignDescriptor(..)")]]
-        bool assignUniform(const std::string& name, const BufferInfoList& bufferInfoList, uint32_t dstArrayElement = 0) { return assignDescriptor(name, bufferInfoList, dstArrayElement); }
+        [[deprecated("use assignDescriptor(..)")]] bool assignUniform(const std::string& name, ref_ptr<Data> data = {}, uint32_t dstArrayElement = 0) { return assignDescriptor(name, data, dstArrayElement); }
 
+        [[deprecated("use assignDescriptor(..)")]] bool assignUniform(const std::string& name, const BufferInfoList& bufferInfoList, uint32_t dstArrayElement = 0) { return assignDescriptor(name, bufferInfoList, dstArrayElement); }
 
         bool assignDescriptor(uint32_t set, uint32_t binding, VkDescriptorType descriptorType, uint32_t descriptorCount, VkShaderStageFlags stageFlags, ref_ptr<Descriptor> descriptor);
 
@@ -120,11 +116,9 @@ namespace vsg
         bool assignDescriptor(const std::string& name, ref_ptr<Data> data = {});
         bool assignTexture(const std::string& name, ref_ptr<Data> textureData = {}, ref_ptr<Sampler> sampler = {});
 
-        [[deprecated("use enableDescriptor(..)")]]
-        bool enableUniform(const std::string& name) { return enableDescriptor(name); }
+        [[deprecated("use enableDescriptor(..)")]] bool enableUniform(const std::string& name) { return enableDescriptor(name); }
 
-        [[deprecated("use assignDescriptor(..)")]]
-        bool assignUniform(const std::string& name, ref_ptr<Data> data = {}) { return assignDescriptor(name, data); }
+        [[deprecated("use assignDescriptor(..)")]] bool assignUniform(const std::string& name, ref_ptr<Data> data = {}) { return assignDescriptor(name, data); }
 
         // setup by assign calls
         ref_ptr<ShaderCompileSettings> shaderHints;

include/vsg/utils/ShaderSet.h

@@ -136,9 +136,7 @@ namespace vsg
         /// add an uniform binding. Not thread safe, should only be called when initially setting up the ShaderSet
         void addDescriptorBinding(const std::string& name, const std::string& define, uint32_t set, uint32_t binding, VkDescriptorType descriptorType, uint32_t descriptorCount, VkShaderStageFlags stageFlags, ref_ptr<Data> data);
 
-        [[deprecated("use addDescriptorBinding(..)")]]
-        void addUniformBinding(const std::string& name, const std::string& define, uint32_t set, uint32_t binding, VkDescriptorType descriptorType, uint32_t descriptorCount, VkShaderStageFlags stageFlags, ref_ptr<Data> data) { addDescriptorBinding(name, define, set, binding, descriptorType, descriptorCount, stageFlags, data); }
-
+        [[deprecated("use addDescriptorBinding(..)")]] void addUniformBinding(const std::string& name, const std::string& define, uint32_t set, uint32_t binding, VkDescriptorType descriptorType, uint32_t descriptorCount, VkShaderStageFlags stageFlags, ref_ptr<Data> data) { addDescriptorBinding(name, define, set, binding, descriptorType, descriptorCount, stageFlags, data); }
 
         /// add a push constant range. Not thread safe, should only be called when initially setting up the ShaderSet
         void addPushConstantRange(const std::string& name, const std::string& define, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size);
@@ -155,11 +153,9 @@ namespace vsg
         /// get the const DescriptorBinding associated with name
         const DescriptorBinding& getDescriptorBinding(const std::string& name) const;
 
-        [[deprecated("use getDescriptorBinding(..)")]]
-        DescriptorBinding& getUniformBinding(const std::string& name) { return getDescriptorBinding(name); }
+        [[deprecated("use getDescriptorBinding(..)")]] DescriptorBinding& getUniformBinding(const std::string& name) { return getDescriptorBinding(name); }
 
-        [[deprecated("use getDescriptorBinding(..)")]]
-        const DescriptorBinding& getUnifomrBinding(const std::string& name) const { return getDescriptorBinding(name); }
+        [[deprecated("use getDescriptorBinding(..)")]] const DescriptorBinding& getUnifomrBinding(const std::string& name) const { return getDescriptorBinding(name); }
 
         /// get the first ArrayState that has matches with defines in the specified list of defines.
         ref_ptr<ArrayState> getSuitableArrayState(const std::set<std::string>& defines) const;

include/vsg/vk/Context.h

@@ -66,14 +66,15 @@ namespace vsg
     class VSG_DECLSPEC Context : public Inherit<Object, Context>
     {
     public:
-        explicit Context(Device* in_device, const ResourceRequirements& resourceRequirements = {});
+        explicit Context(Device* in_device, const ResourceRequirements& in_resourceRequirements = {});
 
         Context(const Context& context);
 
         virtual ~Context();
 
         const uint32_t deviceID = 0;
         ref_ptr<Device> device;
+        ResourceRequirements resourceRequirements;
 
         observer_ptr<View> view;
         uint32_t viewID = 0;

include/vsg/vk/ResourceRequirements.h

@@ -39,17 +39,18 @@ namespace vsg
         uint32_t computeNumDescriptorSets() const;
         DescriptorPoolSizes computeDescriptorPoolSizes() const;
 
-        struct BinDetails
+        struct ViewDetails
         {
             std::set<int32_t> indices;
             std::set<const Bin*> bins;
+            std::set<const Light*> lights;
         };
 
         using Descriptors = std::set<const Descriptor*>;
         using DescriptorSets = std::set<const DescriptorSet*>;
         using DescriptorTypeMap = std::map<VkDescriptorType, uint32_t>;
-        using Views = std::map<const View*, BinDetails>;
-        using BinStack = std::stack<BinDetails>;
+        using Views = std::map<const View*, ViewDetails>;
+        using ViewDetailStack = std::stack<ViewDetails>;
 
         struct DynamicData
         {
@@ -78,14 +79,18 @@ namespace vsg
         DescriptorSets descriptorSets;
         DescriptorTypeMap descriptorTypeMap;
         Views views;
-        BinStack binStack;
+        ViewDetailStack viewDetailsStack;
 
         uint32_t maxSlot = 0;
         uint32_t externalNumDescriptorSets = 0;
         bool containsPagedLOD = false;
 
         VkDeviceSize minimumBufferSize = 16 * 1024 * 1024;
         VkDeviceSize minimumDeviceMemorySize = 16 * 1024 * 1024;
+
+        uivec2 numLightsRange = {8, 1024};
+        uivec2 numShadowMapsRange = {0, 64};
+        uivec2 shadowMapSize = {2048, 2048};
     };
     VSG_type_name(vsg::ResourceRequirements);
 
@@ -114,6 +119,7 @@ namespace vsg
         void apply(const DescriptorBuffer& descriptorBuffer) override;
         void apply(const DescriptorImage& descriptorImage) override;
         void apply(const PagedLOD& plod) override;
+        void apply(const Light& light) override;
         void apply(const View& view) override;
         void apply(const DepthSorted& depthSorted) override;
         void apply(const Bin& bin) override;

src/vsg/app/CommandGraph.cpp

@@ -18,6 +18,10 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 using namespace vsg;
 
+CommandGraph::CommandGraph()
+{
+}
+
 CommandGraph::CommandGraph(ref_ptr<Device> in_device, int family) :
     device(in_device),
     queueFamily(family),