[#57] Added members and creation arguments for values given in asset loader struct

modules/material/include/vkcv/material/pbrMetallicRoughness.hpp

@@ -13,13 +13,31 @@ namespace vkcv::material
     class PBRMaterial : Material
     {
     private:
+        struct vec3 {
+            float x, y, z;
+        };
+        struct vec4 {
+            float x, y, z, a;
+        };
         PBRMaterial(const ImageHandle& colorImg,
             const SamplerHandle& colorSmp,
             const ImageHandle& normalImg,
             const SamplerHandle& normalSmp,
             const ImageHandle& metRoughImg,
             const SamplerHandle& metRoughSmp,
-            const DescriptorSetHandle& setHandle) noexcept;
+            const ImageHandle& occlusionImg,
+            const SamplerHandle& occlusionSmp,
+            const ImageHandle& emissiveImg,
+            const SamplerHandle& emissiveSmp,
+            const DescriptorSetHandle& setHandle,
+            vec4 baseColorFactor,
+            float metallicFactor,
+            float roughnessFactor,
+            float normalScale,
+            float occlusionStrength,
+            vec3 emissiveFactor) noexcept;
+
+
     public:
         PBRMaterial() = delete;
        
@@ -33,8 +51,19 @@ namespace vkcv::material
         const ImageHandle   m_MetRoughTexture;
         const SamplerHandle m_MetRoughSampler;
 
-        // ImageHandle m_OcclusionTexture;
-        // SamplerHandle m_EmissiveTexture;
+        const ImageHandle m_OcclusionTexture;
+        const SamplerHandle m_OcclusionSampler;
+
+        const ImageHandle m_EmissiveTexture;
+        const SamplerHandle m_EmissiveSampler;
+
+        //
+        vec4 m_BaseColorFactor;
+        float m_MetallicFactor;
+        float m_RoughnessFactor;
+        float m_NormalScale;
+        float m_OcclusionStrength;
+        vec3 m_EmissiveFactor;
 
         /*
         * Returns the material's necessary descriptor bindings which serves as its descriptor layout
@@ -45,6 +74,10 @@ namespace vkcv::material
         * 3 - normal sampler
         * 4 - metallic roughness texture
         * 5 - metallic roughness sampler
+        * 6 - occlusion texture
+        * 7 - occlusion sampler
+        * 8 - emissive texture
+        * 9 - emissive sampler
         */
         static std::vector<DescriptorBinding> getDescriptorBindings() noexcept;
 
@@ -55,7 +88,13 @@ namespace vkcv::material
             ImageHandle          &normalImg,
             SamplerHandle        &normalSmp,
             ImageHandle          &metRoughImg,
-            SamplerHandle        &metRoughSmp);
+            SamplerHandle        &metRoughSmp,
+            vec4 baseColorFactor,
+            float metallicFactor,
+            float roughnessFactor,
+            float normalScale,
+            float occlusionStrength,
+            vec3 emissiveFactor);
 
     };
 }
\ No newline at end of file

modules/material/src/vkcv/material/pbrMetallicRoughness.cpp

@@ -4,32 +4,57 @@
 namespace vkcv::material
 {
     PBRMaterial::PBRMaterial(
-        const ImageHandle          &colorImg,
-        const SamplerHandle        &colorSmp,
-        const ImageHandle          &normalImg,
-        const SamplerHandle        &normalSmp,
-        const ImageHandle          &metRoughImg,
-        const SamplerHandle        &metRoughSmp,
-        const DescriptorSetHandle  &setHandle) noexcept :
+        const ImageHandle& colorImg,
+        const SamplerHandle& colorSmp,
+        const ImageHandle& normalImg,
+        const SamplerHandle& normalSmp,
+        const ImageHandle& metRoughImg,
+        const SamplerHandle& metRoughSmp,
+        const ImageHandle& occlusionImg,
+        const SamplerHandle& occlusionSmp,
+        const ImageHandle& emissiveImg,
+        const SamplerHandle& emissiveSmp,
+        const DescriptorSetHandle& setHandle,
+        vec4 baseColorFactor,
+        float metallicFactor,
+        float roughnessFactor,
+        float normalScale,
+        float occlusionStrength,
+        vec3 emissiveFactor) noexcept :
         m_ColorTexture(colorImg),
         m_ColorSampler(colorSmp),
         m_NormalTexture(normalImg),
         m_NormalSampler(normalSmp),
         m_MetRoughTexture(metRoughImg),
         m_MetRoughSampler(metRoughSmp),
-        Material(setHandle)        
+        m_OcclusionTexture(occlusionImg),
+        m_OcclusionSampler(occlusionSmp),
+        m_EmissiveTexture(emissiveImg),
+        m_EmissiveSampler(emissiveSmp),
+        Material(setHandle),
+        m_BaseColorFactor(baseColorFactor),
+        m_MetallicFactor(metallicFactor),
+        m_RoughnessFactor(roughnessFactor),
+        m_NormalScale(normalScale),
+        m_OcclusionStrength(occlusionStrength),
+        m_EmissiveFactor(emissiveFactor)
     {
     }
 
     std::vector<DescriptorBinding> PBRMaterial::getDescriptorBindings() noexcept
     {
         return {{DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT},
+                {DescriptorType::SAMPLER      , 1, ShaderStage::FRAGMENT},
+                {DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT},
+                {DescriptorType::SAMPLER      , 1, ShaderStage::FRAGMENT},
+                {DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT},
                 {DescriptorType::SAMPLER      , 1, ShaderStage::FRAGMENT},
                 {DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT},
                 {DescriptorType::SAMPLER      , 1, ShaderStage::FRAGMENT},
                 {DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT},
                 {DescriptorType::SAMPLER      , 1, ShaderStage::FRAGMENT}};
     }
