Some slang progress

assets/shaders/hello-world.slang

@@ -1,62 +1,53 @@
-
-// Uniform data to be passed from application -> shader.
 cbuffer Uniforms {
   float4x4 u_Projection;
   float4x4 u_View;
   float4x4 u_Model;
   float4 u_Color;
-  int u_HasTexture; // Changed from bool to int for compatibility
-}
+  bool u_HasTexture;
+  uniform Sampler2D u_Texture;
+};
 
-// Per-vertex attributes to be assembled from bound vertex buffers.
 struct AssembledVertex {
   float3 position : POSITION;
-  float2 texcoord : TEXCOORD0;
+  float2 texcoord : TEXCOORD;
 };
 
-// Output of the vertex shader, and input to the fragment shader.
-struct CoarseVertex {
-  float2 texcoord : TEXCOORD0;
-  float4 position : SV_Position; // Needed for rasterization
-};
-
-// Output of the fragment shader.
 struct Fragment {
-  float4 color : SV_Target; // SV_Target is required for color output
+  float4 color;
 };
 
-// Combined Texture and Sampler (avoids linking issues)
-Texture2D textureMap;
-SamplerState textureSampler;
+struct VertexStageOutput {
+  float2 uv : UV;
+  float4 sv_position : SV_Position;
+};
+
+float4 someFunction(float4 color) {
+  return color * float4(0.5, 0.5, 0.5, 1.0);
+}
 
-// Vertex Shader
 [shader("vertex")]
