ContextWebGPU.cpp

#include "ContextWebGPU.h"
 
#include "GraphicsDeviceWebGPU.h"
#include "PipelineStatesWebGPU.h"
#include "Foundation/Logging/Logger.h"
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ContextWebGPU");
 
  WGPULoadOp ConvWebGPULoadOp(Cogs::LoadOp load_op)
  {
    switch(load_op){
    case Cogs::LoadOp::Undefined: return WGPULoadOp_Undefined;
    case Cogs::LoadOp::Clear: return WGPULoadOp_Clear;
    case Cogs::LoadOp::Load: return WGPULoadOp_Load;
    }
    return WGPULoadOp_Undefined;
  }
  WGPUStoreOp ConvWebGPUStoreOp(Cogs::StoreOp store_op)
  {
    switch(store_op){
    case Cogs::StoreOp::Undefined: return WGPUStoreOp_Undefined;
    case Cogs::StoreOp::Store: return WGPUStoreOp_Store;
    case Cogs::StoreOp::Discard: return WGPUStoreOp_Discard;
    }
    return WGPUStoreOp_Undefined;
  }
 
  void decodeConstantBufferBindingHandle(int64_t handle, size_t &group, uint32_t &binding) {
    int64_t i = handle;
    group = i >> 16;
    binding = (i & 0xFFFF) - 1;
  }
 
}
 
namespace Cogs{
 
  void ContextWebGPU::initialize(GraphicsDeviceWebGPU *graphicsDeviceIn)
  {
    graphicsDevice = graphicsDeviceIn;
  }
 
  void ContextWebGPU::frameStatisticsConfigure(bool /*enable*/)
  {
    //assert(false); // TODO
  }
 
  void ContextWebGPU::signal(FenceHandle /*fenceHandle*/)
  {
    // assert(false); // TODO
  }
 
  void ContextWebGPU::clearRenderTarget(const float* value)
  {
    assert(!inRenderPass);
    for(size_t i=0; i<sizeof(clearColor)/sizeof(clearColor[0]); i++){
      clearColor[i].r = value[0];
      clearColor[i].g = value[1];
      clearColor[i].b = value[2];
      clearColor[i].a = value[3];
    }
    do_clear_render_target = true;
    update_render_target = true;
  }
 
  void ContextWebGPU::clearRenderTarget(const float** values, const int numvalues)
  {
    assert(!inRenderPass);
    for(int i=0; i<numvalues; i++){
      clearColor[i].r = values[i][0];
      clearColor[i].g = values[i][1];
      clearColor[i].b = values[i][2];
      clearColor[i].a = values[i][3];
    }
    for(size_t i=numvalues; i<sizeof(clearColor)/sizeof(clearColor[0]); i++){
      clearColor[i] = {};
    }
    do_clear_render_target = true;
    update_render_target = true;
  }
 
  void ContextWebGPU::clearDepth(const float depth)
  {
    assert(!inRenderPass);
    clearDepthVal = depth;
    do_clear_depth = true;
    update_render_target = true;
  }
 
