Merge master into 1.0 branch

CMakeLists.txt

@@ -1,12 +1,12 @@
 cmake_minimum_required(VERSION 3.7)
 
 project(vsg
-    VERSION 1.0.6
+    VERSION 1.0.7
     DESCRIPTION "VulkanSceneGraph library"
     LANGUAGES CXX
 )
 set(VSG_SOVERSION 13)
-SET(VSG_RELEASE_CANDIDATE 0)
+SET(VSG_RELEASE_CANDIDATE 1)
 set(Vulkan_MIN_VERSION 1.1.70.0)
 
 set(VSG_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "Root source directory of VulkanSceneGraph.")

README.md

@@ -23,6 +23,7 @@ Hosted as part of the [vsg-dev](https://github.com/vsg-dev):
 * [osg2vsg](https://github.com/vsg-dev/osg2vsg) OpenSceneGraph integration library that enables converting of OSG to VSG scene graph and use of OpenSceneGraph loaders.
 * [vsgImGui](https://github.com/vsg-dev/vsgImGui) ImGui integration enabling UI in graphics window.
 * [vsgQt](https://github.com/vsg-dev/vsgQt) Qt integration with VulkanSceneGraph.
+* [vsgPoints](https://github.com/vsg-dev/vsgPoints) 3d point cloud loading and rendering for VulkanSceneGraph with database paging support and scalability up to billions of ponts.
 * [vsgUnity](https://github.com/vsg-dev/vsgUnity) plugin for Unity that provides export to native VulkanSceneGraph binary/ascii format.
 * [MyFirstVsgApplication](https://github.com/vsg-dev/MyFirstVsgApplication) simple standalone VSG application that can be used as a template for your own applications.
 * [vsgFramework](https://github.com/vsg-dev/vsgFramework) template project that uses CMake FetchContent to pull in all the main libraries associated with VulkanSceneGraph and dependencies and builds them together.

include/vsg/core/ConstVisitor.h

@@ -154,6 +154,7 @@ namespace vsg
 
         // Values
         virtual void apply(const stringValue&);
+        virtual void apply(const wstringValue&);
         virtual void apply(const boolValue&);
         virtual void apply(const intValue&);
         virtual void apply(const uintValue&);

include/vsg/core/Value.h

@@ -191,6 +191,7 @@ namespace vsg
     }
 
     VSG_value(stringValue, std::string);
+    VSG_value(wstringValue, std::wstring);
 
     VSG_value(boolValue, bool);
     VSG_value(intValue, int);

include/vsg/core/Visitor.h

@@ -154,6 +154,7 @@ namespace vsg
 
         // Values
         virtual void apply(stringValue&);
+        virtual void apply(wstringValue&);
         virtual void apply(boolValue&);
         virtual void apply(intValue&);
         virtual void apply(uintValue&);

include/vsg/io/AsciiInput.h

@@ -89,9 +89,15 @@ namespace vsg
         // read in an individual string
         void _read(std::string& value);
 
+        // read in an individual string
+        void _read(std::wstring& value);
+
         /// read one or more strings
         void read(size_t num, std::string* value) override;
 
+        /// read one or more strings
+        void read(size_t num, std::wstring* value) override;
+
         /// read one or more strings
         void read(size_t num, Path* value) override;
 

include/vsg/io/AsciiOutput.h

@@ -141,7 +141,10 @@ namespace vsg
             _output << '"';
         }
 
+        void _write(const std::wstring& str);
+
         void write(size_t num, const std::string* value) override;
+        void write(size_t num, const std::wstring* value) override;
         void write(size_t num, const Path* value) override;
 
         /// write object

include/vsg/io/BinaryInput.h

@@ -62,6 +62,12 @@ namespace vsg
         /// read one or more strings
         void read(size_t num, std::string* value) override;
 
+        // read in an individual string
+        void _read(std::wstring& value);
+
+        /// read one or more strings
+        void read(size_t num, std::wstring* value) override;
+
         /// read one or more paths
         void read(size_t num, Path* value) override;
 

include/vsg/io/BinaryOutput.h

@@ -51,14 +51,11 @@ namespace vsg
         void write(size_t num, const float* value) override { _write(num, value); }
         void write(size_t num, const double* value) override { _write(num, value); }
 
-        void _write(const std::string& str)
-        {
-            uint32_t size = static_cast<uint32_t>(str.size());
-            _output.write(reinterpret_cast<const char*>(&size), sizeof(uint32_t));
-            _output.write(str.c_str(), size);
-        }
+        void _write(const std::string& str);
+        void _write(const std::wstring& str);
 
         void write(size_t num, const std::string* value) override;
+        void write(size_t num, const std::wstring* value) override;
         void write(size_t num, const Path* value) override;
 
         /// write object

include/vsg/io/Input.h

@@ -62,6 +62,7 @@ namespace vsg
         virtual void read(size_t num, float* value) = 0;
         virtual void read(size_t num, double* value) = 0;
         virtual void read(size_t num, std::string* value) = 0;
+        virtual void read(size_t num, std::wstring* value) = 0;
         virtual void read(size_t num, Path* value) = 0;
 
         // read object

include/vsg/io/Output.h

@@ -62,6 +62,7 @@ namespace vsg
         virtual void write(size_t num, const float* value) = 0;
         virtual void write(size_t num, const double* value) = 0;
         virtual void write(size_t num, const std::string* value) = 0;
+        virtual void write(size_t num, const std::wstring* value) = 0;
         virtual void write(size_t num, const Path* value) = 0;
 
         /// write object

include/vsg/maths/box.h

@@ -49,6 +49,8 @@ namespace vsg
 
         bool valid() const { return min.x <= max.x; }
 
+        explicit operator bool() const noexcept { return valid(); }
+
         T* data() { return min.data(); }
         const T* data() const { return min.data(); }
 
@@ -91,4 +93,25 @@ namespace vsg
 
     VSG_type_name(vsg::box);
     VSG_type_name(vsg::dbox);
+
+    template<typename T>
+    constexpr bool operator==(const t_box<T>& lhs, const t_box<T>& rhs)
+    {
+        return (lhs.min == rhs.min) && (lhs.max == rhs.max);
+    }
+
+    template<typename T>
+    constexpr bool operator!=(const t_box<T>& lhs, const t_box<T>& rhs)
+    {
+        return (lhs.min != rhs.min) || (lhs.max != rhs.max);
+    }
+
+    template<typename T>
+    constexpr bool operator<(const t_box<T>& lhs, const t_box<T>& rhs)
+    {
+        if (lhs.min < rhs.min) return true;
+        if (rhs.min < lhs.min) return false;
+        return lhs.max < rhs.max;
+    }
+
 } // namespace vsg

include/vsg/maths/plane.h

@@ -114,6 +114,30 @@ namespace vsg
     VSG_type_name(vsg::plane);
     VSG_type_name(vsg::dplane);
 
+    template<typename T>
+    constexpr bool operator==(const t_plane<T>& lhs, const t_plane<T>& rhs)
+    {
+        return lhs[0] == rhs[0] && lhs[1] == rhs[1] && lhs[2] == rhs[2] && lhs[3] == rhs[3];
+    }
+
+    template<typename T>
+    constexpr bool operator!=(const t_plane<T>& lhs, const t_plane<T>& rhs)
+    {
+        return lhs[0] != rhs[0] || lhs[1] != rhs[1] || lhs[2] != rhs[2] || lhs[3] != rhs[3];
+    }
+
+    template<typename T>
+    constexpr bool operator<(const t_plane<T>& lhs, const t_plane<T>& rhs)
+    {
+        if (lhs[0] < rhs[0]) return true;
+        if (lhs[0] > rhs[0]) return false;
+        if (lhs[1] < rhs[1]) return true;
+        if (lhs[1] > rhs[1]) return false;
+        if (lhs[2] < rhs[2]) return true;
+        if (lhs[2] > rhs[2]) return false;
+        return lhs[3] < rhs[3];
+    }
+
     template<typename T>
     constexpr T distance(const t_plane<T>& pl, const t_vec3<T>& v)
     {

include/vsg/maths/sphere.h

@@ -108,6 +108,8 @@ namespace vsg
 
         bool valid() const { return radius >= 0.0; }
 
+        explicit operator bool() const noexcept { return valid(); }
+
         T* data() { return value; }
         const T* data() const { return value; }
 
@@ -123,6 +125,27 @@ namespace vsg
 
     VSG_type_name(vsg::sphere);
     VSG_type_name(vsg::dsphere);
+
+    template<typename T>
+    constexpr bool operator==(const t_sphere<T>& lhs, const t_sphere<T>& rhs)
+    {
+        return (lhs.center == rhs.center) && (lhs.radius == rhs.radius);
+    }
+
+    template<typename T>
+    constexpr bool operator!=(const t_sphere<T>& lhs, const t_sphere<T>& rhs)
+    {
+        return (lhs.center != rhs.center) || (lhs.radius != rhs.radius);
+    }
+
+    template<typename T>
+    constexpr bool operator<(const t_sphere<T>& lhs, const t_sphere<T>& rhs)
+    {
+        if (lhs.center < rhs.center) return true;
+        if (rhs.center < lhs.center) return false;
+        return lhs.radius < rhs.radius;
+    }
+
 } // namespace vsg
 
 #if defined(__clang__)

include/vsg/nodes/LOD.h

@@ -44,6 +44,8 @@ namespace vsg
         void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); }
         void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); }
 
+        int compare(const Object& rhs) const override;
+
         void read(Input& input) override;
         void write(Output& output) const override;
 

include/vsg/nodes/PagedLOD.h

@@ -50,6 +50,8 @@ namespace vsg
         void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); }
         void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); }
 
