PipelineStatesWebGPU.cpp

#include "PipelineStatesWebGPU.h"
 
#include "GraphicsDeviceWebGPU.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("PipelineStatesWebGPU");
 
  WGPUBlendOperation wgpu(Cogs::BlendState::BlendOperation opp)
  {
    if(opp == Cogs::BlendState::BlendOperation::Add)
      return WGPUBlendOperation_Add;
    if(opp == Cogs::BlendState::BlendOperation::Subtract)
      return WGPUBlendOperation_Subtract;
    if(opp == Cogs::BlendState::BlendOperation::ReverseSubtract)
      return WGPUBlendOperation_ReverseSubtract;
    if(opp == Cogs::BlendState::BlendOperation::Min)
      return WGPUBlendOperation_Min;
    if(opp == Cogs::BlendState::BlendOperation::Max)
      return WGPUBlendOperation_Max;
    assert(false);
    return WGPUBlendOperation_Add;
  }
 
  WGPUBlendFactor wgpu(Cogs::BlendState::Blend blend)
  {
    if(blend == Cogs::BlendState::Blend::Zero)
      return WGPUBlendFactor_Zero;
    if(blend == Cogs::BlendState::Blend::One)
      return WGPUBlendFactor_One;
    if(blend == Cogs::BlendState::Blend::SourceColor)
      return WGPUBlendFactor_Src;
    if(blend == Cogs::BlendState::Blend::InverseSourceColor)
      return WGPUBlendFactor_OneMinusSrc;
    if(blend == Cogs::BlendState::Blend::SourceAlpha)
      return WGPUBlendFactor_SrcAlpha;
    if(blend == Cogs::BlendState::Blend::InverseSourceAlpha)
      return WGPUBlendFactor_OneMinusSrcAlpha;
    if(blend == Cogs::BlendState::Blend::DestinationAlpha)
      return WGPUBlendFactor_DstAlpha;
    if(blend == Cogs::BlendState::Blend::InverseDestinationAlpha)
      return WGPUBlendFactor_OneMinusDstAlpha;
    if(blend == Cogs::BlendState::Blend::DestinationColor)
      return WGPUBlendFactor_Dst;
    if(blend == Cogs::BlendState::Blend::InverseDestinationColor)
      return WGPUBlendFactor_OneMinusDst;
    if(blend == Cogs::BlendState::Blend::SourceAlphaSaturate)
      return WGPUBlendFactor_SrcAlphaSaturated;
    if(blend == Cogs::BlendState::Blend::BlendFactor)
      return WGPUBlendFactor_Constant;
    if(blend == Cogs::BlendState::Blend::InverseBlendFactor)
      return WGPUBlendFactor_OneMinusConstant;
    assert(false);
    return WGPUBlendFactor_Zero;
  }
}
 
namespace Cogs{
 
  void PipelineStatesWebGPU::initialize(GraphicsDeviceWebGPU *device)
  {
    graphics_device = device;
  }
 
