Slang actually worked.

assets/scenes/test_rpg_scene.json

@@ -25,28 +25,6 @@
       }
     },
 
-    "plane": {
-      "position": [ 0, 0, 0 ],
-      "components": {
-        "mesh": {
-          "type": "PlaneMesh",
-          "size": [ 512, 512 ],
-          "cells": [ 16, 16 ],
-          "uv": [ 0, 0, 0.33, 0.25 ]
-        },
-        "renderer": {
-          "type": "MeshRenderer"
-        },
-        "mat": {
-          "type": "MapMaterial",
-          "texture": "rosatext"
-        },
-        "map": {
-          "type": "RPGMap"
-        }
-      }
-    },
-
     "rosa": {
       "prefab": "rosa",
       "position": [ 0, 0, 0 ],

assets/shaders/hello-world.slang

@@ -0,0 +1,62 @@
+
+// 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
+}
+
+// Per-vertex attributes to be assembled from bound vertex buffers.
+struct AssembledVertex {
+  float3 position : POSITION;
+  float2 texcoord : TEXCOORD0;
+};
+
+// 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
+};
+
+// Combined Texture and Sampler (avoids linking issues)
+Texture2D textureMap;
+SamplerState textureSampler;
+
+// Vertex Shader
+[shader("vertex")]
+CoarseVertex vertexMain(AssembledVertex assembledVertex) {
+  CoarseVertex 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);
+
+  // Pass through texture coordinates
+  output.texcoord = assembledVertex.texcoord;
+
+  return output;
+}
+
+// Fragment Shader
+[shader("fragment")]
+Fragment fragmentMain(CoarseVertex coarseVertex) {
+  Fragment output;
+
+  // Sample the texture if a texture is bound
+  if (u_HasTexture != 0) {
+    output.color = textureMap.Sample(textureSampler, coarseVertex.texcoord);
+  } else {
+    // Use the uniform color if no texture is bound
+    output.color = u_Color;
+  }
+
+  return output;
+}

fragment.glsl

@@ -0,0 +1,80 @@
+#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

@@ -53,6 +53,15 @@ if(DAWN_ENABLE_PHYSICS)
   FetchContent_MakeAvailable(JoltPhysics)
 endif()
 
+# SLANG
+FetchContent_Declare(
+  slang
+  GIT_REPOSITORY https://github.com/shader-slang/slang
+  GIT_TAG v2024.15.1
+)
+FetchContent_MakeAvailable(slang)
+
+
 # OpenAL
 # if(DAWN_TARGET_OPENAL)
 #   set(LIBTYPE "STATIC")

lib/glad/include/KHR/khrplatform.h

@@ -153,6 +153,20 @@ typedef int64_t                 khronos_int64_t;
 typedef uint64_t                khronos_uint64_t;
 #define KHRONOS_SUPPORT_INT64   1
 #define KHRONOS_SUPPORT_FLOAT   1
+/*
+ * To support platform where unsigned long cannot be used interchangeably with
+ * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
+ * Ideally, we could just use (u)intptr_t everywhere, but this could result in
+ * ABI breakage if khronos_uintptr_t is changed from unsigned long to
+ * unsigned long long or similar (this results in different C++ name mangling).
+ * To avoid changes for existing platforms, we restrict usage of intptr_t to
+ * platforms where the size of a pointer is larger than the size of long.
+ */
+#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
+#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
+#define KHRONOS_USE_INTPTR_T
+#endif
+#endif
 
 #elif defined(__VMS ) || defined(__sgi)
 
@@ -235,14 +249,21 @@ typedef unsigned short int     khronos_uint16_t;
  * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
  * to be the only LLP64 architecture in current use.
  */
-#ifdef _WIN64
+#ifdef KHRONOS_USE_INTPTR_T
+typedef intptr_t               khronos_intptr_t;
+typedef uintptr_t              khronos_uintptr_t;
+#elif defined(_WIN64)
 typedef signed   long long int khronos_intptr_t;
 typedef unsigned long long int khronos_uintptr_t;
-typedef signed   long long int khronos_ssize_t;
-typedef unsigned long long int khronos_usize_t;
 #else
 typedef signed   long  int     khronos_intptr_t;
 typedef unsigned long  int     khronos_uintptr_t;
+#endif
+
+#if defined(_WIN64)
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
 typedef signed   long  int     khronos_ssize_t;
 typedef unsigned long  int     khronos_usize_t;
 #endif

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

