Trying to fix wrong tex coord imports

res/shaders/BasePass.slang

@@ -16,7 +16,7 @@ float4 fragmentMain(in FragmentParameter params) : SV_Target
 {
     LightingParameter lightingParams = params.getLightingParameter();
     MaterialParameter materialParams = params.getMaterialParameter();
-	let brdf = Material.prepare(materialParams);
+    var brdf = Material.prepare(materialParams);
     uint2 tileIndex = uint2(floor(params.position_CS.xy / BLOCK_SIZE));
     uint startOffset = pLightCullingData.lightGrid[tileIndex].x;
     uint lightCount = pLightCullingData.lightGrid[tileIndex].y;
@@ -25,10 +25,10 @@ float4 fragmentMain(in FragmentParameter params) : SV_Target
     {
         result += pLightEnv.directionalLights[i].illuminate(lightingParams, brdf);
     }
-    for(uint i = 0; i < pLightEnv.numPointLights; ++i)
+    for (uint i = 0; i < lightCount; ++i)
     {
-        //uint lightIndex = pLightCullingData.lightIndexList[startOffset + i];
+        uint lightIndex = pLightCullingData.lightIndexList[startOffset + i];
-        result += pLightEnv.pointLights[i].illuminate(lightingParams, brdf);
+        result += pLightEnv.pointLights[lightIndex].illuminate(lightingParams, brdf);
     }
     result += brdf.evaluateAmbient(lightingParams.viewDir_WS);
     return float4(result, brdf.getAlpha());

res/shaders/lib/LightEnv.slang

@@ -70,20 +70,15 @@ struct LightEnv
 layout(set=3)
 ParameterBlock<LightEnv> pLightEnv;
 
-[Differentiable]
-float polynomial(float a, float b, float c, float x) {
-    return a * x * x + b * x + c;
-}
-
 interface IBRDF
 {
     float3 evaluate(float3 viewDir_WS, float3 lightDir_WS, float3 lightColor);
-    [mutating] void transformNormal(float3x3 tangentToWorld);
     float3 getNormal();
     float3 getBaseColor();
     float3 evaluateAmbient(float3 viewDir_WS);
     float getAlpha();
     float3 getEmissive();
+    [mutating] void setNormal(float3 n);
 };
 
 struct Phong : IBRDF
@@ -116,11 +111,6 @@ struct Phong : IBRDF
 
         return lightColor * (baseColor * max(nDotL, 0.0)) + specular * pow(max(rDotV, 0.0), max(shininess, 1));
     }
-    [mutating]
-    void transformNormal(float3x3 tangentToWorld)
-    {
-        normal = normalize(mul(tangentToWorld, normal));
-    }
     float3 getNormal()
     {
         return normal;
@@ -141,6 +131,7 @@ struct Phong : IBRDF
     {
         return emissive;
     }
+    [mutating] void setNormal(float3 n) { normal = n; }
 };
 
 struct BlinnPhong : IBRDF
@@ -173,11 +164,6 @@ struct BlinnPhong : IBRDF
 
         return (baseColor * diffuse * lightColor) + (specularColor * specular);
     }
-    [mutating]
-    void transformNormal(float3x3 tangentToWorld)
-    {
-        normal = normalize(mul(tangentToWorld, normal));
-    }
     float3 getNormal()
     {
         return normal;
@@ -198,6 +184,7 @@ struct BlinnPhong : IBRDF
     {
         return emissive;
     }
+    [mutating] void setNormal(float3 n) { normal = n; }
 };
 
 struct CelShading : IBRDF
@@ -230,11 +217,6 @@ struct CelShading : IBRDF
             return darkenedBase * lightColor;
         }
     }
-    [mutating]
-    void transformNormal(float3x3 tangentToWorld)
-    {
-        normal = normalize(mul(tangentToWorld, normal));
-    }
     float3 getNormal()
     {
         return normal;
@@ -255,6 +237,7 @@ struct CelShading : IBRDF
     {
         return emissive;
     }
+    [mutating] void setNormal(float3 n) { normal = n; }
 };
 
 // https://learnopengl.com/PBR/Theory
