mirror of
https://github.com/thorvg/thorvg.git
synced 2025-06-13 11:36:25 +00:00
47b9866f8b
it provide changes public API for webgpu canvas interface to provide nessessary handles to native window for different platforms: API Change: - Result target(void *instance, void *surface, uint32_t w, uint32_t h) noexcept;
672 lines
19 KiB
C++
672 lines
19 KiB
C++
/*
|
|
* Copyright (c) 2023 - 2024 the ThorVG project. All rights reserved.
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#include "tvgWgBindGroups.h"
|
|
|
|
// canvas information group
|
|
WGPUBindGroupLayout WgBindGroupCanvas::layout = nullptr;
|
|
// paint object information group
|
|
WGPUBindGroupLayout WgBindGroupPaint::layout = nullptr;
|
|
// fill properties information groups
|
|
WGPUBindGroupLayout WgBindGroupSolidColor::layout = nullptr;
|
|
WGPUBindGroupLayout WgBindGroupLinearGradient::layout = nullptr;
|
|
WGPUBindGroupLayout WgBindGroupRadialGradient::layout = nullptr;
|
|
WGPUBindGroupLayout WgBindGroupPicture::layout = nullptr;
|
|
// composition and blending properties gropus
|
|
WGPUBindGroupLayout WgBindGroupTexture::layout = nullptr;
|
|
WGPUBindGroupLayout WgBindGroupTextureStorageRgba::layout = nullptr;
|
|
WGPUBindGroupLayout WgBindGroupTextureStorageBgra::layout = nullptr;
|
|
WGPUBindGroupLayout WgBindGroupTextureSampled::layout = nullptr;
|
|
WGPUBindGroupLayout WgBindGroupTexComposeBlend::layout = nullptr;
|
|
WGPUBindGroupLayout WgBindGroupOpacity::layout = nullptr;
|
|
WGPUBindGroupLayout WgBindGroupBlendMethod::layout = nullptr;
|
|
WGPUBindGroupLayout WgBindGroupCompositeMethod::layout = nullptr;
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupCanvas::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryBuffer(0)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 1);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupCanvas::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupCanvas::initialize(WGPUDevice device, WGPUQueue queue, WgShaderTypeMat4x4f& uViewMat)
|
|
{
|
|
release();
|
|
uBufferViewMat = createBuffer(device, queue, &uViewMat, sizeof(uViewMat));
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryBuffer(0, uBufferViewMat)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 1);
|
|
assert(mBindGroup);
|
|
}
|
|
|
|
|
|
void WgBindGroupCanvas::release()
|
|
{
|
|
releaseBindGroup(mBindGroup);
|
|
releaseBuffer(uBufferViewMat);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupPaint::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryBuffer(0),
|
|
makeBindGroupLayoutEntryBuffer(1)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 2);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupPaint::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupPaint::initialize(WGPUDevice device, WGPUQueue queue, WgShaderTypeMat4x4f& uModelMat, WgShaderTypeBlendSettings& uBlendSettings)
|
|
{
|
|
if (!uBufferModelMat && !uBufferBlendSettings && !mBindGroup) {
|
|
uBufferModelMat = createBuffer(device, queue, &uModelMat, sizeof(uModelMat));
|
|
uBufferBlendSettings = createBuffer(device, queue, &uBlendSettings, sizeof(uBlendSettings));
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryBuffer(0, uBufferModelMat),
|
|
makeBindGroupEntryBuffer(1, uBufferBlendSettings)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 2);
|
|
assert(mBindGroup);
|
|
return;
|
|
}
|
|
wgpuQueueWriteBuffer(queue, uBufferModelMat, 0, &uModelMat, sizeof(uModelMat));
|
|
wgpuQueueWriteBuffer(queue, uBufferBlendSettings, 0, &uBlendSettings, sizeof(uBlendSettings));
|
|
}
|
|
|
|
|
|
void WgBindGroupPaint::release()
|
|
{
|
|
releaseBindGroup(mBindGroup);
|
|
releaseBuffer(uBufferBlendSettings);
|
|
releaseBuffer(uBufferModelMat);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupSolidColor::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryBuffer(0)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 1);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupSolidColor::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupSolidColor::initialize(WGPUDevice device, WGPUQueue queue, WgShaderTypeSolidColor &uSolidColor)
|
|
{
|
|
if (!uBufferSolidColor && !mBindGroup) {
|
|
uBufferSolidColor = createBuffer(device, queue, &uSolidColor, sizeof(uSolidColor));
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryBuffer(0, uBufferSolidColor)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 1);
|
|
assert(mBindGroup);
|
|
return;
|
|
}
|
|
wgpuQueueWriteBuffer(queue, uBufferSolidColor, 0, &uSolidColor, sizeof(uSolidColor));
|
|
}
|
|
|
|
|
|
void WgBindGroupSolidColor::release()
|
|
{
|
|
releaseBindGroup(mBindGroup);
|
|
releaseBuffer(uBufferSolidColor);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupLinearGradient::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryBuffer(0)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 1);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupLinearGradient::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupLinearGradient::initialize(WGPUDevice device, WGPUQueue queue, WgShaderTypeLinearGradient &uLinearGradient)
|
|
{
|
|
if (!uBufferLinearGradient && !mBindGroup) {
|
|
uBufferLinearGradient = createBuffer(device, queue, &uLinearGradient, sizeof(uLinearGradient));
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryBuffer(0, uBufferLinearGradient)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 1);
|
|
assert(mBindGroup);
|
|
return;
|
|
}
|
|
wgpuQueueWriteBuffer(queue, uBufferLinearGradient, 0, &uLinearGradient, sizeof(uLinearGradient));
|
|
}
|
|
|
|
|
|
void WgBindGroupLinearGradient::release()
|
|
{
|
|
releaseBindGroup(mBindGroup);
|
|
releaseBuffer(uBufferLinearGradient);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupRadialGradient::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryBuffer(0)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 1);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupRadialGradient::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupRadialGradient::initialize(WGPUDevice device, WGPUQueue queue, WgShaderTypeRadialGradient &uRadialGradient)
|
|
{
|
|
if (!uBufferRadialGradient && !mBindGroup) {
|
|
uBufferRadialGradient = createBuffer(device, queue, &uRadialGradient, sizeof(uRadialGradient));
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryBuffer(0, uBufferRadialGradient)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 1);
|
|
assert(mBindGroup);
|
|
return;
|
|
}
|
|
wgpuQueueWriteBuffer(queue, uBufferRadialGradient, 0, &uRadialGradient, sizeof(uRadialGradient));
|
|
}
|
|
|
|
|
|
void WgBindGroupRadialGradient::release()
|
|
{
|
|
releaseBuffer(uBufferRadialGradient);
|
|
releaseBindGroup(mBindGroup);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupPicture::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntrySampler(0),
|
|
makeBindGroupLayoutEntryTexture(1)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 2);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupPicture::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupPicture::initialize(WGPUDevice device, WGPUQueue queue, WGPUSampler uSampler, WGPUTextureView uTextureView)
|
|
{
|
|
release();
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntrySampler(0, uSampler),
|
|
makeBindGroupEntryTextureView(1, uTextureView)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 2);
|
|
assert(mBindGroup);
|
|
}
|
|
|
|
|
|
void WgBindGroupPicture::release()
|
|
{
|
|
releaseBindGroup(mBindGroup);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupTexture::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryTexture(0)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 1);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupTexture::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupTexture::initialize(WGPUDevice device, WGPUQueue queue, WGPUTextureView uTexture)
|
|
{
|
|
release();
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryTextureView(0, uTexture)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 1);
|
|
assert(mBindGroup);
|
|
}
|
|
|
|
|
|
void WgBindGroupTexture::release()
|
|
{
|
|
releaseBindGroup(mBindGroup);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupTextureStorageRgba::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryStorage(0, WGPUStorageTextureAccess_ReadWrite, WGPUTextureFormat_RGBA8Unorm)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 1);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupTextureStorageRgba::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupTextureStorageRgba::initialize(WGPUDevice device, WGPUQueue queue, WGPUTextureView uTexture)
|
|
{
|
|
release();
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryTextureView(0, uTexture)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 1);
|
|
assert(mBindGroup);
|
|
}
|
|
|
|
|
|
void WgBindGroupTextureStorageRgba::release()
|
|
{
|
|
releaseBindGroup(mBindGroup);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupTextureStorageBgra::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryStorage(0, WGPUStorageTextureAccess_WriteOnly, WGPUTextureFormat_BGRA8Unorm)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 1);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupTextureStorageBgra::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupTextureStorageBgra::initialize(WGPUDevice device, WGPUQueue queue, WGPUTextureView uTexture)
|
|
{
|
|
release();
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryTextureView(0, uTexture)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 1);
|
|
assert(mBindGroup);
|
|
}
|
|
|
|
|
|
void WgBindGroupTextureStorageBgra::release()
|
|
{
|
|
releaseBindGroup(mBindGroup);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupTextureSampled::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntrySampler(0),
|
|
makeBindGroupLayoutEntryTexture(1)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 2);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupTextureSampled::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupTextureSampled::initialize(WGPUDevice device, WGPUQueue queue, WGPUSampler uSampler, WGPUTextureView uTexture)
|
|
{
|
|
release();
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntrySampler(0, uSampler),
|
|
makeBindGroupEntryTextureView(1, uTexture)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 2);
|
|
assert(mBindGroup);
|
|
}
|
|
|
|
|
|
void WgBindGroupTextureSampled::release()
|
|
{
|
|
releaseBindGroup(mBindGroup);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupTexComposeBlend::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryStorage(0, WGPUStorageTextureAccess_ReadOnly, WGPUTextureFormat_RGBA8Unorm),
|
|
makeBindGroupLayoutEntryStorage(1, WGPUStorageTextureAccess_ReadOnly, WGPUTextureFormat_RGBA8Unorm),
|
|
makeBindGroupLayoutEntryStorage(2, WGPUStorageTextureAccess_ReadWrite, WGPUTextureFormat_RGBA8Unorm)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 3);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupTexComposeBlend::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupTexComposeBlend::initialize(WGPUDevice device, WGPUQueue queue, WGPUTextureView uTexSrc, WGPUTextureView uTexMsk, WGPUTextureView uTexDst)
|
|
{
|
|
release();
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryTextureView(0, uTexSrc),
|
|
makeBindGroupEntryTextureView(1, uTexMsk),
|
|
makeBindGroupEntryTextureView(2, uTexDst)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 3);
|
|
assert(mBindGroup);
|
|
}
|
|
|
|
|
|
void WgBindGroupTexComposeBlend::release()
|
|
{
|
|
releaseBindGroup(mBindGroup);
|
|
}
|
|
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupOpacity::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryBuffer(0)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 1);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupOpacity::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupOpacity::initialize(WGPUDevice device, WGPUQueue queue, uint32_t uOpacity)
|
|
{
|
|
release();
|
|
float opacity = uOpacity / 255.0f;
|
|
uBufferOpacity = createBuffer(device, queue, &opacity, sizeof(float));
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryBuffer(0, uBufferOpacity)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 1);
|
|
assert(mBindGroup);
|
|
}
|
|
|
|
|
|
void WgBindGroupOpacity::release()
|
|
{
|
|
releaseBuffer(uBufferOpacity);
|
|
releaseBindGroup(mBindGroup);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupBlendMethod::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryBuffer(0)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 1);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupBlendMethod::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupBlendMethod::initialize(WGPUDevice device, WGPUQueue queue, BlendMethod uBlendMethod)
|
|
{
|
|
release();
|
|
uint32_t blendMethod = (uint32_t)uBlendMethod;
|
|
uBufferBlendMethod = createBuffer(device, queue, &blendMethod, sizeof(blendMethod));
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryBuffer(0, uBufferBlendMethod)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 1);
|
|
assert(mBindGroup);
|
|
}
|
|
|
|
|
|
void WgBindGroupBlendMethod::release()
|
|
{
|
|
releaseBuffer(uBufferBlendMethod);
|
|
releaseBindGroup(mBindGroup);
|
|
}
|
|
|
|
|
|
WGPUBindGroupLayout WgBindGroupCompositeMethod::getLayout(WGPUDevice device)
|
|
{
|
|
if (layout) return layout;
|
|
const WGPUBindGroupLayoutEntry bindGroupLayoutEntries[] {
|
|
makeBindGroupLayoutEntryBuffer(0)
|
|
};
|
|
layout = createBindGroupLayout(device, bindGroupLayoutEntries, 1);
|
|
assert(layout);
|
|
return layout;
|
|
}
|
|
|
|
|
|
void WgBindGroupCompositeMethod::releaseLayout()
|
|
{
|
|
releaseBindGroupLayout(layout);
|
|
}
|
|
|
|
|
|
void WgBindGroupCompositeMethod::initialize(WGPUDevice device, WGPUQueue queue, CompositeMethod uCompositeMethod)
|
|
{
|
|
release();
|
|
uint32_t compositeMethod = (uint32_t)uCompositeMethod;
|
|
uBufferCompositeMethod = createBuffer(device, queue, &compositeMethod, sizeof(compositeMethod));
|
|
const WGPUBindGroupEntry bindGroupEntries[] {
|
|
makeBindGroupEntryBuffer(0, uBufferCompositeMethod)
|
|
};
|
|
mBindGroup = createBindGroup(device, getLayout(device), bindGroupEntries, 1);
|
|
assert(mBindGroup);
|
|
}
|
|
|
|
|
|
void WgBindGroupCompositeMethod::release()
|
|
{
|
|
releaseBuffer(uBufferCompositeMethod);
|
|
releaseBindGroup(mBindGroup);
|
|
}
|
|
|
|
//************************************************************************
|
|
// bind group pools
|
|
//************************************************************************
|
|
|
|
void WgBindGroupOpacityPool::initialize(WgContext& context)
|
|
{
|
|
release(context);
|
|
for (uint32_t opacity = 0; opacity < 256; opacity++) {
|
|
mPool[opacity] = new WgBindGroupOpacity;
|
|
mPool[opacity]->initialize(context.device, context.queue, opacity);
|
|
}
|
|
}
|
|
|
|
|
|
void WgBindGroupOpacityPool::release(WgContext& context)
|
|
{
|
|
for (uint32_t i = 0; i < 256; i++) {
|
|
if (mPool[i]) {
|
|
mPool[i]->release();
|
|
delete mPool[i];
|
|
mPool[i] = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
WgBindGroupOpacity* WgBindGroupOpacityPool::allocate(WgContext& context, uint8_t opacity)
|
|
{
|
|
return mPool[opacity];
|
|
}
|
|
|
|
|
|
void WgBindGroupBlendMethodPool::initialize(WgContext& context)
|
|
{
|
|
release(context);
|
|
for (uint8_t blendMethod = (uint8_t)BlendMethod::Normal;
|
|
blendMethod <= (uint8_t)BlendMethod::SoftLight;
|
|
blendMethod++) {
|
|
mPool[blendMethod] = new WgBindGroupBlendMethod;
|
|
mPool[blendMethod]->initialize(context.device, context.queue, (BlendMethod)blendMethod);
|
|
}
|
|
}
|
|
|
|
|
|
void WgBindGroupBlendMethodPool::release(WgContext& context)
|
|
{
|
|
for (uint8_t blendMethod = (uint8_t)BlendMethod::Normal;
|
|
blendMethod <= (uint8_t)BlendMethod::SoftLight;
|
|
blendMethod++) {
|
|
if (mPool[blendMethod]) {
|
|
mPool[blendMethod]->release();
|
|
delete mPool[blendMethod];
|
|
mPool[blendMethod] = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
WgBindGroupBlendMethod* WgBindGroupBlendMethodPool::allocate(WgContext& context, BlendMethod blendMethod)
|
|
{
|
|
return mPool[(uint8_t)blendMethod];
|
|
}
|
|
|
|
|
|
void WgBindGroupCompositeMethodPool::initialize(WgContext& context)
|
|
{
|
|
release(context);
|
|
for (uint8_t composeMethos = (uint8_t)CompositeMethod::None;
|
|
composeMethos <= (uint8_t)CompositeMethod::DifferenceMask;
|
|
composeMethos++) {
|
|
mPool[composeMethos] = new WgBindGroupCompositeMethod;
|
|
mPool[composeMethos]->initialize(context.device, context.queue, (CompositeMethod)composeMethos);
|
|
}
|
|
}
|
|
|
|
|
|
void WgBindGroupCompositeMethodPool::release(WgContext& context)
|
|
{
|
|
for (uint8_t blendMethod = (uint8_t)CompositeMethod::None;
|
|
blendMethod <= (uint8_t)CompositeMethod::DifferenceMask;
|
|
blendMethod++) {
|
|
if (mPool[blendMethod]) {
|
|
mPool[blendMethod]->release();
|
|
delete mPool[blendMethod];
|
|
mPool[blendMethod] = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
WgBindGroupCompositeMethod* WgBindGroupCompositeMethodPool::allocate(WgContext& context, CompositeMethod composeMethod)
|
|
{
|
|
return mPool[(uint8_t)composeMethod];
|
|
}
|