  size_t PipelineStatesWebGPU::renderPipelineHash(EffectHandle effectHandle,
                                                  InputLayoutHandle inputLayoutHandle,
                                                  PrimitiveType primitiveType,
                                                  RasterizerStateHandle rasterizeStateHandle,
                                                  DepthStencilStateHandle depthStencilStateHandle,
                                                  BlendStateHandle blendStateHandle,
                                                  RenderTargetHandle renderTargetHandle,
                                                  DepthStencilHandle depthStencilHandle,
                                                  WGPUIndexFormat stripIndexFormat)
  {
    EffectsWebGPU &effects = graphics_device->effects;
    BuffersWebGPU &buffers = graphics_device->buffers;
    RenderTargetsWebGPU &render_targets = graphics_device->renderTargets;
 
    size_t pso_hash = Cogs::hash();
    if (HandleIsValid(effectHandle)) {
      EffectWebGPU& effect = effects.effects[effectHandle];
      pso_hash = effect.hash(pso_hash);
    }
    if (HandleIsValid(inputLayoutHandle)) {
      InputLayoutWebGPU& layout = buffers.inputLayouts[inputLayoutHandle];
      pso_hash = layout.hash(pso_hash);
    }
    pso_hash = Cogs::hash(primitiveType, pso_hash);
    pso_hash = Cogs::hash(rasterizeStateHandle.handle, pso_hash);
    pso_hash = Cogs::hash(depthStencilStateHandle.handle, pso_hash);
    pso_hash = Cogs::hash(blendStateHandle.handle, pso_hash);
    if (HandleIsValid(renderTargetHandle)) {
      RenderTargetWebGPU& render_target = render_targets.render_targets[renderTargetHandle];
      pso_hash = Cogs::hash(render_target.count, pso_hash);
      pso_hash = Cogs::hash(render_target.samples, pso_hash);
      for(uint32_t i=0; i<render_target.count; i++){
        pso_hash = Cogs::hash(render_target.format[i], pso_hash);
      }
      //pso_hash = render_target.hash(pso_hash);
    }
    if (HandleIsValid(depthStencilHandle)) {
      DepthStencilTargetWebGPU& depth_target = render_targets.depth_stencil_targets[depthStencilHandle];
      pso_hash = Cogs::hash(depth_target.samples, pso_hash);
      pso_hash = Cogs::hash(depth_target.format, pso_hash);
      //pso_hash = depth_target.hash(pso_hash);
    }
    pso_hash = Cogs::hash(static_cast<int>(stripIndexFormat), pso_hash);
    return pso_hash;
  }
  RenderPipelineHandle PipelineStatesWebGPU::loadRenderPipeline(EffectHandle effectHandle,
                                                                InputLayoutHandle inputLayoutHandle,
                                                                PrimitiveType primitiveType,
                                                                RasterizerStateHandle rasterizeStateHandle,
                                                                DepthStencilStateHandle depthStencilStateHandle,
                                                                BlendStateHandle blendStateHandle,
                                                                RenderTargetHandle renderTargetHandle,
                                                                DepthStencilHandle depthStencilHandle,
                                                                WGPUIndexFormat stripIndexFormat)
  {
    WGPUDevice device = graphics_device->device;
    BuffersWebGPU &buffers = graphics_device->buffers;
    ResourceCountersWebGPU &counters = graphics_device->counters;
    RenderTargetsWebGPU &renderTargets = graphics_device->renderTargets;
 
    size_t pso_hash = renderPipelineHash(effectHandle,
                                         inputLayoutHandle,
                                         primitiveType,
                                         rasterizeStateHandle,
                                         depthStencilStateHandle,
                                         blendStateHandle,
                                         renderTargetHandle,
                                         depthStencilHandle,
                                         stripIndexFormat);
    auto iter = renderPipelineHashMap.find(pso_hash);
    if(iter != renderPipelineHashMap.end()){
      return iter->second;
    }
 
    EffectWebGPU &effect = graphics_device->effects.effects[effectHandle];
    const RasterizerState &rs =
      rasterizeStateHandle ?
      *reinterpret_cast<RasterizerState*>(rasterizeStateHandle.handle):
      RasterizerState::DefaultState();
    // assert(rs.wireFrame == false); // TODO
    // assert(rs.multiSample == true); // TODO
    // assert(rs.scissor == true); // TODO
    // assert(rs.noDepthClip == false); // TODO O requres optional feature "depth-clip-control"
    const DepthStencilState &ds =
      depthStencilStateHandle ?
      *reinterpret_cast<DepthStencilState*>(depthStencilStateHandle.handle) :
      DepthStencilState::DefaultState();
    const BlendState &bsc =
      blendStateHandle ?
      reinterpret_cast<BlendState*>(blendStateHandle.handle)[0] :
      BlendState::DefaultState();
    const BlendState &bsa =
      blendStateHandle ?
      reinterpret_cast<BlendState*>(blendStateHandle.handle)[1] :
      BlendState::DefaultState();
 
    LOG_INFO(logger, "PipelineStateLoad %s", effect.name.c_str());
 
    WGPURenderPipelineDescriptor desc = WGPU_RENDER_PIPELINE_DESCRIPTOR_INIT;
    desc.label = {effect.name.c_str(), WGPU_STRLEN};
    desc.layout = nullptr;
    WGPUPipelineLayout pipeline_layout;
    WGPUBindGroupLayout bind_group_layout;
    {
      WGPUBindGroupLayoutEntry layoutEntryList[EffectWebGPU::maxConstantBuffers];
      size_t numConstantBufferBindings = 0;
      const WebGPUConstantBufferBinding* bindings;
      bindings = graphics_device->effects.getConstantBufferBindings(effectHandle, numConstantBufferBindings);
      for (size_t i = 0; i < numConstantBufferBindings; i++) {
        assert(bindings[i].group == 0);
        layoutEntryList[i] = bindings[i].bg_ent;
      }
      WGPUBindGroupLayoutDescriptor bind_group_layout_desc = WGPU_BIND_GROUP_LAYOUT_DESCRIPTOR_INIT;
      bind_group_layout_desc.label = {effect.name.c_str(), WGPU_STRLEN};
      bind_group_layout_desc.entryCount = numConstantBufferBindings;
      bind_group_layout_desc.entries = layoutEntryList;
      bind_group_layout = wgpuDeviceCreateBindGroupLayout(device, &bind_group_layout_desc);
      counters.bind_group_layout++;
 
      WGPUPipelineLayoutDescriptor pipeline_layout_desc = WGPU_PIPELINE_LAYOUT_DESCRIPTOR_INIT;
      pipeline_layout_desc.bindGroupLayoutCount = 1;
      pipeline_layout_desc.bindGroupLayouts = &bind_group_layout;
      pipeline_layout = wgpuDeviceCreatePipelineLayout(device, &pipeline_layout_desc);
      counters.pipeline_layout++;
      desc.label = {effect.name.c_str(), WGPU_STRLEN};
      desc.layout = pipeline_layout;
    }
 
    WGPUPrimitiveState &primitive_state = desc.primitive;
    {
      assert(primitiveType < PrimitiveType::TriangleListAdjacency); // WebGPU does not support advanced primitives
      if(primitiveType == PrimitiveType::PointList){
        primitive_state.topology = WGPUPrimitiveTopology_PointList;
        primitive_state.stripIndexFormat = WGPUIndexFormat_Undefined;
      }
      else if(primitiveType == PrimitiveType::LineList){
        primitive_state.topology = WGPUPrimitiveTopology_LineList;
        primitive_state.stripIndexFormat = WGPUIndexFormat_Undefined;
      }
      else if(primitiveType == PrimitiveType::LineStrip){
        primitive_state.topology = WGPUPrimitiveTopology_LineStrip;
        primitive_state.stripIndexFormat = stripIndexFormat != WGPUIndexFormat_Undefined ? stripIndexFormat : WGPUIndexFormat_Uint32;
      }
      else if(primitiveType == PrimitiveType::TriangleList){
        primitive_state.topology = WGPUPrimitiveTopology_TriangleList;
        primitive_state.stripIndexFormat = WGPUIndexFormat_Undefined;
      }
      else if(primitiveType == PrimitiveType::TriangleStrip){
        primitive_state.topology = WGPUPrimitiveTopology_TriangleStrip;
        primitive_state.stripIndexFormat = stripIndexFormat != WGPUIndexFormat_Undefined ? stripIndexFormat : WGPUIndexFormat_Uint32;
      }
      else{
        assert(false);
      }
 
      if(rs.frontCounterClockwise)
        primitive_state.frontFace = WGPUFrontFace_CCW;
      else
        primitive_state.frontFace = WGPUFrontFace_CW;
      if(rs.cullMode == RasterizerState::Front)
        primitive_state.cullMode = WGPUCullMode_Front;
      else if(rs.cullMode == RasterizerState::Back)
        primitive_state.cullMode = WGPUCullMode_Back;
      else
        primitive_state.cullMode = WGPUCullMode_None;
    }
 
    WGPUVertexState &vertex_state = desc.vertex;
    {
      vertex_state.module = effect.vs_module;
      vertex_state.entryPoint = {effect.vs_entry.c_str(), WGPU_STRLEN};
      vertex_state.constantCount = 0;
      vertex_state.constants = nullptr;
      if (HandleIsValid(inputLayoutHandle)) {
        InputLayoutWebGPU& layout = buffers.inputLayouts[inputLayoutHandle];
        vertex_state.bufferCount = (uint32_t)layout.vertex_buffer_layout.size();
        vertex_state.buffers = layout.vertex_buffer_layout.data();
      }
    }
 
    bool use_swap_chain = !HandleIsValid(renderTargetHandle) && !HandleIsValid(depthStencilHandle);
 
    uint32_t samples = 0;
    WGPUDepthStencilState depthStencil = WGPU_DEPTH_STENCIL_STATE_INIT;
    if(HandleIsValid(depthStencilHandle) || use_swap_chain){
      if(use_swap_chain){
        SwapChainWebGPU &defaultSwapChain = graphics_device->defaultSwapChain;
        depthStencil.format = defaultSwapChain.depth_format;
        samples = defaultSwapChain.samples;
      }
      else{
        DepthStencilTargetWebGPU &dst = renderTargets.depth_stencil_targets[depthStencilHandle];
        depthStencil.format = dst.format;
        samples = dst.samples;
      }
 
      if(ds.depthEnabled){
        depthStencil.depthWriteEnabled = static_cast<WGPUOptionalBool>(ds.writeEnabled);
 
        if(ds.depthFunction == DepthStencilState::Never)
          depthStencil.depthCompare = WGPUCompareFunction_Never;
        else if(ds.depthFunction == DepthStencilState::Less)
          depthStencil.depthCompare = WGPUCompareFunction_Less;
        else if(ds.depthFunction == DepthStencilState::LessOrEqual)
          depthStencil.depthCompare = WGPUCompareFunction_LessEqual;
        else if(ds.depthFunction == DepthStencilState::Equal)
          depthStencil.depthCompare = WGPUCompareFunction_Equal;
        else if(ds.depthFunction == DepthStencilState::GreaterOrEqual)
          depthStencil.depthCompare = WGPUCompareFunction_GreaterEqual;
        else if(ds.depthFunction == DepthStencilState::Greater)
          depthStencil.depthCompare = WGPUCompareFunction_Greater;
        else if(ds.depthFunction == DepthStencilState::NotEqual)
          depthStencil.depthCompare = WGPUCompareFunction_NotEqual;
        else if(ds.depthFunction == DepthStencilState::Always)
          depthStencil.depthCompare = WGPUCompareFunction_Always;
        else
          assert(false);
      }
      else{
        depthStencil.depthWriteEnabled = WGPUOptionalBool(false);
        depthStencil.depthCompare = WGPUCompareFunction_Always;
      }
 
      depthStencil.stencilFront.compare = WGPUCompareFunction_Always;
      depthStencil.stencilFront.failOp = WGPUStencilOperation_Keep;
      depthStencil.stencilFront.depthFailOp = WGPUStencilOperation_Keep;
      depthStencil.stencilFront.passOp = WGPUStencilOperation_Keep;
 
      depthStencil.stencilBack.compare = WGPUCompareFunction_Always;
      depthStencil.stencilBack.failOp = WGPUStencilOperation_Keep;
      depthStencil.stencilBack.depthFailOp = WGPUStencilOperation_Keep;
      depthStencil.stencilBack.passOp = WGPUStencilOperation_Keep;
 
      depthStencil.stencilReadMask = 0;
      depthStencil.stencilWriteMask = 0;
 
      depthStencil.depthBias = (int32_t)rs.depthBias;
      depthStencil.depthBiasSlopeScale = rs.slopeScaledDepthBias;
      depthStencil.depthBiasClamp = rs.depthBiasClamp;
 
      if(primitiveType == PrimitiveType::PointList ||
         primitiveType == PrimitiveType::LineList ||
         primitiveType == PrimitiveType::LineStrip){
        if(depthStencil.depthBias != 0){
          depthStencil.depthBias = 0;
          LOG_INFO_ONCE(logger, "Setting depthBias to 0 for points and lines (%s).", effect.name.c_str());
        }
        if(depthStencil.depthBiasSlopeScale != 0.0f){
          depthStencil.depthBiasSlopeScale = 0.0f;
          LOG_INFO_ONCE(logger, "Setting depthBiasSlopeScale to 0.0 for points and lines (%s).", effect.name.c_str());
        }
        if(depthStencil.depthBiasClamp != 0.0f){
          depthStencil.depthBiasClamp = 0.0f;
          LOG_INFO_ONCE(logger, "Setting depthBiasClamp to 0.0 for points and lines (%s).", effect.name.c_str());
        }
      }
 
      desc.depthStencil = &depthStencil;
    }
 
    WGPUColorTargetState color_target[8] = {};
    for(uint32_t i=0; i<sizeof(color_target)/sizeof(color_target[0]); i++){
      color_target[i] = WGPU_COLOR_TARGET_STATE_INIT;
    }
    uint32_t color_target_count = 0;
    if(HandleIsValid(renderTargetHandle)){
      RenderTargetWebGPU &rt = renderTargets.render_targets[renderTargetHandle];
      samples = glm::max(rt.samples, samples);
      color_target_count = rt.count;
      for(uint32_t i=0; i<rt.count; i++){
        color_target[i].format = rt.format[i];
        color_target[i].writeMask = WGPUColorWriteMask_All;
      }
    }
    else if(use_swap_chain){
      SwapChainWebGPU &defaultSwapChain = graphics_device->defaultSwapChain;
      color_target_count = 1;
      color_target[0].format = defaultSwapChain.color_format;
      color_target[0].writeMask = WGPUColorWriteMask_All;
    }
 
    WGPUBlendState blend_state = WGPU_BLEND_STATE_INIT;
    if(bsc.enabled || bsa.enabled){
//      assert(bsc.enabled && bsa.enabled);
      blend_state.color.operation = wgpu(bsc.operation);
      blend_state.color.srcFactor = wgpu(bsc.sourceBlend);
      blend_state.color.dstFactor = wgpu(bsc.destinationBlend);
      blend_state.alpha.operation = wgpu(bsa.operation);
      blend_state.alpha.srcFactor = wgpu(bsa.sourceBlend);
      blend_state.alpha.dstFactor = wgpu(bsa.destinationBlend);
      for(uint32_t i=0; i<color_target_count; i++){
        color_target[i].blend = &blend_state; // TODO different blend states?
      }
    }
 
    WGPUFragmentState fragment = WGPU_FRAGMENT_STATE_INIT;
    if(effect.fs_module){
      fragment.module = effect.fs_module;
      fragment.entryPoint = {effect.fs_entry.c_str(), WGPU_STRLEN};
      fragment.constantCount = 0;
      fragment.constants = nullptr;
      if(color_target_count > 0){
        fragment.targetCount = color_target_count;
        fragment.targets = color_target;
      }
      desc.fragment = &fragment;
    }
 
    WGPUMultisampleState &multisample = desc.multisample;
    {
      // WebGPU only supports sample counts 1 and 4.
      multisample.count = samples > 1 ? 4 : 1;
      multisample.mask = ~0x00000000u;
      multisample.alphaToCoverageEnabled = false;
    }
 
    WGPURenderPipeline pipeline = wgpuDeviceCreateRenderPipeline(device, &desc);
    counters.render_pipeline++;
    // TODO async pipeline creation
 
    RenderPipelineWebGPU pipelineState = {};
    pipelineState.hash = pso_hash;
    pipelineState.effect = effectHandle;
    pipelineState.inputLayoutHandle = inputLayoutHandle;
    pipelineState.primitiveType = primitiveType;
    pipelineState.rasterizeStateHandle = rasterizeStateHandle;
    pipelineState.depthStencilStateHandle = depthStencilStateHandle;
    pipelineState.blendStateHandle = blendStateHandle;
    pipelineState.renderTargetHandle = renderTargetHandle;
    pipelineState.depthStencilHandle = depthStencilHandle;
 
    pipelineState.pipeline = pipeline;
    pipelineState.pipeline_layout = pipeline_layout;
    pipelineState.bind_group_layout = bind_group_layout;
 
    auto handle = this->renderPipeline.addResource(std::move(pipelineState));
    renderPipelineHashMap.insert({pso_hash, handle});
    return handle;
  }
 