@@ -23,7 +23,7 @@ void SimpleTexturedMaterial::load(std::shared_ptr<SceneLoadContext> ctx) {
 }
 
 struct Color SimpleTexturedMaterial::getColor() {
-  return this->data.color;
+  return this->data.data.color;
 }
 
 std::shared_ptr<Texture> SimpleTexturedMaterial::getTexture() {
@@ -37,25 +37,25 @@ void SimpleTexturedMaterial::setTexture(
 }
 
 void SimpleTexturedMaterial::setColor(const struct Color color) {
-  this->data.color = color;
+  this->data.data.color = color;
 }
 
 std::vector<std::shared_ptr<IRenderPass>> SimpleTexturedMaterial::getPasses(
   struct RenderPassContext &ctx
 ) {
-  this->data.model = this->getItem()->getWorldTransform();
+  this->data.data.model = this->getItem()->getWorldTransform();
-  this->data.projection = ctx.camera->getProjection();
+  this->data.data.projection = ctx.camera->getProjection();
-  this->data.view = ctx.camera->getItem()->getWorldTransform();
+  this->data.data.view = ctx.camera->getItem()->getWorldTransform();
   auto textures = std::unordered_map<
     shadertexturebinding_t, std::shared_ptr<Texture>
   >();
   
   if(this->texture) {
-    this->data.hasTexture = true;
+    this->data.data.hasTexture = true;
     this->data.texture = 0;
     textures[this->data.texture] = this->texture;
   } else {
-    this->data.hasTexture = false;
+    this->data.data.hasTexture = false;
   }
 
   return {

src/dawn/display/shader/ShaderManager.hpp

@@ -9,7 +9,7 @@
 namespace Dawn {
   class ShaderManager {
     private:
-      std::vector<std::weak_ptr<IShaderBase>> shaders;
+      std::vector<std::shared_ptr<IShaderBase>> shaders;
 
     public:
       /**
@@ -23,7 +23,8 @@ namespace Dawn {
       std::shared_ptr<T> getShader() {
         auto itShaders = shaders.begin();
         while(itShaders != shaders.end()) {
-          auto shader = itShaders->lock();
+          // auto shader = itShaders->lock();
+          auto shader = *itShaders;
           if(!shader) {
             itShaders = shaders.erase(itShaders);
             continue;

src/dawnglfw/display/RenderHost.cpp

@@ -28,8 +28,8 @@ void RenderHost::init(const std::shared_ptr<Game> game) {
 
   // Setup window hints
   glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, false);
-  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
   glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
   glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
 

src/dawnopengl/CMakeLists.txt

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

src/dawnopengl/display/Texture.cpp

@@ -14,6 +14,8 @@ void Texture::bind(const uint8_t slot) {
   glActiveTexture(GL_TEXTURE0 + slot);
   assertNoGLError();
   glBindTexture(GL_TEXTURE_2D, this->id);
+  // assertNoGLError();
+  // glBindSampler(slot, this->samplerId);
   assertNoGLError();
   this->updateTextureProperties();
 }
@@ -52,10 +54,16 @@ void Texture::setSize(
   this->format = format;
   this->dataFormat = dataFormat;
 
+  // Gen texture
   glGenTextures(1, &this->id);
   assertNoGLError();
   if(this->id <= 0) assertUnreachable("Texture generation failed!");
 
+  // Gen sampler
+  // glGenSamplers(1, &this->samplerId);
+  // assertNoGLError();
+  // if(this->samplerId <= 0) assertUnreachable("Sampler generation failed!");
+
   // Initialize the texture to blank
   glActiveTexture(GL_TEXTURE0);
   assertNoGLError();

src/dawnopengl/display/Texture.hpp

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

src/dawnopengl/display/shader/ShaderStage.cpp

@@ -42,6 +42,11 @@ ShaderStage::ShaderStage(
   assertNoGLError();
   glCompileShader(this->id);
   assertNoGLError();
+  
+  // glShaderBinary(1, &this->id, GL_SHADER_BINARY_FORMAT_SPIR_V, source.data(), source.size());
+  // assertNoGLError();
+  // glSpecializeShader(this->id, "main", 0, NULL, NULL);
+  // assertNoGLError();
 
   // Validate
   GLint status;

src/dawnopengl/display/shader/ShaderStructure.hpp

@@ -39,6 +39,7 @@ namespace Dawn {
        * @param getParameters A callback that, when invoked, will populate the
        *                      parameters vector with the parameters for this
        *                      structure.
+       * @param count The number of structures to create.
        */
       ShaderStructure(
         const std::string &structureName,

src/dawnopengl/display/shader/SimpleTexturedShader.cpp

@@ -5,6 +5,11 @@
 
 #include "display/shader/SimpleTexturedShader.hpp"
 
+#include <fstream>
+#include "slang.h"
+#include "slang-gfx.h"
+using namespace slang;
+
 using namespace Dawn;
 
 void SimpleTexturedShader::getStages(
@@ -18,86 +23,237 @@ void SimpleTexturedShader::getStages(
   std::shared_ptr<ShaderStage> vertex;
   std::shared_ptr<ShaderStage> fragment;
 
-  switch(variant) {
+  std::string shader = R"(
-    case ShaderOpenGLVariant::GLSL_330_CORE:
+    cbuffer Uniforms {
-      vertex = std::make_shared<ShaderStage>(
+      float4x4 u_Projection;
-        ShaderStageType::VERTEX,R"(
+      float4x4 u_View;
-          #version 330 core
+      float4x4 u_Model;
-          layout (location = 0) in vec3 aPos;
+      float4 u_Color;
-          layout (location = 1) in vec2 aTexCoord;
+      bool u_HasTexture;
-          uniform mat4 u_Projection;
+    };
-          uniform mat4 u_View;
-          uniform mat4 u_Model;
-          out vec2 o_TextCoord;
-          void main() {
-            gl_Position = u_Projection * u_View * u_Model * vec4(aPos, 1.0);
-            o_TextCoord = vec2(aTexCoord.x, aTexCoord.y);
-          }
-        )"
-      );
-      
-      fragment = std::make_shared<ShaderStage>(
-        ShaderStageType::FRAGMENT,R"(
-          #version 330 core
-          in vec2 o_TextCoord;
-          out vec4 o_Color;
-          uniform vec4 u_Color;
-          uniform bool u_HasTexture;
-          uniform sampler2D u_Texture;
-          void main() {
-            if(u_HasTexture) {
-              o_Color = texture(u_Texture, o_TextCoord);
-            } else {
-              o_Color = u_Color;
-            }
 
-            if(o_Color.a == 0) discard;
+    layout(binding = 1)
-          }
+    uniform Sampler2D u_Texture;
-        )"
-      );
-      break;
 
-    default:
+    struct AssembledVertex {
-      assertUnreachable("Unsupported ShaderOpenGLVariant");
+      float3 position : POSITION;
+      float2 texcoord : TEXCOORD;
+    };
+
+    struct CoarseVertex {
+    };
+
+    struct Fragment {
+      float4 color;
+    };
+
+    struct VertexStageOutput {
+      float2 uv : UV;
+      float4 sv_position : SV_Position;
+    };
+
+    [shader("vertex")]
+    VertexStageOutput vertexMain(
+      AssembledVertex assembledVertex
+    ) {
+      VertexStageOutput output;
+
+      float3 position = assembledVertex.position;
+
+      output.uv = assembledVertex.texcoord;
+
+      output.sv_position = mul(
+        float4(position, 1.0),
+        mul(u_Model, mul(u_View, u_Projection))
+      );
+
+      return output;
+    }
+
+    [shader("fragment")]
+    Fragment fragmentMain(
+      float2 uv: UV
+    ) : SV_Target {
+      Fragment output;
+      if(u_HasTexture) {
+        output.color = u_Texture.Sample(uv) * u_Color;
+      } else {
+        output.color = u_Color;
+      }
+      return output;
+    }
+  )";
+
+  Slang::ComPtr<IGlobalSession> globalSession;
+  createGlobalSession(globalSession.writeRef());
+
+  SessionDesc sessionDesc;
+
+  TargetDesc targetDesc;
+  targetDesc.format = SLANG_GLSL;
+  targetDesc.profile = globalSession->findProfile("glsl_330");
+  sessionDesc.targets = &targetDesc;
+  sessionDesc.targetCount = 1;
+
+  Slang::ComPtr<IBlob> diagnostics;
+  const char* searchPaths[] = { "/home/yourwishes/htdocs/Dawn/assets/shaders/" };
+  sessionDesc.searchPaths = searchPaths;
+  sessionDesc.searchPathCount = 1;
+
+  Slang::ComPtr<ISession> session;
+  globalSession->createSession(sessionDesc, session.writeRef());
+  auto module = session->loadModuleFromSourceString(
+    "hello-world.slang",
+    "hello-world.slang",
+    shader.c_str(),
+    diagnostics.writeRef()
+  );
+  if(diagnostics) {
+    assertUnreachable("Failed to load module %s", (const char*) diagnostics->getBufferPointer());
+    return;
   }
 
-  // Add stages
+  Slang::ComPtr<IEntryPoint> vertexEntryPoint;
+  Slang::ComPtr<IEntryPoint> fragEntryPoint;
+  module->findEntryPointByName("vertexMain", vertexEntryPoint.writeRef());
+  module->findEntryPointByName("fragmentMain", fragEntryPoint.writeRef());
+
+  IComponentType* components[] = { module, vertexEntryPoint, fragEntryPoint };
+  Slang::ComPtr<IComponentType> program;
+  session->createCompositeComponentType(
+    components,
+    sizeof(components) / sizeof(components[0]),
+    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;
+  if(diagnostics) {
+    assertUnreachable("%s\n", (const char*) diagnostics->getBufferPointer());
+    return;
+  }
+
+  int entryPointIndex = 0;
+  int targetIndex = 0; // only one target
+  Slang::ComPtr<IBlob> vertexBlob;
+  result = linkedProgram->getEntryPointCode(
+    entryPointIndex,
+    targetIndex,
+    vertexBlob.writeRef(),
+    diagnostics.writeRef()
+  );
+  if(diagnostics) {
+    assertUnreachable("%s\n", (const char*) diagnostics->getBufferPointer());
+    return;
+  }
+
+  std::string vertexString = (const char*)vertexBlob->getBufferPointer();
+  std::ofstream out("/home/yourwishes/htdocs/Dawn/vertex.glsl");
+  out << vertexString;
+  out.close();
+
+  entryPointIndex = 1;
+  Slang::ComPtr<IBlob> fragmentBlob;
+  result = linkedProgram->getEntryPointCode(
+    entryPointIndex,
+    targetIndex,
+    fragmentBlob.writeRef(),
+    diagnostics.writeRef()
+  );
+  if(diagnostics) {
+    assertUnreachable("%s\n", (const char*) diagnostics->getBufferPointer());
+    return;
+  }
+
+  std::string fragmentString = (const char*)fragmentBlob->getBufferPointer();
+  out.open("/home/yourwishes/htdocs/Dawn/fragment.glsl");
+  out << fragmentString;
+  out.close();
+
+  vertex = std::make_shared<ShaderStage>(
+    ShaderStageType::VERTEX, vertexString
+  );
   stages.push_back(vertex);
+
+  fragment = std::make_shared<ShaderStage>(
+    ShaderStageType::FRAGMENT, fragmentString
+  );
   stages.push_back(fragment);
 
+  structures.push_back(ShaderStructure<struct SimpleTexturedShaderDataSub>(
+    "block_SLANG_ParameterGroup_Uniforms_std140_0",
+    &rel->data,
+    ShaderOpenGLStructureType::STD140,
+    [](const SimpleTexturedShaderDataSub &data, std::vector<struct ShaderParameter> &parameters) {
+      parameters.push_back(ShaderParameter(
+        "u_Projection_0",
+        &data.projection,
+        ShaderParameterType::MAT4
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "u_View_0",
+        &data.view,
+        ShaderParameterType::MAT4
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "u_Model_0",
+        &data.model,
+        ShaderParameterType::MAT4
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "u_Color_0",
+        &data.color,
+        ShaderParameterType::COLOR
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "u_HasTexture_0",
+        &data.hasTexture,
+        ShaderParameterType::BOOLEAN
+      ));
+    }
+  ));
+
+
   // Parameters
-  parameters.push_back(ShaderParameter(
+  // parameters.push_back(ShaderParameter(
-    "u_Projection",
+  //   "u_Projection",
-    &rel->projection,
+  //   &rel->projection,
-    ShaderParameterType::MAT4
+  //   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_View",
+    "u_Texture_0",
-    &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",
     &rel->texture,
     ShaderParameterType::TEXTURE
   ));

src/dawnopengl/display/shader/SimpleTexturedShader.hpp

@@ -7,12 +7,17 @@
 #include "display/shader/Shader.hpp"
 
 namespace Dawn {
-  struct SimpleTexturedShaderData {
+  struct SimpleTexturedShaderDataSub {
     glm::mat4 projection;
     glm::mat4 view;
     glm::mat4 model;
     struct Color color = COLOR_WHITE;
+
     bool hasTexture = false;
+  };
+
+  struct SimpleTexturedShaderData {
+    struct SimpleTexturedShaderDataSub data;
     shadertexturebinding_t texture = 0;
   };
 

src/dawnrpg/display/shader/MapShader.cpp

@@ -18,6 +18,8 @@ void MapShader::getStages(
   std::shared_ptr<ShaderStage> vertex;
   std::shared_ptr<ShaderStage> fragment;
 
+  std::cout << "MapShader::getStages" << std::endl;
+
   switch(variant) {
     case ShaderOpenGLVariant::GLSL_330_CORE:
       vertex = std::make_shared<ShaderStage>(

vertex.glsl

@@ -0,0 +1,88 @@
+#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;
+}
+