@@ -315,7 +298,7 @@ struct CookTorrance : IBRDF
 
     float3 evaluate(float3 viewDir_WS, float3 lightDir_WS, float3 lightColor)
     {
-        float3 n = normal;
+        float3 n = normalize(normal);
         float3 h = normalize(lightDir_WS + viewDir_WS);
 
         float3 F0 = float3(0.04);
@@ -337,12 +320,7 @@ struct CookTorrance : IBRDF
         float nDotL = max(dot(n, lightDir_WS), 0.0);
 
         float3 result = (k_d * baseColor / PI + specular) * nDotL * lightColor;
-        return baseColor;
+        return result;
-    }
-    [mutating]
-    void transformNormal(float3x3 tangentToWorld)
-    {
-        normal = normalize(mul(tangentToWorld, normal));
     }
     float3 getNormal()
     {
@@ -371,5 +349,6 @@ struct CookTorrance : IBRDF
     {
         return emissive;
     }
+    [mutating] void setNormal(float3 n) { normal = n; }
 };
 

res/shaders/lib/MaterialParameter.slang

@@ -98,7 +98,7 @@ struct FragmentParameter
     {
         // in theory, transposing would make this a world-to-tangent matrix, but because we are building the matrix ourselves
         // and something with matrix layouts is working the opposite direction, we need to transpose here
-        return transpose(float3x3(tangent_WS, biTangent_WS, normal_WS));
+        return transpose(float3x3(normalize(tangent_WS), normalize(biTangent_WS), normalize(normal_WS)));
     }
 #endif
     static FragmentParameter interpolate(FragmentParameter f0, FragmentParameter f1, FragmentParameter f2, float3 barycentricCoords)
@@ -142,9 +142,9 @@ struct VertexAttributes
 		result.position_CS = clipPos;
 #ifndef POS_ONLY
         //float3x3 tbn = qTangentToMatrix(qTangent);
-        result.tangent_WS = normalize(mul(transformMatrix, float4(tangent_MS, 0)).xyz);
+        result.tangent_WS = mul(transformMatrix, float4(tangent_MS, 0)).xyz;
-        result.biTangent_WS = normalize(mul(transformMatrix, float4(biTangent_MS, 0)).xyz);
+        result.biTangent_WS = mul(transformMatrix, float4(biTangent_MS, 0)).xyz;
-		result.normal_WS = normalize(mul(transformMatrix, float4(normal_MS, 0)).xyz);
+		result.normal_WS = mul(transformMatrix, float4(normal_MS, 0)).xyz;
 		result.vertexColor = vertexColor;
 		result.position_WS = worldPos.xyz;
         result.texCoords0 = float4(texCoords[0], texCoords[1]);

res/shaders/lib/StaticMeshVertexData.slang

@@ -16,9 +16,8 @@ struct StaticMeshVertexData : IVertexData
 #ifndef POS_ONLY
         //attributes.qTangent = qTangent[index];
         attributes.normal_MS = float3(normals[index * 3 + 0], normals[index * 3 + 1], normals[index * 3 + 2]);
-        float4 tangentSign = float4(tangents[index * 4 + 0], tangents[index * 4 + 1], tangents[index * 4 + 2], tangents[index * 4 + 3]);
+        attributes.tangent_MS = float3(tangents[index * 3 + 0], tangents[index * 3 + 1], tangents[index * 3 + 2]);
-        attributes.tangent_MS = tangentSign.xyz;
+        attributes.biTangent_MS = float3(biTangents[index * 3 + 0], biTangents[index * 3 + 1], biTangents[index * 3 + 2]);;
-        attributes.biTangent_MS = cross(attributes.normal_MS, attributes.tangent_MS) * -tangentSign.w;
 		for(uint i = 0; i < MAX_TEXCOORDS; ++i)
 		{
 			attributes.texCoords[i] = float2(uint16ToFloat(texCoords[i][index * 2 + 0]), uint16ToFloat(texCoords[i][index * 2 + 1]));
@@ -31,6 +30,7 @@ struct StaticMeshVertexData : IVertexData
     //StructuredBuffer<float> qTangents;
 	StructuredBuffer<float> normals;
     StructuredBuffer<float> tangents;
+    StructuredBuffer<float> biTangents;
 	StructuredBuffer<uint16_t> color;
 	StructuredBuffer<uint16_t> texCoords[MAX_TEXCOORDS];
 };