  ComputePipelineHandle PipelineStatesWebGPU::loadComputePipeline(EffectHandle effectHandle)
  {
    WGPUDevice device = graphics_device->device;
 
    size_t pso_hash = Cogs::hash();
    pso_hash = Cogs::hash(effectHandle.handle, pso_hash);
    auto iter = computePipelineHashMap.find(pso_hash);
    if(iter != computePipelineHashMap.end()){
      return iter->second;
    }
 
    ResourceCountersWebGPU &counters = graphics_device->counters;
    EffectWebGPU &effect = graphics_device->effects.effects[effectHandle];
 
    LOG_INFO(logger, "PipelineStateLoad %s", effect.name.c_str());
 
    WGPUComputePipelineDescriptor desc = WGPU_COMPUTE_PIPELINE_DESCRIPTOR_INIT;
    desc.label = {effect.name.c_str(), WGPU_STRLEN};
    desc.layout = nullptr; // Let WebGPU figure out layout?
    WGPUComputeState &compute = desc.compute;
    compute.module = effect.cs_module;
    compute.entryPoint = {effect.cs_entry.c_str(), WGPU_STRLEN};
    compute.constantCount = 0; // TODO
    compute.constants = nullptr; // TODO
    WGPUComputePipeline pipeline = wgpuDeviceCreateComputePipeline(device, &desc);
    counters.compute_pipeline++;
    // TODO async pipeline creation
 
    uint32_t groupIndex = 0;
    WGPUBindGroupLayout layout = wgpuComputePipelineGetBindGroupLayout(pipeline, groupIndex);
    // TODO create our own bind groups?
 
    ComputePipelineWebGPU pipelineState = {};
    pipelineState.hash = pso_hash;
    pipelineState.effect = effectHandle;
 
    pipelineState.pipeline = pipeline;
    pipelineState.layout = layout;
 
    auto handle = this->computePipeline.addResource(std::move(pipelineState));
    computePipelineHashMap.insert({pso_hash, handle});
    return handle;
  }
 
