RenderTargetsWebGPU.cpp

#include "RenderTargetsWebGPU.h"
 
#include "GraphicsDeviceWebGPU.h"
 
#include <cassert>
 
namespace Cogs{
 
  void RenderTargetsWebGPU::initialize(GraphicsDeviceWebGPU *graphicsDeviceIn)
  {
    graphicsDevice = graphicsDeviceIn;
  }
 
  RenderTargetHandle RenderTargetsWebGPU::createRenderTarget(const RenderTargetViewDescription* renderTargetViews, const size_t numViews)
  {
    RenderTargetWebGPU render_target = {};
 
    for(size_t i=0; i<numViews; i++){
      const RenderTargetViewDescription &set = renderTargetViews[i];
      const TextureWebGPU &texture = graphicsDevice->textures.textures[set.texture];
 
      WGPUTextureViewDescriptor desc = {};
      desc.format = texture.view_format;
      desc.dimension = texture.view_dimension;
      if(set.numLayers == 1){
        switch(desc.dimension){
        case WGPUTextureViewDimension_2DArray:
          desc.dimension = WGPUTextureViewDimension_2D;
          break;
        case WGPUTextureViewDimension_CubeArray:
          desc.dimension = WGPUTextureViewDimension_Cube;
          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);
      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;
      
    }
 
    return render_targets.addResource(std::move(render_target));
  }
 
  void RenderTargetsWebGPU::releaseRenderTarget(RenderTargetHandle handle)
  {
    if(!HandleIsValid(handle)) return;
    RenderTargetWebGPU &target = render_targets[handle];
    for(size_t i=0; i<target.count; i++){
      wgpuTextureViewRelease(target.view[i]);
    }
    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;
    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;
 
    {
      const DepthStencilViewDescription &set = depthStencilView;
      const TextureWebGPU &texture = graphicsDevice->textures.textures[set.texture];
 
      WGPUTextureViewDescriptor desc = {};
      desc.format = texture.view_format;
      desc.dimension = texture.view_dimension;
      if(set.numLayers == 1){
        switch(desc.dimension){
        case WGPUTextureViewDimension_2DArray:
          desc.dimension = WGPUTextureViewDimension_2D;
          break;
        case WGPUTextureViewDimension_CubeArray:
          desc.dimension = WGPUTextureViewDimension_Cube;
          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);
      depth_stencil_target.format = texture.view_format;
      depth_stencil_target.samples = texture.samples;
    }
 
    return depth_stencil_targets.addResource(std::move(depth_stencil_target));
  }
 
  void RenderTargetsWebGPU::releaseDepthStencilTarget(DepthStencilHandle handle)
  {
    if(!HandleIsValid(handle)) return;
    DepthStencilTargetWebGPU &target = depth_stencil_targets[handle];
    wgpuTextureViewRelease(target.view);
    depth_stencil_targets.removeResource(handle);
  }
 
}