RenderTargetsWebGPU.cpp

#include "RenderTargetsWebGPU.h"
 
#include "GraphicsDeviceWebGPU.h"
#include "Foundation/Logging/Logger.h"
 
#include <cassert>
 
namespace{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderTargetsWebGPU");
 
  void render_targets_error_callback(WGPUPopErrorScopeStatus status, WGPUErrorType type, WGPUStringView message, void* userdata1, void* userdata2)
  {
    Cogs::RenderTargetsWebGPU *render_targets = (Cogs::RenderTargetsWebGPU*)userdata1;
    (void)render_targets;
    Cogs::GraphicsDeviceWebGPU *ptr = (Cogs::GraphicsDeviceWebGPU*)userdata2;
    (void)ptr;
    if(status == WGPUPopErrorScopeStatus_CallbackCancelled){
      LOG_ERROR(logger, "WebGPU render targets err status: Cancelled");
    }
    if(status == WGPUPopErrorScopeStatus_Error){
      LOG_ERROR(logger, "WebGPU render targets err status: Error");
    }
    if(message.data && message.length){
      LOG_ERROR(logger, "WebGPU render targets err (%d) %.*s", type, WGPUStringViewFormat(message));
    }
  }
}
 
namespace Cogs{
 
  void RenderTargetsWebGPU::initialize(GraphicsDeviceWebGPU *graphicsDeviceIn)
  {
    graphicsDevice = graphicsDeviceIn;
  }
 
  RenderTargetHandle RenderTargetsWebGPU::createRenderTarget(const RenderTargetViewDescription* renderTargetViews, const size_t numViews)
  {
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
    RenderTargetWebGPU render_target = {};
 
    if(graphicsDevice->use_error_scope){
      wgpuDevicePushErrorScope(graphicsDevice->device, graphicsDevice->filter);
    }
 
    for(size_t i=0; i<numViews; i++){
      const RenderTargetViewDescription &set = renderTargetViews[i];
      assert(HandleIsValid(set.texture));
      const TextureWebGPU &texture = graphicsDevice->textures.textures[set.texture];
 
      WGPUTextureViewDescriptor desc = WGPU_TEXTURE_VIEW_DESCRIPTOR_INIT;
      desc.format = texture.view_format;
      desc.dimension = texture.view_dimension;
      if(set.numLayers == 1){
        switch(desc.dimension){
        case WGPUTextureViewDimension_2DArray:
        case WGPUTextureViewDimension_Cube:
        case WGPUTextureViewDimension_CubeArray:
          desc.dimension = WGPUTextureViewDimension_2D;
          break;
        default:
          break;
        }
      }
      desc.baseMipLevel = set.levelIndex;
      desc.mipLevelCount = 1;
      desc.baseArrayLayer = set.layerIndex;
      desc.arrayLayerCount = set.numLayers;
      desc.aspect = WGPUTextureAspect_All;
      render_target.view[i] = wgpuTextureCreateView(texture.texture, &desc);
      counters.texture_view++;
      render_target.textureHandle[i] = set.texture;
      render_target.format[i] = texture.view_format;
    }
    render_target.count = (uint32_t)numViews;
 
    if(numViews){
      const RenderTargetViewDescription &set = renderTargetViews[0];
      const TextureWebGPU &texture = graphicsDevice->textures.textures[set.texture];
      render_target.width = texture.width;
      render_target.height = texture.height;
      render_target.samples = texture.samples;
    }
 
    if(graphicsDevice->use_error_scope){
      WGPUPopErrorScopeCallbackInfo info = WGPU_POP_ERROR_SCOPE_CALLBACK_INFO_INIT;
      info.mode = WGPUCallbackMode_AllowSpontaneous;
      info.callback = render_targets_error_callback;
      info.userdata1 = this;
      info.userdata2 = graphicsDevice;
      WGPUFuture future = wgpuDevicePopErrorScope(graphicsDevice->device, info);
      // WGPUWaitStatus wgpuInstanceWaitAny(WGPUInstance instance, size_t futureCount, WGPUFutureWaitInfo * futures, uint64_t timeoutNS);
    }
 
    return render_targets.addResource(std::move(render_target));
  }
 
  void RenderTargetsWebGPU::releaseRenderTarget(RenderTargetHandle handle)
  {
    if(!HandleIsValid(handle)) return;
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
    RenderTargetWebGPU &target = render_targets[handle];
    for(size_t i=0; i<target.count; i++){
      wgpuTextureViewRelease(target.view[i]);
      counters.texture_view--;
    }
    render_targets.removeResource(handle);
  }
 
  DepthStencilHandle RenderTargetsWebGPU::createDepthStencilTarget(const RenderTargetHandle handle)
  {
    RenderTargetWebGPU &target = render_targets[handle];
    assert(target.width);
    assert(target.height);
    assert(target.samples);
    TextureDescription tex_desc = {};
    tex_desc.target = ResourceDimensions::Texture2D;
    tex_desc.width = target.width;
    tex_desc.height = target.height;
    tex_desc.depth = 1;
    tex_desc.layers = 1;
    tex_desc.faces = 1;
    tex_desc.levels = 1;
    tex_desc.samples = target.samples;
    tex_desc.format = TextureFormat::D32_FLOAT;
    tex_desc.flags = TextureFlags::DepthBuffer;
    TextureHandle textureHandle = graphicsDevice->textures.loadTexture(tex_desc, nullptr);
    DepthStencilViewDescription view_desc = {};
    view_desc.texture = textureHandle;
    view_desc.layerIndex = 0;
    view_desc.numLayers = 1;
    view_desc.levelIndex = 0;
    DepthStencilHandle ret = createDepthStencilTarget(handle, view_desc);
    DepthStencilTargetWebGPU &ds = depth_stencil_targets[ret];
    ds.textureHandle = textureHandle;
    ds.freeTextureHandle = true;
    return ret;
  }
 
