Water rendering doesnt work yet

res/shaders/DepthCullingTask.slang

@@ -32,8 +32,8 @@ bool isBoxVisible(AABB bounding)
     {
         mipOffset += mipDimensions.x * mipDimensions.y;
         mipDimensions = uint2(mipDimensions.x + 1, mipDimensions.y + 1) / 2;
-        screenCornerMin /= 2;
-        screenCornerMax /= 2;
+        screenCornerMin = uint2(screenCornerMin.x + 1, screenCornerMin.y + 1) / 2;
+        screenCornerMax = uint2(screenCornerMax.x, screenCornerMax.y) / 2;
     }
 
     // now we sample 4 texels from the depth at the calculated mip level, this should give us the screen extent of the meshlet
@@ -80,7 +80,8 @@ void taskMain(
 		viewFrustum.sides[1] = computePlane(origin, corners[1], corners[3]);
 		viewFrustum.sides[2] = computePlane(origin, corners[0], corners[1]);
 		viewFrustum.sides[3] = computePlane(origin, corners[3], corners[2]);
-        meshVisible = isBoxVisible(mesh.bounding);
+        //meshVisible = isBoxVisible(mesh.bounding);
+        meshVisible = true;
     }
     GroupMemoryBarrierWithGroupSync();
     if(!meshVisible)

res/shaders/WaterCommon.slang

@@ -23,6 +23,11 @@ struct MaterialParams
     float foamSubtract2;
     float foamSubtract3;
     
+    float tile1;
+    float tile2;
+    float tile3;
+    float tile4;
+
     float normalStrength;
     float foamDepthAttenuation;
     float normalDepthAttenuation;
@@ -42,7 +47,13 @@ struct MaterialParams
     float scatterStrength;
     float scatterShadowStrength;
 
+    uint contributeDisplacement1;
+    uint contributeDisplacement2;
+    uint contributeDisplacement3;
+    uint contributeDisplacement4;
+    
     float3 foamColor;
+
     Texture2DArray displacementTextures;
     Texture2DArray<float2> slopeTextures;
     TextureCube environmentMap;

res/shaders/WaterCompute.slang

@@ -141,8 +141,8 @@ void CS_InitializeSpectrum(uint3 id : SV_DISPATCHTHREADID) {
 
         seed += i + uint(hash(seed) * 10);
         float4 uniformRandSamples = float4(hash(seed), hash(seed * 2), hash(seed * 3), hash(seed * 4));
-        float2 gauss1 = float2(1, 1);UniformToGaussian(uniformRandSamples.x, uniformRandSamples.y);
-        float2 gauss2 = float2(1, 1);UniformToGaussian(uniformRandSamples.z, uniformRandSamples.w);
+        float2 gauss1 = UniformToGaussian(uniformRandSamples.x, uniformRandSamples.y);
+        float2 gauss2 = UniformToGaussian(uniformRandSamples.z, uniformRandSamples.w);
 
         if (pParams.lowCutoff <= kLength && kLength <= pParams.highCutoff) {
             float kAngle = atan2(K.y, K.x);

res/shaders/WaterMesh.slang

@@ -46,22 +46,20 @@ void meshMain(
         float2 base = VERT[i];
         float2 worldTransformed = params.offset + (params.extent * base);
         float3 worldPos = float3(worldTransformed.x, params.height, worldTransformed.y);
-        float3 displacement1 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(worldPos.xz, 0)).xyz;
-        float3 displacement2 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(worldPos.xz, 1)).xyz;
-        float3 displacement3 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(worldPos.xz, 2)).xyz;
-        float3 displacement4 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(worldPos.xz, 3)).xyz;
+        float3 displacement1 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(worldPos.xz * pWaterMaterial.tile1, 0)).xyz * pWaterMaterial.contributeDisplacement1;
+        float3 displacement2 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(worldPos.xz * pWaterMaterial.tile2, 1)).xyz * pWaterMaterial.contributeDisplacement2;
+        float3 displacement3 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(worldPos.xz * pWaterMaterial.tile3, 2)).xyz * pWaterMaterial.contributeDisplacement3;
+        float3 displacement4 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(worldPos.xz * pWaterMaterial.tile4, 3)).xyz * pWaterMaterial.contributeDisplacement4;
         float3 displacement = displacement1 + displacement2 + displacement3 + displacement4;
 
         float4 clipPos = mul(vp, float4(worldPos, 1)); 
         float depth = 1 - clamp(1 / (clipPos.z / clipPos.w), 0, 1);
 
