Bring in latest changes to VSG master into 1.0 branch in prep for 1.0.6 release

CMakeLists.txt

@@ -44,8 +44,8 @@ if (VSG_SUPPORTS_ShaderCompiler)
 
         if (Git_FOUND)
 
-            set(glslang_URL "https://github.com/vsg-dev/glslang.git" CACHE STRING "URL of the glslang git repositiory")
-            set(glslang_branch "VSG-1.0.x" CACHE STRING "branch/tag of the glslang git repositiory")
+            set(glslang_URL "https://github.com/vsg-dev/glslang.git" CACHE STRING "URL of the glslang git repository")
+            set(glslang_branch "VSG-1.0.x" CACHE STRING "branch/tag of the glslang git repository")
 
             execute_process(COMMAND ${GIT_EXECUTABLE} clone --depth 1 --branch ${glslang_branch} ${glslang_URL}
                             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/src

cmake/cppcheck-suppression-list.txt

@@ -134,6 +134,7 @@ returnTempReference:*/include/vsg/core/Inherit.h
 // suppress inappropriate warning of variableScope
 variableScope:*/include/vsg/utils/SharedObjects.h
 variableScope:*/src/vsg/utils/SharedObjects.cpp
+variableScope:*/src/vsg/app/CompileManager.cpp
 
 // suppress really stupid warning of pointerLessThanZero
 pointerLessThanZero:*/src/vsg/app/Viewer.cpp

include/vsg/all.h

@@ -163,6 +163,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include <vsg/ui/CollectEvents.h>
 #include <vsg/ui/FrameStamp.h>
 #include <vsg/ui/KeyEvent.h>
+#include <vsg/ui/Keyboard.h>
 #include <vsg/ui/PlayEvents.h>
 #include <vsg/ui/PointerEvent.h>
 #include <vsg/ui/PrintEvents.h>

include/vsg/app/RenderGraph.h

@@ -41,7 +41,7 @@ namespace vsg
         ref_ptr<Framebuffer> framebuffer;
         ref_ptr<Window> window;
 
-        /// RenderPass to use passed to the vkCmdBeginRenderPass, either obtained from which of the framebuffer or window are active
+        /// RenderPass to use passed to the vkCmdBeginRenderPass, if renderPass is set it takes precedence, if not then either obtained from which of the framebuffer or window are active
         RenderPass* getRenderPass();
 
         /// Get the Exten2D of the attached Framebuffer or Window.
@@ -50,6 +50,9 @@ namespace vsg
         /// ReandingArea settings for VkRenderPassBeginInfo.renderArea passed to the vkCmdBeginRenderPass, usually maps the ViewportState's scissor
         VkRect2D renderArea;
 
+        /// RenderPass to use passed to the vkCmdBeginRenderPass in place of the framebuffer's or window's renderPass. renderPass must be compatible with the render pass used to create the window or framebuffer.
+        ref_ptr<RenderPass> renderPass;
+
         /// Buffer clearing settings for vkRrenderPassInfo.clearValueCount & vkRenderPassInfo.pClearValues passed to the vkCmdBeginRenderPass
         using ClearValues = std::vector<VkClearValue>;
         ClearValues clearValues; // initialize window colour and depth/stencil

include/vsg/app/Trackball.h

@@ -15,8 +15,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include <vsg/app/Camera.h>
 #include <vsg/app/EllipsoidModel.h>
 #include <vsg/maths/transform.h>
-#include <vsg/ui/ApplicationEvent.h>
-#include <vsg/ui/KeyEvent.h>
+#include <vsg/ui/Keyboard.h>
 #include <vsg/ui/PointerEvent.h>
 #include <vsg/ui/ScrollWheelEvent.h>
 #include <vsg/ui/TouchEvent.h>
@@ -37,6 +36,9 @@ namespace vsg
         dvec3 tbc(PointerEvent& event);
 
         void apply(KeyPressEvent& keyPress) override;
+        void apply(KeyReleaseEvent& keyRelease) override;
+        void apply(FocusInEvent& focusIn) override;
+        void apply(FocusOutEvent& focusOut) override;
         void apply(ButtonPressEvent& buttonPress) override;
         void apply(ButtonReleaseEvent& buttonRelease) override;
         void apply(MoveEvent& moveEvent) override;
@@ -81,6 +83,42 @@ namespace vsg
         /// container that maps key symbol bindings with the Viewpoint that should move the LookAt to when pressed.
         std::map<KeySymbol, Viewpoint> keyViewpointMap;
 
+        /// Key that turns the view left around the eye points
+        KeySymbol turnLeftKey = KEY_a;
+
+        /// Key that turns the view right around the eye points
+        KeySymbol turnRightKey = KEY_d;
+
+        /// Key that pitches up the view around the eye point
+        KeySymbol pitchUpKey = KEY_w;
+
+        /// Key that pitches down the view around the eye point
+        KeySymbol pitchDownKey = KEY_s;
+
+        /// Key that rools the view anti-clockwise/left
+        KeySymbol rollLeftKey = KEY_q;
+
+        /// Key that rolls the view clockwise/right
+        KeySymbol rollRightKey = KEY_e;
+
+        /// Key that moves the view forward
+        KeySymbol moveForwardKey = KEY_o;
+
+        /// Key that moves the view backwards
+        KeySymbol moveBackwardKey = KEY_i;
+
+        /// Key that moves the view left
+        KeySymbol moveLeftKey = KEY_Left;
+
+        /// Key that moves the view right
+        KeySymbol moveRightKey = KEY_Right;
+
+        /// Key that moves the view upward
+        KeySymbol moveUpKey = KEY_Up;
+
+        /// Key that moves the view downard
+        KeySymbol moveDownKey = KEY_Down;
+
         /// Button mask value used to enable panning of the view, defaults to left mouse button
         ButtonMask rotateButtonMask = BUTTON_MASK_1;
 
@@ -104,7 +142,8 @@ namespace vsg
         ref_ptr<LookAt> _lookAt;
         ref_ptr<EllipsoidModel> _ellipsoidModel;
 
-        bool _hasFocus = false;
+        bool _hasKeyboardFocus = false;
+        bool _hasPointerFocus = false;
         bool _lastPointerEventWithinRenderArea = false;
 
         enum UpdateMode
@@ -131,6 +170,8 @@ namespace vsg
         ref_ptr<LookAt> _endLookAt;
         std::map<uint32_t, ref_ptr<TouchEvent>> _previousTouches;
 
+        ref_ptr<Keyboard> _keyboard;
+
         double _animationDuration = 0.0;
     };
     VSG_type_name(vsg::Trackball);

