Merge pull request #13 from KTStephano/v0.7

V0.7 -> Master

Author: KTStephano

Examples/ExampleEnv01/StratusGFX.cpp

@@ -3,6 +3,7 @@
 #include <iostream>
 #include <StratusPipeline.h>
 #include <StratusCamera.h>
+#include "StratusAsync.h"
 #include <chrono>
 #include "StratusEngine.h"
 #include "StratusResourceManager.h"
@@ -36,15 +37,14 @@ class RandomLightMover { //: public stratus::Entity {
     glm::vec3 speed;
     bool spawnPhysicalMarker;
 
-    RandomLightMover(const bool spawnPhysicalMarker = true,
-                     const bool brightensWithSun = false) 
+    RandomLightMover(const bool spawnPhysicalMarker = true, stratus::LightPtr ptr = nullptr) 
         : spawnPhysicalMarker(spawnPhysicalMarker) {
         cube = stratus::ResourceManager::Instance()->CreateCube();
         cube->GetRenderNode()->SetMaterial(stratus::MaterialManager::Instance()->CreateDefault());
         cube->GetRenderNode()->EnableLightInteraction(false);
         //cube->scale = glm::vec3(0.25f, 0.25f, 0.25f);
         cube->SetLocalScale(glm::vec3(1.0f));
-        light = stratus::LightPtr(new stratus::PointLight(brightensWithSun));
+        light = ptr ? ptr : stratus::LightPtr(new stratus::PointLight());
         _changeDirection();
     }
 
@@ -78,7 +78,8 @@ class RandomLightMover { //: public stratus::Entity {
 };
 
 struct StationaryLight : public RandomLightMover {
-    StationaryLight(const bool spawnPhysicalMarker = true) : RandomLightMover(spawnPhysicalMarker) {}
+    StationaryLight(const bool spawnPhysicalMarker = true) 
+        : RandomLightMover(spawnPhysicalMarker) {}
 
     void update(double deltaSeconds) override {
         cube->SetLocalPosition(position);
@@ -90,7 +91,7 @@ struct StationaryLight : public RandomLightMover {
 
 struct FakeRTGILight : public RandomLightMover {
     FakeRTGILight(const bool spawnPhysicalMarker = true)
-        : RandomLightMover(spawnPhysicalMarker, /* brightensWithSun = */ true) {}
+        : RandomLightMover(spawnPhysicalMarker, stratus::LightPtr(new stratus::VirtualPointLight())) {}
 
     void update(double deltaSeconds) override {
         cube->SetLocalPosition(position);
@@ -140,6 +141,17 @@ class Sponza : public stratus::Application {
 
         worldLight->setRotation(stratus::Rotation(stratus::Degrees(0.0f), stratus::Degrees(10.0f), stratus::Degrees(0.0f)));
 
+        // for (int i = 0; i < 64; ++i) {
+        //     float x = rand() % 600;
+        //     float y = rand() % 600;
+        //     float z = rand() % 200;
+        //     stratus::VirtualPointLight * vpl = new stratus::VirtualPointLight();
+        //     vpl->setIntensity(worldLight->getIntensity() * 50.0f);
+        //     vpl->position = glm::vec3(x, y, z);
+        //     vpl->setColor(worldLight->getColor());
+        //     World()->AddLight(stratus::LightPtr((stratus::Light *)vpl));
+        // }
+
         return true;
     }
 
@@ -159,6 +171,8 @@ class Sponza : public stratus::Application {
         float fogDensity = stratus::RendererFrontend::Instance()->GetAtmosphericFogDensity();
         float scatterControl = stratus::RendererFrontend::Instance()->GetAtmosphericScatterControl();
 
+        const glm::vec3 warmMorningColor = glm::vec3(254.0f / 255.0f, 232.0f / 255.0f, 176.0f / 255.0f);
+
         //STRATUS_LOG << "Camera " << camera.getYaw() << " " << camera.getPitch() << std::endl;
 
         // Check for key/mouse events
@@ -223,6 +237,11 @@ class Sponza : public stratus::Application {
                             }
                             break;
                         case SDL_SCANCODE_I:
+                            if (released) {
+                                worldLightMoveDirection = -worldLightMoveDirection;
+                            }
+                            break;
+                        case SDL_SCANCODE_L:
                             if (released) {
                                 worldLight->setEnabled( !worldLight->getEnabled() );
                             }
@@ -267,8 +286,7 @@ class Sponza : public stratus::Application {
                             if (released) {
                                 std::unique_ptr<RandomLightMover> mover(new FakeRTGILight(/*spawnPhysicalMarker = */ false));
                                 mover->light->setIntensity(worldLight->getIntensity() * 100);
-                                const auto worldLightColor = worldLight->getColor();
-                                mover->light->setColor(worldLightColor.r, worldLightColor.g, worldLightColor.b);
+                                mover->light->setColor(warmMorningColor);
                                 mover->position = camera->getPosition();
                                 mover->addToScene();
                                 lightMovers.push_back(std::move(mover));
@@ -279,8 +297,7 @@ class Sponza : public stratus::Application {
                             if (released) {
                                 std::unique_ptr<RandomLightMover> mover(new FakeRTGILight(/*spawnPhysicalMarker = */ false));
                                 mover->light->setIntensity(worldLight->getIntensity() * 50);
-                                const auto worldLightColor = worldLight->getColor();
-                                mover->light->setColor(worldLightColor.r, worldLightColor.g, worldLightColor.b);
+                                mover->light->setColor(warmMorningColor);
                                 mover->position = camera->getPosition();
                                 mover->addToScene();
                                 lightMovers.push_back(std::move(mover));
@@ -293,6 +310,7 @@ class Sponza : public stratus::Application {
                                 mover->light->setIntensity(worldLight->getIntensity() * 10);
                                 const auto worldLightColor = glm::vec3(1.0f, 0.0f, 0.0f);
                                 mover->light->setColor(worldLightColor.r, worldLightColor.g, worldLightColor.b);
+                                ((stratus::VirtualPointLight *)mover->light.get())->SetNumShadowSamples(9);
                                 mover->position = camera->getPosition();
                                 mover->addToScene();
                                 lightMovers.push_back(std::move(mover));
@@ -305,6 +323,7 @@ class Sponza : public stratus::Application {
                                 mover->light->setIntensity(worldLight->getIntensity() * 10);
                                 const auto worldLightColor = glm::vec3(0.0f, 1.0f, 0.0f);
                                 mover->light->setColor(worldLightColor.r, worldLightColor.g, worldLightColor.b);
+                                ((stratus::VirtualPointLight *)mover->light.get())->SetNumShadowSamples(9);
                                 mover->position = camera->getPosition();
                                 mover->addToScene();
                                 lightMovers.push_back(std::move(mover));
@@ -317,19 +336,34 @@ class Sponza : public stratus::Application {
                                 mover->light->setIntensity(worldLight->getIntensity() * 10);
                                 const auto worldLightColor = glm::vec3(0.0f, 0.0f, 1.0f);
                                 mover->light->setColor(worldLightColor.r, worldLightColor.g, worldLightColor.b);
+                                ((stratus::VirtualPointLight *)mover->light.get())->SetNumShadowSamples(9);
                                 mover->position = camera->getPosition();
                                 mover->addToScene();
                                 lightMovers.push_back(std::move(mover));
                             }
                             break;
                         }
+                        case SDL_SCANCODE_G: {
+                            if (released) {
+                                const bool enabled = World()->GetGlobalIlluminationEnabled();
+                                World()->SetGlobalIlluminationEnabled( !enabled );
+                            }
+                            break;
+                        }
                         case SDL_SCANCODE_C: {
                             for (auto& light : lightMovers) {
                                 light->removeFromScene();
                             }
                             lightMovers.clear();
                             break;
                         }
+                        case SDL_SCANCODE_Z:
+                            if (released) {
+                                if (lightMovers.size() > 0) {
+                                    lightMovers[lightMovers.size() - 1]->removeFromScene();
+                                    lightMovers.pop_back();
+                                }
+                            }
                         default: break;
                     }
                     break;
@@ -343,14 +377,17 @@ class Sponza : public stratus::Application {
         // worldLight->setRotation(glm::vec3(75.0f, 0.0f, 0.0f));
         //worldLight->setRotation(stratus::Rotation(stratus::Degrees(30.0f), stratus::Degrees(0.0f), stratus::Degrees(0.0f)));
         if (!worldLightPaused) {
-            worldLight->offsetRotation(glm::vec3(value * deltaSeconds, 0.0f, 0.0f));
+            worldLight->offsetRotation(glm::vec3(worldLightMoveDirection * value * deltaSeconds, 0.0f, 0.0f));
         }
 
+        #define LERP(x, v1, v2) (x * v1 + (1.0f - x) * v2)
+
         //renderer->toggleWorldLighting(worldLightEnabled);
         stratus::RendererFrontend::Instance()->SetWorldLight(worldLight);
         // worldLight->setColor(glm::vec3(1.0f, 0.75f, 0.5));
         // worldLight->setColor(glm::vec3(1.0f, 0.75f, 0.75f));
-        worldLight->setColor(glm::vec3(1.0f));
+        const float x = std::sinf(stratus::Radians(worldLight->getRotation().x).value());
+        worldLight->setColor(warmMorningColor);
         worldLight->setPosition(camera->getPosition());
         //worldLight->setRotation(glm::vec3(90.0f, 0.0f, 0.0f));
         //renderer->setWorldLight(worldLight);
@@ -407,6 +444,7 @@ class Sponza : public stratus::Application {
     std::vector<stratus::EntityPtr> entities;
     stratus::CameraPtr camera;
     glm::vec3 cameraSpeed;
+    float worldLightMoveDirection = 1.0; // -1.0 reverses it
     float camSpeedDivide = 0.25f; // For slowing camera down
     stratus::LightPtr cameraLight;
     stratus::InfiniteLightPtr worldLight;

Examples/ExampleEnv02/Sponza.cpp

@@ -12,6 +12,7 @@
 #include <StratusUtils.h>
 #include <memory>
 #include <filesystem>
+#include "StratusAsync.h"
 
 class RandomLightMover { //: public stratus::Entity {
     glm::vec3 _direction = glm::vec3(0.0f);

Examples/ExampleEnv04/Forest.cpp

@@ -0,0 +1,27 @@
+#include "StratusApplication.h"
+#include "StratusResourceManager.h"
+#include "StratusRendererFrontend.h"
+#include "StratusMaterial.h"
+#include "StratusEngine.h"
+
+namespace stratus {
+    #define INSTANCE(type) stratus::##type::Instance()
+
+    Application * Application::_instance = nullptr;
+
+    ResourceManager * Application::Resources() {
+        return INSTANCE(ResourceManager);
+    }
+
+    RendererFrontend * Application::World() {
+        return INSTANCE(RendererFrontend);
+    }
+
+    MaterialManager * Application::Materials() {
+        return INSTANCE(MaterialManager);
+    }
+
+    Engine * Application::Stratus() {
+        return INSTANCE(Engine);
+    }
+}

Source/StratusApplication.cpp

@@ -4,10 +4,19 @@
 #include <string>
 
 namespace stratus {
+    class ResourceManager;
+    class RendererFrontend;
+    class MaterialManager;
+    class Engine;
+
     // Special interface class which the engine knows is the entry point
     // for the application (e.g. editor or game)
     class Application : public SystemModule {
+        friend class Engine;
+
     public:
+        static Application * Instance() { return _instance; }
+
         virtual ~Application() = default;
 
         // Sets the name of the window
@@ -16,5 +25,14 @@ namespace stratus {
         virtual const char * Name() const {
             return GetAppName();
         }
+
+        // Convenience functions for common use cases
+        static ResourceManager * Resources();
+        static RendererFrontend * World();
+        static MaterialManager * Materials();
+        static Engine * Stratus();
+
+    private:
+        static Application * _instance;
     };
 }