-        displacement = lerp(0, displacement, pow(saturate(depth), pWaterMaterial.displacementDepthAttenuation));
-
         worldPos += displacement;
 
         WaterVertex v;
         v.position_WS = worldPos;
-        v.position_CS = clipPos;// mul(vp, float4(worldPos, 1));
+        v.position_CS = mul(vp, float4(worldPos, 1));
         v.texCoord = worldPos.xz;
         v.depth = clipPos.z / clipPos.w;
         vertices[i] = v;

res/shaders/WaterPass.slang

@@ -30,20 +30,20 @@ float4 main(WaterVertex vert) : SV_TARGET {
     float VdotH = clamp(dot(viewDir, halfwayDir), 0, 1);
     
     
-    float4 displacementFoam1 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord, 0));
+    float4 displacementFoam1 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord * pWaterMaterial.tile1, 0));
     displacementFoam1.a += pWaterMaterial.foamSubtract0;
-    float4 displacementFoam2 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord, 0));
+    float4 displacementFoam2 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord * pWaterMaterial.tile2, 0));
     displacementFoam2.a += pWaterMaterial.foamSubtract1;
-    float4 displacementFoam3 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord, 0));
+    float4 displacementFoam3 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord * pWaterMaterial.tile3, 0));
     displacementFoam3.a += pWaterMaterial.foamSubtract2;
-    float4 displacementFoam4 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord, 0));
+    float4 displacementFoam4 = pWaterMaterial.displacementTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord * pWaterMaterial.tile4, 0));
     displacementFoam4.a += pWaterMaterial.foamSubtract3;
     float4 displacementFoam = displacementFoam1 + displacementFoam2 + displacementFoam3 + displacementFoam4;
 
-    float2 slopes1 = pWaterMaterial.slopeTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord, 0));
-    float2 slopes2 = pWaterMaterial.slopeTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord, 1));
-    float2 slopes3 = pWaterMaterial.slopeTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord, 2));
-    float2 slopes4 = pWaterMaterial.slopeTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord, 3));
+    float2 slopes1 = pWaterMaterial.slopeTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord * pWaterMaterial.tile1, 0));
+    float2 slopes2 = pWaterMaterial.slopeTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord * pWaterMaterial.tile2, 1));
+    float2 slopes3 = pWaterMaterial.slopeTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord * pWaterMaterial.tile3, 2));
+    float2 slopes4 = pWaterMaterial.slopeTextures.Sample(pWaterMaterial.sampler, float3(vert.texCoord * pWaterMaterial.tile4, 3));
     float2 slopes = slopes1 + slopes2 + slopes3 + slopes4;
     
     slopes *= pWaterMaterial.normalStrength;

src/Engine/Component/WaterTile.h

@@ -9,7 +9,7 @@ struct WaterTile
 {
     IVector2 location;
     float height;
-    constexpr static float DIMENSIONS = 100;
+    constexpr static float DIMENSIONS = 10;
 };
 }
 }

src/Engine/Graphics/RenderPass/DepthCullingPass.cpp

@@ -47,6 +47,7 @@ DepthCullingPass::DepthCullingPass(Gfx::PGraphics graphics, PScene scene) : Rend
                                                                            .hasTaskShader = true,
                                                                            .useMaterial = false,
                                                                            .useVisibility = true,