+        int compare(const Object& rhs) const override;
+
         void read(Input& input) override;
         void write(Output& output) const override;
 
@@ -62,9 +64,6 @@ namespace vsg
         // external file to load when child 0 is null.
         Path filename;
 
-        // priority value assigned by record traversal as a guide to how important the external child is for loading.
-        mutable std::atomic<double> priority{0.0};
-
         dsphere bound;
 
         using Children = std::array<Child, 2>;
@@ -81,6 +80,9 @@ namespace vsg
     public:
         ref_ptr<Options> options;
 
+        // priority value assigned by record traversal as a guide to how important the external child is for loading.
+        mutable std::atomic<double> priority{0.0};
+
         mutable std::atomic_uint64_t frameHighResLastUsed{0};
         mutable std::atomic_uint requestCount{0};
 

include/vsg/nodes/QuadGroup.h

@@ -40,6 +40,8 @@ namespace vsg
         void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); }
         void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); }
 
+        int compare(const Object& rhs) const override;
+
         void read(Input& input) override;
         void write(Output& output) const override;
 

include/vsg/nodes/Switch.h

@@ -39,6 +39,8 @@ namespace vsg
         void traverse(ConstVisitor& visitor) const override { t_traverse(*this, visitor); }
         void traverse(RecordTraversal& visitor) const override { t_traverse(*this, visitor); }
 
