Capture: Render Pass with pipeline/bindGroup

This is the next step up from a pass with no pipeline

Bug: 451389801
Change-Id: I6a6a696417e832fb0a478bece207c55af3a340b8
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/268314
Reviewed-by: Kai Ninomiya <[email protected]>
Commit-Queue: Gregg Tavares <[email protected]>

Author: greggman

src/dawn/native/webgpu/BindGroupWGPU.cpp

@@ -135,7 +135,7 @@ MaybeError BindGroup::AddReferenced(CaptureContext& captureContext) {
     {
         BindGroupLayoutInternalBase* layout = GetLayout();
         const auto& bindingMap = layout->GetBindingMap();
-        for (const auto& [bindingNumbers, apiBindingIndex] : bindingMap) {
+        for (const auto& [bindingNumber, apiBindingIndex] : bindingMap) {
             BindingIndex bindingIndex = layout->AsBindingIndex(apiBindingIndex);
             const auto& bindingInfo = layout->GetAPIBindingInfo(apiBindingIndex);
 
@@ -160,20 +160,32 @@ MaybeError BindGroup::CaptureCreationParameters(CaptureContext& captureContext)
     for (const auto& [bindingNumber, apiBindingIndex] : bindingMap) {
         BindingIndex bindingIndex = layout->AsBindingIndex(apiBindingIndex);
         const auto& bindingInfo = layout->GetAPIBindingInfo(apiBindingIndex);
+        uint32_t binding = uint32_t(bindingNumber);
 
         MatchVariant(
             bindingInfo.bindingLayout,
             [&](const BufferBindingInfo& info) {
                 const auto& entry = GetBindingAsBufferBinding(bindingIndex);
                 entries.push_back(schema::BindGroupEntry{{
-                    .binding = uint32_t(bindingNumber),
+                    .binding = binding,
                     .bufferId = captureContext.GetId(entry.buffer),
                     .offset = entry.offset,
                     .size = entry.size,
                     .samplerId = 0,
                     .textureViewId = 0,
                 }});
             },
+            [&](const TextureBindingInfo& info) {
+                const auto& entry = GetBindingAsTextureView(bindingIndex);
+                entries.push_back(schema::BindGroupEntry{{
+                    .binding = binding,
+                    .bufferId = 0,
+                    .offset = 0,
+                    .size = 0,
+                    .samplerId = 0,
+                    .textureViewId = captureContext.GetId(entry),
+                }});
+            },
             [&](const auto& info) { DAWN_CHECK(false); });
     }
 

src/dawn/replay/Replay.cpp

@@ -117,6 +117,40 @@ wgpu::BindGroupEntry ToWGPU(const Replay& replay, const schema::BindGroupEntry&
     };
 }
 
+wgpu::StencilFaceState ToWGPU(const schema::StencilFaceState& state) {
+    return wgpu::StencilFaceState{
+        .compare = state.compare,
+        .failOp = state.failOp,
+        .depthFailOp = state.depthFailOp,
+        .passOp = state.passOp,
+    };
+}
+
+wgpu::BlendComponent ToWGPU(const schema::BlendComponent& component) {
+    return wgpu::BlendComponent{
+        .operation = component.operation,
+        .srcFactor = component.srcFactor,
+        .dstFactor = component.dstFactor,
+    };
+}
+
+wgpu::BlendState ToWGPU(const schema::BlendState& state) {
+    return wgpu::BlendState{
+        .color = ToWGPU(state.color),
+        .alpha = ToWGPU(state.alpha),
+    };
+}
+
+bool IsBlendComponentEnabled(const wgpu::BlendComponent& component) {
+    return component.operation != wgpu::BlendOperation::Add ||
+           component.srcFactor != wgpu::BlendFactor::One ||
+           component.dstFactor != wgpu::BlendFactor::Zero;
+}
+
+bool IsBlendEnabled(const wgpu::BlendState& blend) {
+    return IsBlendComponentEnabled(blend.color) || IsBlendComponentEnabled(blend.alpha);
+}
+
 MaybeError ReadContentIntoBuffer(ReadHead& readHead,
                                  wgpu::Device device,
                                  wgpu::Buffer buffer,
@@ -230,6 +264,92 @@ ResultOrError<wgpu::ComputePipeline> CreateComputePipeline(const Replay& replay,
     return {computePipeline};
 }
 
+template <typename F>
+ResultOrError<wgpu::RenderPipeline> CreateRenderPipeline(const Replay& replay,
+                                                         wgpu::Device device,
+                                                         ReadHead& readHead,
+                                                         const std::string& label,
+                                                         F func) {
+    schema::RenderPipeline pipeline;
+    DAWN_TRY(Deserialize(readHead, &pipeline));
+
+    std::vector<wgpu::ConstantEntry> vertexConstants = ToWGPU(pipeline.vertex.program.constants);
+    std::vector<wgpu::ConstantEntry> fragmentConstants =
+        ToWGPU(pipeline.fragment.program.constants);
+    std::vector<wgpu::ColorTargetState> colorTargets;
+    std::vector<wgpu::BlendState> blendStates(pipeline.fragment.targets.size());
+
+    wgpu::FragmentState* fragment = nullptr;
+    wgpu::FragmentState fragmentState;
+    if (pipeline.fragment.program.moduleId) {
+        fragment = &fragmentState;
+        fragmentState.module =
+            replay.GetObjectById<wgpu::ShaderModule>(pipeline.fragment.program.moduleId);
+        fragmentState.entryPoint = wgpu::StringView(pipeline.fragment.program.entryPoint);
+        fragmentState.constantCount = fragmentConstants.size();
+        fragmentState.constants = fragmentConstants.data();
+        for (const auto& target : pipeline.fragment.targets) {
+            wgpu::BlendState& blend = blendStates[colorTargets.size()];
+            blend = ToWGPU(target.blend);
+            colorTargets.push_back({
+                .format = target.format,
+                .blend = IsBlendEnabled(blend) ? &blend : nullptr,
+                .writeMask = target.writeMask,
+            });
+        }
+        fragmentState.targetCount = colorTargets.size();
+        fragmentState.targets = colorTargets.data();
+    }
+
+    wgpu::DepthStencilState* depthStencil = nullptr;
+    wgpu::DepthStencilState depthStencilState;
+    if (pipeline.depthStencil.format != wgpu::TextureFormat::Undefined) {
+        depthStencil = &depthStencilState;
+        depthStencilState.format = pipeline.depthStencil.format;
+        depthStencilState.depthWriteEnabled = pipeline.depthStencil.depthWriteEnabled;
+        depthStencilState.depthCompare = pipeline.depthStencil.depthCompare;
+        depthStencilState.stencilFront = ToWGPU(pipeline.depthStencil.stencilFront);
+        depthStencilState.stencilBack = ToWGPU(pipeline.depthStencil.stencilBack);
+        depthStencilState.stencilReadMask = pipeline.depthStencil.stencilReadMask;
+        depthStencilState.stencilWriteMask = pipeline.depthStencil.stencilWriteMask;
+        depthStencilState.depthBias = pipeline.depthStencil.depthBias;
+        depthStencilState.depthBiasSlopeScale = pipeline.depthStencil.depthBiasSlopeScale;
+        depthStencilState.depthBiasClamp = pipeline.depthStencil.depthBiasClamp;
+    }
+
+    wgpu::RenderPipelineDescriptor desc{
+        .label = wgpu::StringView(label),
+        .layout = replay.GetObjectById<wgpu::PipelineLayout>(pipeline.layoutId),
+        .vertex =
+            {
+                .module =
+                    replay.GetObjectById<wgpu::ShaderModule>(pipeline.vertex.program.moduleId),
+                .entryPoint = wgpu::StringView(pipeline.vertex.program.entryPoint),
+                .constantCount = vertexConstants.size(),
+                .constants = vertexConstants.data(),
+            },
+        .primitive =
+            {
+                .topology = pipeline.primitive.topology,
+                .stripIndexFormat = pipeline.primitive.stripIndexFormat,
+                .frontFace = pipeline.primitive.frontFace,
+                .cullMode = pipeline.primitive.cullMode,
+                .unclippedDepth = pipeline.primitive.unclippedDepth,
+            },
+        .depthStencil = depthStencil,
+        .multisample =
+            {
+                .count = pipeline.multisample.count,
+                .mask = pipeline.multisample.mask,
+                .alphaToCoverageEnabled = pipeline.multisample.alphaToCoverageEnabled,
+            },
+        .fragment = fragment,
+    };
+    wgpu::RenderPipeline renderPipeline = device.CreateRenderPipeline(&desc);
+    func(renderPipeline, pipeline.groupIndexIds);
+    return {renderPipeline};
+}
+
 ResultOrError<wgpu::ShaderModule> CreateShaderModule(wgpu::Device device,
                                                      ReadHead& readHead,
                                                      const std::string& label) {
@@ -554,6 +674,25 @@ MaybeError Replay::CreateResource(wgpu::Device device, ReadHead& readHead) {
             return {};
         }
 
+        case schema::ObjectType::RenderPipeline: {
+            wgpu::RenderPipeline renderPipeline;
+            DAWN_TRY_ASSIGN(
+                renderPipeline,
+                CreateRenderPipeline(
+                    *this, device, readHead, resource.label,
+                    [this](wgpu::RenderPipeline& renderPipeline,
+                           const std::vector<schema::BindGroupLayoutIndexIdPair>& groupIndexIds) {
+                        // Register any implicit bindgroups.
+                        for (const auto& groupIndexId : groupIndexIds) {
+                            wgpu::BindGroupLayout bgl =
+                                renderPipeline.GetBindGroupLayout(groupIndexId.groupIndex);
+                            mResources.insert({groupIndexId.bindGroupLayoutId, {"", bgl}});
+                        }
+                    }));
+            mResources.insert({resource.id, {resource.label, renderPipeline}});
+            return {};
+        }
+
         case schema::ObjectType::ShaderModule: {
             wgpu::ShaderModule shaderModule;
             DAWN_TRY_ASSIGN(shaderModule, CreateShaderModule(device, readHead, resource.label));
@@ -629,8 +768,7 @@ MaybeError Replay::Play() {
                 break;
             }
             default: {
-                // UNIMPLEMENTED();
-                break;
+                return DAWN_INTERNAL_ERROR("unimplemented root command");
             }
         }
     }

src/dawn/tests/white_box/CaptureAndReplayTests.cpp

@@ -35,6 +35,7 @@
 #include "dawn/replay/Replay.h"
 #include "dawn/tests/DawnTest.h"
 #include "dawn/tests/MockCallback.h"
+#include "dawn/utils/ComboRenderPipelineDescriptor.h"
 #include "dawn/utils/TestUtils.h"
 #include "dawn/utils/WGPUHelpers.h"
 
@@ -1223,6 +1224,88 @@ TEST_P(CaptureAndReplayTests, CaptureRenderPassBasic) {
     }
 }
 
+// Capture and replay the a render pass where a texture is rendered into another.
+TEST_P(CaptureAndReplayTests, CaptureRenderPassBasicWithBindGroup) {
+    const uint8_t myData[] = {0x11, 0x22, 0x33, 0x44};
+
+    wgpu::TextureDescriptor textureDesc;
+    textureDesc.label = "srcTexture";
+    textureDesc.size = {1, 1, 1};
+    textureDesc.format = wgpu::TextureFormat::RGBA8Uint;
+    textureDesc.usage = wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::CopyDst;
+    wgpu::Texture srcTexture = device.CreateTexture(&textureDesc);
+
+    {
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(0, 4);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::All);
+        wgpu::Extent3D extent = {1, 1, 1};
+        queue.WriteTexture(&texelCopyTextureInfo, myData, sizeof(myData), &texelCopyBufferLayout,
+                           &extent);
+    }
+
+    textureDesc.usage = wgpu::TextureUsage::RenderAttachment;
+    textureDesc.label = "dstTexture";
+    wgpu::Texture dstTexture = device.CreateTexture(&textureDesc);
+
+    const char* shader = R"(
+        @group(0) @binding(0) var tex: texture_2d<u32>;
+
+        @vertex fn vs() -> @builtin(position) vec4f {
+            return vec4f(0.0, 0.0, 0.0, 1.0);
+        }
+
+        @fragment fn fs() -> @location(0) vec4u {
+            return textureLoad(tex, vec2u(0), 0);
+        }
+    )";
+    auto module = utils::CreateShaderModule(device, shader);
+
+    utils::ComboRenderPipelineDescriptor desc;
+    desc.vertex.module = module;
+    desc.cFragment.module = module;
+    desc.cFragment.targetCount = 1;
+    desc.cTargets[0].format = wgpu::TextureFormat::RGBA8Uint;
+    desc.primitive.topology = wgpu::PrimitiveTopology::PointList;
+    wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&desc);
+
+    wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0),
+                                                     {
+                                                         {0, srcTexture.CreateView()},
+                                                     });
+    wgpu::CommandBuffer commands;
+    {
+        wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+
+        utils::ComboRenderPassDescriptor passDescriptor({dstTexture.CreateView()});
+        wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&passDescriptor);
+        pass.SetPipeline(pipeline);
+        pass.SetBindGroup(0, bindGroup);
+        pass.Draw(1);
+        pass.End();
+
+        commands = encoder.Finish();
+    }
+
+    // --- capture ---
+    auto recorder = Recorder::CreateAndStart(device);
+
+    queue.Submit(1, &commands);
+
+    // --- replay ---
+    auto capture = recorder.Finish();
+    auto replay = capture.Replay(device);
+
+    {
+        wgpu::Texture texture = replay->GetObjectByLabel<wgpu::Texture>("dstTexture");
+        ASSERT_NE(texture, nullptr);
+
+        uint8_t expected[] = {0x11, 0x22, 0x33, 0x44};
+        EXPECT_TEXTURE_EQ(&expected[0], texture, {0, 0}, {1, 1}, 0, wgpu::TextureAspect::All);
+    }
+}
+
 DAWN_INSTANTIATE_TEST(CaptureAndReplayTests, WebGPUBackend());
 
 }  // anonymous namespace