Merge pull request #67 from KTStephano/v0.10

V0.10

Author: KTStephano

README.md

@@ -94,6 +94,14 @@ Because of the MPL license, any community changes made to the rendering code wil
 | RAM | 8 GB |
 | GPU | Nvidia GTX 1050 Ti |
 
+# Downloading Sample 3D Model Data
+
+1) A zip file containing Sponza, Interrogation Room, San Miguel, Bistro, Bathroom, etc. can be found here: [https://drive.google.com/file/d/1m56T8cWMwAOHTAIbxAn-891trehgJpzH/view?usp=drive_link](https://drive.google.com/file/d/1m56T8cWMwAOHTAIbxAn-891trehgJpzH/view?usp=drive_link)
+
+2) Extract the Resources.zip folder into the root of StratusGFX. It will then be at the same level as Bin/, Examples/, Source/, Tests/. Make sure that the folder structure looks like StratusGFX/Resources/* where * will be folders such as Sponza, Bistro, etc.
+
+(see further down this README for a full list of credits for where the sample 3D model data came from)
+
 # Building For Windows & Linux
 
 This code base will currently not work on MacOS. Linux and Windows should both be fine so long as the graphics driver supports OpenGL 4.6 and the compiler supports C++17.
@@ -103,6 +111,22 @@ First set up the repo
     git clone --recursive https://github.com/KTStephano/StratusGFX.git
     cd StratusGFX
 
+## Option 1: Standard Build
+
+This is the preferred build if all you want to do is build the examples and run them.
+
+    python3 ./build_examples.py --assimp
+
+-> LINUX NOTE: If you get an error during the assimp build of the above step, use your local package manager to install assimp instead. Then re-run the above step as:
+
+    python3 ./build_examples.py
+
+Now you should be able to go into the StratusGFX/Bin/ folder and run the examples!
+
+## Option 2: Development Build
+
+Use this if you plan to make source code changes to anything in Examples/ Source/ or Tests/. You will only need to build the dependencies once and then after that you can just re-run the cmake build step any time you make changes.
+
 Build 3rd party dependencies -> should only need to do this once per clone
 
     python3 ./dependency_build.py --assimp
@@ -115,40 +139,30 @@ Now build the StratusGFX source
 
 ### Windows
 
-    cmake -Bbuild -S. -DBUILD_TESTS=OFF
+    cmake -Bbuild -S. -DBUILD_TESTS=ON
     cmake --build build/ -j 8 --config RelWithDebInfo
 
 ### Linux
 
-    cmake -Bbuild -S. -DCMAKE_BUILD_TYPE=RelWithDebInfo -DBUILD_TESTS=OFF
+    cmake -Bbuild -S. -DCMAKE_BUILD_TYPE=RelWithDebInfo -DBUILD_TESTS=ON
     cmake --build build/ -j 8
 
-All executables will be put into StratusGFX/Bin. Make sure you run them while inside Bin/. Good ones to run to see if it worked are 
+All executables will be put into StratusGFX/Bin folder. Make sure you run them while inside StratusGFX/Bin/. Good ones to run to see if it worked are 
 
     Ex00_StartupShutdown.exe (runs through initialize, run one frame, shutdown sequence)
     Ex01_StratusGFX.exe (you should see a forest of red cubes since textures aren't bundled with source)
     StratusEngineUnitTests.exe
     StratusEngineIntegrationTests.exe
 
-# First Places to Look
-
-You can check [High Level Architecture Overview](https://ktstephano.github.io/rendering/stratusgfx/architecture), or you can start by looking through the code under Examples/ExampleEnv00 and Examples/ExampleEnv01. They both depend on code that is inside of Examples/Common which is another good place to look around.
-
-None of the test scenes are bundled with this source so the rest of the environments will be completely blank when running.
-
-# Running Example Environments 2-7
-
-When starting the examples will take a bit to load/process. You can see the status in the console. After starting you may experience some temporary frame drops but this will stabilize quickly.
-
--> More in depth explanation here: [Examples](https://github.com/KTStephano/StratusGFX/wiki/Examples)
+# Running The Examples
 
-1) A zip file containing Sponza, Interrogation Room, San Miguel, Bistro and Bathroom can be found here: [https://drive.google.com/file/d/1m56T8cWMwAOHTAIbxAn-891trehgJpzH/view?usp=drive_link](https://drive.google.com/file/d/1m56T8cWMwAOHTAIbxAn-891trehgJpzH/view?usp=drive_link)
+If you are having trouble with the downloading of the 3D assets or running the examples, a good place to check is here:
 
-2) Extract the Resources.zip folder into the root of StratusGFX. It will then be at the same level as Bin/, Examples/, Source/, Tests/. Make sure that the folder structure looks like StratusGFX/Resources/* where * will be folders such as Sponza, Bistro, etc.
+[https://github.com/KTStephano/StratusGFX/wiki/Examples](https://github.com/KTStephano/StratusGFX/wiki/Examples)
 
-3) Change directory into Bin/ and run the example environments.
+If this does not help then feel free to send me an email (jtstephano@gmail.com) or open an issue.
 
-Example environment 01 will still be a forest of red cubes since its textures and models aren't part of the bundle.
+# Credits For 3D Assets Used In Examples
 
 Credits for the 3D assets used in the examples/demos are as follows:
 
@@ -168,6 +182,12 @@ Credits for the 3D assets used in the examples/demos are as follows:
 
 [Abandoned Warehouse](https://sketchfab.com/3d-models/abandoned-warehouse-1e40d433ed6f48fb880a0d2172aff7ca)
 
+# First Places to Look
+
+You can check [High Level Architecture Overview](https://ktstephano.github.io/rendering/stratusgfx/architecture), or you can start by looking through the code under Examples/ExampleEnv00 and Examples/ExampleEnv01. They both depend on code that is inside of Examples/Common which is another good place to look around.
+
+None of the test scenes are bundled with this source so the rest of the environments will be completely blank when running.
+
 # Controls For Example Environments
 
 WASD to move
@@ -182,4 +202,4 @@ E toggles directional light
 
 G toggles global illumination
 
-R recompiles all shaders
+R recompiles all shaders

Source/Engine/StratusCommon.h

@@ -10,6 +10,7 @@
 #include <exception>
 #include <stdexcept>
 #include <functional>
+#include "StratusPointer.h"
 
 #define BITMASK64_POW2(offset) (1ull << offset)
 #define BITMASK_POW2(offset)   (1 << offset)

Source/Engine/StratusEntity.cpp

@@ -11,9 +11,9 @@ namespace stratus {
 
     EntityPtr Entity::Create(EntityComponentSet * ptr) {
         if (ptr != nullptr) {
-           return ThreadSafePoolAllocator<Entity>::AllocateSharedCustomConstruct(PlacementNew_<EntityComponentSet *>, ptr);
+           return ThreadSafeSmartPoolAllocator<Entity>::AllocateSharedCustomConstruct(PlacementNew_<EntityComponentSet *>, ptr);
         }
-        return ThreadSafePoolAllocator<Entity>::AllocateSharedCustomConstruct(PlacementNew_<>);
+        return ThreadSafeSmartPoolAllocator<Entity>::AllocateSharedCustomConstruct(PlacementNew_<>);
     }
 
     void EntityComponent::MarkChanged() {

Source/Engine/StratusEntity.h

@@ -53,7 +53,7 @@ ComponentAllocator_<Component>& GetComponentAllocator_() {
         static name * Create(const Types& ... args) {                                       \
             auto& allocator = GetComponentAllocator_<name>();                               \
             auto ul = std::unique_lock(allocator.m);                                        \
-            return allocator.allocator.Allocate(args...);                                   \
+            return allocator.allocator.AllocateConstruct(args...);                                   \
         }                                                                                   \
         static void Destroy(name * ptr) {                                                   \
             if (ptr == nullptr) return;                                                     \

Source/Engine/StratusPointer.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#include <cstddef>
+
+namespace stratus {
+    template<typename T>
+    struct DefaultUnsafePtrDeleter_ {
+        static void DestroyAndDeallocate(T * ptr) {
+            delete ptr;
+        }
+    };
+
+    template<typename T, typename Deleter>
+    struct UnsafePtrControlBlock_ {
+        Deleter deleter;
+        size_t refcount = 1;
+        T * ptr = nullptr;
+
+        UnsafePtrControlBlock_(T * ptr, Deleter deleter)
+            : ptr(ptr), deleter(deleter) {}
+    };
+
+    // Lightweight reference-counted thread-unsafe pointer wrapper
+    template<typename T, typename Deleter = DefaultUnsafePtrDeleter_<T>>
+    class UnsafePtr final {
+        UnsafePtr(UnsafePtrControlBlock_<T, Deleter> * control)
+            : control_(control) {}
+
+    public:
+        UnsafePtr() {}
+
+        UnsafePtr(T * ptr, Deleter deleter = Deleter()) {
+            if (ptr == nullptr) return;
+
+            control_ = new UnsafePtrControlBlock_<T, Deleter>(ptr, deleter);
+        }
+
+        UnsafePtr(const UnsafePtr& other) {
+            if (other.control_ == nullptr) return;
+            control_ = other.control_;
+            control_->refcount++;
+        }
+
+        UnsafePtr(UnsafePtr&& other) {
+            control_ = other.control_;
+            other.control_ = nullptr;
+        }
+
+        UnsafePtr& operator=(const UnsafePtr& other) {
+            if (operator==(other)) return *this;
+
+            Reset();
+            control_ = other.control_;
+            other.control_->refcount++;
+
+            return *this;
+        }
+
+        UnsafePtr& operator=(UnsafePtr&& other) {
+            if (operator==(other)) return *this;
+
+            Reset();
+            control_ = other.control_;
+            other.control_ = nullptr;
+
+            return *this;
+        }
+
+        ~UnsafePtr() {
+            Reset();
+        }
+
+        bool operator==(const UnsafePtr& other) const {
+            return control_ == other.control_;
+        }
+
+        bool operator!=(const UnsafePtr& other) const {
+            return !(operator==(other));
+        }
+
+        bool operator==(std::nullptr_t) const {
+            return control_ == nullptr;
+        }
+
+        bool operator!=(std::nullptr_t) const {
+            return !(operator==(nullptr));
+        }
+
+        operator bool() const {
+            return control_ != nullptr;
+        }
+
+        T& operator*() {
+            return *(control_->ptr);
+        }
+
+        const T& operator*() const {
+            return *(control_->ptr);
+        }
+
+        T * operator->() {
+            return control_->ptr;
+        }
+
+        const T * operator->() const {
+            return control_->ptr;
+        }
+
+        T * Get() {
+            return control_ == nullptr ? nullptr : control_->ptr;
+        }
+
+        const T * Get() const {
+            return control_ == nullptr ? nullptr : control_->ptr;
+        }
+
+        void Reset() {
+            if (control_ == nullptr) return;
+
+            control_->refcount--;
+            if (control_->refcount == 0) {
+                auto ptr = control_->ptr;
+                control_->deleter.DestroyAndDeallocate(ptr);
+
+                delete control_;
+            }
+            control_ = nullptr;
+        }
+
+        size_t RefCount() const {
+            return control_ == nullptr ? 0 : control_->refcount;
+        }
+
+        template<typename E, typename ... Args>
+        friend UnsafePtr<E> MakeUnsafe(Args&&... args);
+
+    private:
+        UnsafePtrControlBlock_<T, Deleter> * control_ = nullptr;
+    };
+
+    template<typename E, typename ... Args>
+    UnsafePtr<E> MakeUnsafe(Args&&... args) {
+        auto ptr = new E(std::forward<Args>(args)...);
+        return UnsafePtr<E>(new UnsafePtrControlBlock_(ptr, DefaultUnsafePtrDeleter_<E>()));
+    }
+
+    static_assert(sizeof(UnsafePtr<int>) == sizeof(void *));
+}