324 lines
12 KiB
C++
324 lines
12 KiB
C++
/****************************************************************************
|
|
Copyright (c) 2019-2023 Xiamen Yaji Software Co., Ltd.
|
|
|
|
http://www.cocos.com
|
|
|
|
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.
|
|
****************************************************************************/
|
|
|
|
#pragma once
|
|
|
|
#include "GLES3GPUObjects.h"
|
|
|
|
namespace cc {
|
|
namespace gfx {
|
|
|
|
class GLES3Device;
|
|
class GLES3QueryPool;
|
|
|
|
class GLES3CmdBeginRenderPass final : public GLESCmd {
|
|
public:
|
|
GLES3GPURenderPass *gpuRenderPass = nullptr;
|
|
GLES3GPUFramebuffer *gpuFBO = nullptr;
|
|
Rect renderArea;
|
|
Color clearColors[MAX_ATTACHMENTS];
|
|
float clearDepth = 1.0F;
|
|
uint32_t clearStencil = 0U;
|
|
uint32_t subpassIdx = 0U;
|
|
|
|
GLES3CmdBeginRenderPass() : GLESCmd(GLESCmdType::BEGIN_RENDER_PASS) {}
|
|
|
|
void clear() override {
|
|
gpuRenderPass = nullptr;
|
|
gpuFBO = nullptr;
|
|
}
|
|
};
|
|
|
|
class GLES3CmdBindStates final : public GLESCmd {
|
|
public:
|
|
GLES3GPUPipelineState *gpuPipelineState = nullptr;
|
|
GLES3GPUInputAssembler *gpuInputAssembler = nullptr;
|
|
ccstd::vector<GLES3GPUDescriptorSet *> gpuDescriptorSets;
|
|
ccstd::vector<uint32_t> dynamicOffsets;
|
|
DynamicStates dynamicStates;
|
|
|
|
GLES3CmdBindStates() : GLESCmd(GLESCmdType::BIND_STATES) {}
|
|
|
|
void clear() override {
|
|
gpuPipelineState = nullptr;
|
|
gpuInputAssembler = nullptr;
|
|
gpuDescriptorSets.clear();
|
|
dynamicOffsets.clear();
|
|
}
|
|
};
|
|
|
|
class GLES3CmdDraw final : public GLESCmd {
|
|
public:
|
|
DrawInfo drawInfo;
|
|
|
|
GLES3CmdDraw() : GLESCmd(GLESCmdType::DRAW) {}
|
|
void clear() override {}
|
|
};
|
|
|
|
class GLES3CmdDispatch final : public GLESCmd {
|
|
public:
|
|
GLES3GPUDispatchInfo dispatchInfo;
|
|
|
|
GLES3CmdDispatch() : GLESCmd(GLESCmdType::DISPATCH) {}
|
|
void clear() override {
|
|
dispatchInfo.indirectBuffer = nullptr;
|
|
dispatchInfo.indirectOffset = 0;
|
|
}
|
|
};
|
|
|
|
class GLES3CmdBarrier final : public GLESCmd {
|
|
public:
|
|
GLbitfield barriers = 0U;
|
|
GLbitfield barriersByRegion = 0U;
|
|
|
|
GLES3CmdBarrier() : GLESCmd(GLESCmdType::BARRIER) {}
|
|
void clear() override {
|
|
barriers = 0U;
|
|
barriersByRegion = 0U;
|
|
}
|
|
};
|
|
|
|
class GLES3CmdUpdateBuffer final : public GLESCmd {
|
|
public:
|
|
GLES3GPUBuffer *gpuBuffer = nullptr;
|
|
const uint8_t *buffer = nullptr;
|
|
uint32_t size = 0;
|
|
uint32_t offset = 0;
|
|
|
|
GLES3CmdUpdateBuffer() : GLESCmd(GLESCmdType::UPDATE_BUFFER) {}
|
|
|
|
void clear() override {
|
|
gpuBuffer = nullptr;
|
|
buffer = nullptr;
|
|
}
|
|
};
|
|
|
|
class GLES3CmdCopyBufferToTexture final : public GLESCmd {
|
|
public:
|
|
GLES3GPUTexture *gpuTexture = nullptr;
|
|
const BufferTextureCopy *regions = nullptr;
|
|
uint32_t count = 0U;
|
|
const uint8_t *const *buffers = nullptr;
|
|
|
|
GLES3CmdCopyBufferToTexture() : GLESCmd(GLESCmdType::COPY_BUFFER_TO_TEXTURE) {}
|
|
|
|
void clear() override {
|
|
gpuTexture = nullptr;
|
|
regions = nullptr;
|
|
count = 0U;
|
|
buffers = nullptr;
|
|
}
|
|
};
|
|
|
|
class GLES3CmdBlitTexture final : public GLESCmd {
|
|
public:
|
|
GLES3GPUTextureView *gpuTextureSrcView = nullptr;
|
|
GLES3GPUTextureView *gpuTextureDstView = nullptr;
|
|
const TextureBlit *regions = nullptr;
|
|
uint32_t count = 0U;
|
|
Filter filter = Filter::POINT;
|
|
|
|
GLES3CmdBlitTexture() : GLESCmd(GLESCmdType::BLIT_TEXTURE) {}
|
|
|
|
void clear() override {
|
|
gpuTextureSrcView = nullptr;
|
|
gpuTextureDstView = nullptr;
|
|
regions = nullptr;
|
|
count = 0U;
|
|
}
|
|
};
|
|
|
|
enum class GLES3QueryType : uint8_t {
|
|
BEGIN,
|
|
END,
|
|
RESET,
|
|
GET_RESULTS,
|
|
};
|
|
|
|
class GLES3CmdQuery final : public GLESCmd {
|
|
public:
|
|
GLES3QueryPool *queryPool = nullptr;
|
|
GLES3QueryType type = GLES3QueryType::BEGIN;
|
|
uint32_t id = 0U;
|
|
|
|
GLES3CmdQuery() : GLESCmd(GLESCmdType::QUERY) {}
|
|
|
|
void clear() override {
|
|
queryPool = nullptr;
|
|
type = GLES3QueryType::BEGIN;
|
|
id = 0U;
|
|
}
|
|
};
|
|
|
|
struct GLES3CmdPackage {
|
|
CachedArray<GLESCmdType> cmds;
|
|
CachedArray<GLES3CmdBeginRenderPass *> beginRenderPassCmds;
|
|
CachedArray<GLES3CmdBindStates *> bindStatesCmds;
|
|
CachedArray<GLES3CmdDraw *> drawCmds;
|
|
CachedArray<GLES3CmdDispatch *> dispatchCmds;
|
|
CachedArray<GLES3CmdBarrier *> barrierCmds;
|
|
CachedArray<GLES3CmdUpdateBuffer *> updateBufferCmds;
|
|
CachedArray<GLES3CmdCopyBufferToTexture *> copyBufferToTextureCmds;
|
|
CachedArray<GLES3CmdBlitTexture *> blitTextureCmds;
|
|
CachedArray<GLES3CmdQuery *> queryCmds;
|
|
};
|
|
|
|
class GLES3GPUCommandAllocator final {
|
|
public:
|
|
CommandPool<GLES3CmdBeginRenderPass> beginRenderPassCmdPool;
|
|
CommandPool<GLES3CmdBindStates> bindStatesCmdPool;
|
|
CommandPool<GLES3CmdDraw> drawCmdPool;
|
|
CommandPool<GLES3CmdDispatch> dispatchCmdPool;
|
|
CommandPool<GLES3CmdBarrier> barrierCmdPool;
|
|
CommandPool<GLES3CmdUpdateBuffer> updateBufferCmdPool;
|
|
CommandPool<GLES3CmdCopyBufferToTexture> copyBufferToTextureCmdPool;
|
|
CommandPool<GLES3CmdBlitTexture> blitTextureCmdPool;
|
|
CommandPool<GLES3CmdQuery> queryCmdPool;
|
|
|
|
void clearCmds(GLES3CmdPackage *cmdPackage) {
|
|
if (cmdPackage->beginRenderPassCmds.size()) {
|
|
beginRenderPassCmdPool.freeCmds(cmdPackage->beginRenderPassCmds);
|
|
}
|
|
if (cmdPackage->bindStatesCmds.size()) {
|
|
bindStatesCmdPool.freeCmds(cmdPackage->bindStatesCmds);
|
|
}
|
|
if (cmdPackage->drawCmds.size()) {
|
|
drawCmdPool.freeCmds(cmdPackage->drawCmds);
|
|
}
|
|
if (cmdPackage->dispatchCmds.size()) {
|
|
dispatchCmdPool.freeCmds(cmdPackage->dispatchCmds);
|
|
}
|
|
if (cmdPackage->barrierCmds.size()) {
|
|
barrierCmdPool.freeCmds(cmdPackage->barrierCmds);
|
|
}
|
|
if (cmdPackage->updateBufferCmds.size()) {
|
|
updateBufferCmdPool.freeCmds(cmdPackage->updateBufferCmds);
|
|
}
|
|
if (cmdPackage->copyBufferToTextureCmds.size()) {
|
|
copyBufferToTextureCmdPool.freeCmds(cmdPackage->copyBufferToTextureCmds);
|
|
}
|
|
if (cmdPackage->blitTextureCmds.size()) {
|
|
blitTextureCmdPool.freeCmds(cmdPackage->blitTextureCmds);
|
|
}
|
|
if (cmdPackage->queryCmds.size()) {
|
|
queryCmdPool.freeCmds(cmdPackage->queryCmds);
|
|
}
|
|
|
|
cmdPackage->cmds.clear();
|
|
}
|
|
|
|
inline void reset() {
|
|
beginRenderPassCmdPool.release();
|
|
bindStatesCmdPool.release();
|
|
drawCmdPool.release();
|
|
dispatchCmdPool.release();
|
|
barrierCmdPool.release();
|
|
updateBufferCmdPool.release();
|
|
copyBufferToTextureCmdPool.release();
|
|
blitTextureCmdPool.release();
|
|
}
|
|
};
|
|
|
|
void cmdFuncGLES3CreateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer);
|
|
void cmdFuncGLES3DestroyBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer);
|
|
void cmdFuncGLES3ResizeBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer);
|
|
void cmdFuncGLES3CreateTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture);
|
|
void cmdFuncGLES3DestroyTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture);
|
|
void cmdFuncGLES3ResizeTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture);
|
|
void cmdFuncGLES3CreateTextureView(GLES3Device *device, GLES3GPUTextureView *gpuTextureView);
|
|
void cmdFuncGLES3CreateShader(GLES3Device *device, GLES3GPUShader *gpuShader, GLES3GPUPipelineLayout *pipelineLayout);
|
|
void cmdFuncGLES3DestroyShader(GLES3Device *device, GLES3GPUShader *gpuShader);
|
|
void cmdFuncGLES3CreateRenderPass(GLES3Device *device, GLES3GPURenderPass *gpuRenderPass);
|
|
void cmdFuncGLES3DestroyRenderPass(GLES3Device *device, GLES3GPURenderPass *gpuRenderPass);
|
|
void cmdFuncGLES3CreateInputAssembler(GLES3Device *device, GLES3GPUInputAssembler *gpuInputAssembler);
|
|
void cmdFuncGLES3DestroyInputAssembler(GLES3Device *device, GLES3GPUInputAssembler *gpuInputAssembler);
|
|
void cmdFuncGLES3CreateFramebuffer(GLES3Device *device, GLES3GPUFramebuffer *gpuFBO);
|
|
void cmdFuncGLES3DestroyFramebuffer(GLES3Device *device, GLES3GPUFramebuffer *gpuFBO);
|
|
void cmdFuncGLES3CreateGeneralBarrier(GLES3Device *device, GLES3GPUGeneralBarrier *barrier);
|
|
void cmdFuncGLES3CreateQueryPool(GLES3Device *device, GLES3GPUQueryPool *gpuQueryPool);
|
|
void cmdFuncGLES3DestroyQueryPool(GLES3Device *device, GLES3GPUQueryPool *gpuQueryPool);
|
|
void cmdFuncGLES3PrepareSamplerInfo(GLES3Device *device, GLES3GPUSampler *gpuSampler);
|
|
|
|
void completeBarrier(GLES3GPUGeneralBarrier *barrier);
|
|
|
|
void cmdFuncGLES3Query(GLES3Device *device, GLES3QueryPool *query, GLES3QueryType type, uint32_t id);
|
|
|
|
void cmdFuncGLES3BeginRenderPass(GLES3Device *device,
|
|
GLES3GPURenderPass *gpuRenderPass = nullptr,
|
|
GLES3GPUFramebuffer *gpuFramebuffer = nullptr,
|
|
const Rect *renderArea = nullptr,
|
|
const Color *clearColors = nullptr,
|
|
float clearDepth = 1.F,
|
|
uint32_t clearStencil = 0);
|
|
|
|
void cmdFuncGLES3EndRenderPass(GLES3Device *device);
|
|
|
|
void cmdFuncGLES3BindState(GLES3Device *device,
|
|
GLES3GPUPipelineState *gpuPipelineState,
|
|
GLES3GPUInputAssembler *gpuInputAssembler,
|
|
const GLES3GPUDescriptorSet *const *gpuDescriptorSets,
|
|
const uint32_t *dynamicOffsets = nullptr,
|
|
const DynamicStates *dynamicStates = nullptr);
|
|
|
|
void cmdFuncGLES3Draw(GLES3Device *device, const DrawInfo &drawInfo);
|
|
|
|
void cmdFuncGLES3UpdateBuffer(GLES3Device *device,
|
|
GLES3GPUBuffer *gpuBuffer,
|
|
const void *buffer,
|
|
uint32_t offset,
|
|
uint32_t size);
|
|
|
|
void cmdFuncGLES3CopyBuffersToTexture(GLES3Device *device,
|
|
const uint8_t *const *buffers,
|
|
GLES3GPUTexture *gpuTexture,
|
|
const BufferTextureCopy *regions,
|
|
uint32_t count);
|
|
void cmdFuncGLES3CopyTextureToBuffers(GLES3Device *device,
|
|
GLES3GPUTextureView *gpuTextureView,
|
|
uint8_t *const *buffers,
|
|
const BufferTextureCopy *regions,
|
|
uint32_t count);
|
|
|
|
void cmdFuncGLES3BlitTexture(GLES3Device *device,
|
|
GLES3GPUTextureView *gpuTextureSrcView,
|
|
GLES3GPUTextureView *gpuTextureDstView,
|
|
const TextureBlit *regions,
|
|
uint32_t count,
|
|
Filter filter);
|
|
|
|
void cmdFuncGLES3ExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmdPackage);
|
|
|
|
void cmdFuncGLES3Dispatch(GLES3Device *device, const GLES3GPUDispatchInfo &info);
|
|
|
|
void cmdFuncGLES3MemoryBarrier(GLES3Device *device, GLbitfield barriers, GLbitfield barriersByRegion);
|
|
|
|
void cmdFuncGLES3InsertMarker(GLES3Device *device, GLsizei length, const char *marker);
|
|
void cmdFuncGLES3PushGroupMarker(GLES3Device *device, GLsizei length, const char *marker);
|
|
void cmdFuncGLES3PopGroupMarker(GLES3Device *device);
|
|
|
|
GLint cmdFuncGLES3GetMaxSampleCount(const GLES3Device *device, Format format, TextureUsage usage, TextureFlags flags);
|
|
|
|
} // namespace gfx
|
|
} // namespace cc
|