src/Editor/Asset/MeshLoader.cpp

@@ -152,9 +152,10 @@ void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>&
             aiTextureMapMode mapMode = aiTextureMapMode_Clamp;
             float blend = std::numeric_limits<float>::max();
             aiTextureOp op = aiTextureOp_Add;
-            if (material->GetTexture(type, index, &texPath, &mapping, &uvIndex, nullptr, nullptr, nullptr) != AI_SUCCESS) {
+            if (material->GetTexture(type, index, &texPath, &mapping, &uvIndex, &blend, &op, &mapMode) != AI_SUCCESS) {
                 std::cout << "fuck" << std::endl;
             }
+            uvIndex = 1;
             std::string textureKey = fmt::format("{0}Texture{1}", paramKey, index);
             auto texFilename = std::filesystem::path(texPath.C_Str());
             PTextureAsset texture;
@@ -536,7 +537,7 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
             }
             Array<StaticMeshVertexData::NormalType> normals(mesh->mNumVertices);
             Array<StaticMeshVertexData::TangentType> tangents(mesh->mNumVertices);
-            //Array<StaticMeshVertexData::BiTangentType> biTangents(mesh->mNumVertices);
+            Array<StaticMeshVertexData::BiTangentType> biTangents(mesh->mNumVertices);
             Array<StaticMeshVertexData::ColorType> colors(mesh->mNumVertices);
 
             for (uint32 i = 0; i < mesh->mNumVertices; ++i) {
@@ -562,10 +563,12 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
                 // so we try to cross the two, and see what is the result, and if it is
                 // the same as b, the dot product is 1, and if they are inverse, the dot product is
                 // -1, which is the sign we need
-                tangents[i] = Vector4(tangent, dot(glm::cross(normal, tangent), biTangent));
+                tangents[i] = tangent;
+                biTangents[i] = biTangent;
 
                 if (mesh->HasVertexColors(0)) {
-                    colors[i] = StaticMeshVertexData::ColorType(mesh->mColors[0][i].r * 65535, mesh->mColors[0][i].g * 65535, mesh->mColors[0][i].b * 65535);
+                    colors[i] = StaticMeshVertexData::ColorType(mesh->mColors[0][i].r * 65535, mesh->mColors[0][i].g * 65535,
+                                                                mesh->mColors[0][i].b * 65535);
                 } else {
                     colors[i] = StaticMeshVertexData::ColorType(1, 1, 1);
                 }
@@ -577,7 +580,7 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
             }
             vertexData->loadNormals(offset, normals);
             vertexData->loadTangents(offset, tangents);
-            //vertexData->loadBitangents(offset, biTangents);
+            vertexData->loadBitangents(offset, biTangents);
             vertexData->loadColors(offset, colors);
 
             Array<uint32> indices(mesh->mNumFaces * 3);

src/Editor/main.cpp