  void PipelineStatesWebGPU::releaseRenderPipeline(RenderPipelineHandle handle)
  {
    ResourceCountersWebGPU &counters = graphics_device->counters;
    RenderPipelineWebGPU &pipeline = renderPipeline[handle];
 
    wgpuRenderPipelineRelease(pipeline.pipeline);
    counters.render_pipeline--;
    wgpuPipelineLayoutRelease(pipeline.pipeline_layout);
    counters.pipeline_layout--;
    wgpuBindGroupLayoutRelease(pipeline.bind_group_layout);
    counters.bind_group_layout--;
 
    size_t hash = pipeline.hash;
    renderPipelineHashMap.erase(hash);
    renderPipeline.removeResource(handle);
  }
 
  void PipelineStatesWebGPU::releaseComputePipeline(ComputePipelineHandle handle)
  {
    ResourceCountersWebGPU &counters = graphics_device->counters;
    ComputePipelineWebGPU &pipeline = computePipeline[handle];
 
    wgpuBindGroupLayoutRelease(pipeline.layout);
    wgpuComputePipelineRelease(pipeline.pipeline);
    counters.compute_pipeline--;
 
    size_t hash = pipeline.hash;
    computePipelineHashMap.erase(hash);
    computePipeline.removeResource(handle);
  }
 
  void PipelineStatesWebGPU::releaseResources()
  {
    std::vector<RenderPipelineHandle> renderPipelineHandles;
    renderPipelineHandles.reserve(renderPipelineHashMap.size());
    for(auto &tmp : renderPipelineHashMap){
      renderPipelineHandles.push_back(tmp.second);
    }
    for(auto &tmp : renderPipelineHandles){
      releaseRenderPipeline(tmp);
    }
 
    std::vector<ComputePipelineHandle> computePipelineHandles;
    computePipelineHandles.reserve(computePipelineHashMap.size());
    for(auto &tmp : computePipelineHashMap){
      computePipelineHandles.push_back(tmp.second);
    }
    for(auto &tmp : computePipelineHandles){
      releaseComputePipeline(tmp);
    }
  }
 
}