-CoarseVertex vertexMain(AssembledVertex assembledVertex) {
-  CoarseVertex output;
+VertexStageOutput vertexMain(AssembledVertex assembledVertex) {
+  VertexStageOutput output;
 
-  // Transform vertex position using Model-View-Projection matrix
-  float4 worldPosition = mul(u_Model, float4(assembledVertex.position, 1.0));
-  float4 viewPosition = mul(u_View, worldPosition);
-  output.position = mul(u_Projection, viewPosition);
+  float3 position = assembledVertex.position;
 
-  // Pass through texture coordinates
-  output.texcoord = assembledVertex.texcoord;
+  output.uv = assembledVertex.texcoord;
+
+  output.sv_position = mul(
+    float4(position, 1.0),
+    mul(u_Model, mul(u_View, u_Projection))
+  );
 
   return output;
 }
 
-// Fragment Shader
 [shader("fragment")]
-Fragment fragmentMain(CoarseVertex coarseVertex) {
+Fragment fragmentMain(float2 uv: UV) : SV_Target {
   Fragment output;
-
-  // Sample the texture if a texture is bound
-  if (u_HasTexture != 0) {
-    output.color = textureMap.Sample(textureSampler, coarseVertex.texcoord);
+  if(u_HasTexture) {
+    output.color = u_Texture.Sample(uv) * u_Color;
   } else {
-    // Use the uniform color if no texture is bound
-    output.color = u_Color;
+      output.color = someFunction(u_Color);
   }
-
   return output;
 }

fragment.glsl

@@ -1,80 +0,0 @@
-#version 450
-layout(column_major) uniform;
-layout(column_major) buffer;
-
-#line 1883 0
-struct _MatrixStorage_float4x4std140_0
-{
-    vec4  data_0[4];
-};
-
-
-#line 7 1
-struct SLANG_ParameterGroup_Uniforms_std140_0
-{
-    _MatrixStorage_float4x4std140_0 u_Projection_0;
-    _MatrixStorage_float4x4std140_0 u_View_0;
-    _MatrixStorage_float4x4std140_0 u_Model_0;
-    vec4 u_Color_0;
-    bool u_HasTexture_0;
-};
-
-
-#line 2
-layout(binding = 0)
-layout(std140) uniform block_SLANG_ParameterGroup_Uniforms_std140_0
-{
-    _MatrixStorage_float4x4std140_0 u_Projection_0;
-    _MatrixStorage_float4x4std140_0 u_View_0;
-    _MatrixStorage_float4x4std140_0 u_Model_0;
-    vec4 u_Color_0;
-    bool u_HasTexture_0;
-}Uniforms_0;
-layout(binding = 1)
-uniform sampler2D u_Texture_0;
-
-
-#line 4811 0
-layout(location = 0)
-out vec4 entryPointParam_fragmentMain_color_0;
-
-
-#line 4811
-layout(location = 0)
-in vec2 uv_0;
-
-
-#line 21 1
-struct Fragment_0
-{
-    vec4 color_0;
-};
-
-
-#line 49
-void main()
-{
-
-    Fragment_0 output_0;
-    if(Uniforms_0.u_HasTexture_0)
-    {
-
-#line 54
-        output_0.color_0 = (texture((u_Texture_0), (uv_0))) * Uniforms_0.u_Color_0;
-
-#line 53
-    }
-    else
-    {
-        output_0.color_0 = Uniforms_0.u_Color_0;
-
-#line 53
-    }
-
-#line 53
-    entryPointParam_fragmentMain_color_0 = output_0.color_0;
-
-#line 53
-    return;
-}
-

lib/CMakeLists.txt

@@ -57,7 +57,7 @@ endif()
 FetchContent_Declare(
   slang
   GIT_REPOSITORY https://github.com/shader-slang/slang
-  GIT_TAG v2024.15.1
+  GIT_TAG v2024.17
 )
 FetchContent_MakeAvailable(slang)
 

src/dawn/CMakeLists.txt

@@ -10,6 +10,7 @@ target_link_libraries(${DAWN_TARGET_NAME}
     glm::glm
     nlohmann_json::nlohmann_json
     freetype
+    slang
 )
 
 # Includes
@@ -37,5 +38,6 @@ add_subdirectory(ui)
 
 # Assets
 tool_copy(en en.json)
+tool_copy(helloShader shaders/hello-world.slang)
 
 add_dependencies(${DAWN_TARGET_NAME} dawnassets)

src/dawn/asset/AssetLoader.cpp

@@ -5,6 +5,7 @@
 
 #include "AssetLoader.hpp"
 #include "assert/assert.hpp"
+#include "asset/AssetManager.hpp"
 
 using namespace Dawn;
 
@@ -27,6 +28,12 @@ std::shared_ptr<AssetManager> AssetLoader::getAssetManager() {
   return am;
 }
 
+void AssetLoader::loadImmediately() {
+  while(!this->loaded) {
+    this->getAssetManager()->update();
+  }
+}
+
 AssetLoader::~AssetLoader() {
   this->loaded = false;
 }

src/dawn/asset/AssetLoader.hpp

@@ -58,6 +58,11 @@ namespace Dawn {
        */
       std::shared_ptr<AssetManager> getAssetManager();
 
+      /**
+       * Load the asset immediately, this is blocking on the main thread.
+       */
+      void loadImmediately();
+      
       /**
        * Dispose the asset item.
        */

src/dawn/asset/loader/CMakeLists.txt

@@ -9,6 +9,8 @@ target_sources(${DAWN_TARGET_NAME}
     TextureLoader.cpp
     JSONLoader.cpp
     TrueTypeLoader.cpp
+    ShaderLoader.cpp
+    StringLoader.cpp
 )
 
 # Subdirs

src/dawn/asset/loader/ShaderLoader.cpp

@@ -0,0 +1,137 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "ShaderLoader.hpp"
+#include "assert/assert.hpp"
+#include "asset/AssetManager.hpp"
+#include "game/Game.hpp"
+
+#include <fstream>
+
+using namespace Dawn;
+
+const std::string ShaderLoader::ASSET_TYPE = "shader";
+
+ShaderLoader::ShaderLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  AssetLoader(assetManager, name),
+  state(ShaderLoaderState::INITIAL)
+{
+}
+
+void ShaderLoader::updateAsync() {
+}
+
+void ShaderLoader::updateSync() {
+  if(state != ShaderLoaderState::INITIAL) return;
+
+  this->state = ShaderLoaderState::LOADING;
+  assertFalse(loaded, "ShaderLoader already loaded.");
+
+  auto sm = this->getAssetManager()->getGame()->shaderManager;
+
+  // Load the shader string
+  Slang::ComPtr<IBlob> diagnostics;
+  module = sm->session->loadModule(
+    this->name.c_str(),
+    diagnostics.writeRef()
+  );
+
+  // Get list of entry points and create components
+  int32_t definedEntryPointCount = module->getDefinedEntryPointCount();
+  IComponentType** components = new IComponentType*[definedEntryPointCount + 1];
+  int32_t j = 0;
+
+  components[j++] = module;
+
+  for(auto i = 0; i < definedEntryPointCount; i++) {
+    Slang::ComPtr<IEntryPoint> ep;
+    auto result = module->getDefinedEntryPoint(i, ep.writeRef());
+
+    if(result != SLANG_OK) {
+      assertUnreachable("Failed to get entry point.");
+      return;
+    }
+
+    auto name = ep->getFunctionReflection()->getName();
+    std::cout << "Found entry point: " << name << std::endl;
+    entryPoints.push_back(std::string(name));
+    components[j++] = ep;
+  }
+
+  // Create the composite component type
+  sm->session->createCompositeComponentType(
+    components,
+    sizeof(components) / sizeof(components[0]),
+    program.writeRef()
+  );
+
+  // Link the program.
+  auto result = program->link(linkedProgram.writeRef(), diagnostics.writeRef());
+  if(diagnostics) {
+    assertUnreachable("%s\n", (const char*) diagnostics->getBufferPointer());
+    return;
+  }
+
+  // result
+  Slang::ComPtr<IBlob> blob;
+  auto result2 = linkedProgram->getEntryPointCode(
+    0,
+    0,
+    blob.writeRef(),
+    diagnostics.writeRef()
+  );
+
+  if(diagnostics) {
+    assertUnreachable("%s\n", (const char*) diagnostics->getBufferPointer());
+  }
+
+  this->state = ShaderLoaderState::LOADED;
+  this->loaded = true;
+}
+
+std::string ShaderLoader::getAssetType() const {
+  return ShaderLoader::ASSET_TYPE;
+}
+
+std::string ShaderLoader::getEntryPointCode(const std::string &entryPoint) {
+  assertTrue(loaded, "ShaderLoader not loaded.");
+  assertNotNull(linkedProgram, "ShaderLoader linkedProgram is null.");
+
+  // Get the entry point index
+  int32_t entryIndex = -1;
+  for(auto i = 0; i < entryPoints.size(); i++) {
+    if(entryPoints[i] != entryPoint) continue;
+    entryIndex = i;
+    break;
+  }
+  assertTrue(entryIndex != -1, "EntryPoint not found.");
+
+  // Find the entry point code
+  Slang::ComPtr<IBlob> blob;
+  Slang::ComPtr<IBlob> diagnostics;
+  auto result = linkedProgram->getEntryPointCode(
+    entryIndex,
+    0,
+    blob.writeRef(),
+    diagnostics.writeRef()
+  );
+
+  if(diagnostics) {
+    assertUnreachable("%s\n", (const char*) diagnostics->getBufferPointer());
+    return "";
+  }
+
+  return std::string((const char*)blob->getBufferPointer());
+}
+
+ShaderLoader::~ShaderLoader() {
+  if(linkedProgram) {
+    linkedProgram->release();
+    linkedProgram = nullptr;
+  }
+}

src/dawn/asset/loader/ShaderLoader.hpp

@@ -0,0 +1,40 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "asset/AssetLoader.hpp"
+#include "asset/AssetDataLoader.hpp"
+#include "display/shader/ShaderManager.hpp"
+
+namespace Dawn {
+  enum class ShaderLoaderState {
+    INITIAL,
+    LOADING,
+    LOADED
+  };
+
+  class ShaderLoader : public AssetLoader {
+    protected:
+      enum ShaderLoaderState state;
+
+    public:
+      const static std::string ASSET_TYPE;
+
+      std::vector<std::string> entryPoints;
+      Slang::ComPtr<IComponentType> linkedProgram;
+      Slang::ComPtr<IComponentType> program;
+      IModule* module;
+
+      ShaderLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
+      void updateSync() override;
+      void updateAsync() override;
+      std::string getAssetType() const override;
+      std::string getEntryPointCode(const std::string &entryPoint);
+      ~ShaderLoader();
+  };
+}

src/dawn/asset/loader/StringLoader.cpp

@@ -0,0 +1,38 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "StringLoader.hpp"
+
+using namespace Dawn;
+
+const std::string StringLoader::ASSET_TYPE = "string";
+
+StringLoader::StringLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  AssetLoader(assetManager, name),
+  loader(name),
+  state(StringLoaderState::INITIAL)
+{
+}
+
+void StringLoader::updateSync() {
+}
+
+void StringLoader::updateAsync() {
+  if(this->state != StringLoaderState::INITIAL) return;
+  this->state = StringLoaderState::LOADING_STRING;
+  this->data = this->loader.getEntireContentsAsString();
+  this->state = StringLoaderState::DONE;
+  this->loaded = true;
+}
+
+std::string StringLoader::getAssetType() const {
+  return StringLoader::ASSET_TYPE;
+}
+
+StringLoader::~StringLoader() {
+}

src/dawn/asset/loader/StringLoader.hpp

@@ -0,0 +1,36 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "asset/AssetLoader.hpp"
+#include "asset/AssetDataLoader.hpp"
+
+namespace Dawn {
+  enum class StringLoaderState {
+    INITIAL,
+    LOADING_STRING,
+    DONE
+  };
+
+  class StringLoader : public AssetLoader {
+    protected:
+      AssetDataLoader loader;
+      enum StringLoaderState state;
+
+    public:
+      const static std::string ASSET_TYPE;
+
+      std::string data;
+
+      StringLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
+      void updateSync() override;
+      void updateAsync() override;
+      std::string getAssetType() const override;
+      ~StringLoader();
+  };
+}

src/dawn/component/display/material/Material.cpp

@@ -4,13 +4,16 @@
 // https://opensource.org/licenses/MIT
 
 #include "Material.hpp"
+#include "game/Game.hpp"
 
 using namespace Dawn;
 
 void Material::onInit() {
-
+  this->lockedShaders = this->getLockedShaders(
+    getGame()->renderHost->shaderManager
+  );
 }
 
 void Material::onDispose() {
-  
+  this->lockedShaders.clear();
 }

src/dawn/component/display/material/Material.hpp

@@ -12,7 +12,19 @@ namespace Dawn {
     public SceneComponent,
     public IRenderableComponent
   {
+    private:
+      std::vector<std::shared_ptr<IShaderBase>> lockedShaders;
+
     protected:
+      /**
+       * Locks the shaders to be used for rendering.
+       * 
+       * @param shaderManager Shader manager to use.
+       * @return List of shaders to be used.
+       */
+      virtual std::vector<std::shared_ptr<IShaderBase>> getLockedShaders(
+        ShaderManager &shaderManager
+      ) = 0;
 
     public:
       void onInit() override;

src/dawn/component/display/material/SimpleTexturedMaterial.cpp

@@ -9,6 +9,14 @@
 
 using namespace Dawn;
 
+std::vector<
+  std::shared_ptr<IShaderBase>
+> SimpleTexturedMaterial::getLockedShaders(ShaderManager &shaderManager) {
+  return {
+    shaderManager.getShader<SimpleTexturedShader>()
+  };
+}
+
 void SimpleTexturedMaterial::load(std::shared_ptr<SceneLoadContext> ctx) {
   if(ctx->data.contains("color")) {
     this->setColor(JSON::color(ctx->data["color"]));

src/dawn/component/display/material/SimpleTexturedMaterial.hpp

@@ -14,6 +14,11 @@ namespace Dawn {
       struct SimpleTexturedShaderData data;
       std::shared_ptr<Texture> texture;
 
+    protected:
+      std::vector<std::shared_ptr<IShaderBase>> getLockedShaders(
+        ShaderManager &shaderManager
+      ) override;
+
     public:
       void load(std::shared_ptr<SceneLoadContext> ctx) override;
       

src/dawn/display/shader/CMakeLists.txt

@@ -8,4 +8,6 @@ target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     IShader.cpp
     IShaderStage.cpp
+    ShaderManager.cpp
+    ShaderManagerSlangFileSystem.cpp
 )

src/dawn/display/shader/ShaderManager.cpp

@@ -0,0 +1,48 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "ShaderManager.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+ShaderManager::ShaderManager() {
+}
+
+void ShaderManager::init(const std::shared_ptr<Game> &game) {
+  assertNotNull(game, "Game instance must not be null.");
+
+  this->game = game;
+
+  // Create the file system
+  this->fileSystem.sm = shared_from_this();
+
+  // Create the global session
+  createGlobalSession(globalSession.writeRef());
+
+  // Set the target description, TODO: interface
+  targetDescription.format = SLANG_GLSL;
+  targetDescription.profile = globalSession->findProfile("glsl_330");
+
+  // Set the session description
+  sessionDescription.targets = &targetDescription;
+  sessionDescription.targetCount = 1;
+  sessionDescription.searchPathCount = 0;
+  sessionDescription.fileSystem = &this->fileSystem;
+
+  // Create session
+  globalSession->createSession(sessionDescription, session.writeRef());
+}
+
+std::shared_ptr<Game> ShaderManager::getGame() {
+  auto game = this->game.lock();
+  assertNotNull(game, "Game instance must not be null.");
+  return game;
+}
+
+ShaderManager::~ShaderManager() {
+  // Clear all shaders
+  shaders.clear();
+}

src/dawn/display/shader/ShaderManager.hpp

@@ -5,13 +5,45 @@
 
 #pragma once
 #include "display/shader/Shader.hpp"
+#include "ShaderManagerSlangFileSystem.hpp"
+using namespace slang;
 
 namespace Dawn {
-  class ShaderManager {
+  class Game;
+  class ShaderLoader;
+
+  class ShaderManager : public std::enable_shared_from_this<ShaderManager> {
     private:
-      std::vector<std::shared_ptr<IShaderBase>> shaders;
+      std::vector<std::weak_ptr<IShaderBase>> shaders;
+
+      std::weak_ptr<Game> game;
+      ShaderManagerSlangFileSystem fileSystem;
+
+      Slang::ComPtr<IGlobalSession> globalSession;
+      TargetDesc targetDescription;
+      SessionDesc sessionDescription;
+      Slang::ComPtr<ISession> session;
 
     public:
+      /**
+       * Creates a new shader manager.
+       */
+      ShaderManager();
+
+      /**
+       * Initializes the shader manager.
+       * 
+       * @param game The game instance that the shader manager is being used in.
+       */
+      void init(const std::shared_ptr<Game> &game);
+
+      /**
+       * Retreives the game instance.
+       * 
+       * @return Game instance.
+       */
+      std::shared_ptr<Game> getGame();
+
       /**
        * Retreives an instance of the shader from the shader manager. If the
        * shader does not exist it will be created.
@@ -23,8 +55,7 @@ namespace Dawn {
       std::shared_ptr<T> getShader() {
         auto itShaders = shaders.begin();
         while(itShaders != shaders.end()) {
-          // auto shader = itShaders->lock();
-          auto shader = *itShaders;
+          auto shader = itShaders->lock();
           if(!shader) {
             itShaders = shaders.erase(itShaders);
             continue;
@@ -44,8 +75,8 @@ namespace Dawn {
       /**
        * Disposes of all shaders.
        */
-      ~ShaderManager() {
-        shaders.clear();
-      }
+      ~ShaderManager();
+
+      friend class ShaderLoader;
   };
 }

src/dawn/display/shader/ShaderManagerSlangFileSystem.cpp

@@ -0,0 +1,78 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "ShaderManagerSlangFileSystem.hpp"
+#include "assert/assert.hpp"
+#include "display/shader/ShaderManager.hpp"
+#include "game/Game.hpp"
+#include "asset/loader/StringLoader.hpp"
+#include "util/String.hpp"
+
+using namespace Dawn;
+
+void const * ShaderManagerSlangString::getBufferPointer() {
+  return this->str.c_str();
+}
+
+size_t ShaderManagerSlangString::getBufferSize() {
+  return this->str.size();
+}
+
+SlangResult ShaderManagerSlangString::queryInterface(
+  SlangUUID const& uuid,
+  void** outObject
+) {
+  return SLANG_E_NOT_IMPLEMENTED;
+}
+
+uint32_t ShaderManagerSlangString::addRef() {
+  return refs++;
+}
+
+uint32_t ShaderManagerSlangString::release() {
+  return refs--;
+}
+
+//
+
+SlangResult ShaderManagerSlangFileSystem::loadFile(
+  const char* path,
+  ISlangBlob** outBlob
+) {
+  auto shaderManager = this->sm.lock();
+  assertNotNull(shaderManager, "ShaderManager must not be null.");
+  
+  if(!String::endsWith(path, ".slang")) return SLANG_E_NOT_FOUND;
+
+  std::cout << "Loading: " << path << std::endl;
+  auto loader = shaderManager->getGame()->assetManager->get<StringLoader>(path);
+  loader->loadImmediately();
+
+  auto blob = new ShaderManagerSlangString();
+  blob->str = loader->data;
+  *outBlob = blob;
+
+  std::cout << "Loaded: " << path << std::endl;
+  return SLANG_OK;
+}
+
+SlangResult ShaderManagerSlangFileSystem::queryInterface(
+  SlangUUID const& uuid,
+  void** outObject
+) {
+  return SLANG_E_NOT_IMPLEMENTED;
+}
+
+uint32_t ShaderManagerSlangFileSystem::addRef() {
+  return refs++;
+}
+
+uint32_t ShaderManagerSlangFileSystem::release() {
+  return refs--;
+}
+
+void * ShaderManagerSlangFileSystem::castAs(SlangUUID const& uuid) {
+  return nullptr;
+}

src/dawn/display/shader/ShaderManagerSlangFileSystem.hpp

@@ -0,0 +1,46 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawn.hpp"
+#include "slang.h"
+#include "slang-gfx.h"
+#include "slang-com-ptr.h"
+using namespace slang;
+
+namespace Dawn {
+  class ShaderManager;
+
+  struct ShaderManagerSlangString : public ISlangBlob {
+    std::string str;
+    uint32_t refs = 0;
+
+    void const* getBufferPointer() override;
+    size_t getBufferSize() override;
+    SlangResult queryInterface(SlangUUID const& uuid, void** outObject) override;
+    uint32_t addRef() override;
+    uint32_t release() override;
+  };
+
+  struct ShaderManagerSlangFileSystem : public ISlangFileSystem {
+    private:
+      std::weak_ptr<ShaderManager> sm;
+      uint32_t refs = 0;
+
+    public:
+      SlangResult loadFile(
+        const char* path,
+        ISlangBlob** outBlob
+      ) override;
+      
+      SlangResult queryInterface(SlangUUID const& uuid, void** outObject) override;
+
+      uint32_t addRef() override;
+      uint32_t release() override;
+      void * castAs(SlangUUID const& uuid) override;
+
+      friend class ShaderManager;
+  };
+}

src/dawn/game/IGame.cpp

@@ -62,6 +62,9 @@ void IGame::init() {
   settingsManager->init(selfAsGame);
   settingsManager->load();
 
+  shaderManager = std::make_shared<ShaderManager>();
+  shaderManager->init(shared_from_this());
+
   this->initManagers();
 
   // TEST

src/dawn/game/IGame.hpp

@@ -13,6 +13,7 @@
 #include "locale/LocaleManager.hpp"
 #include "save/SaveManager.hpp"
 #include "settings/SettingsManager.hpp"
+#include "display/shader/ShaderManager.hpp"
 
 #ifdef DAWN_ENABLE_PHYSICS
   #include "physics/PhysicsManager.hpp"
@@ -59,6 +60,7 @@ namespace Dawn {
       std::shared_ptr<AssetManager> assetManager;
       std::shared_ptr<LocaleManager> localeManager;
       std::shared_ptr<SettingsManager> settingsManager;
+      std::shared_ptr<ShaderManager> shaderManager;
       
       #ifdef DAWN_ENABLE_PHYSICS
         std::shared_ptr<PhysicsManager> physicsManager;

src/dawn/util/String.cpp

@@ -34,3 +34,12 @@ std::vector<std::string> String::split(
   res.push_back(s.substr(posStart));
   return res;
 }
+
+bool_t String::endsWith(const std::string &str, const std::string &needle) {
+  if(str.length() >= needle.length()) {
+    return (0 == str.compare(
+      str.length() - needle.length(), needle.length(), needle
+    ));
+  }
+  return false;
+}

src/dawn/util/String.hpp

@@ -37,5 +37,14 @@ namespace Dawn {
         const std::string &str,
         const std::string &delim
       );
+
+      /**
+       * Checks if the given string starts with the given needle.
+       * 
+       * @param str String to check.
+       * @param needle String to check for.
+       * @return True if the string starts with the needle.
+       */
+      static bool_t endsWith(const std::string &str, const std::string &needle);
   };
 }

src/dawnopengl/CMakeLists.txt

@@ -6,7 +6,6 @@
 # Libraries
 target_link_libraries(${DAWN_TARGET_NAME}
   PUBLIC
-    slang
 )
 
 # Includes

src/dawnopengl/display/Texture.hpp

@@ -17,7 +17,7 @@ namespace Dawn {
       int32_t width = -1;
       int32_t height = -1;
       GLuint id = -1;
-      GLuint samplerId = -1;
+      // GLuint samplerId = -1;
       TextureFormat format;
       TextureDataFormat dataFormat;
 

src/dawnopengl/display/shader/Shader.hpp

@@ -87,6 +87,27 @@ namespace Dawn {
         assertNoGLError();
         assertTrue(status == GL_TRUE, "Failed to link shader program.");
 
+        std::vector<std::string> uniformNames;
+        GLint numUniforms = 0;
+
+        // Get the number of active uniforms
+        glGetProgramiv(shaderProgram, GL_ACTIVE_UNIFORMS, &numUniforms);
+        assertNoGLError();
+
+        // Iterate through each uniform
+        // for (GLint i = 0; i < numUniforms; ++i) {
+        //   char name[256];
+        //   GLsizei length;
+        //   GLint size;
+        //   GLenum type;
+
+        //   // Get the uniform name
+        //   glGetActiveUniform(shaderProgram, i, sizeof(name), &length, &size, &type, name);
+        //   assertNoGLError();
+        //   std::cout << "Uniform: " << i << ":" << name << std::endl;
+        //   // uniformNames.push_back(std::string(name));
+        // }
+
         // Map parameters correctly.
         std::for_each(
           parameters.begin(),

src/dawnopengl/display/shader/SimpleTexturedShader.cpp

@@ -30,19 +30,14 @@ void SimpleTexturedShader::getStages(
       float4x4 u_Model;
       float4 u_Color;
       bool u_HasTexture;
-    };
-
-    layout(binding = 1)
       uniform Sampler2D u_Texture;
+    };
 
     struct AssembledVertex {
       float3 position : POSITION;
       float2 texcoord : TEXCOORD;
     };
 
-    struct CoarseVertex {
-    };
-
     struct Fragment {
       float4 color;
     };
@@ -126,8 +121,6 @@ void SimpleTexturedShader::getStages(
     program.writeRef()
   );
 
-  slang::ProgramLayout* layout = program->getLayout();
-
   Slang::ComPtr<IComponentType> linkedProgram;
   auto result = program->link(linkedProgram.writeRef(), diagnostics.writeRef());
   std::cout << "Result: " << result << std::endl;
@@ -150,6 +143,21 @@ void SimpleTexturedShader::getStages(
     return;
   }
 
+  slang::ProgramLayout* layout = program->getLayout();
+  unsigned parameterCount = layout->getParameterCount();
+  for(unsigned pp = 0; pp < parameterCount; pp++) {
+    slang::VariableLayoutReflection* parameter = layout->getParameterByIndex(pp);
+    std::cout << "Parameter: " << parameter->getName() << std::endl;
+    
+    auto layout = parameter->getTypeLayout();
+    auto fields = layout->getFieldCount();
+    for(unsigned ff = 0; ff < fields; ff++) {
+      slang::VariableLayoutReflection* field = layout->getFieldByIndex(ff);
+      std::string fieldName = field->getName();
+      std::cout << "Field: " << fieldName << std::endl;
+    }
+  }
+
   std::string vertexString = (const char*)vertexBlob->getBufferPointer();
   std::ofstream out("/home/yourwishes/htdocs/Dawn/vertex.glsl");
   out << vertexString;
@@ -220,40 +228,9 @@ void SimpleTexturedShader::getStages(
     }
   ));
 
-
   // Parameters
-  // parameters.push_back(ShaderParameter(
-  //   "u_Projection",
-  //   &rel->projection,
-  //   ShaderParameterType::MAT4
-  // ));
-
-  // parameters.push_back(ShaderParameter(
-  //   "u_View",
-  //   &rel->view,
-  //   ShaderParameterType::MAT4
-  // ));
-
-  // parameters.push_back(ShaderParameter(
-  //   "u_Model",
-  //   &rel->model,
-  //   ShaderParameterType::MAT4
-  // ));
-
-  // parameters.push_back(ShaderParameter(
-  //   "u_Color",
-  //   &rel->color,
-  //   ShaderParameterType::COLOR
-  // ));
-
-  // parameters.push_back(ShaderParameter(
-  //   "u_HasTexture",
-  //   &rel->hasTexture,
-  //   ShaderParameterType::BOOLEAN
-  // ));
-
   parameters.push_back(ShaderParameter(
-    "u_Texture_0",
+    "Uniforms_u_Texture_0",
     &rel->texture,
     ShaderParameterType::TEXTURE
   ));

src/dawnrpg/component/display/material/MapMaterial.cpp

@@ -9,6 +9,14 @@
 
 using namespace Dawn;
 
+std::vector<
+  std::shared_ptr<IShaderBase>
+> MapMaterial::getLockedShaders(ShaderManager &shaderManager) {
+  return {
+    shaderManager.getShader<MapShader>()
+  };
+}
+
 void MapMaterial::load(std::shared_ptr<SceneLoadContext> ctx) {
   if(ctx->data.contains("color")) {
     this->setColor(JSON::color(ctx->data["color"]));

src/dawnrpg/component/display/material/MapMaterial.hpp

@@ -10,6 +10,11 @@
 
 namespace Dawn {
   class MapMaterial : public Material {
+    protected:
+      std::vector<std::shared_ptr<IShaderBase>> getLockedShaders(
+        ShaderManager &shaderManager
+      ) override;
+
     private:
       struct MapShaderData data;
       std::shared_ptr<Texture> texture;

src/dawnrpg/game/Game.cpp

@@ -11,6 +11,8 @@
 #include "component/RPGPlayer.hpp"
 #include "component/RPGMap.hpp"
 
+#include "asset/loader/ShaderLoader.hpp"
+
 using namespace Dawn;
 
 Game::Game() : IGame() {
@@ -27,6 +29,10 @@ std::string Game::getInitialScene() {
 void Game::initManagers() {
   this->rpgManager = std::make_shared<RPGManager>();
   this->rpgManager->init(shared_from_this());
+
+  auto sl = assetManager->get<ShaderLoader>("shaders/hello-world.slang");
+  sl->loadImmediately();
+  auto code = sl->getEntryPointCode("vertexMain");
 }
 
 Game::~Game() {

vertex.glsl

@@ -1,88 +0,0 @@
-#version 450
-layout(column_major) uniform;
-layout(column_major) buffer;
-
-#line 1312 0
-struct _MatrixStorage_float4x4std140_0
-{
-    vec4  data_0[4];
-};
-
-
-#line 7 1
-struct SLANG_ParameterGroup_Uniforms_std140_0
-{
-    _MatrixStorage_float4x4std140_0 u_Projection_0;
-    _MatrixStorage_float4x4std140_0 u_View_0;
-    _MatrixStorage_float4x4std140_0 u_Model_0;
-    vec4 u_Color_0;
-    bool u_HasTexture_0;
-};
-
-
-#line 2
-layout(binding = 0)
-layout(std140) uniform block_SLANG_ParameterGroup_Uniforms_std140_0
-{
-    _MatrixStorage_float4x4std140_0 u_Projection_0;
-    _MatrixStorage_float4x4std140_0 u_View_0;
-    _MatrixStorage_float4x4std140_0 u_Model_0;
-    vec4 u_Color_0;
-    bool u_HasTexture_0;
-}Uniforms_0;
-
-#line 2
-mat4x4 unpackStorage_0(_MatrixStorage_float4x4std140_0 _S1)
-{
-
-#line 2
-    return mat4x4(_S1.data_0[0][0], _S1.data_0[0][1], _S1.data_0[0][2], _S1.data_0[0][3], _S1.data_0[1][0], _S1.data_0[1][1], _S1.data_0[1][2], _S1.data_0[1][3], _S1.data_0[2][0], _S1.data_0[2][1], _S1.data_0[2][2], _S1.data_0[2][3], _S1.data_0[3][0], _S1.data_0[3][1], _S1.data_0[3][2], _S1.data_0[3][3]);
-}
-
-
-#line 13
-layout(location = 0)
-out vec2 entryPointParam_vertexMain_uv_0;
-
-
-#line 13
-layout(location = 0)
-in vec3 assembledVertex_position_0;
-
-
-#line 13
-layout(location = 1)
-in vec2 assembledVertex_texcoord_0;
-
-
-#line 25
-struct VertexStageOutput_0
-{
-    vec2 uv_0;
-    vec4 sv_position_0;
-};
-
-void main()
-{
-
-    VertexStageOutput_0 output_0;
-
-
-
-    output_0.uv_0 = assembledVertex_texcoord_0;
-
-    output_0.sv_position_0 = (((((((((unpackStorage_0(Uniforms_0.u_Projection_0)) * (unpackStorage_0(Uniforms_0.u_View_0))))) * (unpackStorage_0(Uniforms_0.u_Model_0))))) * (vec4(assembledVertex_position_0, 1.0))));
-
-#line 45
-    VertexStageOutput_0 _S2 = output_0;
-
-#line 45
-    entryPointParam_vertexMain_uv_0 = output_0.uv_0;
-
-#line 45
-    gl_Position = _S2.sv_position_0;
-
-#line 45
-    return;
-}
-