include/vsg/app/WindowResizeHandler.h

@@ -26,6 +26,8 @@ namespace vsg
     class VSG_DECLSPEC UpdateGraphicsPipelines : public vsg::Inherit<vsg::Visitor, UpdateGraphicsPipelines>
     {
     public:
+        UpdateGraphicsPipelines();
+
         vsg::ref_ptr<vsg::Context> context;
         std::set<std::pair<const vsg::Object*, uint32_t>> visited;
 

include/vsg/core/Allocator.h

@@ -93,13 +93,15 @@ namespace vsg
             Allocator* parent = nullptr;
             std::string name;
             size_t blockSize = 0;
-            std::list<std::unique_ptr<MemoryBlock>> memoryBlocks;
+            std::map<void*, std::unique_ptr<MemoryBlock>> memoryBlocks;
+            MemoryBlock* latestMemoryBlock = nullptr;
 
             MemoryBlocks(Allocator* in_parent, const std::string& in_name, size_t in_blockSize);
             virtual ~MemoryBlocks();
 
             void* allocate(std::size_t size);
             bool deallocate(void* ptr, std::size_t size);
+
             size_t deleteEmptyMemoryBlocks();
             size_t totalAvailableSize() const;
             size_t totalReservedSize() const;
@@ -114,6 +116,9 @@ namespace vsg
 
         mutable std::mutex mutex;
 
+        double allocationTime = 0.0;
+        double deallocationTime = 0.0;
+
     protected:
         // if you are assigning a custom allocator you must retain the old allocator to manage the memory it allocated and needs to delete
         std::unique_ptr<Allocator> nestedAllocator;
@@ -135,7 +140,7 @@ namespace vsg
 
         allocator_affinity_nodes() = default;
         template<class U>
-        constexpr allocator_affinity_nodes(const allocator_affinity_nodes<U>&) noexcept {}
+        explicit constexpr allocator_affinity_nodes(const allocator_affinity_nodes<U>&) noexcept {}
 
         value_type* allocate(std::size_t n)
         {

include/vsg/core/ConstVisitor.h

@@ -109,6 +109,8 @@ namespace vsg
     class ExposeWindowEvent;
     class ConfigureWindowEvent;
     class CloseWindowEvent;
+    class FocusInEvent;
+    class FocusOutEvent;
     class KeyEvent;
     class KeyPressEvent;
     class KeyReleaseEvent;
@@ -356,6 +358,8 @@ namespace vsg
         virtual void apply(const ExposeWindowEvent&);
         virtual void apply(const ConfigureWindowEvent&);
         virtual void apply(const CloseWindowEvent&);
+        virtual void apply(const FocusInEvent&);
+        virtual void apply(const FocusOutEvent&);
         virtual void apply(const KeyEvent&);
         virtual void apply(const KeyPressEvent&);
         virtual void apply(const KeyReleaseEvent&);

include/vsg/core/Visitor.h

@@ -109,6 +109,8 @@ namespace vsg
     class ExposeWindowEvent;
     class ConfigureWindowEvent;
     class CloseWindowEvent;
+    class FocusInEvent;
+    class FocusOutEvent;
     class KeyEvent;
     class KeyPressEvent;
     class KeyReleaseEvent;
@@ -356,6 +358,8 @@ namespace vsg
         virtual void apply(ExposeWindowEvent&);
         virtual void apply(ConfigureWindowEvent&);
         virtual void apply(CloseWindowEvent&);
+        virtual void apply(FocusInEvent&);
+        virtual void apply(FocusOutEvent&);
         virtual void apply(KeyEvent&);
         virtual void apply(KeyPressEvent&);
         virtual void apply(KeyReleaseEvent&);

include/vsg/io/mem_stream.h

@@ -21,7 +21,7 @@ namespace vsg
 {
 
     /// Input stream that enables reading from a read only block of memory
-    /// Like std::string_view the memory referenced by the mem_stream has been kept in memory for the duration of the mem_stream existance.
+    /// Like std::string_view the memory referenced by the mem_stream has been kept in memory for the duration of the mem_stream existence.
     class VSG_DECLSPEC mem_stream : public std::istream
     {
     public:

include/vsg/maths/mat4.h

@@ -198,8 +198,9 @@ namespace vsg
                          lhs[0] * rhs[3][0] + lhs[1] * rhs[3][1] + lhs[2] * rhs[3][2] + lhs[3] * rhs[3][3]);
     }
 
-    /* Left multiplication of a plane and a matrix. This can be used directly to transform a plane
-       from a coordinate system's local coordinates to world coordinates. */
+    /* Left multiplication of a plane and a matrix. If the matrix is the inverse of the
+       local-to-world transform i.e., the world-to-local transform, then this can be used directly
+       to transform a plane from a coordinate system's local coordinates to world coordinates. */
     template<typename T, typename R>
     t_plane<T> operator*(const t_plane<T>& lhs, const t_mat4<R>& rhs)
     {

include/vsg/maths/plane.h

@@ -102,6 +102,8 @@ namespace vsg
 
         bool valid() const { return n.x != 0.0 && n.y != 0.0 && n.z != 0.0; }
 
+        explicit operator bool() const noexcept { return valid(); }
+
         T* data() { return value; }
         const T* data() const { return value; }
     };

include/vsg/maths/quat.h

@@ -141,6 +141,8 @@ namespace vsg
             z = axis.z * sinhalfangle * inversenorm;
             w = coshalfangle;
         }
+
+        explicit operator bool() const noexcept { return value[0] != 0.0 || value[1] != 0.0 || value[2] != 0.0 || value[3] != 0.0; }
     };
 
     using quat = t_quat<float>;   /// float quaternion