+                                                                           .dumpIntermediates = true,
                                                                        });
     } else {
         graphics->getShaderCompiler()->registerRenderPass("DepthPass", Gfx::PassConfig{

src/Engine/Graphics/RenderPass/WaterRenderer.cpp

@@ -258,13 +258,92 @@ WaterRenderer::WaterRenderer(Gfx::PGraphics graphics, PScene scene, Gfx::PDescri
     waterFragment = graphics->createFragmentShader({2});
 
     waterLayout->create();
+
+    displaySpectrums[0] = {
+        .scale = 0.01f,
+        .windSpeed = 2,
+        .windDirection = 22,
+        .fetch = 100000,
+        .spreadBlend = 0.642,
+        .swell = 1,
+        .peakEnhancement = 1,
+        .shortWavesFade = 0.25f,
+    };
+    displaySpectrums[1] = {
+        .scale = 0.07f,
+        .windSpeed = 2,
+        .windDirection = 59,
+        .fetch = 1000,
+        .spreadBlend = 0,
+        .swell = 1,
+        .peakEnhancement = 1,
+        .shortWavesFade = 0.01f,
+    };
+    displaySpectrums[2] = {
+        .scale = 0.25f,
+        .windSpeed = 20,
+        .windDirection = 97,
+        .fetch = 100000000,
+        .spreadBlend = 0.14f,
+        .swell = 1,
+        .peakEnhancement = 1,
+        .shortWavesFade = 0.5f,
+    };
+    displaySpectrums[3] = {
+        .scale = 0.25f,
+        .windSpeed = 20,
+        .windDirection = 67,
+        .fetch = 1000000,
+        .spreadBlend = 0.47f,
+        .swell = 1,
+        .peakEnhancement = 1,
+        .shortWavesFade = 0.5f,
+    };
+    displaySpectrums[4] = {
+        .scale = 0.15f,
+        .windSpeed = 5,
+        .windDirection = 105,
+        .fetch = 1000000,
+        .spreadBlend = 0.2f,
+        .swell = 1,
+        .peakEnhancement = 1,
+        .shortWavesFade = 0.5f,
+    };
+    displaySpectrums[5] = {
+        .scale = 0.1f,
+        .windSpeed = 1,
+        .windDirection = 19,
+        .fetch = 10000,
+        .spreadBlend = 0.298f,
+        .swell = 0.695f,
+        .peakEnhancement = 1,
+        .shortWavesFade = 0.5f,
+    };
+    displaySpectrums[6] = {
+        .scale = 1.0f,
+        .windSpeed = 1,
+        .windDirection = 209,
+        .fetch = 200000,
+        .spreadBlend = 0.56f,
+        .swell = 1,
+        .peakEnhancement = 1,
+        .shortWavesFade = 0.0001f,
+    };
+    displaySpectrums[7] = {
+        .scale = 0.25f,
+        .windSpeed = 1,
+        .windDirection = 0,
+        .fetch = 1000,
+        .spreadBlend = 0,
+        .swell = 0,
+        .peakEnhancement = 1,
+        .shortWavesFade = 0.0001f,
+    };
 }
 
 WaterRenderer::~WaterRenderer() {}
 
 void WaterRenderer::beginFrame() {
-    std::cout << "Test" << std::endl;
-    updateFFTDescriptor();
     struct WaterPayload {
         Vector2 offset;
         float extent;
@@ -273,8 +352,8 @@ void WaterRenderer::beginFrame() {
     Array<WaterPayload> payloads;
     scene->view<Component::WaterTile>([&](Component::WaterTile& tile) {
         payloads.add(WaterPayload{
-            .offset = Vector2(tile.location) * Component::WaterTile::DIMENSIONS,
-            .extent = Component::WaterTile::DIMENSIONS,
+            .offset = Vector2(tile.location),
+            .extent = 1,
             .height = tile.height,
         });
     });
@@ -298,7 +377,7 @@ void WaterRenderer::beginFrame() {
 
     boyancyData->changeLayout(Gfx::SE_IMAGE_LAYOUT_GENERAL, Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_SHADER_STAGE_MESH_BIT_EXT,
                               Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-
+    updateFFTDescriptor();
     Gfx::OComputeCommand updateCommand = graphics->createComputeCommand("WaterUpdate");
     updateCommand->bindPipeline(updateSpectrumForFFT);
     updateCommand->bindDescriptor(computeSet);
@@ -334,6 +413,8 @@ void WaterRenderer::beginFrame() {
     assembleCommand->dispatch(threadGroupsX, threadGroupsY, 1);
     graphics->executeCommands(std::move(assembleCommand));
 
+    graphics->waitDeviceIdle();
+
     // transition for mipmap gen
     displacementTextures->changeLayout(
         Gfx::SE_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
@@ -357,7 +438,6 @@ void WaterRenderer::beginFrame() {
                               Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_SHADER_STAGE_MESH_BIT_EXT);
 
     updateMaterialDescriptor();
-    graphics->waitDeviceIdle();
 }
 
 Gfx::ORenderCommand WaterRenderer::render(Gfx::PDescriptorSet viewParamsSet) {
@@ -443,12 +523,13 @@ void WaterRenderer::updateFFTDescriptor() {
     spectrumBuffer->updateContents(0, sizeof(SpectrumParameters) * spectrums.size(), spectrums.data());
     spectrumBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,
                                     Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+
     params.deltaTime = Gfx::getCurrentFrameDelta();
     params.frameTime = Gfx::getCurrentFrameTime();
     paramsBuffer->updateContents(0, sizeof(ComputeParams), &params);
     paramsBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_UNIFORM_READ_BIT,
                                   Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    computeLayout->reset();
+
     computeSet = computeLayout->allocateDescriptorSet();
     computeSet->updateBuffer(0, paramsBuffer);
     computeSet->updateTexture(1, 0, Gfx::PTexture2D(spectrumTextures));
@@ -462,7 +543,10 @@ void WaterRenderer::updateFFTDescriptor() {
 }
 
 void WaterRenderer::updateMaterialDescriptor() {
-    materialLayout->reset();
+    materialUniforms->updateContents(0, sizeof(MaterialParams), &materialParams);
+    materialUniforms->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
+                                      Gfx::SE_ACCESS_UNIFORM_READ_BIT,
+                                      Gfx::SE_PIPELINE_STAGE_MESH_SHADER_BIT_EXT | Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
     materialSet = materialLayout->allocateDescriptorSet();
     materialSet->updateBuffer(0, materialUniforms);
     materialSet->updateTexture(1, Gfx::PTexture2D(displacementTextures));

src/Engine/Graphics/RenderPass/WaterRenderer.h

@@ -64,16 +64,25 @@ class WaterRenderer {
         float depth = 20.0f;
         float lowCutoff = 0.0001f;
         float highCutoff = 9000.0f;
-        int seed = 0;
+        int seed = 1;
         Vector2 lambda = Vector2(1, 1);
         uint32 N = 1024;
-        uint32 lengthScale0 = 256;
-        uint32 lengthScale1 = 256;
-        uint32 lengthScale2 = 256;
-        uint32 lengthScale3 = 256;
-        float foamBias = -0.5f;
-        float foamDecayRate = 0.05f;
-        float foamAdd = 0.5f;
+
+        // Layer 1
+        uint32 lengthScale1 = 94;
+
+        // Layer 2
+        uint32 lengthScale2 = 128;
+
+        // Layer 3
+        uint32 lengthScale3 = 64;
+
+        // Layer 4
+        uint32 lengthScale4 = 32;
+        
+        float foamBias = 0.85f;
+        float foamDecayRate = 0.0175f;
+        float foamAdd = 0.1f;
         float foamThreshold = 0.0f;
     } params;
     float speed = 1.0f;
@@ -89,34 +98,44 @@ class WaterRenderer {
     Gfx::OSampler linearRepeatSampler;
 
     struct MaterialParams {
-        Vector sunDirection = Vector(0, -1, 0);
+        Vector sunDirection = Vector(-1.29f, -1.0f, 4.86f);
         float displacementDepthAttenuation = 1;
 
-        float foamSubtract0 = 0;
-        float foamSubtract1 = 0;
-        float foamSubtract2 = 0;
-        float foamSubtract3 = 0;
+        float foamSubtract0 = 0.04f;
+        float foamSubtract1 = -0.04f;
+        float foamSubtract2 = -0.46f;
+        float foamSubtract3 = -0.38f;
+
+        float tile1 = 0.01f;
+        float tile2 = 3.0f;
+        float tile3 = 3.0f;
+        float tile4 = 0.13f;
 
         float normalStrength = 1;
         float foamDepthAttenuation = 1;
         float normalDepthAttenuation = 1;
-        float roughness = 0.1f;
+        float roughness = 0.075f;
 
-        Vector sunIrradiance = Vector(1, 1, 1);
-        float foamRoughnessModifier = 1;
+        Vector sunIrradiance = Vector(1.0f, 0.694f, 0.32f);
+        float foamRoughnessModifier = 0;
 
-        Vector scatterColor = Vector(1, 1, 1);
-        float environmentLightStrength = 1;
+        Vector scatterColor = Vector(0.016f, 0.0735f, 0.16f);
+        float environmentLightStrength = 0.5f;
 
-        Vector bubbleColor = Vector(1, 1, 1);
+        Vector bubbleColor = Vector(0, 0.02f, 0.016f);
         float heightModifier = 1;
 
         float bubbleDensity = 1;
         float wavePeakScatterStrength = 1;
         float scatterStrength = 1;
-        float scatterShadowStrength = 1;
+        float scatterShadowStrength = 0.5f;
 
-        Vector foamColor = Vector(1, 1, 1);
+        uint32 contributeDisplacement1 = true;
+        uint32 contributeDisplacement2 = false;
+        uint32 contributeDisplacement3 = false;
+        uint32 contributeDisplacement4 = false;
+
+        Vector foamColor = Vector(0.6f, 0.5568f, 0.492f);
     } materialParams;
     // Water
     Gfx::OUniformBuffer materialUniforms;

src/Engine/Graphics/Shader.cpp

@@ -47,6 +47,7 @@ ShaderPermutation ShaderCompiler::getTemplate(std::string name) {
         permutation.setTaskFile(pass.taskFile);
     }
     permutation.setVisibilityPass(pass.useVisibility);
+    permutation.setDumpIntermediates(pass.dumpIntermediates);
     return permutation;
 }
 
@@ -117,6 +118,10 @@ void ShaderCompiler::createShaders(ShaderPermutation permutation, Gfx::OPipeline
     if (permutation.visibilityPass) {
         createInfo.defines["VISIBILITY"] = "1";
     }
+    if (permutation.dumpIntermediates)
+    {
+        createInfo.dumpIntermediate = true;
+    }
     createInfo.typeParameter.add({Pair<const char*, const char*>("IVertexData", permutation.vertexDataName)});
     createInfo.modules.add(permutation.vertexDataName);
 

src/Engine/Graphics/Shader.h

@@ -100,6 +100,7 @@ struct ShaderPermutation {
     uint8 depthCulling;
     uint8 visibilityPass;
     uint8 rayTracing;
+    uint8 dumpIntermediates;
     // TODO: lightmapping etc
     ShaderPermutation() { std::memset(this, 0, sizeof(ShaderPermutation)); }
     void setTaskFile(std::string_view name) {
@@ -139,6 +140,7 @@ struct ShaderPermutation {
     void setPositionOnly(bool enable) { positionOnly = enable; }
     void setDepthCulling(bool enable) { depthCulling = enable; }
     void setVisibilityPass(bool enable) { visibilityPass = enable; }
+    void setDumpIntermediates(bool enable) { dumpIntermediates = enable; }
 };
 // Hashed ShaderPermutation for fast lookup
 struct PermutationId {
@@ -168,6 +170,7 @@ struct PassConfig {
     bool useMaterial = false;
     bool useVisibility = false;
     bool rayTracing = false;
+    bool dumpIntermediates = false;
 };
 class ShaderCompiler {
   public:

src/Engine/Graphics/Vulkan/Command.cpp

@@ -194,6 +194,14 @@ void RenderCommand::begin(PRenderPass renderPass, PFramebuffer framebuffer, VkQu
         beginInfo.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
     }
     VK_CHECK(vkBeginCommandBuffer(handle, &beginInfo));
+    VkDebugUtilsObjectNameInfoEXT nameInfo = {
+        .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
+        .pNext = nullptr,
+        .objectType = VK_OBJECT_TYPE_COMMAND_BUFFER,
+        .objectHandle = (uint64)handle,
+        .pObjectName = name.c_str(),
+    };
+    vkSetDebugUtilsObjectNameEXT(graphics->getDevice(), &nameInfo);
 }
 
 void RenderCommand::end() { VK_CHECK(vkEndCommandBuffer(handle)); }
@@ -374,6 +382,14 @@ void ComputeCommand::begin(VkQueryPipelineStatisticFlags pipelineFlags) {
         .pInheritanceInfo = &inheritanceInfo,
     };
     VK_CHECK(vkBeginCommandBuffer(handle, &beginInfo));
+    VkDebugUtilsObjectNameInfoEXT nameInfo = {
+        .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
+        .pNext = nullptr,
+        .objectType = VK_OBJECT_TYPE_COMMAND_BUFFER,
+        .objectHandle = (uint64)handle,
+        .pObjectName = name.c_str(),
+    };
+    vkSetDebugUtilsObjectNameEXT(graphics->getDevice(), &nameInfo);
 }
 
 void ComputeCommand::end() {
@@ -399,6 +415,7 @@ void ComputeCommand::bindDescriptor(Gfx::PDescriptorSet descriptorSet, Array<uin
     assert(threadId == std::this_thread::get_id());
     auto descriptor = descriptorSet.cast<DescriptorSet>();
     assert(descriptor->writeDescriptors.size() == 0);
+    descriptor->bind();
     boundResources.add(descriptor.getHandle());
 
     for (const auto& binding : descriptor->boundResources) {