Merge pull request #352 from SHADE-DP/SP3-1-Rendering

Implemented improved shadows (still abit whack), trajectory system (untested), and window resize event

Assets/Scenes/MainGame.shade

@@ -8440,6 +8440,11 @@
   IsActive: true
   NumberOfChildren: 0
   Components:
+    Transform Component:
+      Translate: {x: 0, y: 0, z: 0}
+      Rotate: {x: 0, y: 0, z: 0}
+      Scale: {x: 1, y: 1, z: 1}
+      IsActive: true
     Light Component:
       Position: {x: 0, y: 0, z: 0}
       Type: Directional
@@ -8469,14 +8474,14 @@
   NumberOfChildren: 0
   Components:
     Transform Component:
-      Translate: {x: 2, y: 1.5, z: -5.5999999}
+      Translate: {x: 0.242245644, y: 1.56757355, z: -6.07086945}
       Rotate: {x: -0, y: 0, z: -0}
       Scale: {x: 1, y: 1, z: 1}
       IsActive: true
     Light Component:
       Position: {x: 2, y: 1.5, z: -5.5999999}
       Type: Directional
-      Direction: {x: -0.245000005, y: 0, z: 0}
+      Direction: {x: 0, y: 0, z: -1}
       Color: {x: 0, y: 0, z: 0, w: 1}
       Layer: 4294967295
       Strength: 1

Assets/Shaders/DeferredComposite_CS.glsl

@@ -48,19 +48,34 @@ layout(std430, set = 1, binding = 4) buffer AmbientLightData
   AmbientLightStruct aLightData[];
 } AmbLightData;
 
+float LinStep (float val, float low, float high)
+{
+  return clamp ((val - low)/(high - low), 0.0f, 1.0f);
+}
+
 float CalcShadowValue (sampler2D shadowMap, vec4 worldSpaceFragPos, mat4 lightPV)
 {
+  // clip space for fragment from light view space
   vec4 fragPosLightPOV = lightPV * worldSpaceFragPos;
+
+  // Perform perspective division and convert to 0 to 1 range
   vec3 converted = (fragPosLightPOV.xyz / fragPosLightPOV.w) * vec3(0.5f) + vec3(0.5f);
 
-  float sampledDepth = texture(shadowMap, converted.xy).r;
+  // float sampledDepth = texture(shadowMap, converted.xy).r;
+  // float sampledDepth = texture(shadowMap, converted.xy).z;
+  vec2 moments = texture(shadowMap, converted.xy).xy;
 
   if (converted.x < 0.0f || converted.x > 1.0f || converted.y < 0.0f || converted.y > 1.0f)
     return 1.0f;
 
-  if (fragPosLightPOV.z > sampledDepth && fragPosLightPOV.w > 0.0f)
+  if (fragPosLightPOV.z > moments.x && fragPosLightPOV.w > 0.0f)
   {
-    return 0.7f;
+    float p = step (fragPosLightPOV.z, moments.x);
+    float variance = max (moments.y - (moments.x * moments.x), 0.00002f);
+
+    float d = fragPosLightPOV.z - moments.x;
+    float pMax = LinStep (variance / (variance + (d * d)), 0.9f, 1.0f);
+    return min (max (p, pMax), 1.0f);
   }
   else
     return 1.0f;

Assets/Shaders/ShadowMap_FS.glsl

@@ -3,8 +3,10 @@
 #extension GL_ARB_shading_language_420pack : enable
 #extension GL_EXT_nonuniform_qualifier : require
 
+layout(location = 0) out vec4 shadowMap;
 
 void main()
 {
-
+    // shadowMap = vec4 (0.0f, 0.0f, gl_FragCoord.z, 1.0f);
+    shadowMap = vec4 (gl_FragCoord.z, gl_FragCoord.z * gl_FragCoord.z, 0.0f, 1.0f);
 }

Assets/Shaders/Trajectory_FS.glsl

@@ -0,0 +1,22 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+#extension GL_EXT_nonuniform_qualifier : require
+
+
+layout(location = 0) in struct
+{
+  vec4 vertPos; // location 0
+  vec2 uv; // location = 1
+  vec4 color; // location = 2
+
+} In;
+
+layout(location = 0) out vec4 fragColor;
+
+
+void main()
+{
+  // default red first
+  fragColor = In.color;
+}

Assets/Shaders/Trajectory_FS.shshaderb.shmeta

@@ -0,0 +1,3 @@
+Name: Trajectory_FS
+ID: 45635685
+Type: 2

Assets/Shaders/Trajectory_VS.glsl

@@ -0,0 +1,36 @@
+#version 450
+#extension GL_KHR_vulkan_glsl : enable
+
+// vertex inputs
+layout(location = 0) in vec3 aPos;
+layout(location = 1) in vec2 aUV;
+layout(location = 2) in vec4 aColor;
+layout(location = 3) in mat4 aTransform;
+
+// between shader stages
+layout(location = 0) out struct
+{
+  vec4 vertPos; // location 0
+  vec2 uv; // location = 1
+  vec4 color; // location = 2
+
+} Out;
+
+
+// Camera data
+layout(set = 1, binding = 0) uniform CameraData
+{
+  vec4 position; 
+  mat4 vpMat;
+  mat4 viewMat;
+  mat4 projMat;
+} cameraData;
+
+
+void main()
+{
+  Out.uv = aUV;
+  Out.color = aColor;
+
+  gl_Position = cameraData.projMat * aTransform * vec4(aPos, 1.0f);
+}

Assets/Shaders/Trajectory_VS.shshaderb.shmeta

@@ -0,0 +1,3 @@
+Name: Trajectory_VS
+ID: 41042628
+Type: 2

SHADE_Engine/src/Camera/SHCameraSystem.cpp

@@ -12,6 +12,7 @@
 #include "Editor/SHEditor.h"
 #include "Math/SHRay.h"
 #include "Physics/System/SHPhysicsSystem.h"
+#include "Graphics/Events/SHGraphicsEvents.h"
 
 
 namespace SHADE
@@ -123,6 +124,13 @@ namespace SHADE
     SHComponentManager::CreateComponentSparseSet<SHCameraComponent>();
     SHComponentManager::CreateComponentSparseSet<SHCameraArmComponent>();
 
+    std::shared_ptr<SHEventReceiverSpec<SHCameraSystem>> thisReceiver
+    {
+      std::make_shared<SHEventReceiverSpec<SHCameraSystem>>(this, &SHCameraSystem::ReceiveWindowResizeEvent)
+    };
+    ReceiverPtr receiver = std::dynamic_pointer_cast<SHEventReceiver>(thisReceiver);
+    SHEventManager::SubscribeTo(SH_WINDOW_RESIZE_EVENT, receiver);
+    
   }
 
   void SHCameraSystem::Exit(void) 