@@ -25,7 +25,7 @@ using namespace Seele::Editor;
 static Gfx::OGraphics graphics;
 
 int main() {
-    std::string gameName = "MinecraftClone";
+    std::string gameName = "MeshShadingDemo";
     std::filesystem::path outputPath = fmt::format("../../{0}Game", gameName);
     std::filesystem::path sourcePath = fmt::format("../../{0}", gameName);
 #ifdef WIN32
@@ -57,9 +57,13 @@ int main() {
         AssetImporter::importEnvironmentMap(EnvironmentImportArgs{
             .filePath = sourcePath / "import" / "textures" / "newport_loft.hdr",
         });
-        AssetImporter::importTexture(TextureImportArgs{
+        //AssetImporter::importTexture(TextureImportArgs{
-            .filePath = sourcePath / "import" / "textures" / "grass_block_side.png",
+        //    .filePath = sourcePath / "import" / "textures" / "grass_block_side.png",
-            .importPath = "",
+        //    .importPath = "",
+        //});
+        AssetImporter::importMesh(MeshImportArgs{
+            .filePath = sourcePath / "import" / "models" / "main1_sponza" / "floor.glb",
+            .importPath = "sponza",
         });
 
         getThreadPool().waitIdle();

src/Engine/Graphics/StaticMeshVertexData.cpp

@@ -40,11 +40,11 @@ void StaticMeshVertexData::loadTangents(uint64 offset, const Array<TangentType>&
     dirty = true;
 }
 
-/*void StaticMeshVertexData::loadBitangents(uint64 offset, const Array<BiTangentType>& data) {
+void StaticMeshVertexData::loadBitangents(uint64 offset, const Array<BiTangentType>& data) {
     assert(offset + data.size() <= head);
     std::memcpy(bitData.data() + offset, data.data(), data.size() * sizeof(BiTangentType));
     dirty = true;
-}*/
+}
 
 void StaticMeshVertexData::loadColors(uint64 offset, const Array<ColorType>& data) {
     assert(offset + data.size() <= head);
@@ -70,17 +70,17 @@ void StaticMeshVertexData::serializeMesh(MeshId id, ArchiveBuffer& buffer) {
     Array<PositionType> pos(numVertices);
     Array<NormalType> nor(numVertices);
     Array<TangentType> tan(numVertices);
-    //Array<BiTangentType> bit(numVertices);
+    Array<BiTangentType> bit(numVertices);
     Array<ColorType> col(numVertices);
     std::memcpy(pos.data(), posData.data() + offset, numVertices * sizeof(PositionType));
     std::memcpy(nor.data(), norData.data() + offset, numVertices * sizeof(NormalType));
     std::memcpy(tan.data(), tanData.data() + offset, numVertices * sizeof(TangentType));
-    //std::memcpy(bit.data(), bitData.data() + offset, numVertices * sizeof(BiTangentType));
+    std::memcpy(bit.data(), bitData.data() + offset, numVertices * sizeof(BiTangentType));
     std::memcpy(col.data(), colData.data() + offset, numVertices * sizeof(ColorType));
     Serialization::save(buffer, pos);
     Serialization::save(buffer, nor);
     Serialization::save(buffer, tan);
-    //Serialization::save(buffer, bit);
+    Serialization::save(buffer, bit);
     Serialization::save(buffer, col);
 }
 
@@ -100,22 +100,22 @@ uint64 StaticMeshVertexData::deserializeMesh(MeshId id, ArchiveBuffer& buffer) {
     Array<PositionType> pos;
     Array<NormalType> nor;
     Array<TangentType> tan;
-    //Array<BiTangentType> bit;
+    Array<BiTangentType> bit;
     Array<ColorType> col;
     Serialization::load(buffer, pos);
     Serialization::load(buffer, nor);
     Serialization::load(buffer, tan);
-    //Serialization::load(buffer, bit);
+    Serialization::load(buffer, bit);
     Serialization::load(buffer, col);
     loadPositions(offset, pos);
     loadNormals(offset, nor);
     loadTangents(offset, tan);
-    //loadBitangents(offset, bit);
+    loadBitangents(offset, bit);
     loadColors(offset, col);
     result += pos.size() * sizeof(PositionType);
     result += nor.size() * sizeof(NormalType);
     result += tan.size() * sizeof(TangentType);
-    //result += bit.size() * sizeof(BiTangentType);
+    result += bit.size() * sizeof(BiTangentType);
     result += col.size() * sizeof(ColorType);
     return result;
 }
@@ -135,10 +135,10 @@ void StaticMeshVertexData::init(Gfx::PGraphics _graphics) {
         .name = TANGENTS_NAME,
         .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER,
     });
-    /*descriptorLayout->addDescriptorBinding(Gfx::DescriptorBinding{
+    descriptorLayout->addDescriptorBinding(Gfx::DescriptorBinding{
         .name = BITANGENTS_NAME,
         .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-    });*/
+    });
     descriptorLayout->addDescriptorBinding(Gfx::DescriptorBinding{
         .name = COLORS_NAME,
         .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER,
@@ -160,7 +160,7 @@ void StaticMeshVertexData::destroy() {
     positions = nullptr;
     normals = nullptr;
     tangents = nullptr;
-    //biTangents = nullptr;
+    biTangents = nullptr;
     colors = nullptr;
     descriptorSet = nullptr;
     descriptorLayout = nullptr;
@@ -170,7 +170,7 @@ void StaticMeshVertexData::resizeBuffers() {
     posData.resize(verticesAllocated);
     norData.resize(verticesAllocated);
     tanData.resize(verticesAllocated);
-    //bitData.resize(verticesAllocated);
+    bitData.resize(verticesAllocated);
     colData.resize(verticesAllocated);
     for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
         texData[i].resize(verticesAllocated);
@@ -203,14 +203,14 @@ void StaticMeshVertexData::updateBuffers() {
             },
         .name = "Tangents",
     });
-    /*biTangents = graphics->createShaderBuffer(ShaderBufferCreateInfo{
+    biTangents = graphics->createShaderBuffer(ShaderBufferCreateInfo{
         .sourceData =
             {
                 .size = verticesAllocated * sizeof(BiTangentType),
                 .data = (uint8*)bitData.data(),
             },
         .name = "BiTangents",
-    });*/
+    });
     colors = graphics->createShaderBuffer(ShaderBufferCreateInfo{
         .sourceData =
             {
@@ -234,7 +234,7 @@ void StaticMeshVertexData::updateBuffers() {
     descriptorSet->updateBuffer(POSITIONS_NAME, 0, positions);
     descriptorSet->updateBuffer(NORMALS_NAME, 0, normals);
     descriptorSet->updateBuffer(TANGENTS_NAME, 0, tangents);
-    //descriptorSet->updateBuffer(BITANGENTS_NAME, 0, biTangents);
+    descriptorSet->updateBuffer(BITANGENTS_NAME, 0, biTangents);
     descriptorSet->updateBuffer(COLORS_NAME, 0, colors);
     for (uint32 i = 0; i < MAX_TEXCOORDS; ++i) {
         descriptorSet->updateBuffer(TEXCOORDS_NAME, i, texCoords[i]);

src/Engine/Graphics/StaticMeshVertexData.h

@@ -10,8 +10,8 @@ class StaticMeshVertexData : public VertexData {
   public:
     using PositionType = Vector;
     using NormalType = Vector;
-    using TangentType = Vector4;
+    using TangentType = Vector;
-    //using BiTangentType = Vector;
+    using BiTangentType = Vector;
     using TexCoordType = U16Vector2;
     using ColorType = U16Vector;
 
@@ -22,7 +22,7 @@ class StaticMeshVertexData : public VertexData {
     void loadTexCoords(uint64 offset, uint64 index, const Array<TexCoordType>& data);
     void loadNormals(uint64 offset, const Array<NormalType>& data);
     void loadTangents(uint64 offset, const Array<TangentType>& data);
-    //void loadBitangents(uint64 offset, const Array<BiTangentType>& data);
+    void loadBitangents(uint64 offset, const Array<BiTangentType>& data);
     void loadColors(uint64 offset, const Array<ColorType>& data);
     virtual void serializeMesh(MeshId id, ArchiveBuffer& buffer) override;
     virtual uint64 deserializeMesh(MeshId id, ArchiveBuffer& buffer) override;
@@ -45,15 +45,15 @@ class StaticMeshVertexData : public VertexData {
     constexpr static const char* NORMALS_NAME = "normals";
     Gfx::OShaderBuffer tangents;
     constexpr static const char* TANGENTS_NAME = "tangents";
-    //Gfx::OShaderBuffer biTangents;
+    Gfx::OShaderBuffer biTangents;
-    //constexpr static const char* BITANGENTS_NAME = "biTangents";
+    constexpr static const char* BITANGENTS_NAME = "biTangents";
     Gfx::OShaderBuffer colors;
     constexpr static const char* COLORS_NAME = "colors";
     Array<PositionType> posData;
     Array<TexCoordType> texData[MAX_TEXCOORDS];
     Array<NormalType> norData;
     Array<TangentType> tanData;
-    //Array<BiTangentType> bitData;
+    Array<BiTangentType> bitData;
     Array<ColorType> colData;
     Gfx::ODescriptorLayout descriptorLayout;
     Gfx::PDescriptorSet descriptorSet;

src/Engine/Material/Material.cpp

@@ -170,12 +170,10 @@ void Material::compile() {
     for (const auto& expr : codeExpressions) {
         codeStream << "\t\t" << expr->evaluate(varState);
     }
-    //for (const auto& [name, exp] : brdf.variables) {
+    for (const auto& [name, exp] : brdf.variables) {
-    for(auto it = brdf.variables.begin(); it != brdf.variables.end(); ++it){
-        auto [name, exp] = *it;
         codeStream << "\t\tresult." << name << " = " << varState[exp] << ";" << std::endl;
     }
-    codeStream << "\t\tresult.transformNormal(input.tangentToWorld);" << std::endl;
+    codeStream << "\t\tresult.normal = mul(input.tangentToWorld, result.normal);" << std::endl;
     codeStream << "\t\treturn result;\n";
     codeStream << "\t}\n";
     codeStream << "};\n";

src/Engine/Material/ShaderExpression.cpp

@@ -312,6 +312,10 @@ std::string MulExpression::evaluate(Map<std::string, std::string>& varState) con
     if (varState.contains(rhs)) {
         rhs = varState[rhs];
     }
+    if (inputs.at("lhs").type == ExpressionType::MATRIX2 || inputs.at("lhs").type == ExpressionType::MATRIX3 ||
+        inputs.at("lhs").type == ExpressionType::MATRIX4) { // TODO
+        return fmt::format("let {} = mul({}, {});\n", varName, lhs, rhs);
+    }
     return fmt::format("let {} = {} * {};\n", varName, lhs, rhs);
 }
 

src/Engine/Material/ShaderExpression.h

@@ -11,6 +11,9 @@ enum class ExpressionType {
     FLOAT2,
     FLOAT3,
     FLOAT4,
+    MATRIX2,
+    MATRIX3,
+    MATRIX4,
     TEXTURE,
     SAMPLER,
 };

src/Engine/Platform/Windows/GameInterface.cpp

@@ -14,7 +14,11 @@ void GameInterface::reload() {
         destroyInstance(game);
         FreeLibrary(lib);
     }
-    std::filesystem::copy(dllPath.parent_path().parent_path() / "res" / "shaders", "./shaders/game", std::filesystem::copy_options::overwrite_existing);
+    auto shaderPath = dllPath.parent_path().parent_path() / "res" / "shaders";
+    if (std::filesystem::exists(shaderPath))
+    {
+        std::filesystem::copy(shaderPath, "./shaders/game", std::filesystem::copy_options::overwrite_existing);
+    }
     lib = LoadLibraryA(dllPath.string().c_str());
     createInstance = (decltype(createInstance))GetProcAddress(lib, "createInstance");
     destroyInstance = (decltype(destroyInstance))GetProcAddress(lib, "destroyInstance");

src/Engine/System/CameraUpdater.cpp

@@ -9,6 +9,6 @@ CameraUpdater::~CameraUpdater() {}
 
 void CameraUpdater::update(Component::Camera& camera, Component::Transform& transform) {
     Vector eyePos = transform.getPosition();
-    Vector lookAt = eyePos - transform.getForward();
+    Vector lookAt = eyePos + transform.getForward();
     camera.viewMatrix = glm::lookAt(eyePos, lookAt, Vector(0, 1, 0));
 }