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");
 
    void context_error_callback(WGPUPopErrorScopeStatus status, WGPUErrorType type, WGPUStringView message, void* userdata1, void* userdata2)
  {
    Cogs::ContextWebGPU *context = (Cogs::ContextWebGPU*)userdata1;
    (void)context;
    Cogs::GraphicsDeviceWebGPU *ptr = (Cogs::GraphicsDeviceWebGPU*)userdata2;
    (void)ptr;
    if(status == WGPUPopErrorScopeStatus_CallbackCancelled){
      LOG_ERROR(logger, "WebGPU context err status: Cancelled");
    }
    if(status == WGPUPopErrorScopeStatus_Error){
      LOG_ERROR(logger, "WebGPU context err status: Error");
    }
    if(message.data && message.length){
      LOG_ERROR(logger, "WebGPU context err (%d) %.*s", type, WGPUStringViewFormat(message));
    }
  }
 
  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::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] = WGPU_COLOR_INIT;
    }
    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::pushCommandGroupAnnotation(const StringView & name)
  {
    (void)name;
 
    // TODO: This seems to become messed up when changing render passes, etc
 
    // WGPUStringView label = {name.data(), name.length()};
    // if(renderPassEncoder != 0){
    //   wgpuRenderPassEncoderPushDebugGroup(renderPassEncoder, label);
    //   annotation_type.push_back(ANNOTATION_TYPE_RENDER_PASS);
    // }
    // else if(computePassEncoder != 0){
    //   wgpuComputePassEncoderPushDebugGroup(computePassEncoder, label);
    //   annotation_type.push_back(ANNOTATION_TYPE_COMPUTE_PASS);
    // }
    // // else if(renderBundleEncoder != 0){
    // //   annotation_type.push_back(ANNOTATION_TYPE_RENDER_BUNDLE);
    // //   wgpuRenderBundleEncoderPushDebugGroup(renderBundleEncoder, label);
    // // }
    // else{
    //   wgpuCommandEncoderPushDebugGroup(graphicsDevice->commandEncoder, label);
    //   annotation_type.push_back(ANNOTATION_TYPE_COMMAND_ENCODER);
    // }
  }
 
  void ContextWebGPU::popCommandGroupAnnotation()
  {
    // assert(annotation_type.size());
    // WGPUAnnotationType type = annotation_type.back();
    // annotation_type.pop_back();
    // if(type == ANNOTATION_TYPE_RENDER_PASS){
    //   assert(renderPassEncoder != 0);
    //   wgpuRenderPassEncoderPopDebugGroup(renderPassEncoder);
    // }
    // else if(type == ANNOTATION_TYPE_COMPUTE_PASS){
    //   assert(computePassEncoder != 0);
    //   wgpuComputePassEncoderPopDebugGroup(computePassEncoder);
    // }
    // // else if(type == ANNOTATION_TYPE_RENDER_BUNDLE){
    // //   assert(renderBundleEncoder != 0);
    // //   wgpuRenderBundleEncoderPopDebugGroup(renderBundleEncoder);
    // // }
    // else{
    //   assert(type == ANNOTATION_TYPE_COMMAND_ENCODER);
    //   wgpuCommandEncoderPopDebugGroup(graphicsDevice->commandEncoder);
    // }
  }
 
  void ContextWebGPU::setAnnotationMarker(const StringView & name)
  {
    WGPUStringView label = {name.data(), name.length()};
    if(renderPassEncoder != 0){
      wgpuRenderPassEncoderInsertDebugMarker(renderPassEncoder, label);
    }
    else if(computePassEncoder != 0){
      wgpuComputePassEncoderInsertDebugMarker(computePassEncoder, label);
    }
    // else if(renderBundleEncoder != 0){
    //   wgpuRenderBundleEncoderInsertDebugMarker(renderBundleEncoder, label);
    // }
    else{
      wgpuCommandEncoderInsertDebugMarker(graphicsDevice->commandEncoder, label);
    }
  }
 
  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] = {}; // WGPU_RENDER_PASS_COLOR_ATTACHMENT_INIT
    WGPURenderPassDepthStencilAttachment ds_attachment = WGPU_RENDER_PASS_DEPTH_STENCIL_ATTACHMENT_INIT;
    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;
    }
 
    if(graphicsDevice->use_error_scope){
      wgpuDevicePushErrorScope(graphicsDevice->device, graphicsDevice->filter);
    }
 
    WGPURenderPassDescriptor render_pass_desc = WGPU_RENDER_PASS_DESCRIPTOR_INIT;
    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;
 
    if(graphicsDevice->use_error_scope){
      WGPUPopErrorScopeCallbackInfo info = WGPU_POP_ERROR_SCOPE_CALLBACK_INFO_INIT;
      info.mode = WGPUCallbackMode_AllowSpontaneous;
      info.callback = context_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);
    }
  }
 
  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 = WGPU_BIND_GROUP_ENTRY_INIT;
    size_t group = ~(size_t)0;
    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 = WGPU_BIND_GROUP_ENTRY_INIT;
    size_t group = ~(size_t)0;
    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 = WGPU_BIND_GROUP_ENTRY_INIT;
    size_t group = ~(size_t)0;
    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;
    currentIndexFormat = format;
    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 = WGPU_BIND_GROUP_ENTRY_INIT;
    size_t group = ~(size_t)0;
    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)
  {
    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);
      if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numIndexes, true); }
    }
    else{
      LOG_ERROR_ONCE(logger, "skip drawIndexed(), updateRenderPipeline failed.");
    }
  }
 
  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);
      if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numVertexes*numInstances, false); }
    }
    else{
      LOG_ERROR_ONCE(logger, "skip draw()/drawInstanced(), updateRenderPipeline failed.");
    }
  }
 
  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);
      if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numIndexes*numInstances, true); }
    }
    else{
      LOG_ERROR_ONCE(logger, "skip drawInstancedIndexed(), updateRenderPipeline failed.");
    }
  }
 
  void ContextWebGPU::beginRenderPassInt()
  {
    assert(renderPassEncoder == 0);
    assert(computePassEncoder == 0);
    WGPURenderPassColorAttachment color_attachment[8] = {}; // WGPU_RENDER_PASS_COLOR_ATTACHMENT_INIT
    WGPURenderPassDepthStencilAttachment ds_attachment = WGPU_RENDER_PASS_DEPTH_STENCIL_ATTACHMENT_INIT;
    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;
    }
 
    if(graphicsDevice->use_error_scope){
      wgpuDevicePushErrorScope(graphicsDevice->device, graphicsDevice->filter);
    }
 
    WGPURenderPassDescriptor render_pass_desc = WGPU_RENDER_PASS_DESCRIPTOR_INIT;
    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;
    current_bind_group = {};
    update_descriptors = true;
 
    if(graphicsDevice->use_error_scope){
      WGPUPopErrorScopeCallbackInfo info = WGPU_POP_ERROR_SCOPE_CALLBACK_INFO_INIT;
      info.mode = WGPUCallbackMode_AllowSpontaneous;
      info.callback = context_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);
    }
  }
 
  void ContextWebGPU::updateRenderPass()
  {
    if(update_render_target){
      endComputePass();
      endRenderPassInt();
      beginRenderPassInt();
      update_render_target = false;
    }
  }
 
  bool ContextWebGPU::updateRenderPipeline(PrimitiveType primitiveType)
  {
    assert(renderPassEncoder);
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
    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,
                                                       currentIndexFormat);
      if(hash != pipelineState.hash) reload = true;
    }
    else{
      reload = true;
    }
    if(reload){
      RenderPipelineHandle pipelineStateHandle = pipeline_states.loadRenderPipeline
        (
         effect,
         inputLayoutHandle,
         primitiveType,
         rasterizeStateHandle,
         depthStencilStateHandle,
         blendStateHandle,
         renderTargetHandle,
         depthStencilHandle,
         currentIndexFormat
         );
      RenderPipelineWebGPU pipelineState = pipeline_states.renderPipeline[pipelineStateHandle];
      currentRenderPipeline = pipelineStateHandle;
    }
    if(HandleIsValid(currentRenderPipeline)){
      RenderPipelineWebGPU &pipelineState = pipeline_states.renderPipeline[currentRenderPipeline];
      wgpuRenderPassEncoderSetPipeline(renderPassEncoder, pipelineState.pipeline);
    }
    if(update_descriptors){
      update_descriptors = false;
      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;
      }
      descriptor_count += (uint32_t)descriptors.size();
      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 (%s)", bindings[ii].bg_ent.binding, bindings[ii].name.c_str());
          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 = WGPU_BIND_GROUP_DESCRIPTOR_INIT;
      // char const * label;
      bg_desc.layout = pipelineState.bind_group_layout;
      bg_desc.entryCount = (uint32_t)entries.size();
      bg_desc.entries = entries.data();
      current_bind_group = wgpuDeviceCreateBindGroup(graphicsDevice->device, &bg_desc);
      bind_groups.push_back(current_bind_group);
      counters.bind_group++;
    }
    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 = WGPU_COMPUTE_PASS_DESCRIPTOR_INIT;
    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);
    wgpuComputePassEncoderRelease(computePassEncoder);
    computePassEncoder = 0;
  }
 
  void ContextWebGPU::updateComputePass()
  {
    if(!computePassEncoder){
      endRenderPassInt();
      beginComputePass();
      update_render_target = true;
    }
  }
 
  void ContextWebGPU::updateComputePipeline()
  {
    assert(computePassEncoder);
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
    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){
      update_descriptors = false;
      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;
      }
      descriptor_count += (uint32_t)descriptors.size();
 
      WGPUBindGroupDescriptor bg_desc = WGPU_BIND_GROUP_DESCRIPTOR_INIT;
      // 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);
      bind_groups.push_back(current_bind_group);
      counters.bind_group++;
    }
    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 = WGPU_TEXEL_COPY_TEXTURE_INFO_INIT;
    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 = WGPU_TEXEL_COPY_BUFFER_INFO_INIT;
    dst.layout.offset = 0;
    dst.layout.bytesPerRow = (uint32_t)buffer.size;
    dst.layout.rowsPerImage = 1;
    dst.buffer = buffer.buffer;
    WGPUExtent3D size = WGPU_EXTENT_3D_INIT;
    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 = WGPU_TEXEL_COPY_TEXTURE_INFO_INIT;
    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 = WGPU_TEXEL_COPY_BUFFER_INFO_INIT;
    dst.layout.offset = 0;
    dst.layout.bytesPerRow = (uint32_t)buffer.size;
    dst.layout.rowsPerImage = 1;
    dst.buffer = buffer.buffer;
    WGPUExtent3D size = WGPU_EXTENT_3D_INIT;
    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 = WGPU_BUFFER_MAP_CALLBACK_INFO_INIT;
      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 (void*)wgpuBufferGetConstMappedRange(buffer.buffer, 0, buffer.size);
    }
    else{
      assert(mapMode == MapMode::WriteDiscard);
      buffer.NextInstance(graphicsDevice, graphicsDevice->buffers);
      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{
      if(buffer.size > 0){
        wgpuQueueWriteBuffer(graphicsDevice->queue, buffer.buffer, 0, buffer.map, buffer.size);
        if(uploadStatisticsEnabled) uploadStatisticsBufferUpload(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];
    assert(!buffer.is_read_buffer);
    if(size == 0) return;
    if(size > buffer.size){
      LOG_ERROR(logger, "updateBuffer: write size (%zu) exceeds buffer size (%zu)", size, buffer.size);
      return;
    }
    buffer.NextInstance(graphicsDevice, graphicsDevice->buffers);
    wgpuQueueWriteBuffer(graphicsDevice->queue, buffer.buffer, 0, data, size);
    if(uploadStatisticsEnabled) uploadStatisticsBufferUpload(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);
 
    if(uploadStatisticsEnabled) uploadStatisticsTextureUpload(texture.estimatedByteSize); // TODO size?
  }
 
  void ContextWebGPU::updateSubBuffer(BufferHandle handle, const size_t offset, const size_t size, const void* data)
  {
    BufferWebGPU &buffer = graphicsDevice->buffers.buffers[handle];
    if(size == 0) return;
    assert(!buffer.is_read_buffer);
    if(offset + size > buffer.size){
      LOG_ERROR(logger, "updateSubBuffer: write range (offset: %zu, size: %zu) exceeds buffer size (%zu)", offset, size, buffer.size);
      return;
    }
    assert(buffer.alias_idx == 0); // TODO Copy over alias buffer data...
    buffer.alias_idx++;
    wgpuQueueWriteBuffer(graphicsDevice->queue, buffer.buffer, offset, data, size);
    if(uploadStatisticsEnabled) uploadStatisticsBufferUpload(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 = WGPU_TEXEL_COPY_TEXTURE_INFO_INIT;
    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 = WGPU_TEXEL_COPY_TEXTURE_INFO_INIT;
    copy_dst.texture = dst.texture;
    copy_dst.mipLevel = dstLevel;
    copy_dst.origin = {dstX, dstY, dstZ+dstLayer};
    copy_dst.aspect = WGPUTextureAspect_All;
 
    WGPUExtent3D size = WGPU_EXTENT_3D_INIT;
    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
  }
 
  void ContextWebGPU::beginFrame() {
    prevStats = currStats;
    currStats = FrameStatistics{};
 
    prevUploadStats = currUploadStats;
    currUploadStats = UploadStatistics{};
  }
 
  void ContextWebGPU::frameStatisticsAccountDrawCall(size_t count, bool indexed)
  {
    // bucket is position of most significant bit, zero is zero.
    unsigned bucket = 0;
    size_t t = count;
    if ((t & 0xFFFF0000) != 0) { bucket += 16; t = t >> 16u; }
    if ((t & 0x0000FF00) != 0) { bucket += 8; t = t >> 8u; }
    if ((t & 0x000000F0) != 0) { bucket += 4; t = t >> 4u; }
    if ((t & 0x0000000C) != 0) { bucket += 2; t = t >> 2u; }
    if ((t & 0x00000002) != 0) { bucket += 1; }
 
#ifdef _DEBUG
    assert(uint64_t(count) < (uint64_t(1) << (bucket + 1)));
    if (count) {
      assert((uint64_t(1) << bucket) <= uint64_t(count));
    }
    else {
      assert(bucket == 0);
    }
#endif
 
    currStats.drawCallHistogram[bucket]++;
    currStats.vertices += count;
    if (indexed) currStats.indices += count;
  }
 
  void ContextWebGPU::uploadStatisticsBufferUpload(size_t size)
  {
    currUploadStats.bufferUploads++;
    currUploadStats.bufferUploadSize += size;
  }
 
  void ContextWebGPU::uploadStatisticsTextureUpload(size_t size)
  {
    currUploadStats.textureUploads++;
    currUploadStats.textureUploadSize += size;
  }
 
  EffectHandle ContextWebGPU::getCurrentEffect()
  {
    return effect;
  }
 
  EffectsWebGPU *ContextWebGPU::getEffects()
  {
    return &graphicsDevice->effects;
  }
 
  void ContextWebGPU::ClearBindGroups()
  {
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
    for(auto &bg : last_bind_groups){
      wgpuBindGroupRelease(bg);
      counters.bind_group--;
    }
    last_bind_groups.clear();
    current_bind_group = {};
    update_descriptors = true;
 
    counters.descriptor_count = descriptor_count;
    descriptor_count = 0;
  }
  void ContextWebGPU::SwapBindGroups()
  {
    last_bind_groups = std::move(bind_groups);
  }
}