@@ -130,6 +138,16 @@ namespace SHADE
 
   }
 
+  SHEventHandle SHCameraSystem::ReceiveWindowResizeEvent(SHEventPtr eventPtr) noexcept
+  {
+    auto const& EVENT_DATA = reinterpret_cast<const SHEventSpec<SHWindowResizeEvent>*>(eventPtr.get())->data;
+
+    //std::cout << EVENT_DATA->resizeWidth << std::endl;
+    //std::cout << EVENT_DATA->resizeHeight << std::endl;
+
+    return eventPtr->handle;
+  }
+
   SHCameraComponent* SHCameraSystem::GetEditorCamera(void) noexcept
   {
     return &editorCamera;

SHADE_Engine/src/Camera/SHCameraSystem.h

@@ -46,6 +46,11 @@ namespace SHADE
 		};
 		friend class CameraSystemUpdate;
 
+    /*-----------------------------------------------------------------------*/
+    /* Light functions                                                       */
+    /*-----------------------------------------------------------------------*/
+    SHEventHandle ReceiveWindowResizeEvent(SHEventPtr eventPtr) noexcept;
+
 
 		SHCameraComponent* GetEditorCamera (void) noexcept;
 		void GetCameraAxis(SHCameraComponent const& camera, SHVec3& forward, SHVec3& right, SHVec3& up) const noexcept;

SHADE_Engine/src/Events/SHEventDefines.h

@@ -25,4 +25,5 @@ constexpr SHEventIdentifier SH_SCENE_EXIT_POST                    { 16 };
 constexpr SHEventIdentifier SH_GRAPHICS_LIGHT_ENABLE_SHADOW_EVENT { 17 };
 constexpr SHEventIdentifier SH_BUTTON_CLICK_EVENT                 { 18 };
 constexpr SHEventIdentifier SH_PHYSICS_COLLIDER_DRAW_EVENT        { 19 };
+constexpr SHEventIdentifier SH_WINDOW_RESIZE_EVENT                { 20 };
 

SHADE_Engine/src/Graphics/Events/SHGraphicsEvents.h

@@ -14,4 +14,13 @@ namespace SHADE
     //! Generate a renderer for the light component
     bool generateRenderer;
   };
+
+  struct SHWindowResizeEvent
+  {
+    // New width when window resizes
+    uint32_t resizeWidth;
+
+    // New height when window resizes
+    uint32_t resizeHeight;
+  };
 }

SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsPredefinedData.cpp

@@ -52,6 +52,12 @@ namespace SHADE
       {SHPredefinedDescriptorTypes::RENDER_GRAPH_RESOURCE,              3},
       {SHPredefinedDescriptorTypes::RENDER_GRAPH_NODE_COMPUTE_RESOURCE, 4},
     });
+
+    perSystemData[SHUtilities::ConvertEnum(SystemType::TRAJECTORY_RENDERING)].descMappings.AddMappings
+    ({
+      {SHPredefinedDescriptorTypes::STATIC_DATA, 0},
+      {SHPredefinedDescriptorTypes::CAMERA,      1},
+    });
   }
 
   void SHGraphicsPredefinedData::InitDummyPipelineLayouts(Handle<SHVkLogicalDevice> logicalDevice) noexcept
@@ -222,6 +228,12 @@ namespace SHADE
       SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::CAMERA |
       SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::LIGHTS
     );
+
+    perSystemData[SHUtilities::ConvertEnum(SystemType::TRAJECTORY_RENDERING)].descSetLayouts = GetPredefinedDescSetLayouts
+    (
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::STATIC_DATA |
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::CAMERA
+    );
   }
 
   void SHGraphicsPredefinedData::InitPredefinedVertexInputState(void) noexcept

SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsPredefinedData.h

@@ -38,6 +38,7 @@ namespace SHADE
       BATCHING_ANIM,
       TEXT_RENDERING,
       RENDER_GRAPH_NODE_COMPUTE,
+      TRAJECTORY_RENDERING,
       NUM_TYPES
     };
     static constexpr int SYSTEM_TYPE_COUNT = static_cast<int>(SystemType::NUM_TYPES);

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsConstants.h

@@ -64,6 +64,17 @@ namespace SHADE
       /***************************************************************************/
       static constexpr std::string_view DEFERRED_COMPOSITE_PASS = "Deferred Comp Pass";
 
+      /***************************************************************************/
+      /*!
+
+        \brief
+          Name of vfx render graph node.
+
+      */
+      /***************************************************************************/
+      static constexpr std::string_view VFX_PASS = "Vfx Pass";
+
+
       /***************************************************************************/
       /*!
 
@@ -117,6 +128,7 @@ namespace SHADE
 
       static constexpr std::string_view GBUFFER_WRITE_SUBPASS = "G-Buffer Write";
       static constexpr std::string_view UI_SUBPASS = "UI";
+      static constexpr std::string_view VFX_SUBPASS = "VFX";
 
       static constexpr std::array USABLE_SUBPASSES = 
       {
@@ -282,6 +294,13 @@ namespace SHADE
       */
       /***************************************************************************/
       static constexpr uint32_t BONE_MATRIX_FIRST_INDEX = 8;
+      /***************************************************************************/
+      /*!
+        \brief
+          Vertex buffer bindings for color
+      */
+      /***************************************************************************/
+      static constexpr uint32_t TRAJECTORY_COLOR = 2;
 
       static constexpr uint32_t CALCULATED_GLYPH_POSITION = 0;
       static constexpr uint32_t GLYPH_INDEX = 1;

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp

@@ -129,6 +129,7 @@ namespace SHADE
 
     //SHAssetManager::CompileAsset("../../Assets/Shaders/DeferredComposite_CS.glsl", false);
     //SHAssetManager::CompileAsset("../../Assets/Shaders/ShadowMap_FS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/ShadowMap_FS.glsl", false);
     //SHAssetManager::CompileAsset("../../Assets/Shaders/SSAO_CS.glsl", false);
     //SHAssetManager::CompileAsset("../../Assets/Shaders/SSAOBlur_CS.glsl", false);
     //SHAssetManager::CompileAsset("../../Assets/Shaders/PureCopy_CS.glsl", false);
@@ -137,7 +138,8 @@ namespace SHADE
     //SHAssetManager::CompileAsset("../../Assets/Shaders/UI_VS.glsl", false);
     //SHAssetManager::CompileAsset("../../Assets/Shaders/UI_FS.glsl", false);
     //SHAssetManager::CompileAsset("../../Assets/Shaders/Text_VS.glsl", false);
-
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/Trajectory_VS.glsl", false);
+    //SHAssetManager::CompileAsset("../../Assets/Shaders/Trajectory_FS.glsl", false);
 
     // Load Built In Shaders
     static constexpr AssetID VS_DEFAULT    = 39210065;  defaultVertShader       = SHResourceManager::LoadOrGet<SHVkShaderModule>(VS_DEFAULT);
@@ -153,8 +155,10 @@ namespace SHADE
     static constexpr AssetID TEXT_FS       = 38024754;  textFS                  = SHResourceManager::LoadOrGet<SHVkShaderModule>(TEXT_FS);
     static constexpr AssetID RENDER_SC_VS  = 48082949;  renderToSwapchainVS     = SHResourceManager::LoadOrGet<SHVkShaderModule>(RENDER_SC_VS);
     static constexpr AssetID RENDER_SC_FS  = 36869006;  renderToSwapchainFS     = SHResourceManager::LoadOrGet<SHVkShaderModule>(RENDER_SC_FS);
-    static constexpr AssetID SHADOW_MAP_VS = 44646107;  shadowMapVS = SHResourceManager::LoadOrGet<SHVkShaderModule>(SHADOW_MAP_VS);
+    static constexpr AssetID SHADOW_MAP_VS = 44646107;  shadowMapVS             = SHResourceManager::LoadOrGet<SHVkShaderModule>(SHADOW_MAP_VS);
-    static constexpr AssetID SHADOW_MAP_FS = 45925790;  shadowMapFS = SHResourceManager::LoadOrGet<SHVkShaderModule>(SHADOW_MAP_FS);
+    static constexpr AssetID SHADOW_MAP_FS = 45925790;  shadowMapFS             = SHResourceManager::LoadOrGet<SHVkShaderModule>(SHADOW_MAP_FS);
+    static constexpr AssetID TRAJECTORY_VS = 41042628;  trajectoryVS            = SHResourceManager::LoadOrGet<SHVkShaderModule>(TRAJECTORY_VS);
+    static constexpr AssetID TRAJECTORY_FS = 45635685;  trajectoryFS            = SHResourceManager::LoadOrGet<SHVkShaderModule>(TRAJECTORY_FS);
 
   }
 
@@ -307,13 +311,24 @@ namespace SHADE
         lightingSubSystem->PrepareShadowMapsForRead(cmdBuffer);
       });
 
+    /*-----------------------------------------------------------------------*/
+    /* VFX PASS                                                              */
+    /*-----------------------------------------------------------------------*/
+    auto vfxPass = renderGraph->AddNode(SHGraphicsConstants::RenderGraphEntityNames::VFX_PASS.data(), { "Scene", "Depth Buffer" }, { SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data(), SHGraphicsConstants::RenderGraphEntityNames::DEFERRED_COMPOSITE_PASS.data() });
+    auto vfxSubpass = vfxPass->AddSubpass("Vfx Subpass", worldViewport, worldRenderer);
+    vfxSubpass->AddColorOutput("Scene");
+    vfxSubpass->AddDepthOutput("Depth Buffer");
+    vfxSubpass->AddExteriorDrawCalls([=](Handle<SHVkCommandBuffer> cmdBuffer, Handle<SHRenderer> renderer, uint32_t frameIndex)
+      {
+        trajectoryRenderingSubSystem->Render(cmdBuffer, renderer, frameIndex);
+      });
 
     /*-----------------------------------------------------------------------*/
     /* DEBUG DRAW PASS INIT                                                  */
     /*-----------------------------------------------------------------------*/
     // Set up Debug Draw Passes
     // - Depth Tested
-    auto debugDrawNodeDepth = renderGraph->AddNode(SHGraphicsConstants::RenderGraphEntityNames::DEBUG_DRAW_DEPTH_PASS.data(), {"Scene", "Depth Buffer"}, {SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data(), SHGraphicsConstants::RenderGraphEntityNames::DEFERRED_COMPOSITE_PASS.data()});
+    auto debugDrawNodeDepth = renderGraph->AddNode(SHGraphicsConstants::RenderGraphEntityNames::DEBUG_DRAW_DEPTH_PASS.data(), {"Scene", "Depth Buffer"}, { SHGraphicsConstants::RenderGraphEntityNames::VFX_PASS.data()/*, SHGraphicsConstants::RenderGraphEntityNames::DEFERRED_COMPOSITE_PASS.data()*/});
     auto debugDrawDepthSubpass = debugDrawNodeDepth->AddSubpass("Debug Draw with Depth", worldViewport, worldRenderer);
     debugDrawDepthSubpass->AddColorOutput("Scene");
     debugDrawDepthSubpass->AddDepthOutput("Depth Buffer");
@@ -432,6 +447,11 @@ namespace SHADE
     auto uiNode = renderGraph->GetNode(SHGraphicsConstants::RenderGraphEntityNames::SCREEN_SPACE_PASS.data());
     textRenderingSubSystem->Init(device, uiNode->GetRenderpass(), uiNode->GetSubpass(SHGraphicsConstants::RenderGraphEntityNames::UI_SUBPASS), descPool, textVS, textFS);
 
+    trajectoryRenderingSubSystem = resourceManager.Create<SHTrajectoryRenderingSubSystem>();
+
+    auto vfxNode = renderGraph->GetNode(SHGraphicsConstants::RenderGraphEntityNames::SCREEN_SPACE_PASS.data());
+    trajectoryRenderingSubSystem->Init(device, vfxNode->GetRenderpass(), vfxNode->GetSubpass(SHGraphicsConstants::RenderGraphEntityNames::UI_SUBPASS), trajectoryVS, trajectoryFS);
+
     SHGlobalDescriptorSets::SetLightingSubSystem(lightingSubSystem);
 
   }