  void ContextWebGPU::beginRenderPass(const RenderPassInfo &info)
  {
    assert(renderPassEncoder == 0);
    assert(computePassEncoder == 0);
    assert(!inRenderPass);
    inRenderPass = true;
    update_render_target = false;
 
    renderTargetHandle = info.renderTargetHandle;
    depthStencilHandle = info.depthStencilHandle;
 
    WGPURenderPassColorAttachment color_attachment[8] = {};
    WGPURenderPassDepthStencilAttachment ds_attachment = {};
    uint32_t color_attachment_count = 0;
    uint32_t ds_attachment_count = 0;
 
    const char *name = nullptr;
    if (HandleIsValid(info.renderTargetHandle) || HandleIsValid(info.depthStencilHandle)) {
      name = "Custom Render Pass";
      if(HandleIsValid(info.renderTargetHandle)){
        RenderTargetWebGPU &target = graphicsDevice->renderTargets.render_targets[info.renderTargetHandle];
        for(size_t i=0; i<target.count; i++){
          WGPURenderPassColorAttachment &att = color_attachment[i];
          att.view = target.view[i];
          att.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
          if(info.resolveHandle[i]){
            att.resolveTarget = graphicsDevice->textures.textureViews[info.resolveHandle[i]].texture_view;
          }
          else{
            att.resolveTarget = nullptr;
          }
          att.loadOp = ConvWebGPULoadOp(info.loadOp[i]);
          att.storeOp = ConvWebGPUStoreOp(info.storeOp[i]);
          att.clearValue.r = info.clearValue[i][0];
          att.clearValue.g = info.clearValue[i][1];
          att.clearValue.b = info.clearValue[i][2];
          att.clearValue.a = info.clearValue[i][3];
        }
        color_attachment_count = target.count;
      }
      if(HandleIsValid(info.depthStencilHandle)){
        DepthStencilTargetWebGPU &target = graphicsDevice->renderTargets.depth_stencil_targets[info.depthStencilHandle];
        WGPURenderPassDepthStencilAttachment &att = ds_attachment;
        att.view = target.view;
        att.depthLoadOp = ConvWebGPULoadOp(info.depthLoadOp);
        att.depthStoreOp = ConvWebGPUStoreOp(info.depthStoreOp);
        att.depthClearValue = info.depthClearValue;
        att.depthReadOnly = info.depthReadOnly;
        att.stencilLoadOp = WGPULoadOp_Undefined;
        att.stencilStoreOp = WGPUStoreOp_Undefined;
        att.stencilClearValue = 0;
        att.stencilReadOnly = false;
        ds_attachment_count = 1;
      }
    }
    else{
      name = "Default Render Pass";
      SwapChainWebGPU &defaultSwapChain = graphicsDevice->defaultSwapChain;
      if(defaultSwapChain.samples > 1){
        color_attachment[0].view = defaultSwapChain.colorBufferView;
        color_attachment[0].resolveTarget = defaultSwapChain.resolveView;
      }
      else{
        color_attachment[0].view = defaultSwapChain.resolveView;
      }
      color_attachment[0].depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
      color_attachment[0].loadOp = ConvWebGPULoadOp(info.loadOp[0]);
      color_attachment[0].storeOp = ConvWebGPUStoreOp(info.storeOp[0]);
      color_attachment[0].clearValue.r = info.clearValue[0][0];
      color_attachment[0].clearValue.g = info.clearValue[0][1];
      color_attachment[0].clearValue.b = info.clearValue[0][2];
      color_attachment[0].clearValue.a = info.clearValue[0][3];
      color_attachment_count = 1;
 
      ds_attachment.view = defaultSwapChain.depthBufferView;
      ds_attachment.depthLoadOp = ConvWebGPULoadOp(info.depthLoadOp);
      ds_attachment.depthStoreOp = ConvWebGPUStoreOp(info.depthStoreOp);
      ds_attachment.depthClearValue = info.depthClearValue;
      ds_attachment.depthReadOnly = info.depthReadOnly;
      ds_attachment.stencilLoadOp = WGPULoadOp_Undefined;
      ds_attachment.stencilStoreOp = WGPUStoreOp_Undefined;
      ds_attachment.stencilClearValue = 0;
      ds_attachment.stencilReadOnly = false;
      ds_attachment_count = 1;
    }
 
    WGPURenderPassDescriptor render_pass_desc = {};
    render_pass_desc.label = {name, WGPU_STRLEN};
    if(color_attachment_count){
      render_pass_desc.colorAttachmentCount = color_attachment_count;
      render_pass_desc.colorAttachments = color_attachment;
    }
    if(ds_attachment_count){
      render_pass_desc.depthStencilAttachment = &ds_attachment;
    }
    render_pass_desc.occlusionQuerySet = nullptr;
    // render_pass_desc.timestampWriteCount = 0;
    render_pass_desc.timestampWrites = nullptr;
    renderPassEncoder = wgpuCommandEncoderBeginRenderPass(graphicsDevice->commandEncoder, &render_pass_desc);
  }
  void ContextWebGPU::endRenderPass()
  {
    assert(renderPassEncoder);
    assert(inRenderPass);
    inRenderPass = false;
    wgpuRenderPassEncoderEnd(renderPassEncoder);
    wgpuRenderPassEncoderRelease(renderPassEncoder);
    renderPassEncoder = 0;
    update_render_target = true;
  }
 
  void ContextWebGPU::setRenderTarget(const RenderTargetHandle rt_handle, const DepthStencilHandle ds_handle)
  {
    if(HandleIsValid(rt_handle))
      renderTargetHandle = rt_handle;
    else
      renderTargetHandle = {};
    if(HandleIsValid(ds_handle))
      depthStencilHandle = ds_handle;
    else
      depthStencilHandle = {};
    rasterizeStateHandle = {};
    blendStateHandle = {};
    assert(do_clear_render_target == false); // Maybe do update render pass to force clear?
    assert(do_clear_depth == false); // Maybe do update render pass to force clear?
    do_clear_render_target = false;
    do_clear_depth = false;
    update_render_target = true;
  }
 
  void ContextWebGPU::setViewport(const float x, const float y, const float width, const float height)
  {
    updateRenderPass();
    float minDepth = 0.0f; // TODO
    float maxDepth = 1.0f; // TODO
    wgpuRenderPassEncoderSetViewport(renderPassEncoder, x, y, width, height, minDepth, maxDepth);
  }
 
  void ContextWebGPU::setScissor(const int x, const int y, const int width, const int height)
  {
    updateRenderPass();
    int w, h;
    graphicsDevice->getSize(w, h); // TODO
    int xx = glm::clamp(x, 0, w);
    int yy = glm::clamp(y, 0, h);
    int ww = glm::clamp(width, 0, w-xx);
    int hh = glm::clamp(height, 0, h-yy);
    wgpuRenderPassEncoderSetScissorRect(renderPassEncoder, xx, yy, ww, hh);
  }
 
  void ContextWebGPU::setDepthStencilState(const DepthStencilStateHandle handle)
  {
    if(HandleIsValid(handle))
      depthStencilStateHandle = handle;
    else
      depthStencilStateHandle = {};
  }
 
  void ContextWebGPU::setBlendState(const BlendStateHandle handle, const float *constants)
  {
    updateRenderPass();
    if(HandleIsValid(handle))
      blendStateHandle = handle;
    else
      blendStateHandle = {};
    WGPUColor color; // Emulate dx11 with 1.0f constants if not set
    if(constants){
      color.r = constants[0];
      color.g = constants[1];
      color.b = constants[2];
      color.a = constants[3];
    }
    else{
      color.r = 1.0f;
      color.g = 1.0f;
      color.b = 1.0f;
      color.a = 1.0f;
    }
    wgpuRenderPassEncoderSetBlendConstant(renderPassEncoder, &color);
  }
 
  void ContextWebGPU::setRasterizerState(const RasterizerStateHandle handle)
  {
    if(HandleIsValid(handle))
      rasterizeStateHandle = handle;
    else
      rasterizeStateHandle = {};
  }
 
  void ContextWebGPU::setDefaults() {
    rasterizeStateHandle = {};
    depthStencilStateHandle = {};
    blendStateHandle = {};
  }
 