+        int compare(const Object& rhs) const override;
+
         void read(Input& input) override;
         void write(Output& output) const override;
 

include/vsg/text/Text.h

@@ -66,6 +66,7 @@ namespace vsg
         size_t count = 0;
 
         void apply(const stringValue& text) override;
+        void apply(const wstringValue& text) override;
         void apply(const ubyteArray& text) override;
         void apply(const ushortArray& text) override;
         void apply(const uintArray& text) override;

include/vsg/vk/RenderPass.h

@@ -117,7 +117,16 @@ namespace vsg
     extern VSG_DECLSPEC AttachmentDescription defaultColorAttachment(VkFormat imageFormat);
     extern VSG_DECLSPEC AttachmentDescription defaultDepthAttachment(VkFormat depthFormat);
 
+    /// create RenderPass with color and depth buffers
     extern VSG_DECLSPEC ref_ptr<RenderPass> createRenderPass(Device* device, VkFormat imageFormat, VkFormat depthFormat, bool requiresDepthRead = false);
+
+    /// create RenderPass with multisampled color and depth buffers
     extern VSG_DECLSPEC ref_ptr<RenderPass> createMultisampledRenderPass(Device* device, VkFormat imageFormat, VkFormat depthFormat, VkSampleCountFlagBits samples, bool requiresDepthRead = false);
 
+    /// create RenderPass with color buffers
+    extern VSG_DECLSPEC ref_ptr<RenderPass> createRenderPass(Device* device, VkFormat imageFormat);
+
+    /// create RenderPass with multisampled color buffer
+    extern VSG_DECLSPEC ref_ptr<RenderPass> createMultisampledRenderPass(Device* device, VkFormat imageFormat, VkSampleCountFlagBits samples);
+
 } // namespace vsg

src/vsg/CMakeLists.txt

@@ -1,5 +1,3 @@
-include(CheckCXXSourceCompiles)
-
 # collect all the headers in the source directory
 file(GLOB HEADERS ${VSG_SOURCE_DIR}/include/vsg/*.h ${VSG_SOURCE_DIR}/include/vsg/*/*.h)
 
@@ -241,10 +239,20 @@ set(LIBRARIES PUBLIC
 
 # Check for std::atomic
 if(NOT MSVC AND NOT ANDROID AND NOT APPLE)
+  include(CheckCXXSourceCompiles)
+
   check_cxx_source_compiles("
     #include <atomic>
-    std::atomic<int> a;
-    int main() { return a; }"
+    int main()
+    {
+        std::atomic_uint64_t a64(1);
+        auto orig_value = a64.load();
+
+        uint64_t new_value = 1;
+        auto r = a64.compare_exchange_weak(orig_value, new_value);
+
+        return 0;
+    }"
     HAVE_CXX_ATOMIC_WITHOUT_LIB
   )
   if(NOT HAVE_CXX_ATOMIC_WITHOUT_LIB)