@@ -566,6 +586,7 @@ namespace SHADE
     }
 
     textRenderingSubSystem->Run(frameIndex);
+    trajectoryRenderingSubSystem->Run(frameIndex);
 
 
     for (auto renderer : renderers)
@@ -588,19 +609,19 @@ namespace SHADE
 
     static bool shadowAdded = false;
 
-    if (shadowAdded == false/* && SHInputManager::GetKey(SHInputManager::SH_KEYCODE::B)*/)
+    //if (shadowAdded == false && SHInputManager::GetKey(SHInputManager::SH_KEYCODE::B))
-    {
+    //{
-      shadowAdded = true;
+    //  shadowAdded = true;
-      auto& lightComps = SHComponentManager::GetDense<SHLightComponent>();
+    //  auto& lightComps = SHComponentManager::GetDense<SHLightComponent>();
-      if (lightComps.size() > 2)
+    //  //if (lightComps.size() > 2)
-      {
+    //  //{
-        lightComps[2].SetEnableShadow(true);
+    //  //  lightComps[2].SetEnableShadow(true);
-      }
+    //  //}
-      //for (auto& comp : lightComps)
+    //  for (auto& comp : lightComps)
-      //{
+    //  {
-      //  comp.SetEnableShadow(true);
+    //    comp.SetEnableShadow(true);
-      //}
+    //  }
-    }
+    //}
 
     renderGraph->Begin(frameIndex);
     auto cmdBuffer = renderGraph->GetCommandBuffer(frameIndex);
@@ -779,10 +800,11 @@ namespace SHADE
     // we need to wait for the device to finish using the graph first
     device->WaitIdle();
 
-    auto const&       EVENT_DATA       = reinterpret_cast<const SHEventSpec<SHLightEnableShadowEvent>*>(eventPtr.get())->data;
+    auto const&       EVENT_DATA            = reinterpret_cast<const SHEventSpec<SHLightEnableShadowEvent>*>(eventPtr.get())->data;
-    auto*             lightComp        = SHComponentManager::GetComponent<SHLightComponent>(EVENT_DATA->lightEntity);
+    auto*             lightComp             = SHComponentManager::GetComponent<SHLightComponent>(EVENT_DATA->lightEntity);
-    std::string       resourceName     = "ShadowMap " + std::to_string(EVENT_DATA->lightEntity);
+    std::string       depthResourceName     = "ShadowMap_Depth " + std::to_string(EVENT_DATA->lightEntity);
-    Handle<SHSubpass> companionSubpass = renderGraph->GetNode(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data())->GetSubpass(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_WRITE_SUBPASS);
+    std::string       shadowMapResourceName = "ShadowMap " + std::to_string(EVENT_DATA->lightEntity);
+    Handle<SHSubpass> companionSubpass  = renderGraph->GetNode(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data())->GetSubpass(SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_WRITE_SUBPASS);
 
     if (EVENT_DATA->generateRenderer)
     {
@@ -795,14 +817,16 @@ namespace SHADE
     }
 
     // Add the shadow map resource to the graph
-    renderGraph->AddResource(resourceName, {SH_RENDER_GRAPH_RESOURCE_FLAGS::DEPTH, SH_RENDER_GRAPH_RESOURCE_FLAGS::INPUT}, false, SHLightingSubSystem::SHADOW_MAP_WIDTH, SHLightingSubSystem::SHADOW_MAP_HEIGHT, vk::Format::eD32Sfloat);
+    renderGraph->AddResource(depthResourceName, {SH_RENDER_GRAPH_RESOURCE_FLAGS::DEPTH}, false, SHLightingSubSystem::SHADOW_MAP_WIDTH, SHLightingSubSystem::SHADOW_MAP_HEIGHT, vk::Format::eD32Sfloat);
+    renderGraph->AddResource(shadowMapResourceName, { SH_RENDER_GRAPH_RESOURCE_FLAGS::COLOR, SH_RENDER_GRAPH_RESOURCE_FLAGS::INPUT }, false, SHLightingSubSystem::SHADOW_MAP_WIDTH, SHLightingSubSystem::SHADOW_MAP_HEIGHT, vk::Format::eR32G32B32A32Sfloat);
 
     // link resource to node. This means linking the resource and regenerating the node's renderpass and framebuffer.
-    auto shadowMapNode = renderGraph->AddNodeAfter(SHGraphicsConstants::RenderGraphEntityNames::SHADOW_MAP_PASS.data() + resourceName, {resourceName.c_str()}, SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data());
+    auto shadowMapNode = renderGraph->AddNodeAfter(SHGraphicsConstants::RenderGraphEntityNames::SHADOW_MAP_PASS.data() + shadowMapResourceName, {depthResourceName.c_str(), shadowMapResourceName.c_str()}, SHGraphicsConstants::RenderGraphEntityNames::GBUFFER_PASS.data());
 
     // Add a subpass to render to that shadow map
-    auto newSubpass = shadowMapNode->RuntimeAddSubpass(resourceName + " Subpass", shadowMapViewport, lightComp->GetRenderer());
+    auto newSubpass = shadowMapNode->RuntimeAddSubpass(shadowMapResourceName + " Subpass", shadowMapViewport, lightComp->GetRenderer());
-    newSubpass->AddDepthOutput(resourceName, SH_RENDER_GRAPH_RESOURCE_FLAGS::DEPTH);
+    newSubpass->AddColorOutput(shadowMapResourceName);
+    newSubpass->AddDepthOutput(depthResourceName, SH_RENDER_GRAPH_RESOURCE_FLAGS::DEPTH);
 
     // regenerate the node
     shadowMapNode->RuntimeStandaloneRegenerate();
@@ -828,7 +852,7 @@ namespace SHADE
     newSubpass->SetCompanionSubpass(companionSubpass, shadowMapPipeline); // set companion subpass and pipeline 
     
     // add the shadow map to the lighting system