  void ContextWebGPU::setEffect(EffectHandle handle)
  {
    if(HandleIsValid(handle))
      effect = handle;
    else
      effect = {};
    inputLayoutHandle = {};
    descriptors.clear();
    update_descriptors = true;
  }
 
  void ContextWebGPU::setTexture(const StringView& name, unsigned int unit, TextureHandle textureHandle)
  {
    setTexture(getEffects()->getTextureBinding(getCurrentEffect(), name, unit), textureHandle);
  }
 
  void ContextWebGPU::setTexture(const TextureBindingHandle binding, const TextureHandle handle)
  {
    // WebGPU does not support setting invalid textures, so we remove the binding from the descriptor. 
    // If it is needed we will detect the issue when creatng the bindgroup if the texture is required
    if (!HandleIsValid(handle)) {
      descriptors.erase((uint32_t)binding.handle);
      return;
    }
    if (!HandleIsValid(binding)) {
      return;
    }
    TextureWebGPU texture = graphicsDevice->textures.textures[handle];
    WGPUBindGroupEntry bg_ent = {};
    size_t group;
    decodeConstantBufferBindingHandle(binding.handle, group, bg_ent.binding);
    assert(group == 0);
    bg_ent.buffer = nullptr;
    bg_ent.offset = 0;
    bg_ent.size = 0;
    bg_ent.sampler = nullptr;
    bg_ent.textureView = texture.texture_view;
    descriptors[bg_ent.binding] = bg_ent;
    update_descriptors = true;
  }
 
  void ContextWebGPU::setTexture(const StringView& name, TextureViewHandle textureViewHandle)
  {
    setTexture(getEffects()->getTextureBinding(getCurrentEffect(), name, 1), textureViewHandle);
  }
 
  void ContextWebGPU::setTexture(const TextureBindingHandle binding, TextureViewHandle handle)
  {
    // WebGPU does not support setting invalid textures, so we remove the binding from the descriptor. 
    // If it is needed we will detect the issue when creatng the bindgroup if the texture is required
    if (!HandleIsValid(handle)) {
      descriptors.erase((uint32_t)binding.handle);
      return;
    }
    TextureViewWebGPU texture_view = graphicsDevice->textures.textureViews[handle];
    WGPUBindGroupEntry bg_ent = {};
    size_t group;
    decodeConstantBufferBindingHandle(binding.handle, group, bg_ent.binding);
    assert(group == 0);
    bg_ent.buffer = nullptr;
    bg_ent.offset = 0;
    bg_ent.size = 0;
    bg_ent.sampler = nullptr;
    bg_ent.textureView = texture_view.texture_view;
    descriptors[bg_ent.binding] = bg_ent;
    update_descriptors = true;
  }
 
  void ContextWebGPU::setSamplerState(const StringView& name, unsigned int unit, SamplerStateHandle handle)
  {
    setSamplerState(getEffects()->getSamplerStateBinding(getCurrentEffect(), name, unit), handle);
  }
 
  void ContextWebGPU::setSamplerState(const SamplerStateBindingHandle binding, const SamplerStateHandle handle)
  {
    // WebGPU does not support setting invalid samplers, so we remove the binding from the descriptor. 
    // If it is needed we will detect the issue when creatng the bindgroup if the sampler is required
    if (!HandleIsValid(handle)) {
      descriptors.erase((uint32_t)binding.handle); 
      return;
    }
    if (!HandleIsValid(binding)) {
      return;
    }
    SamplerStateWebGPU sampler = graphicsDevice->textures.samplerStates[handle];
    WGPUBindGroupEntry bg_ent = {};
    size_t group;
    decodeConstantBufferBindingHandle(binding.handle, group, bg_ent.binding);
    assert(group == 0);
    bg_ent.buffer = nullptr;
    bg_ent.offset = 0;
    bg_ent.size = 0;
    bg_ent.sampler = sampler.sampler;
    bg_ent.textureView = nullptr;
    descriptors[bg_ent.binding] = bg_ent;
    //WGPUBindGroupLayoutEntry bg_le{
    //  .binding = (uint32_t)binding.handle,
    //  .sampler = {
    //    .type = WGPUSamplerBindingType_Filtering,
    //  }
    //};
    update_descriptors = true;
  }
 
  void ContextWebGPU::setInputLayout(const InputLayoutHandle handle)
  {
    if(HandleIsValid(handle))
      inputLayoutHandle = handle;
    else
      inputLayoutHandle = {};
  }
 
  void ContextWebGPU::setVertexBuffers(const VertexBufferHandle* vertexBufferHandles, const size_t count, const uint32_t* /*strides*/, const uint32_t* offsets)
  {
    updateRenderPass();
    for(size_t i=0; i<count; i++){
      BufferWebGPU buffer = graphicsDevice->buffers.buffers[(BufferHandle)vertexBufferHandles[i].handle];
      uint32_t slot = (uint32_t)i;
      // uint32_t stride = strides ? strides[i] : 0;
      uint32_t offset = offsets ? offsets[i] : 0;
      wgpuRenderPassEncoderSetVertexBuffer(renderPassEncoder, slot, buffer.buffer, offset, buffer.size-offset);
    }
  }
 
  void ContextWebGPU::setVertexBuffers(const VertexBufferHandle * handles, const size_t count)
  {
    setVertexBuffers(handles, count, nullptr, nullptr);
  }
 