+
     PBRMaterial PBRMaterial::create(
         vkcv::Core* core,
         ImageHandle& colorImg,
@@ -37,18 +62,23 @@ namespace vkcv::material
         ImageHandle& normalImg,
         SamplerHandle& normalSmp,
         ImageHandle& metRoughImg,
-        SamplerHandle& metRoughSmp)
+        SamplerHandle& metRoughSmp,
+        ImageHandle& occlusionImg,
+        SamplerHandle& occlusionSmp,
+        ImageHandle& emissiveImg,
+        SamplerHandle& emissiveSmp,
+        vec4 baseColorFactor,
+        float metallicFactor,
+        float roughnessFactor,
+        float normalScale,
+        float occlusionStrength,
+        vec3 emissiveFactor)
     {
         //Test if Images and samplers valid, if not use default
         uint32_t width  = core->getImageWidth(colorImg); //use colorImg size as default
         uint32_t height = core->getImageHeight(colorImg);
         uint32_t n = width * height;
-        struct vec3 {
-            float x, y, z;
-        };
-        struct vec4 {
-            float x, y, z, a;
-        }; 
+       
 
         if (!colorImg) {
             width = core->getImageWidth(metRoughImg); // if colorImg has no size
@@ -74,6 +104,20 @@ namespace vkcv::material
             defaultRough.fill(roughData.data());
             metRoughImg = defaultRough.getHandle();
         }
+        if (!occlusionImg || (core->getImageWidth(occlusionImg) != width) || (core->getImageHeight(occlusionImg) != height)) {
+            vkcv::Image defaultOcclusion = core->createImage(vk::Format::eR8G8B8A8Srgb, width, height);
+            std::vector<vec4> occlusionData(n);
+            std::fill(occlusionData.begin(), occlusionData.end(), vec4{ 228, 51 , 255, 1 });
+            defaultOcclusion.fill(occlusionData.data());
+            occlusionImg = defaultOcclusion.getHandle();
+        }
+        if (!emissiveImg || (core->getImageWidth(emissiveImg) != width) || (core->getImageHeight(emissiveImg) != height)) {
+            vkcv::Image defaultEmissive = core->createImage(vk::Format::eR8G8B8A8Srgb, width, height);
+            std::vector<vec4> emissiveData(n);
+            std::fill(emissiveData.begin(), emissiveData.end(), vec4{ 228, 51 , 255, 1 });
+            defaultEmissive.fill(emissiveData.data());
+            emissiveImg = defaultEmissive.getHandle();
+        }
         if (!colorSmp) {            
             colorSmp = core->createSampler(
                 vkcv::SamplerFilterType::LINEAR,
@@ -98,6 +142,23 @@ namespace vkcv::material
                 vkcv::SamplerAddressMode::REPEAT
             );            
         }
+        if (!occlusionSmp) {
+            occlusionSmp = core->createSampler(
+                vkcv::SamplerFilterType::LINEAR,
+                vkcv::SamplerFilterType::LINEAR,
+                vkcv::SamplerMipmapMode::LINEAR,
+                vkcv::SamplerAddressMode::REPEAT
+            );
+        }
+        if (!emissiveSmp) {
+            emissiveSmp = core->createSampler(
+                vkcv::SamplerFilterType::LINEAR,
+                vkcv::SamplerFilterType::LINEAR,
+                vkcv::SamplerMipmapMode::LINEAR,
+                vkcv::SamplerAddressMode::REPEAT
+            );
+        }
+        
 
 
         //create descriptorset
@@ -107,13 +168,34 @@ namespace vkcv::material
         setWrites.sampledImageWrites = {
             vkcv::SampledImageDescriptorWrite(0, colorImg),
             vkcv::SampledImageDescriptorWrite(2, normalImg),
-            vkcv::SampledImageDescriptorWrite(4, metRoughImg) };
+            vkcv::SampledImageDescriptorWrite(4, metRoughImg),
+            vkcv::SampledImageDescriptorWrite(6, occlusionImg),
+            vkcv::SampledImageDescriptorWrite(8, emissiveImg) };
         setWrites.samplerWrites = {
             vkcv::SamplerDescriptorWrite(1, colorSmp),
             vkcv::SamplerDescriptorWrite(3, normalSmp),
-            vkcv::SamplerDescriptorWrite(5, metRoughSmp) };
+            vkcv::SamplerDescriptorWrite(5, metRoughSmp),
+            vkcv::SamplerDescriptorWrite(7, occlusionSmp),
+            vkcv::SamplerDescriptorWrite(9, emissiveSmp) };
         core->writeDescriptorSet(descriptorSetHandle, setWrites);
 
-        return PBRMaterial(colorImg, colorSmp, normalImg, normalSmp, metRoughImg, metRoughSmp, descriptorSetHandle);        
+        return PBRMaterial(
+            colorImg,
+            colorSmp,
+            normalImg,
+            normalSmp,
+            metRoughImg,
+            metRoughSmp,
+            occlusionImg,
+            occlusionSmp,
+            emissiveImg,
+            emissiveSmp,
+            descriptorSetHandle,
+            baseColorFactor,
+            metallicFactor,
+            roughnessFactor,
+            normalScale,
+            occlusionStrength,
+            emissiveFactor);
     }
 }
\ No newline at end of file