-    uint32_t const NEW_SHADOW_MAP_INDEX = lightingSubSystem->AddShadowMap(renderGraph->GetRenderGraphResource(resourceName), EVENT_DATA->lightEntity);
+    uint32_t const NEW_SHADOW_MAP_INDEX = lightingSubSystem->AddShadowMap(renderGraph->GetRenderGraphResource(shadowMapResourceName), EVENT_DATA->lightEntity);
 
     auto nodeCompute = renderGraph->GetNode(SHGraphicsConstants::RenderGraphEntityNames::DEFERRED_COMPOSITE_PASS.data())->GetNodeCompute(SHGraphicsConstants::RenderGraphEntityNames::DEFERRED_COMPOSITE_COMPUTE.data());
     nodeCompute->ModifyWriteDescImageComputeResource(SHGraphicsConstants::DescriptorSetBindings::SHADOW_MAP_IMAGE_SAMPLER_DATA, lightingSubSystem->GetViewSamplerLayout(NEW_SHADOW_MAP_INDEX), NEW_SHADOW_MAP_INDEX);
@@ -1154,6 +1178,14 @@ namespace SHADE
 #ifdef SHEDITOR
     cameraSystem->GetEditorCamera()->SetWidth(static_cast<float>(resizeWidth));
     cameraSystem->GetEditorCamera()->SetHeight(static_cast<float>(resizeHeight));
+
+    // Create new event and broadcast it
+    SHWindowResizeEvent newEvent;
+    newEvent.resizeWidth = resizeWidth;
+    newEvent.resizeHeight = resizeHeight;
+
+    SHEventManager::BroadcastEvent<SHWindowResizeEvent>(newEvent, SH_WINDOW_RESIZE_EVENT);
+
 #else
 
 #endif

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h

@@ -36,6 +36,7 @@ of DigiPen Institute of Technology is prohibited.
 #include "Graphics/MiddleEnd/TextRendering/SHFontLibrary.h"
 #include "Graphics/MiddleEnd/Interface/SHRenderer.h"
 #include "Graphics/Events/SHGraphicsEvents.h"