  void ContextWebGPU::setIndexBuffer(IndexBufferHandle bufferHandle, uint32_t stride, uint32_t offset_in)
  {
    if (bufferHandle == IndexBufferHandle::NoHandle) {
      return;
    }
    updateRenderPass();
    WGPUIndexFormat format = (stride == 2) ? WGPUIndexFormat_Uint16 : WGPUIndexFormat_Uint32;
    uint64_t offset = offset_in;
    BufferWebGPU buffer = graphicsDevice->buffers.buffers[(BufferHandle)bufferHandle.handle];
    wgpuRenderPassEncoderSetIndexBuffer(renderPassEncoder, buffer.buffer, format, offset, buffer.size);
  }
 
  void ContextWebGPU::setVertexArrayObject(VertexArrayObjectHandle /*vertexArrayObject*/)
  {
    assert(false); // TODO
  }
 
  void ContextWebGPU::setConstantBuffer(const StringView& name, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size)
  {
    setConstantBuffer(getEffects()->getConstantBufferBinding(getCurrentEffect(), name), bufferHandle, offset, size);
  }
 
  void ContextWebGPU::setConstantBuffer(const ConstantBufferBindingHandle binding, const BufferHandle handle, const uint32_t offset, const uint32_t size)
  {
    // WebGPU does not support setting invalid buffers, so we remove the binding from the descriptor. 
    // If it is needed we will detect the issue when creatng the bindgroup if the buffer is required
    if (!HandleIsValid(handle)) {
      descriptors.erase((uint32_t)binding.handle);
      return;
    }
    if (!HandleIsValid(binding)) {
      return;
    }
 
    BufferWebGPU &buffer = graphicsDevice->buffers.buffers[handle];
    WGPUBindGroupEntry bg_ent = {};
    size_t group;
    decodeConstantBufferBindingHandle(binding.handle, group, bg_ent.binding);
    assert(group == 0);
    bg_ent.buffer = buffer.buffer;
    bg_ent.offset = offset;
    bg_ent.size = (size == ~0u) ? WGPU_WHOLE_SIZE : size;
    bg_ent.sampler = nullptr;
    bg_ent.textureView = nullptr;
    descriptors[bg_ent.binding] = bg_ent;
    update_descriptors = true;
  }
 
  void ContextWebGPU::setBuffer(const StringView& name, BufferHandle bufferHandle)
  {
    auto binding = getEffects()->getBufferBinding(getCurrentEffect(), name);
    setBuffer(binding, bufferHandle);
    getEffects()->releaseBufferBinding(binding);
  }
 
  void ContextWebGPU::setBuffer(const BufferBindingHandle /*bufferBindingHandle*/, BufferHandle /*bufferHandle*/)
  {
    assert(false); // TODO
  }
 
  void ContextWebGPU::setBufferCounter(BufferHandle /*bufferHandle*/, uint32_t /*value*/)
  {
    assert(false); // TODO
  }
 
  void ContextWebGPU::setBufferCounter(BufferHandle /*bufferHandle*/, BufferHandle /*sourceBufferHandle*/)
  {
    assert(false); // TODO
  }
 
  void ContextWebGPU::getBufferCounter(BufferHandle /*bufferHandle*/, BufferHandle /*destinationBufferHandle*/)
  {
    assert(false); // TODO
  }
 
  void ContextWebGPU::draw(PrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes)
  {
    updateRenderPass();
    if (updateRenderPipeline(primitiveType)) {
      drawInstanced(primitiveType, startVertex, numVertexes, 0, 1);
    }
  }
 
  void ContextWebGPU::drawIndexed(PrimitiveType primitiveType, const size_t startIndex, const size_t numIndexes, const size_t startVertex)
  {
    updateRenderPass();
    if (updateRenderPipeline(primitiveType)) {
      wgpuRenderPassEncoderDrawIndexed(renderPassEncoder, (uint32_t)numIndexes, 1, (uint32_t)startIndex, (int32_t)startVertex, 0);
    }
  }
 
  void ContextWebGPU::drawInstanced(PrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes, const size_t startInstance, const size_t numInstances)
  {
    updateRenderPass();
    if (updateRenderPipeline(primitiveType)) {
      wgpuRenderPassEncoderDraw(renderPassEncoder, (uint32_t)numVertexes, (uint32_t)numInstances, (uint32_t)startVertex, (uint32_t)startInstance);
    }
  }
 
  void ContextWebGPU::drawInstancedIndexed(PrimitiveType primitiveType, const size_t startInstance, const size_t numInstances, const size_t startIndex, const size_t numIndexes)
  {
    updateRenderPass();
    if (updateRenderPipeline(primitiveType)) {
      wgpuRenderPassEncoderDrawIndexed(renderPassEncoder, (uint32_t)numIndexes, (uint32_t)numInstances, (uint32_t)startIndex, 0, (uint32_t)startInstance);
    }
  }
 