  DepthStencilHandle RenderTargetsWebGPU::createDepthStencilTarget(const RenderTargetHandle handle, const TextureHandle textureHandle)
  {
    DepthStencilViewDescription view_desc = {};
    view_desc.texture = textureHandle;
    view_desc.layerIndex = 0;
    view_desc.numLayers = 1;
    view_desc.levelIndex = 0;
    return createDepthStencilTarget(handle, view_desc);
  }
 
  DepthStencilHandle RenderTargetsWebGPU::createDepthStencilTarget(const RenderTargetHandle, const DepthStencilViewDescription& depthStencilView)
  {
    DepthStencilTargetWebGPU depth_stencil_target;
 
    if(graphicsDevice->use_error_scope){
      wgpuDevicePushErrorScope(graphicsDevice->device, graphicsDevice->filter);
    }
 
    {
      ResourceCountersWebGPU &counters = graphicsDevice->counters;
      const DepthStencilViewDescription &set = depthStencilView;
      const TextureWebGPU &texture = graphicsDevice->textures.textures[set.texture];
 
      WGPUTextureViewDescriptor desc = WGPU_TEXTURE_VIEW_DESCRIPTOR_INIT;
      desc.format = texture.view_format;
      desc.dimension = texture.view_dimension;
      if(set.numLayers == 1){
        switch(desc.dimension){
        case WGPUTextureViewDimension_2DArray:
        case WGPUTextureViewDimension_CubeArray:
        case WGPUTextureViewDimension_Cube:
          desc.dimension = WGPUTextureViewDimension_2D;
          break;
        default:
          break;
        }
      }
      desc.baseMipLevel = set.levelIndex;
      desc.mipLevelCount = 1;
      desc.baseArrayLayer = set.layerIndex;
      desc.arrayLayerCount = set.numLayers;
      desc.aspect = WGPUTextureAspect_All;
      depth_stencil_target.view = wgpuTextureCreateView(texture.texture, &desc);
      counters.texture_view++;
      depth_stencil_target.format = texture.view_format;
      depth_stencil_target.samples = texture.samples;
    }
 
    if(graphicsDevice->use_error_scope){
      WGPUPopErrorScopeCallbackInfo info = WGPU_POP_ERROR_SCOPE_CALLBACK_INFO_INIT;
      info.mode = WGPUCallbackMode_AllowSpontaneous;
      info.callback = render_targets_error_callback;
      info.userdata1 = this;
      info.userdata2 = graphicsDevice;
      WGPUFuture future = wgpuDevicePopErrorScope(graphicsDevice->device, info);
      // WGPUWaitStatus wgpuInstanceWaitAny(WGPUInstance instance, size_t futureCount, WGPUFutureWaitInfo * futures, uint64_t timeoutNS);
    }
 
    return depth_stencil_targets.addResource(std::move(depth_stencil_target));
  }
 
  void RenderTargetsWebGPU::releaseDepthStencilTarget(DepthStencilHandle handle)
  {
    if(!HandleIsValid(handle)) return;
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
    DepthStencilTargetWebGPU &target = depth_stencil_targets[handle];
    wgpuTextureViewRelease(target.view);
    counters.texture_view--;
    if(target.freeTextureHandle){
      graphicsDevice->textures.releaseTexture(target.textureHandle);
    }
    depth_stencil_targets.removeResource(handle);
  }
 
  RenderTargetLayout RenderTargetsWebGPU::getLayout(const RenderTargetHandle renderTargetHandle, const DepthStencilHandle depthStencilHandle)
  {
    RenderTargetLayout layout;
 
    if(HandleIsValid(renderTargetHandle)){
      const RenderTargetWebGPU &target = render_targets[renderTargetHandle];
      layout.numColorTargets = static_cast<uint8_t>(target.count);
      layout.samples = static_cast<uint8_t>(target.samples);
 
      for(size_t i=0; i<target.count; i++){
        layout.colorFormats[i] = graphicsDevice->textures.textures[target.textureHandle[i]].format;
      }
    } else {
      layout.numColorTargets = 1;
      layout.colorFormats[0] = TextureFormat::B8G8R8A8_UNORM_SRGB;
      layout.samples = static_cast<uint8_t>(graphicsDevice->defaultSwapChain.samples);
    }
 
    if(HandleIsValid(depthStencilHandle)){
      const DepthStencilTargetWebGPU &target = depth_stencil_targets[depthStencilHandle];
      layout.depthStencilFormat = graphicsDevice->textures.textures[target.textureHandle].format;
    } else if(!HandleIsValid(renderTargetHandle)){
      layout.depthStencilFormat = TextureFormat::D32_FLOAT;
    }
 
    return layout;
  }
 
  void RenderTargetsWebGPU::releaseResources()
  {
    {
      std::vector<RenderTargetHandle> handles;
      for (auto& resource : render_targets) {
        handles.push_back(render_targets.getHandle(resource));
      }
      for (auto& handle : handles) {
        releaseRenderTarget(handle);
      }
    }
    {
      std::vector<DepthStencilHandle> handles;
      for (auto& resource : depth_stencil_targets) {
        handles.push_back(depth_stencil_targets.getHandle(resource));
      }
      for (auto& handle : handles) {
        releaseDepthStencilTarget(handle);
      }
    }
  }
 
}