include/vsg/maths/vec2.h

@@ -130,6 +130,8 @@ namespace vsg
             }
             return *this;
         }
+
+        explicit operator bool() const noexcept { return value[0] != 0.0 || value[1] != 0.0; }
     };
 
     using vec2 = t_vec2<float>;           // float 2D vector

include/vsg/maths/vec3.h

@@ -140,6 +140,8 @@ namespace vsg
             }
             return *this;
         }
+
+        explicit operator bool() const noexcept { return value[0] != 0.0 || value[1] != 0.0 || value[2] != 0.0; }
     };
 
     using vec3 = t_vec3<float>;           // float 3D vector

include/vsg/maths/vec4.h

@@ -154,6 +154,8 @@ namespace vsg
             }
             return *this;
         }
+
+        explicit operator bool() const noexcept { return value[0] != 0.0 || value[1] != 0.0 || value[2] != 0.0 || value[3] != 0.0; }
     };
 
     using vec4 = t_vec4<float>;           // float 4D vector

include/vsg/ui/Keyboard.h

@@ -0,0 +1,49 @@
+#pragma once
+
+/* <editor-fold desc="MIT License">
+
+Copyright(c) 2023 Robert Osfield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+</editor-fold> */
+
+#include <vsg/ui/ApplicationEvent.h>
+#include <vsg/ui/KeyEvent.h>
+
+namespace vsg
+{
+
+    /// Keyboard tracks keyboard events to maintain the key pressed state and how long the key has been hel for
+    class VSG_DECLSPEC Keyboard : public Inherit<Visitor, Keyboard>
+    {
+    public:
+        void apply(KeyPressEvent& keyPress) override;
+        void apply(KeyReleaseEvent& keyRelease) override;
+        void apply(FocusInEvent& focusIn) override;
+        void apply(FocusOutEvent& focusOut) override;
+
+        struct KeyHistory
+        {
+            vsg::time_point timeOfFirstKeyPress = {};
+            vsg::time_point timeOfLastKeyPress = {};
+            vsg::time_point timeOfKeyRelease = {};
+            bool handled = false;
+        };
+
+        std::map<KeySymbol, KeyHistory> keyState;
+
+        /// return true if key is currently pressed
+        bool pressed(KeySymbol key, bool ignore_handled_keys = true);
+
+        /// return a pair of times, the first is the time, in seconds, since the key was first pressed and the second is the time, in secnds, since it was released.
+        /// if the key hasn't been pressed then then first value will be < 0.0, if the key is still pressed then the second value will be 0.0.
+        std::pair<double, double> times(KeySymbol key, bool ignore_handled_keys = true);
+    };
+    VSG_type_name(vsg::Keyboard);
+
+} // namespace vsg