  void ContextWebGPU::beginRenderPassInt()
  {
    assert(renderPassEncoder == 0);
    assert(computePassEncoder == 0);
    WGPURenderPassColorAttachment color_attachment[8] = {};
    WGPURenderPassDepthStencilAttachment ds_attachment = {};
    uint32_t color_attachment_count = 0;
    uint32_t ds_attachment_count = 0;
 
    WGPULoadOp loadOp = do_clear_render_target ? WGPULoadOp_Clear : WGPULoadOp_Load;
    do_clear_render_target = false;
    WGPULoadOp depthLoadOp = do_clear_depth ? WGPULoadOp_Clear : WGPULoadOp_Load;
    do_clear_depth = false;
    const char *name = nullptr;
    if (HandleIsValid(renderTargetHandle) || HandleIsValid(depthStencilHandle)) {
      name = "Custom Render Pass";
      if(HandleIsValid(renderTargetHandle)){
        RenderTargetWebGPU &target = graphicsDevice->renderTargets.render_targets[renderTargetHandle];
        for(size_t i=0; i<target.count; i++){
          WGPURenderPassColorAttachment &att = color_attachment[i];
          att.view = target.view[i];
          att.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
          att.resolveTarget = nullptr;
          att.loadOp = loadOp;
          att.storeOp = WGPUStoreOp_Store;
          att.clearValue = clearColor[i];
        }
        color_attachment_count = target.count;
      }
      if(HandleIsValid(depthStencilHandle)){
        DepthStencilTargetWebGPU &target = graphicsDevice->renderTargets.depth_stencil_targets[depthStencilHandle];
        WGPURenderPassDepthStencilAttachment &att = ds_attachment;
        att.view = target.view;
        att.depthLoadOp = depthLoadOp;
        att.depthStoreOp = WGPUStoreOp_Store;
        att.depthClearValue = clearDepthVal;
        att.depthReadOnly = false;
        att.stencilLoadOp = WGPULoadOp_Undefined;
        att.stencilStoreOp = WGPUStoreOp_Undefined;
        att.stencilClearValue = 0;
        att.stencilReadOnly = false;
        ds_attachment_count = 1;
      }
    }
    else{
      name = "Default Render Pass";
      SwapChainWebGPU &defaultSwapChain = graphicsDevice->defaultSwapChain;
      if(defaultSwapChain.samples > 1){
        color_attachment[0].view = defaultSwapChain.colorBufferView;
        color_attachment[0].resolveTarget = defaultSwapChain.resolveView;
      }
      else{
        color_attachment[0].view = defaultSwapChain.resolveView;
      }
      color_attachment[0].depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
      color_attachment[0].loadOp = loadOp;
      color_attachment[0].storeOp = WGPUStoreOp_Store;
      color_attachment[0].clearValue = clearColor[0];
      color_attachment_count = 1;
 
      ds_attachment.view = defaultSwapChain.depthBufferView;
      ds_attachment.depthLoadOp = depthLoadOp;
      ds_attachment.depthStoreOp = WGPUStoreOp_Store;
      ds_attachment.depthClearValue = clearDepthVal;
      ds_attachment.depthReadOnly = false;
      ds_attachment.stencilLoadOp = WGPULoadOp_Undefined;
      ds_attachment.stencilStoreOp = WGPUStoreOp_Undefined;
      ds_attachment.stencilClearValue = 0;
      ds_attachment.stencilReadOnly = false;
      ds_attachment_count = 1;
    }
 
    WGPURenderPassDescriptor render_pass_desc = {};
    render_pass_desc.label = {name, WGPU_STRLEN};
    if(color_attachment_count){
      render_pass_desc.colorAttachmentCount = color_attachment_count;
      render_pass_desc.colorAttachments = color_attachment;
    }
    if(ds_attachment_count){
      render_pass_desc.depthStencilAttachment = &ds_attachment;
    }
    render_pass_desc.occlusionQuerySet = nullptr;
    // render_pass_desc.timestampWriteCount = 0;
    render_pass_desc.timestampWrites = nullptr;
    renderPassEncoder = wgpuCommandEncoderBeginRenderPass(graphicsDevice->commandEncoder, &render_pass_desc);
  }
 
  void ContextWebGPU::endRenderPassInt()
  {
    assert(!inRenderPass);
    if(!renderPassEncoder) return;
    wgpuRenderPassEncoderEnd(renderPassEncoder);
    wgpuRenderPassEncoderRelease(renderPassEncoder);
    renderPassEncoder = 0;
    update_render_target = true;
  }
 
  void ContextWebGPU::updateRenderPass()
  {
    if(update_render_target){
      endComputePass();
      endRenderPassInt();
      beginRenderPassInt();
      update_render_target = false;
    }
  }
 
  bool ContextWebGPU::updateRenderPipeline(PrimitiveType primitiveType)
  {
    assert(renderPassEncoder);
    PipelineStatesWebGPU &pipeline_states = graphicsDevice->pipeline_states;
    bool reload = false;
    if(HandleIsValid(currentRenderPipeline)){
      RenderPipelineWebGPU pipelineState = pipeline_states.renderPipeline[currentRenderPipeline];
      size_t hash = pipeline_states.renderPipelineHash(effect,
                                                       inputLayoutHandle,
                                                       primitiveType,
                                                       rasterizeStateHandle,
                                                       depthStencilStateHandle,
                                                       blendStateHandle,
                                                       renderTargetHandle,
                                                       depthStencilHandle);
      if(hash != pipelineState.hash) reload = true;
    }
    else{
      reload = true;
    }
    if(reload){
      RenderPipelineHandle pipelineStateHandle = pipeline_states.loadRenderPipeline
        (
         effect,
         inputLayoutHandle,
         primitiveType,
         rasterizeStateHandle,
         depthStencilStateHandle,
         blendStateHandle,
         renderTargetHandle,
         depthStencilHandle
         );
      RenderPipelineWebGPU pipelineState = pipeline_states.renderPipeline[pipelineStateHandle];
      currentRenderPipeline = pipelineStateHandle;
    }
    if(HandleIsValid(currentRenderPipeline)){
      RenderPipelineWebGPU &pipelineState = pipeline_states.renderPipeline[currentRenderPipeline];
      wgpuRenderPassEncoderSetPipeline(renderPassEncoder, pipelineState.pipeline);
    }
    if(update_descriptors){
      RenderPipelineWebGPU &pipelineState = pipeline_states.renderPipeline[currentRenderPipeline];
 
      std::vector<WGPUBindGroupEntry> entries;
      entries.resize(descriptors.size());
      uint32_t i=0;
      for(auto &tmp : descriptors){
        entries[i++] = tmp.second;
      }
      size_t num_bindings;
      auto bindings = getEffects()->getConstantBufferBindings(effect, num_bindings);
      
      for (size_t ii = 0; ii < num_bindings; ii++) {
        bool found = false;
        for (size_t j = 0; j < entries.size(); j++) {
          if (bindings[ii].bg_ent.binding == entries[j].binding) {
            found = true;
          }
        }
        if (!found) {
          LOG_ERROR_ONCE(logger, "binding %d in layout but not set", bindings[ii].bg_ent.binding);
          return false;
        }
      }
      for (size_t j = 0; j < entries.size(); j++) {
        bool found = false;
        for (size_t ii = 0; ii < num_bindings; ii++) {
          if (bindings[ii].bg_ent.binding == entries[j].binding) {
            found = true;
          }
        }
        if (!found) {
          LOG_ERROR_ONCE(logger, "binding %d is set but not in layout", entries[j].binding);
          return false;
        }
      }
      WGPUBindGroupDescriptor bg_desc = {};
      // char const * label;
      bg_desc.layout = pipelineState.layout;
      bg_desc.entryCount = (uint32_t)entries.size();
      bg_desc.entries = entries.data();
      current_bind_group = wgpuDeviceCreateBindGroup(graphicsDevice->device, &bg_desc);
    }
    if(current_bind_group){
      uint32_t groupIndex = 0;
      wgpuRenderPassEncoderSetBindGroup(renderPassEncoder, groupIndex, current_bind_group, 0, nullptr);
    }
    return true;
  }
 
