git_clone/thorvg
1
0
Fork 0
mirror of https://github.com/thorvg/thorvg.git synced 2025-06-14 12:04:29 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

wg_engine: animation optimizations (part 1)

Browse source 
[issues 1479: update](#1479)

gpu vertex buffer reallocations optimization
This commit is contained in:
Sergii Liebodkin 2024-02-14 15:08:28 +02:00 • committed by Hermet Park
parent 11ddfdb193
commit 21b1ef6f5f
3 changed files with 60 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
src/renderer/wg_engine/tvgWgCommon.cpp
View file

@ -158,7 +158,7 @@ WGPUTexture WgContext::createTexture2d(WGPUTextureUsageFlags usage, WGPUTextureF
}
WGPUTextureView WgContext::createTextureView2d(WGPUTexture texture, WGPU_NULLABLE char const * label)
WGPUTextureView WgContext::createTextureView2d(WGPUTexture texture, char const * label)
{
WGPUTextureViewDescriptor textureViewDescColor{};
textureViewDescColor.nextInChain = nullptr;
@ -174,6 +174,18 @@ WGPUTextureView WgContext::createTextureView2d(WGPUTexture texture, WGPU_NULLABL
};
WGPUBuffer WgContext::createBuffer(WGPUBufferUsageFlags usage, uint64_t size,char const * label)
{
WGPUBufferDescriptor bufferDesc{};
bufferDesc.nextInChain = nullptr;
bufferDesc.label = label;
bufferDesc.usage = usage;
bufferDesc.size = size;
bufferDesc.mappedAtCreation = false;
return wgpuDeviceCreateBuffer(device, &bufferDesc);
}
void WgContext::releaseSampler(WGPUSampler& sampler)
{
if (sampler) {
@ -182,6 +194,7 @@ void WgContext::releaseSampler(WGPUSampler& sampler)
}
}
void WgContext::releaseTexture(WGPUTexture& texture)
{
if (texture) {
@ -195,8 +208,20 @@ void WgContext::releaseTexture(WGPUTexture& texture)
void WgContext::releaseTextureView(WGPUTextureView& textureView)
{
if (textureView) wgpuTextureViewRelease(textureView);
textureView = nullptr;
if (textureView) {
wgpuTextureViewRelease(textureView);
textureView = nullptr;
}
}
void WgContext::releaseBuffer(WGPUBuffer& buffer)
{
if (buffer) {
wgpuBufferDestroy(buffer);
wgpuBufferRelease(buffer);
buffer = nullptr;
}
}

5
src/renderer/wg_engine/tvgWgCommon.h
View file

@ -52,10 +52,13 @@ struct WgContext {
WGPUSampler createSampler(WGPUFilterMode minFilter, WGPUMipmapFilterMode mipmapFilter);
WGPUTexture createTexture2d(WGPUTextureUsageFlags usage, WGPUTextureFormat format, uint32_t width, uint32_t height, char const * label);
WGPUTextureView createTextureView2d(WGPUTexture texture, WGPU_NULLABLE char const * label);
WGPUTextureView createTextureView2d(WGPUTexture texture, char const * label);
WGPUBuffer createBuffer(WGPUBufferUsageFlags usage, uint64_t size,char const * label);
void releaseSampler(WGPUSampler& sampler);
void releaseTexture(WGPUTexture& texture);
void releaseTextureView(WGPUTextureView& textureView);
void releaseBuffer(WGPUBuffer& buffer);
};
struct WgBindGroup

68
src/renderer/wg_engine/tvgWgRenderData.cpp
View file

@ -48,43 +48,45 @@ void WgMeshData::drawImage(WGPURenderPassEncoder renderPassEncoder)
void WgMeshData::update(WgContext& context, WgGeometryData* geometryData){
release(context);
assert(geometryData);
// buffer position data create and write
if(geometryData->positions.count > 0) {
vertexCount = geometryData->positions.count;
WGPUBufferDescriptor bufferDesc{};
bufferDesc.nextInChain = nullptr;
bufferDesc.label = "Buffer position geometry data";
bufferDesc.usage = WGPUBufferUsage_CopyDst | WGPUBufferUsage_Vertex;
bufferDesc.size = sizeof(float) * vertexCount * 2; // x, y
bufferDesc.mappedAtCreation = false;
bufferPosition = wgpuDeviceCreateBuffer(context.device, &bufferDesc);
if (bufferPosition && (wgpuBufferGetSize(bufferPosition) < sizeof(float) * vertexCount * 2))
context.releaseBuffer(bufferPosition);
if (!bufferPosition) {
bufferPosition = context.createBuffer(
WGPUBufferUsage_CopyDst | WGPUBufferUsage_Vertex,
sizeof(float) * vertexCount * 2,
"Buffer position geometry data");
}
assert(bufferPosition);
wgpuQueueWriteBuffer(context.queue, bufferPosition, 0, &geometryData->positions[0], vertexCount * sizeof(float) * 2);
}
// buffer vertex data create and write
if(geometryData->texCoords.count > 0) {
WGPUBufferDescriptor bufferDesc{};
bufferDesc.nextInChain = nullptr;
bufferDesc.label = "Buffer tex coords geometry data";
bufferDesc.usage = WGPUBufferUsage_CopyDst | WGPUBufferUsage_Vertex;
bufferDesc.size = sizeof(float) * vertexCount * 2; // u, v
bufferDesc.mappedAtCreation = false;
bufferTexCoord = wgpuDeviceCreateBuffer(context.device, &bufferDesc);
assert(bufferPosition);
if (bufferTexCoord && (wgpuBufferGetSize(bufferTexCoord) < sizeof(float) * vertexCount * 2))
context.releaseBuffer(bufferTexCoord);
if (!bufferTexCoord) {
bufferTexCoord = context.createBuffer(
WGPUBufferUsage_CopyDst | WGPUBufferUsage_Vertex,
sizeof(float) * vertexCount * 2,
"Buffer tex coords geometry data");
}
assert(bufferTexCoord);
wgpuQueueWriteBuffer(context.queue, bufferTexCoord, 0, &geometryData->texCoords[0], vertexCount * sizeof(float) * 2);
}
// buffer index data create and write
if(geometryData->indexes.count > 0) {
indexCount = geometryData->indexes.count;
WGPUBufferDescriptor bufferDesc{};
bufferDesc.nextInChain = nullptr;
bufferDesc.label = "Buffer index geometry data";
bufferDesc.usage = WGPUBufferUsage_CopyDst | WGPUBufferUsage_Index;
bufferDesc.size = sizeof(uint32_t) * indexCount;
bufferDesc.mappedAtCreation = false;
bufferIndex = wgpuDeviceCreateBuffer(context.device, &bufferDesc);
if (bufferIndex && (wgpuBufferGetSize(bufferIndex) < sizeof(uint32_t) * indexCount))
context.releaseBuffer(bufferIndex);
if (!bufferIndex) {
bufferIndex = context.createBuffer(
WGPUBufferUsage_CopyDst | WGPUBufferUsage_Index,
sizeof(uint32_t) * indexCount,
"Buffer index geometry data");
}
assert(bufferIndex);
wgpuQueueWriteBuffer(context.queue, bufferIndex, 0, &geometryData->indexes[0], indexCount * sizeof(uint32_t));
}
@ -93,23 +95,9 @@ void WgMeshData::update(WgContext& context, WgGeometryData* geometryData){
void WgMeshData::release(WgContext& context)
{
if (bufferIndex) {
wgpuBufferDestroy(bufferIndex);
wgpuBufferRelease(bufferIndex);
bufferIndex = nullptr;
indexCount = 0;
}
if (bufferTexCoord) {
wgpuBufferDestroy(bufferTexCoord);
wgpuBufferRelease(bufferTexCoord);
bufferTexCoord = nullptr;
}
if (bufferPosition) {
wgpuBufferDestroy(bufferPosition);
wgpuBufferRelease(bufferPosition);
bufferPosition = nullptr;
bufferPosition = 0;
}
context.releaseBuffer(bufferIndex);
context.releaseBuffer(bufferTexCoord);
context.releaseBuffer(bufferPosition);
};
//***********************************************************************