include/vsg/ui/WindowEvent.h

@@ -93,4 +93,26 @@ namespace vsg
     };
     VSG_type_name(vsg::CloseWindowEvent);
 
+    /// FocusInEvent represents a window aquiring focus event.
+    class FocusInEvent : public Inherit<WindowEvent, FocusInEvent>
+    {
+    public:
+        FocusInEvent() {}
+
+        FocusInEvent(Window* in_window, time_point in_time) :
+            Inherit(in_window, in_time) {}
+    };
+    VSG_type_name(vsg::FocusInEvent);
+
+    /// FocusOutEvent represents a window loosing focus event.
+    class FocusOutEvent : public Inherit<WindowEvent, FocusOutEvent>
+    {
+    public:
+        FocusOutEvent() {}
+
+        FocusOutEvent(Window* in_window, time_point in_time) :
+            Inherit(in_window, in_time) {}
+    };
+    VSG_type_name(vsg::FocusOutEvent);
+
 } // namespace vsg

include/vsg/vk/Device.h

@@ -58,6 +58,8 @@ namespace vsg
         const Extensions* getExtensions() const { return _extensions.get(); }
 
         /// get the address of specified function using vkGetDeviceProcAddr
+        /// for core commands beyond the apiVersion specified in vsg::Instance creation, vkGetDeviceProcAddr may return a non-nullptr function pointer, though the function pointer must not be called.
+        /// for extension commands, vkGetDeviceProcAddr will always return nullptr if the extension is not enabled in vsg::Device creation.
         template<typename T>
         bool getProcAddr(T& procAddress, const char* pName, const char* pNameFallback = nullptr) const
         {
@@ -68,6 +70,9 @@ namespace vsg
             return (procAddress);
         }
 
+        /// device-level core functionality can be used if both VkInstance and VkPhysicalDevice support the Vulkan version that provides it.
+        bool supportsApiVersion(uint32_t version) const;
+
     protected:
         virtual ~Device();
 

include/vsg/vk/PhysicalDevice.h

@@ -75,6 +75,9 @@ namespace vsg
         /// Call vkEnumerateDeviceExtensionProperties to enumerate extension properties.
         std::vector<VkExtensionProperties> enumerateDeviceExtensionProperties(const char* pLayerName = nullptr);
 
+        /// return true if the extension is supported by physicalDevice
+        bool supportsDeviceExtension(const char* extensionName);
+
     protected:
         // use Instance::getDevice(..) to create PhysicalDevice
         PhysicalDevice(Instance* instance, VkPhysicalDevice device);

src/vsg/CMakeLists.txt

@@ -192,6 +192,7 @@ set(SOURCES
     ui/ShiftEventTime.cpp
     ui/PlayEvents.cpp
     ui/PrintEvents.cpp
+    ui/Keyboard.cpp
 
     vk/CommandBuffer.cpp
     vk/CommandPool.cpp

src/vsg/app/CompileManager.cpp

@@ -202,7 +202,7 @@ CompileResult CompileManager::compile(ref_ptr<Object> object, ContextSelectionFu
         catch (...)
         {
             vsg::debug("CompileManager::compile() exception caught");
-            result.message = "Exception occured during compilation.";
+            result.message = "Exception occurred during compilation.";
             result.result = VK_ERROR_UNKNOWN;
         }