  void ContextWebGPU::dispatchCompute(const unsigned int threadGroupsX, const unsigned int threadGroupsY, const unsigned int threadGroupsZ)
  {
    updateComputePass();
    updateComputePipeline();
    wgpuComputePassEncoderDispatchWorkgroups(computePassEncoder, threadGroupsX, threadGroupsY, threadGroupsZ);
  }
 
  void ContextWebGPU::beginComputePass()
  {
    assert(renderPassEncoder == 0);
    assert(computePassEncoder == 0);
    WGPUComputePassDescriptor compute_pass_desc = {};
    compute_pass_desc.label = {"Compute Pass", WGPU_STRLEN};
    // compute_pass_desc.timestampWriteCount = 0;
    compute_pass_desc.timestampWrites = nullptr;
    computePassEncoder = wgpuCommandEncoderBeginComputePass(graphicsDevice->commandEncoder, &compute_pass_desc);
  }
 
  void ContextWebGPU::endComputePass()
  {
    if(!computePassEncoder) return;
    wgpuComputePassEncoderEnd(computePassEncoder);
    computePassEncoder = 0;
  }
 
  void ContextWebGPU::updateComputePass()
  {
    if(!computePassEncoder){
      // endComputePass();
      endRenderPassInt();
      beginComputePass();
      update_render_target = true;
    }
  }
 
  void ContextWebGPU::updateComputePipeline()
  {
    assert(computePassEncoder);
    PipelineStatesWebGPU &pipeline_states = graphicsDevice->pipeline_states;
    bool reload = false;
    if(HandleIsValid(currentComputePipeline)){
      ComputePipelineWebGPU pipelineState = pipeline_states.computePipeline[currentComputePipeline];
      if(pipelineState.effect != effect) reload = true;
    }
    else{
      reload = true;
    }
    if(reload){
      ComputePipelineHandle pipelineStateHandle = pipeline_states.loadComputePipeline(effect);
      ComputePipelineWebGPU pipelineState = pipeline_states.computePipeline[pipelineStateHandle];
      currentComputePipeline = pipelineStateHandle;
    }
    if(HandleIsValid(currentComputePipeline)){
      ComputePipelineWebGPU &pipelineState = pipeline_states.computePipeline[currentComputePipeline];
      wgpuComputePassEncoderSetPipeline(computePassEncoder, pipelineState.pipeline);
    }
    if(update_descriptors){
      ComputePipelineWebGPU &pipelineState = pipeline_states.computePipeline[currentComputePipeline];
 
      std::vector<WGPUBindGroupEntry> entries;
      entries.resize(descriptors.size());
      uint32_t i=0;
      for(auto &tmp : descriptors){
        entries[i++] = tmp.second;
      }
 
      WGPUBindGroupDescriptor bg_desc = {};
      // char const * label;
      bg_desc.layout = pipelineState.layout;
      bg_desc.entryCount = (uint32_t)entries.size();
      bg_desc.entries = entries.data();
      current_bind_group = wgpuDeviceCreateBindGroup(graphicsDevice->device, &bg_desc);
    }
    if(current_bind_group){
      uint32_t groupIndex = 0;
      wgpuComputePassEncoderSetBindGroup(computePassEncoder, groupIndex, current_bind_group, 0, nullptr);
    }
  }
 