+#include "Graphics/MiddleEnd/TrajectoryRendering/SHTrajectoryRenderingSubSystem.h"
 
 namespace SHADE
 {
@@ -470,6 +471,8 @@ namespace SHADE
     Handle<SHVkShaderModule>                                  renderToSwapchainFS;
     Handle<SHVkShaderModule>                                  shadowMapVS;
     Handle<SHVkShaderModule>                                  shadowMapFS;
+    Handle<SHVkShaderModule>                                  trajectoryVS;
+    Handle<SHVkShaderModule>                                  trajectoryFS;
 
     // Fonts
     Handle<SHFont>                                            testFont;
@@ -505,6 +508,7 @@ namespace SHADE
     Handle<SHPostOffscreenRenderSystem>                       postOffscreenRenderSubSystem;
     Handle<SHLightingSubSystem>                               lightingSubSystem;
     Handle<SHTextRenderingSubSystem>                          textRenderingSubSystem;
+    Handle<SHTrajectoryRenderingSubSystem>                    trajectoryRenderingSubSystem;
     Handle<SHSSAO>                                            ssaoStorage;
 
     uint32_t                                                  resizeWidth = 1;

SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp

@@ -395,7 +395,11 @@ namespace SHADE
     switch (lightComp->GetLightData().type)
     {
     case SH_LIGHT_TYPE::DIRECTIONAL:
-      return SHMatrix::Transpose(SHMatrix::LookAtLH(lightComp->GetLightData().position, SHVec3::Normalise (lightComp->GetLightData().direction), SHVec3(0.0f, -1.0f, 0.0f)));
+    {
+      SHTransformComponent* transform = SHComponentManager::GetComponent<SHTransformComponent>(lightComp->GetEID());
+
+      return SHMatrix::Transpose(SHMatrix::LookAtLH(transform->GetWorldPosition(), SHVec3::Normalise(lightComp->GetLightData().direction), SHVec3(0.0f, -1.0f, 0.0f)));
+    }
       //return SHMatrix::Transpose(SHMatrix::LookAtLH(/*lightComp->GetLightData().position*/SHVec3(1.27862f, 4.78952f, 4.12811f), SHVec3(-0.280564f, -0.66262f, -0.69422f), SHVec3(0.0f, -1.0f, 0.0f)));
     case SH_LIGHT_TYPE::POINT:
       return {};
@@ -518,7 +522,7 @@ namespace SHADE
       if (auto renderer = light.GetRenderer())
       {
         //SHMatrix orthoMatrix = SHMatrix::OrthographicRH()
-        renderer->UpdateDataManual(frameIndex, GetViewMatrix(&light), SHMatrix::OrthographicLH(10.0f, 10.0f, 1.0f, 50.0f));
+        renderer->UpdateDataManual(frameIndex, GetViewMatrix(&light), SHMatrix::OrthographicLH(12.0f, 12.0f, 1.0f, 80.0f));
       }
 
       auto enumValue = SHUtilities::ConvertEnum(light.GetLightData().type);
@@ -627,16 +631,16 @@ namespace SHADE
     // add to barriers
     shadowMapMemoryBarriers.push_back (vk::ImageMemoryBarrier
       {
-        .srcAccessMask = vk::AccessFlagBits::eDepthStencilAttachmentWrite,
+        .srcAccessMask = vk::AccessFlagBits::eColorAttachmentWrite | vk::AccessFlagBits::eColorAttachmentRead,
         .dstAccessMask = vk::AccessFlagBits::eShaderRead,
-        .oldLayout = vk::ImageLayout::eDepthAttachmentOptimal,
+        .oldLayout = vk::ImageLayout::eColorAttachmentOptimal,
         .newLayout = vk::ImageLayout::eShaderReadOnlyOptimal,
         .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .image = newShadowMap->GetImage()->GetVkImage(),
         .subresourceRange = vk::ImageSubresourceRange
         {
-          .aspectMask = vk::ImageAspectFlagBits::eDepth, 
+          .aspectMask = vk::ImageAspectFlagBits::eColor, 
           .baseMipLevel = 0,
           .levelCount = 1,
           .baseArrayLayer = 0,
@@ -651,7 +655,7 @@ namespace SHADE
   void SHLightingSubSystem::PrepareShadowMapsForRead(Handle<SHVkCommandBuffer> cmdBuffer) noexcept
   {
     // Issue barrier to transition shadow maps for reading in compute shader
-    cmdBuffer->PipelineBarrier(vk::PipelineStageFlagBits::eEarlyFragmentTests | vk::PipelineStageFlagBits::eLateFragmentTests, vk::PipelineStageFlagBits::eComputeShader, {}, {}, {}, shadowMapMemoryBarriers);
+    cmdBuffer->PipelineBarrier(vk::PipelineStageFlagBits::eColorAttachmentOutput, vk::PipelineStageFlagBits::eComputeShader, {}, {}, {}, shadowMapMemoryBarriers);
   }
 
   //void SHLightingSubSystem::HandleResize(Handle<SHRenderGraphNodeCompute> compute) noexcept

SHADE_Engine/src/Graphics/MiddleEnd/Particles/SHParticleSubSustem.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "Resource/SHHandle.h"
+#include "Graphics/Pipeline/SHPipelineState.h"
+#include "Math/SHMatrix.h"
+
+namespace SHADE
+{
+  class SHVkLogicalDevice;
+  class SHVkDescriptorPool;
+  class SHVkDescriptorSetGroup;
+  class SHVkDescriptorSetLayout;
+  class SHVkBuffer;
+  class SHLightComponent;
+  class SHVkCommandBuffer;
+  class SHVkPipeline;
+  class SHVkPipelineLayout;
+  class SHVkRenderpass;
+  class SHSubpass;
+  class SHVkShaderModule;
+  class SHRenderer;
+
+
+
+  class SHParticleSubSystem
+  {
+  private:
+
+    Handle<SHVkLogicalDevice> logicalDevice;
+
+
+  public:
+    void Init(Handle<SHVkLogicalDevice> device, Handle<SHVkRenderpass> compatibleRenderpass, Handle<SHSubpass> subpass) noexcept;
+
+    void Run(uint32_t frameIndex) noexcept;
+
+    void Render(Handle<SHVkCommandBuffer> cmdBuffer, Handle<SHRenderer> renderer, uint32_t frameIndex) noexcept;
+    void Exit(void) noexcept;
+
+  };
+}

SHADE_Engine/src/Graphics/MiddleEnd/Particles/SHParticleSubSystem.cpp

@@ -0,0 +1,7 @@
+#include "SHpch.h"
+#include "SHParticleSubSustem.h"
+
+namespace SHADE
+{
+  
+}

SHADE_Engine/src/Graphics/MiddleEnd/TrajectoryRendering/SHTrajectoryRenderableComponent.cpp

@@ -0,0 +1,96 @@
+#include "SHpch.h"
+#include "SHTrajectoryRenderableComponent.h"
+
+namespace SHADE
+{
+
+  /***************************************************************************/
+  /*!
+
+    \brief
+      On create the text has nothing.
+
+  */
+  /***************************************************************************/
+  void SHTrajectoryRenderableComponent::OnCreate(void)
+  {
+  }
+
+  void SHTrajectoryRenderableComponent::OnDestroy(void)
+  {
+
+  }
+
+
+  void SHTrajectoryRenderableComponent::ClearPositions(void) noexcept
+  {
+    positions.clear();
+  }
+
+  bool SHTrajectoryRenderableComponent::HasPositions(void) const noexcept
+  {
+    return !positions.empty();
+  }
+
+  std::vector<SHVec3> SHTrajectoryRenderableComponent::GetPositions(void) const noexcept
+  {
+    return positions;
+  }
+
+  Handle<SHMesh> SHTrajectoryRenderableComponent::GetMesh(void) const noexcept
+  {
+    return mesh;
+  }
+
+  SHVec4 const& SHTrajectoryRenderableComponent::GetStartColor(void) const noexcept
+  {
+    return startColor;
+  }
+
+  SHVec4 const& SHTrajectoryRenderableComponent::GetEndColor(void) const noexcept
+  {
+    return endColor;
+  }
+
+  float SHTrajectoryRenderableComponent::GetColorEvolveRate(void) const noexcept
+  {
+    return colorEvolveRate;
+  }
+
+  void SHTrajectoryRenderableComponent::SetMesh(Handle<SHMesh> newMesh) noexcept
+  {
+    mesh = newMesh;
+  }
+
+  void SHTrajectoryRenderableComponent::SetPositions(std::vector<SHVec3> const& inPositions) noexcept
+  {
+    positions = inPositions;
+  }
+
+  void SHTrajectoryRenderableComponent::SetStartColor(SHVec4 color) noexcept
+  {
+    startColor = color;
+  }
+
+  void SHTrajectoryRenderableComponent::SetEndColor(SHVec4 color) noexcept
+  {
+    endColor = color;
+
+  }
+
+  void SHTrajectoryRenderableComponent::SetColorEvolveRate(float rate) noexcept
+  {
+    colorEvolveRate = rate;
+  }
+
+}
+
+namespace rttr
+{
+  RTTR_REGISTRATION
+  {
+    using namespace SHADE;
+
+    registration::class_<SHTrajectoryRenderableComponent>("Trajectory Renderer Component");
+  };
+}

SHADE_Engine/src/Graphics/MiddleEnd/TrajectoryRendering/SHTrajectoryRenderableComponent.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "Math/Vector/SHVec3.h"
+#include "Math/Vector/SHVec4.h"
+#include "Resource/SHHandle.h"
+#include "ECS_Base/Components/SHComponent.h"
+#include <rttr/registration>
+
+namespace SHADE
+{
+  class SHMesh;
+
+  class SHTrajectoryRenderableComponent : public SHComponent
+  {
+  private:
+
+    //! Mesh used to render the trajectory
+    Handle<SHMesh> mesh;
+
+    //! positions to plot for rendering. Will be cleared every frame.
+    std::vector<SHVec3> positions;
+
+    //! Starting color of the trajectory
+    SHVec4 startColor;
+
+    //! Color the trajectory should evolve to the longer it is
+    SHVec4 endColor;
+
+    //! evolving rate of the color
+    float colorEvolveRate;
+
+  public:
+    /*-----------------------------------------------------------------------*/
+    /* PRIVATE MEMBER FUNCTIONS                                              */
+    /*-----------------------------------------------------------------------*/
+    void SetMesh(Handle<SHMesh> newMesh) noexcept;
+    void SetPositions (std::vector<SHVec3> const& inPositions) noexcept;
+    void SetStartColor(SHVec4 startColor) noexcept;
+    void SetEndColor  (SHVec4 endColor) noexcept;
+    void SetColorEvolveRate (float rate) noexcept;
+
+    std::vector<SHVec3> GetPositions       (void) const noexcept;
+    Handle<SHMesh>      GetMesh            (void) const noexcept;
+    SHVec4 const&       GetStartColor      (void) const noexcept;
+    SHVec4 const&       GetEndColor        (void) const noexcept;
+    float               GetColorEvolveRate (void) const noexcept;
+
+    void OnCreate(void) override final;
+    void OnDestroy(void) override final;
+
+    void ClearPositions(void) noexcept;
+    bool HasPositions(void) const noexcept;
+
+
+    RTTR_ENABLE()
+
+  };
+}

SHADE_Engine/src/Graphics/MiddleEnd/TrajectoryRendering/SHTrajectoryRenderingSubSystem.cpp

@@ -0,0 +1,191 @@
+#include "SHpch.h"
+#include "SHTrajectoryRenderingSubSystem.h"
+#include "ECS_Base/Managers/SHComponentManager.h"
+#include "Graphics/MiddleEnd/TrajectoryRendering/SHTrajectoryRenderableComponent.h"
+#include "Graphics/Devices/SHVkLogicalDevice.h"
+#include "Math/Transform/SHTransformComponent.h"
+#include "Graphics\MiddleEnd\Interface\SHMeshLibrary.h"
+#include "Graphics/SHVkUtil.h"
+#include "Graphics/MiddleEnd/GlobalData/SHGraphicsPredefinedData.h"
+#include "Graphics/Pipeline/SHVkPipeline.h"
+#include "Graphics/RenderGraph/SHSubpass.h"
+#include "Graphics/MiddleEnd/GlobalData/SHGlobalDescriptorSets.h"
+#include "Graphics/MiddleEnd/Interface/SHRenderer.h"
+
+namespace SHADE
+{
+  
+
+  void SHTrajectoryRenderingSubSystem::Init(Handle<SHVkLogicalDevice> device, Handle<SHVkRenderpass> compatibleRenderpass, Handle<SHSubpass> subpass, Handle<SHVkShaderModule> trajectoryVS, Handle<SHVkShaderModule> trajectoryFS) noexcept
+  {
+    logicalDevice = device;
+
+    SHComponentManager::CreateComponentSparseSet<SHTrajectoryRenderableComponent>();
+
+    // prepare pipeline layout params
+    SHPipelineLayoutParams plParams
+    {
+      .shaderModules = {trajectoryVS, trajectoryFS},
+      .predefinedDescSetLayouts = SHGraphicsPredefinedData::GetSystemData(SHGraphicsPredefinedData::SystemType::TRAJECTORY_RENDERING).descSetLayouts
+    };
+
+    pipelineLayout = logicalDevice->CreatePipelineLayout(plParams);
+
+    // Create pipeline
+    pipeline = logicalDevice->CreateGraphicsPipeline(pipelineLayout, nullptr, compatibleRenderpass, subpass);
+
+    // vertex input state of the pipeline
+    SHVertexInputState vertexInputState;
+    vertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_3D) }); // Attribute positions at binding 0
+    vertexInputState.AddBinding(false, false, { SHVertexAttribute(SHAttribFormat::FLOAT_2D) }); // Attribute uv at binding 1
+    vertexInputState.AddBinding(true, true, { SHVertexAttribute(SHAttribFormat::FLOAT_4D) }); // Instanced attribute color at binding 2
+    vertexInputState.AddBinding(true, true, { SHVertexAttribute(SHAttribFormat::MAT_4D) }); // Instanced Transform at binding 3 - 6 (4 slots)
+
+    pipeline->GetPipelineState().SetVertexInputState(vertexInputState);
+
+    SHColorBlendState colorBlendState{};
+    colorBlendState.logic_op_enable = VK_FALSE;
+    colorBlendState.logic_op = vk::LogicOp::eCopy;
+
+
+    auto const& subpassColorReferences = subpass->GetColorAttachmentReferences();
+    colorBlendState.attachments.reserve(static_cast<uint32_t>(subpassColorReferences.size()));
+
+    for (auto& att : subpassColorReferences)
+    {
+      colorBlendState.attachments.push_back(vk::PipelineColorBlendAttachmentState
+        {
+          .blendEnable = SHVkUtil::IsBlendCompatible(subpass->GetFormatFromAttachmentReference(att.attachment)) ? true : false,
+          .srcColorBlendFactor = vk::BlendFactor::eSrcAlpha,
+          .dstColorBlendFactor = vk::BlendFactor::eOneMinusSrcAlpha,
+          .colorBlendOp = vk::BlendOp::eAdd,
+          .srcAlphaBlendFactor = vk::BlendFactor::eOne,
+          .dstAlphaBlendFactor = vk::BlendFactor::eZero,
+          .alphaBlendOp = vk::BlendOp::eAdd,
+          .colorWriteMask = vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG | vk::ColorComponentFlagBits::eB | vk::ColorComponentFlagBits::eA,
+        }
+      );
+    }
+
+    pipeline->GetPipelineState().SetColorBlenState(colorBlendState);
+  }
+
+  void SHTrajectoryRenderingSubSystem::Run(uint32_t frameIndex) noexcept
+  {
+    auto& comps = SHComponentManager::GetDense<SHTrajectoryRenderableComponent>();
+    for (auto& comp : comps)
+    {
+      comp.SetPositions(std::vector
+        {
+          SHVec3 {},
+          SHVec3 {}
+        });
+
+      // If has positions, feed data to buffer.
+      if (comp.HasPositions())
+      {
+        SHTransformComponent* transform = SHComponentManager::GetComponent_s<SHTransformComponent>(comp.GetEID());
+        if (transform)
+        {
+          // convenient variable
+          SHVec4 const& startColor = comp.GetStartColor();
+          SHVec4 const& endColor = comp.GetEndColor();
+          float colorEvolveRate = comp.GetColorEvolveRate();
+
+          // trs to be reused
+          SHMatrix trs = transform->GetTRS();
+
+          // starting color of trajectory
+          SHVec4 currentColor = comp.GetStartColor();
+
+          // Start from 0 and slowly evolve to 1
+          float lerpValue = 0.0f;
+
+          // Will be used for baseInstance later
+          uint32_t oldTransformDataSize = transformData.size();
+
+          auto meshHandle = comp.GetMesh();
+
+          auto const& positions = comp.GetPositions();
+          for (auto& pos : positions)
+          {
+            // modify position and reuse matrix
+            trs.m[3][0] = pos.x;
+            trs.m[3][1] = pos.y;
+            trs.m[3][2] = pos.z;
+
+            transformData.push_back(trs);
+            colorData.push_back(currentColor);
+
+            // evolve color
+            currentColor = SHVec4::Lerp(startColor, endColor, lerpValue);
+
+            // evolve lerp value and clamp to 1
+            lerpValue = std::max (1.0f, lerpValue + colorEvolveRate);
+          }
+
+          // add draw data for this trajectory 
+          drawData.push_back(vk::DrawIndexedIndirectCommand 
+            {
+              .indexCount = meshHandle->IndexCount,
+              .instanceCount = static_cast<uint32_t>(transformData.size()) - oldTransformDataSize,
+              .firstIndex = meshHandle->FirstIndex,
+              .vertexOffset = meshHandle->FirstVertex,
+              .firstInstance = oldTransformDataSize
+            });
+        }
+      }
+
+      // clear at the end of every frame since data is already in buffers
+      comp.ClearPositions();
+    }
+
+    if (!transformData.empty())
+    {
+      // read transform data to buffer
+      // read draw data to buffer
+      SHVkUtil::EnsureBufferAndCopyHostVisibleData(logicalDevice, transformBuffer, transformData.data(), sizeof (SHMatrix) * transformData.size(), vk::BufferUsageFlagBits::eVertexBuffer, "Trajectory System Transform Buffer");
+
+      SHVkUtil::EnsureBufferAndCopyHostVisibleData(logicalDevice, drawDataBuffer, drawData.data(), sizeof(vk::DrawIndexedIndirectCommand) * drawData.size(), vk::BufferUsageFlagBits::eIndirectBuffer, "Trajectory System Draw Data Buffer");
+
+      SHVkUtil::EnsureBufferAndCopyHostVisibleData(logicalDevice, colorBuffer, colorData.data(), sizeof(SHVec4) * colorData.size(), vk::BufferUsageFlagBits::eVertexBuffer, "Trajectory System Color Data Buffer");
+    }
+
+  }
+
+  void SHTrajectoryRenderingSubSystem::Render(Handle<SHVkCommandBuffer> cmdBuffer, Handle<SHRenderer> renderer, uint32_t frameIndex) noexcept
+  {
+    if (!transformData.empty())
+    {
+      auto const& mappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::TRAJECTORY_RENDERING);
+      uint32_t staticGlobalSetIndex = mappings.at(SHPredefinedDescriptorTypes::STATIC_DATA);
+      uint32_t cameraSetIndex = mappings.at(SHPredefinedDescriptorTypes::CAMERA);
+
+      cmdBuffer->BindPipeline(pipeline);
+
+      // Bind global data
+      SHGlobalDescriptorSets::BindStaticGlobalData(cmdBuffer, SH_PIPELINE_TYPE::GRAPHICS, staticGlobalSetIndex);
+
+      // Bind camera data
+      renderer->BindDescriptorSet(cmdBuffer, SH_PIPELINE_TYPE::GRAPHICS, cameraSetIndex, frameIndex);
+
+      // Bind color vertex buffer 
+      cmdBuffer->BindVertexBuffer(SHGraphicsConstants::VertexBufferBindings::TRAJECTORY_COLOR, colorBuffer, 0);
+
+      // call draw call
+      cmdBuffer->DrawMultiIndirect(drawDataBuffer, drawData.size());
+
+      // clear CPU transform and draw data
+      transformData.clear();
+      drawData.clear();
+      colorData.clear();
+    }
+
+  }
+
+  void SHTrajectoryRenderingSubSystem::Exit(void) noexcept
+  {
+
+  }
+
+}

SHADE_Engine/src/Graphics/MiddleEnd/TrajectoryRendering/SHTrajectoryRenderingSubSystem.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include "Resource/SHHandle.h"
+#include "Graphics/Pipeline/SHPipelineState.h"
+#include "Math/SHMatrix.h"
+
+namespace SHADE
+{
+  class SHVkLogicalDevice;
+  class SHVkDescriptorPool;
+  class SHVkDescriptorSetGroup;
+  class SHVkDescriptorSetLayout;
+  class SHVkBuffer;
+  class SHLightComponent;
+  class SHVkCommandBuffer;
+  class SHVkPipeline;
+  class SHVkPipelineLayout;
+  class SHVkRenderpass;
+  class SHSubpass;
+  class SHVkShaderModule;
+  class SHRenderer;
+
+
+
+  class SHTrajectoryRenderingSubSystem
+  {
+  private:
+
+    Handle<SHVkLogicalDevice>                   logicalDevice;
+
+    //! Every trajectory renderable will have one of these
+    std::vector<vk::DrawIndexedIndirectCommand> drawData;
+
+    //! For the MDI call
+    Handle<SHVkBuffer>                          drawDataBuffer;
+
+    //! matrix data to copy into buffer
+    std::vector<SHMatrix>                       transformData;
+
+    //! All trajectory renderables will use this transform buffer
+    Handle<SHVkBuffer>                          transformBuffer;
+
+    //! Each object will have their own color data
+    std::vector<SHVec4>                         colorData;
+
+    //! buffer to hold color data for objects
+    Handle<SHVkBuffer>                          colorBuffer;
+
+    //! Pipeline for rendering the trajectories
+    Handle<SHVkPipeline>                        pipeline;
+
+    //! Pipeline layout for the pipeline
+    Handle<SHVkPipelineLayout>                  pipelineLayout;
+
+
+  	
+  public:
+    void Init (Handle<SHVkLogicalDevice> device, Handle<SHVkRenderpass> compatibleRenderpass, Handle<SHSubpass> subpass, Handle<SHVkShaderModule> textVS, Handle<SHVkShaderModule> textFS) noexcept;
+
+    void Run(uint32_t frameIndex) noexcept;
+
+    void Render(Handle<SHVkCommandBuffer> cmdBuffer, Handle<SHRenderer> renderer, uint32_t frameIndex) noexcept;
+    void Exit(void) noexcept;
+
+  };
+}