  void ContextWebGPU::readDepthBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer)
  {
    const WGPUCommandEncoder &commandEncoder = graphicsDevice->commandEncoder;
    TexturesWebGPU &textures = graphicsDevice->textures;
    BufferWebGPU buffer = graphicsDevice->buffers.buffers[bufferHandle];
 
    endRenderPassInt();
 
    WGPUTexelCopyTextureInfo src = {};
    if (HandleIsValid(renderTargetHandle) || HandleIsValid(depthStencilHandle)) {
      if(!HandleIsValid(depthStencilHandle)) return;
      DepthStencilTargetWebGPU &target = graphicsDevice->renderTargets.depth_stencil_targets[depthStencilHandle];
      TextureWebGPU &src_tex = textures.textures[target.textureHandle];
      src.texture = src_tex.texture;
    }
    else{
      SwapChainWebGPU &defaultSwapChain = graphicsDevice->defaultSwapChain;
      src.texture = defaultSwapChain.depthBufferTexture;
    }
    src.mipLevel = 0;
    src.origin = {(uint32_t)x, (uint32_t)y, 0};
    src.aspect = WGPUTextureAspect_DepthOnly;
    WGPUTexelCopyBufferInfo dst = {};
    dst.layout.offset = 0;
    dst.layout.bytesPerRow = (uint32_t)buffer.size;
    dst.layout.rowsPerImage = 1;
    dst.buffer = buffer.buffer;
    WGPUExtent3D size = {};
    size.width = width;
    size.height = height;
    size.depthOrArrayLayers = 1;
    wgpuCommandEncoderCopyTextureToBuffer(commandEncoder, &src, &dst, &size);
  }
 
  void ContextWebGPU::readColorBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer)
  {
    const WGPUCommandEncoder &commandEncoder = graphicsDevice->commandEncoder;
    TexturesWebGPU &textures = graphicsDevice->textures;
    BufferWebGPU buffer = graphicsDevice->buffers.buffers[bufferHandle];
 
    endRenderPassInt();
 
    WGPUTexelCopyTextureInfo src = {};
    if (HandleIsValid(renderTargetHandle) || HandleIsValid(depthStencilHandle)) {
      if(!HandleIsValid(renderTargetHandle)) return;
      RenderTargetWebGPU target = graphicsDevice->renderTargets.render_targets[renderTargetHandle];
      TextureWebGPU &src_tex = textures.textures[target.textureHandle[0]];
      src.texture = src_tex.texture;
    }
    else{
      SwapChainWebGPU &defaultSwapChain = graphicsDevice->defaultSwapChain;
#ifdef EMSCRIPTEN
      // assert(false); // TODO ...
      src.texture = defaultSwapChain.colorBufferTexture;
#else
      src.texture = defaultSwapChain.resolveTexture;
#endif
    }
    src.mipLevel = 0;
    src.origin = {(uint32_t)x, (uint32_t)y, 0};
    src.aspect = WGPUTextureAspect_All;
    WGPUTexelCopyBufferInfo dst = {};
    dst.layout.offset = 0;
    dst.layout.bytesPerRow = (uint32_t)buffer.size;
    dst.layout.rowsPerImage = 1;
    dst.buffer = buffer.buffer;
    WGPUExtent3D size = {};
    size.width = width;
    size.height = height;
    size.depthOrArrayLayers = 1;
    wgpuCommandEncoderCopyTextureToBuffer(commandEncoder, &src, &dst, &size);
  }
 
  void *ContextWebGPU::map(BufferHandle handle, MapMode::EMapMode mapMode, uint32_t* stride)
  {
    assert(stride == nullptr || stride[0] == 0);
    BufferWebGPU &buffer = graphicsDevice->buffers.buffers[handle];
    if(buffer.is_read_buffer){
      assert(mapMode == MapMode::Read);
      uint32_t offset = 0;
      WGPUBufferMapCallback callback = nullptr;
      void * userdata = nullptr;
      WGPUBufferMapCallbackInfo callbackInfo = {};
      callbackInfo.callback = callback;
      callbackInfo.mode = WGPUCallbackMode_AllowProcessEvents;
      callbackInfo.nextInChain = nullptr;
      callbackInfo.userdata1 = userdata;
      wgpuBufferMapAsync(buffer.buffer, WGPUMapMode_Read, offset, buffer.size, callbackInfo);
#ifndef EMSCRIPTEN
      WGPUBufferMapState state = wgpuBufferGetMapState(buffer.buffer);
      while(state != WGPUBufferMapState_Mapped){
        // TODO this is bad... (Redesign for callback?)
        assert(state == WGPUBufferMapState_Pending);
        wgpuInstanceProcessEvents(graphicsDevice->instance);
        wgpuDeviceTick(graphicsDevice->device);
        state = wgpuBufferGetMapState(buffer.buffer);
      }
#else
      assert(false);
#endif
      // return wgpuBufferGetMappedRange(buffer.buffer, 0, buffer.size);
      return (void*)wgpuBufferGetConstMappedRange(buffer.buffer, 0, buffer.size);
    }
    else{
      assert(mapMode == MapMode::WriteDiscard);
      buffer.NextInstance(graphicsDevice);
      buffer.map = new char[buffer.size];
      return buffer.map;
    }
  }
 
  void *ContextWebGPU::map(TextureHandle /*textureHandle*/, MapMode::EMapMode /*accessMode*/, uint32_t* /*rowPitch*/, uint32_t* /*depthPitch*/)
  {
    assert(false); // TODO
    return nullptr;
  }
 
  void ContextWebGPU::unmap(BufferHandle handle)
  {
    BufferWebGPU &buffer = graphicsDevice->buffers.buffers[handle];
    if(buffer.is_read_buffer){
      // WGPUBufferMapState state = wgpuBufferGetMapState(buffer.buffer);
      // if(state == WGPUBufferMapState_Mapped)
      wgpuBufferUnmap(buffer.buffer);
    }
    else{
      // const WGPUCommandEncoder &commandEncoder = graphicsDevice->commandEncoder;
      // wgpuCommandEncoderWriteBuffer(commandEncoder, buffer.buffer, 0, (uint8_t*)buffer.map, buffer.size);
      wgpuQueueWriteBuffer(graphicsDevice->queue, buffer.buffer, 0, buffer.map, buffer.size);
      delete [] (char*)buffer.map;
      buffer.map = nullptr;
    }
  }
 
  void ContextWebGPU::unmap(TextureHandle /*textureHandle*/)
  {
    assert(false); // TODO
  }
 
  void ContextWebGPU::updateBuffer(BufferHandle handle, const void* data, const size_t size)
  {
    BufferWebGPU &buffer = graphicsDevice->buffers.buffers[handle];
    buffer.NextInstance(graphicsDevice);
    wgpuQueueWriteBuffer(graphicsDevice->queue, buffer.buffer, 0, data, size);
  }
 
  void ContextWebGPU::updateSubTexture(TextureHandle textureHandle, const size_t level, const void* data)
  {
    assert(HandleIsValid(textureHandle) && "Texture handle is invalid.");
 
    TextureWebGPU & texture = graphicsDevice->textures.textures[textureHandle];
 
    const uint32_t width = Cogs::getMipSize(texture.width, static_cast<uint32_t>(level));
    const uint32_t height = Cogs::getMipSize(texture.height, static_cast<uint32_t>(level));
 
    WGPUTexelCopyTextureInfo destinationTexture;
    destinationTexture.texture = texture.texture;
    destinationTexture.mipLevel = static_cast<uint32_t>(level);
    destinationTexture.aspect = WGPUTextureAspect_All;
    destinationTexture.origin = { 0, 0, 0 };
 
    const Cogs::FormatInfo *textureFormat = Cogs::getFormatInfo(texture.format);
 
    WGPUTexelCopyBufferLayout sourceLayout;
    sourceLayout.offset = 0;
    sourceLayout.bytesPerRow = textureFormat->blockSize * ((width + textureFormat->blockExtent.width - 1) / textureFormat->blockExtent.width);
    sourceLayout.rowsPerImage = (height + textureFormat->blockExtent.height - 1) / textureFormat->blockExtent.height;
 
    size_t size = sourceLayout.bytesPerRow * sourceLayout.rowsPerImage;
 
    WGPUExtent3D extent;
    extent.width = width;
    extent.height = height;
    extent.depthOrArrayLayers = 1;
 
    wgpuQueueWriteTexture(graphicsDevice->queue, &destinationTexture, data, static_cast<size_t>(size), &sourceLayout, &extent);
  }
 
  void ContextWebGPU::updateSubBuffer(BufferHandle handle, const size_t offset, const size_t size, const void* data)
  {
    BufferWebGPU &buffer = graphicsDevice->buffers.buffers[handle];
    assert(buffer.alias_idx == 0); // TODO Copy over alias buffer data...
    buffer.alias_idx++;
    wgpuQueueWriteBuffer(graphicsDevice->queue, buffer.buffer, offset, data, size);
  }
 
  void ContextWebGPU::resolveResource(TextureHandle /*source*/, TextureHandle /*destination*/)
  {
    assert(false); // TODO
  }
 
  void ContextWebGPU::copyResource(BufferHandle /*destinationHandle*/, BufferHandle /*sourceHandle*/)
  {
    assert(false); // TODO
  }
 
  void ContextWebGPU::copyResource(TextureHandle /*destinationHandle*/, TextureHandle /*sourceHandle*/)
  {
    assert(false); // TODO
  }
 
  void ContextWebGPU::copyTexture(TextureHandle dstHandle, unsigned dstSub, unsigned dstX, unsigned dstY, unsigned dstZ, TextureHandle srcHandle, unsigned srcSub)
  {
    graphicsDevice->maybeCreateUploadCommandEncoder();
    const WGPUCommandEncoder &commandEncoder = graphicsDevice->commandEncoder;
    TexturesWebGPU &textures = graphicsDevice->textures;
 
    TextureWebGPU &src = textures.textures[srcHandle];
    TextureWebGPU &dst = textures.textures[dstHandle];
 
    uint32_t srcLevel = 0;      // TODO srcSub%LevelCount
    uint32_t srcLayer = srcSub; // TODO srcSub/LevelCount
 
    WGPUTexelCopyTextureInfo copy_src = {};
    copy_src.texture = src.texture;
    copy_src.mipLevel = srcLevel;
    copy_src.origin = {0, 0, srcLayer};
    copy_src.aspect = WGPUTextureAspect_All;
 
    uint32_t dstLevel = 0;      // TODO dstSub%LevelCount
    uint32_t dstLayer = dstSub; // TODO dstSub/LevelCount
 
    WGPUTexelCopyTextureInfo copy_dst = {};
    copy_dst.texture = dst.texture;
    copy_dst.mipLevel = dstLevel;
    copy_dst.origin = {dstX, dstY, dstZ+dstLayer};
    copy_dst.aspect = WGPUTextureAspect_All;
 
    WGPUExtent3D size = {};
    size.width = src.width;
    size.height = src.height;
    size.depthOrArrayLayers = 1;
    wgpuCommandEncoderCopyTextureToTexture(commandEncoder, &copy_src, &copy_dst, &size);
  }
 
  void ContextWebGPU::clearResource(BufferHandle /*destinationHandle*/, uint32_t* /*values*/)
  {
    assert(false); // TODO
  }
 
  void ContextWebGPU::clearResource(BufferHandle /*destinationHandle*/, float* /*values*/)
  {
    assert(false); // TODO
  }
 
  EffectHandle ContextWebGPU::getCurrentEffect()
  {
    return effect;
  }
 
  EffectsWebGPU *ContextWebGPU::getEffects()
  {
    return &graphicsDevice->effects;
  }
 
}