GLES3: immediate submission

This commit is contained in:
Yun Hsiao Wu
2020-11-27 12:42:48 +08:00
committed by Yun Hsiao Wu
parent 1a65678152
commit 162bbcf474
18 changed files with 309 additions and 335 deletions
@@ -33,13 +33,6 @@ public:
virtual void copyBuffersToTexture(const uint8_t *const *buffers, Texture *texture, const BufferTextureCopy *regions, uint count) override;
virtual void execute(const CommandBuffer *const *cmdBuffs, uint32_t count) override;
using CommandBuffer::begin;
using CommandBuffer::updateBuffer;
using CommandBuffer::execute;
using CommandBuffer::bindDescriptorSet;
using CommandBuffer::beginRenderPass;
using CommandBuffer::copyBuffersToTexture;
virtual uint getNumDrawCalls() const override { return _remote->getNumDrawCalls(); }
virtual uint getNumInstances() const override { return _remote->getNumInstances(); }
virtual uint getNumTris() const override { return _remote->getNumTris(); }
@@ -71,18 +71,13 @@ bool DeviceProxy::initialize(const DeviceInfo &info) {
cbInfo.queue = _queue;
for (auto &context : _contexts) {
context.commandBuffer = createCommandBuffer(cbInfo);
context.commandBuffer = createCommandBuffer();
context.commandBuffer->initialize(cbInfo);
context.encoder = CC_NEW(CommandEncoder);
context.encoder->RunConsumerThread();
}
ENCODE_COMMAND_1(
getMainEncoder(),
DeviceMakeCurrent,
remote, getRemote(),
{
remote->makeCurrent();
});
setImmediateMode(false);
return true;
}
@@ -20,21 +20,6 @@ struct SubmitContext final {
class CC_DLL DeviceProxy : public Proxy<Device> {
public:
using Device::copyBuffersToTexture;
using Device::createBuffer;
using Device::createCommandBuffer;
using Device::createDescriptorSet;
using Device::createDescriptorSetLayout;
using Device::createFence;
using Device::createFramebuffer;
using Device::createInputAssembler;
using Device::createPipelineLayout;
using Device::createPipelineState;
using Device::createQueue;
using Device::createRenderPass;
using Device::createSampler;
using Device::createShader;
using Device::createTexture;
using Proxy::Proxy;
virtual bool initialize(const DeviceInfo &info) override;
@@ -59,6 +44,7 @@ public:
virtual PipelineState *createPipelineState() override;
virtual void copyBuffersToTexture(const uint8_t *const *buffers, Texture *dst, const BufferTextureCopy *regions, uint count) override;
virtual void setImmediateMode(bool immediateMode) { return _remote->setImmediateMode(immediateMode); }
virtual SurfaceTransform getSurfaceTransform() const override { return _remote->getSurfaceTransform(); }
virtual uint getWidth() const override { return _remote->getWidth(); }
virtual uint getHeight() const override { return _remote->getHeight(); }
+1 -1
View File
@@ -70,7 +70,7 @@ public:
copyBuffersToTexture(buffers.data(), dst, regions.data(), static_cast<uint>(regions.size()) );
}
virtual void makeCurrent() {}
virtual void setImmediateMode(bool immediateMode) {}
virtual SurfaceTransform getSurfaceTransform() const { return _transform; }
virtual uint getWidth() const { return _width; }
virtual uint getHeight() const { return _height; }
@@ -79,9 +79,6 @@ void CommandEncoder::MemoryAllocator::Free(uint8_t* const chunk) noexcept
CommandEncoder::CommandEncoder()
{
//mImmediateMode = true;
//mFreeChunksByUser = false;
uint8_t* const chunk = MemoryAllocator::GetInstance().Request();
mW.mCurrentMemoryChunk = chunk;
@@ -113,6 +113,7 @@ public:
void RecycleMemoryChunk(uint8_t* const chunk) const noexcept;
static void FreeChunksInFreeQueue(CommandEncoder* const mainCommandbuffer) noexcept;
inline void SetImmediateMode(bool immediateMode) noexcept { mImmediateMode = immediateMode; }
inline int GetPendingCommandCount() const noexcept { return mW.mPendingCommandCount; }
inline int GetWrittenCommandCount() const noexcept { return mW.mWrittenCommandCount; }
inline int GetNewCommandCount() const noexcept { return mR.mNewCommandCount; }
@@ -227,7 +227,7 @@ void GLES2Device::present() {
queue->_numTriangles = 0;
}
void GLES2Device::makeCurrent() {
void GLES2Device::setImmediateMode(bool immediateMode) {
if (!_renderContext) {
ContextInfo ctxInfo;
ctxInfo.windowHandle = _windowHandle;
@@ -80,7 +80,7 @@ public:
virtual PipelineLayout *createPipelineLayout() override;
virtual PipelineState *createPipelineState() override;
virtual void copyBuffersToTexture(const uint8_t *const *buffers, Texture *dst, const BufferTextureCopy *regions, uint count) override;
virtual void makeCurrent() override;
virtual void setImmediateMode(bool immediateMode) override;
CC_INLINE bool useVAO() const { return _useVAO; }
CC_INLINE bool useDrawInstanced() const { return _useDrawInstanced; }
@@ -53,7 +53,6 @@ bool GLES3CommandBuffer::initialize(const CommandBufferInfo &info) {
size_t setCount = ((GLES3Device *)_device)->bindingMappingInfo().bufferOffsets.size();
_curGPUDescriptorSets.resize(setCount);
_curDynamicOffsets.resize(setCount);
_curDynamicOffsetCounts.resize(setCount);
return true;
}
@@ -85,7 +84,6 @@ void GLES3CommandBuffer::begin(RenderPass *renderPass, uint subpass, Framebuffer
_curGPUPipelineState = nullptr;
_curGPUInputAssember = nullptr;
_curGPUDescriptorSets.assign(_curGPUDescriptorSets.size(), nullptr);
_curDynamicOffsetCounts.assign(_curDynamicOffsetCounts.size(), 0u);
_numDrawCalls = 0;
_numInstances = 0;
@@ -147,7 +145,6 @@ void GLES3CommandBuffer::bindDescriptorSet(uint set, DescriptorSet *descriptorSe
}
if (dynamicOffsetCount) {
_curDynamicOffsets[set] = dynamicOffsets;
_curDynamicOffsetCounts[set] = dynamicOffsetCount;
_isStateInvalid = true;
}
}
@@ -368,13 +365,8 @@ void GLES3CommandBuffer::BindStates() {
GLES3CmdBindStates *cmd = _cmdAllocator->bindStatesCmdPool.alloc();
cmd->gpuPipelineState = _curGPUPipelineState;
cmd->gpuInputAssembler = _curGPUInputAssember;
cmd->gpuDescriptorSets.push_back(_curGPUDescriptorSets[0]);
for (size_t i = 0u; i < _curDynamicOffsets.size(); i++) {
const uint *dynamicOffset = _curDynamicOffsets[i];
uint count = _curDynamicOffsetCounts[i];
cmd->dynamicOffsets.insert(cmd->dynamicOffsets.end(), dynamicOffset, dynamicOffset + count);
}
cmd->gpuDescriptorSets = _curGPUDescriptorSets;
cmd->dynamicOffsets = _curDynamicOffsets;
cmd->viewport = _curViewport;
cmd->scissor = _curScissor;
cmd->lineWidth = _curLineWidth;
@@ -64,16 +64,13 @@ public:
protected:
virtual void BindStates();
GLES3GPUCommandAllocator *_cmdAllocator = nullptr;
GLES3CmdPackage *_curCmdPackage = nullptr;
queue<GLES3CmdPackage *> _pendingPackages, _freePackages;
GLES3CmdPackage *_cmdPackage = nullptr;
GLES3GPUCommandAllocator *_gles3Allocator = nullptr;
bool _isInRenderPass = false;
GLES3GPUPipelineState *_curGPUPipelineState = nullptr;
GLES3GPUInputAssembler *_curGPUInputAssember = nullptr;
vector<GLES3GPUDescriptorSet *> _curGPUDescriptorSets;
vector<const uint *> _curDynamicOffsets;
vector<uint> _curDynamicOffsetCounts;
Viewport _curViewport;
Rect _curScissor;
float _curLineWidth = 1.0f;
+221 -180
View File
@@ -1453,7 +1453,6 @@ void GLES3CmdFuncDestroyFramebuffer(GLES3Device *device, GLES3GPUFramebuffer *gp
}
void GLES3CmdFuncBeginRenderPass(GLES3Device *device, GLES3GPURenderPass *gpuRenderPass, GLES3GPUFramebuffer *gpuFramebuffer, const Rect &renderArea, size_t numClearColors, const Color *clearColors, float clearDepth, int clearStencil) {
GLES3ObjectCache &gfxStateCache = device->stateCache()->gfxStateCache;
gfxStateCache.gpuRenderPass = gpuRenderPass;
gfxStateCache.gpuFramebuffer = gpuFramebuffer;
gfxStateCache.numClearColors = numClearColors;
@@ -1464,17 +1463,17 @@ void GLES3CmdFuncBeginRenderPass(GLES3Device *device, GLES3GPURenderPass *gpuRen
if (gpuFramebuffer && gpuRenderPass) {
if (cache->glFramebuffer != gpuFramebuffer->glFramebuffer) {
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, gpuFramebuffer->glFramebuffer));
glBindFramebuffer(GL_FRAMEBUFFER, gpuFramebuffer->glFramebuffer);
cache->glFramebuffer = gpuFramebuffer->glFramebuffer;
// render targets are drawn with flipped-Y
gfxStateCache.reverseCW = gpuFramebuffer->isOffscreen;
gfxStateCache.reverseCW = !!gpuFramebuffer->glFramebuffer;
}
if (cache->viewport.left != renderArea.x ||
cache->viewport.top != renderArea.y ||
cache->viewport.width != renderArea.width ||
cache->viewport.height != renderArea.height) {
GL_CHECK(glViewport(renderArea.x, renderArea.y, renderArea.width, renderArea.height));
glViewport(renderArea.x, renderArea.y, renderArea.width, renderArea.height);
cache->viewport.left = renderArea.x;
cache->viewport.top = renderArea.y;
cache->viewport.width = renderArea.width;
@@ -1485,7 +1484,7 @@ void GLES3CmdFuncBeginRenderPass(GLES3Device *device, GLES3GPURenderPass *gpuRen
cache->scissor.y != renderArea.y ||
cache->scissor.width != renderArea.width ||
cache->scissor.height != renderArea.height) {
GL_CHECK(glScissor(renderArea.x, renderArea.y, renderArea.width, renderArea.height));
glScissor(renderArea.x, renderArea.y, renderArea.width, renderArea.height);
cache->scissor.x = renderArea.x;
cache->scissor.y = renderArea.y;
cache->scissor.width = renderArea.width;
@@ -1501,8 +1500,8 @@ void GLES3CmdFuncBeginRenderPass(GLES3Device *device, GLES3GPURenderPass *gpuRen
switch (colorAttachment.loadOp) {
case LoadOp::LOAD: break; // GL default behaviour
case LoadOp::CLEAR: {
if (cache->bs.targets[0].blendColorMask != ColorMask::ALL) {
GL_CHECK(glColorMask(true, true, true, true));
if (cache->bs.targets[0]->blendColorMask != ColorMask::ALL) {
glColorMask(true, true, true, true);
}
if (gpuFramebuffer->isOffscreen) {
@@ -1511,10 +1510,10 @@ void GLES3CmdFuncBeginRenderPass(GLES3Device *device, GLES3GPURenderPass *gpuRen
fColors[1] = clearColors[j].y;
fColors[2] = clearColors[j].z;
fColors[3] = clearColors[j].w;
GL_CHECK(glClearBufferfv(GL_COLOR, j, fColors));
glClearBufferfv(GL_COLOR, j, fColors);
} else {
const Color &color = clearColors[j];
GL_CHECK(glClearColor(color.x, color.y, color.z, color.w));
glClearColor(color.x, color.y, color.z, color.w);
glClears |= GL_COLOR_BUFFER_BIT;
}
break;
@@ -1535,10 +1534,9 @@ void GLES3CmdFuncBeginRenderPass(GLES3Device *device, GLES3GPURenderPass *gpuRen
switch (gpuRenderPass->depthStencilAttachment.depthLoadOp) {
case LoadOp::LOAD: break; // GL default behaviour
case LoadOp::CLEAR: {
if (!cache->dss.depthWrite) {
GL_CHECK(glDepthMask(true));
}
GL_CHECK(glClearDepthf(clearDepth));
glDepthMask(true);
cache->dss.depthWrite = true;
glClearDepthf(clearDepth);
glClears |= GL_DEPTH_BUFFER_BIT;
break;
}
@@ -1556,12 +1554,12 @@ void GLES3CmdFuncBeginRenderPass(GLES3Device *device, GLES3GPURenderPass *gpuRen
case LoadOp::LOAD: break; // GL default behaviour
case LoadOp::CLEAR: {
if (!cache->dss.stencilWriteMaskFront) {
GL_CHECK(glStencilMaskSeparate(GL_FRONT, 0xffffffff));
glStencilMaskSeparate(GL_FRONT, 0xffffffff);
}
if (!cache->dss.stencilWriteMaskBack) {
GL_CHECK(glStencilMaskSeparate(GL_BACK, 0xffffffff));
glStencilMaskSeparate(GL_BACK, 0xffffffff);
}
GL_CHECK(glClearStencil(clearStencil));
glClearStencil(clearStencil);
glClears |= GL_STENCIL_BUFFER_BIT;
break;
}
@@ -1576,41 +1574,40 @@ void GLES3CmdFuncBeginRenderPass(GLES3Device *device, GLES3GPURenderPass *gpuRen
}
if (numAttachments) {
GL_CHECK(glInvalidateFramebuffer(GL_FRAMEBUFFER, numAttachments, invalidAttachments));
glInvalidateFramebuffer(GL_FRAMEBUFFER, numAttachments, invalidAttachments);
}
if (glClears) {
GL_CHECK(glClear(glClears));
glClear(glClears);
}
// restore states
if (glClears & GL_COLOR_BUFFER_BIT) {
ColorMask colorMask = cache->bs.targets[0].blendColorMask;
ColorMask colorMask = cache->bs.targets[0]->blendColorMask;
if (colorMask != ColorMask::ALL) {
GL_CHECK(glColorMask((GLboolean)(colorMask & ColorMask::R),
(GLboolean)(colorMask & ColorMask::G),
(GLboolean)(colorMask & ColorMask::B),
(GLboolean)(colorMask & ColorMask::A)));
glColorMask((GLboolean)(colorMask & ColorMask::R),
(GLboolean)(colorMask & ColorMask::G),
(GLboolean)(colorMask & ColorMask::B),
(GLboolean)(colorMask & ColorMask::A));
}
}
if ((glClears & GL_DEPTH_BUFFER_BIT) && !cache->dss.depthWrite) {
GL_CHECK(glDepthMask(false));
if ((glClears & GL_COLOR_BUFFER_BIT) && !cache->dss.depthWrite) {
glDepthMask(false);
}
if (glClears & GL_STENCIL_BUFFER_BIT) {
if (!cache->dss.stencilWriteMaskFront) {
GL_CHECK(glStencilMaskSeparate(GL_FRONT, 0));
glStencilMaskSeparate(GL_FRONT, 0);
}
if (!cache->dss.stencilWriteMaskBack) {
GL_CHECK(glStencilMaskSeparate(GL_BACK, 0));
glStencilMaskSeparate(GL_BACK, 0);
}
}
}
}
void GLES3CmdFuncEndRenderPass(GLES3Device *device) {
GLES3ObjectCache &gfxStateCache = device->stateCache()->gfxStateCache;
size_t numClearColors = gfxStateCache.numClearColors;
GLES3GPURenderPass *gpuRenderPass = gfxStateCache.gpuRenderPass;
GLES3GPUFramebuffer *gpuFramebuffer = gfxStateCache.gpuFramebuffer;
@@ -1660,15 +1657,14 @@ void GLES3CmdFuncEndRenderPass(GLES3Device *device) {
}
if (numAttachments) {
GL_CHECK(glInvalidateFramebuffer(GL_FRAMEBUFFER, numAttachments, invalidAttachments));
glInvalidateFramebuffer(GL_FRAMEBUFFER, numAttachments, invalidAttachments);
}
}
void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipelineState, GLES3GPUInputAssembler *gpuInputAssembler,
vector<GLES3GPUDescriptorSet *> &gpuDescriptorSets, vector<uint> &dynamicOffsets, Viewport &viewport, Rect &scissor,
vector<GLES3GPUDescriptorSet *> &gpuDescriptorSets, vector<const uint *> &dynamicOffsets, Viewport &viewport, Rect &scissor,
float lineWidth, bool depthBiasEnabled, GLES3DepthBias &depthBias, Color &blendConstants, GLES3DepthBounds &depthBounds,
GLES3StencilWriteMask &stencilWriteMask, GLES3StencilCompareMask &stencilCompareMask) {
GLES3ObjectCache &gfxStateCache = device->stateCache()->gfxStateCache;
GLES3GPUStateCache *cache = device->stateCache();
bool isShaderChanged = false;
@@ -1679,7 +1675,7 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
if (gpuPipelineState->gpuShader) {
if (cache->glProgram != gpuPipelineState->gpuShader->glProgram) {
GL_CHECK(glUseProgram(gpuPipelineState->gpuShader->glProgram));
glUseProgram(gpuPipelineState->gpuShader->glProgram);
cache->glProgram = gpuPipelineState->gpuShader->glProgram;
isShaderChanged = true;
}
@@ -1690,23 +1686,23 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
switch (gpuPipelineState->rs.cullMode) {
case CullMode::NONE: {
if (cache->isCullFaceEnabled) {
GL_CHECK(glDisable(GL_CULL_FACE));
glDisable(GL_CULL_FACE);
cache->isCullFaceEnabled = false;
}
} break;
case CullMode::FRONT: {
if (!cache->isCullFaceEnabled) {
GL_CHECK(glEnable(GL_CULL_FACE));
glEnable(GL_CULL_FACE);
cache->isCullFaceEnabled = true;
}
GL_CHECK(glCullFace(GL_FRONT));
glCullFace(GL_FRONT);
} break;
case CullMode::BACK: {
if (!cache->isCullFaceEnabled) {
GL_CHECK(glEnable(GL_CULL_FACE));
glEnable(GL_CULL_FACE);
cache->isCullFaceEnabled = true;
}
GL_CHECK(glCullFace(GL_BACK));
glCullFace(GL_BACK);
} break;
default:
break;
@@ -1715,56 +1711,56 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
}
bool isFrontFaceCCW = gpuPipelineState->rs.isFrontFaceCCW != gfxStateCache.reverseCW;
if (cache->rs.isFrontFaceCCW != isFrontFaceCCW) {
GL_CHECK(glFrontFace(isFrontFaceCCW ? GL_CCW : GL_CW));
glFrontFace(isFrontFaceCCW ? GL_CCW : GL_CW);
cache->rs.isFrontFaceCCW = isFrontFaceCCW;
}
if ((cache->rs.depthBias != gpuPipelineState->rs.depthBias) ||
(cache->rs.depthBiasSlop != gpuPipelineState->rs.depthBiasSlop)) {
GL_CHECK(glPolygonOffset(cache->rs.depthBias, cache->rs.depthBiasSlop));
glPolygonOffset(cache->rs.depthBias, cache->rs.depthBiasSlop);
cache->rs.depthBiasSlop = gpuPipelineState->rs.depthBiasSlop;
}
if (cache->rs.lineWidth != gpuPipelineState->rs.lineWidth) {
GL_CHECK(glLineWidth(gpuPipelineState->rs.lineWidth));
glLineWidth(gpuPipelineState->rs.lineWidth);
cache->rs.lineWidth = gpuPipelineState->rs.lineWidth;
}
// bind depth-stencil state
if (cache->dss.depthTest != gpuPipelineState->dss.depthTest) {
if (gpuPipelineState->dss.depthTest) {
GL_CHECK(glEnable(GL_DEPTH_TEST));
glEnable(GL_DEPTH_TEST);
} else {
GL_CHECK(glDisable(GL_DEPTH_TEST));
glDisable(GL_DEPTH_TEST);
}
cache->dss.depthTest = gpuPipelineState->dss.depthTest;
}
if (cache->dss.depthWrite != gpuPipelineState->dss.depthWrite) {
GL_CHECK(glDepthMask(gpuPipelineState->dss.depthWrite));
glDepthMask(gpuPipelineState->dss.depthWrite);
cache->dss.depthWrite = gpuPipelineState->dss.depthWrite;
}
if (cache->dss.depthFunc != gpuPipelineState->dss.depthFunc) {
GL_CHECK(glDepthFunc(GLES3_CMP_FUNCS[(int)gpuPipelineState->dss.depthFunc]));
glDepthFunc(GLES3_CMP_FUNCS[(int)gpuPipelineState->dss.depthFunc]);
cache->dss.depthFunc = gpuPipelineState->dss.depthFunc;
}
// bind depth-stencil state - front
if (gpuPipelineState->dss.stencilTestFront || gpuPipelineState->dss.stencilTestBack) {
if (!cache->isStencilTestEnabled) {
GL_CHECK(glEnable(GL_STENCIL_TEST));
glEnable(GL_STENCIL_TEST);
cache->isStencilTestEnabled = true;
}
} else {
if (cache->isStencilTestEnabled) {
GL_CHECK(glDisable(GL_STENCIL_TEST));
glDisable(GL_STENCIL_TEST);
cache->isStencilTestEnabled = false;
}
}
if (cache->dss.stencilFuncFront != gpuPipelineState->dss.stencilFuncFront ||
cache->dss.stencilRefFront != gpuPipelineState->dss.stencilRefFront ||
cache->dss.stencilReadMaskFront != gpuPipelineState->dss.stencilReadMaskFront) {
GL_CHECK(glStencilFuncSeparate(GL_FRONT,
GLES3_CMP_FUNCS[(int)gpuPipelineState->dss.stencilFuncFront],
gpuPipelineState->dss.stencilRefFront,
gpuPipelineState->dss.stencilReadMaskFront));
glStencilFuncSeparate(GL_FRONT,
GLES3_CMP_FUNCS[(int)gpuPipelineState->dss.stencilFuncFront],
gpuPipelineState->dss.stencilRefFront,
gpuPipelineState->dss.stencilReadMaskFront);
cache->dss.stencilFuncFront = gpuPipelineState->dss.stencilFuncFront;
cache->dss.stencilRefFront = gpuPipelineState->dss.stencilRefFront;
cache->dss.stencilReadMaskFront = gpuPipelineState->dss.stencilReadMaskFront;
@@ -1772,16 +1768,16 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
if (cache->dss.stencilFailOpFront != gpuPipelineState->dss.stencilFailOpFront ||
cache->dss.stencilZFailOpFront != gpuPipelineState->dss.stencilZFailOpFront ||
cache->dss.stencilPassOpFront != gpuPipelineState->dss.stencilPassOpFront) {
GL_CHECK(glStencilOpSeparate(GL_FRONT,
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilFailOpFront],
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilZFailOpFront],
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilPassOpFront]));
glStencilOpSeparate(GL_FRONT,
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilFailOpFront],
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilZFailOpFront],
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilPassOpFront]);
cache->dss.stencilFailOpFront = gpuPipelineState->dss.stencilFailOpFront;
cache->dss.stencilZFailOpFront = gpuPipelineState->dss.stencilZFailOpFront;
cache->dss.stencilPassOpFront = gpuPipelineState->dss.stencilPassOpFront;
}
if (cache->dss.stencilWriteMaskFront != gpuPipelineState->dss.stencilWriteMaskFront) {
GL_CHECK(glStencilMaskSeparate(GL_FRONT, gpuPipelineState->dss.stencilWriteMaskFront));
glStencilMaskSeparate(GL_FRONT, gpuPipelineState->dss.stencilWriteMaskFront);
cache->dss.stencilWriteMaskFront = gpuPipelineState->dss.stencilWriteMaskFront;
}
@@ -1789,10 +1785,10 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
if (cache->dss.stencilFuncBack != gpuPipelineState->dss.stencilFuncBack ||
cache->dss.stencilRefBack != gpuPipelineState->dss.stencilRefBack ||
cache->dss.stencilReadMaskBack != gpuPipelineState->dss.stencilReadMaskBack) {
GL_CHECK(glStencilFuncSeparate(GL_BACK,
GLES3_CMP_FUNCS[(int)gpuPipelineState->dss.stencilFuncBack],
gpuPipelineState->dss.stencilRefBack,
gpuPipelineState->dss.stencilReadMaskBack));
glStencilFuncSeparate(GL_BACK,
GLES3_CMP_FUNCS[(int)gpuPipelineState->dss.stencilFuncBack],
gpuPipelineState->dss.stencilRefBack,
gpuPipelineState->dss.stencilReadMaskBack);
cache->dss.stencilFuncBack = gpuPipelineState->dss.stencilFuncBack;
cache->dss.stencilRefBack = gpuPipelineState->dss.stencilRefBack;
cache->dss.stencilReadMaskBack = gpuPipelineState->dss.stencilReadMaskBack;
@@ -1800,25 +1796,25 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
if (cache->dss.stencilFailOpBack != gpuPipelineState->dss.stencilFailOpBack ||
cache->dss.stencilZFailOpBack != gpuPipelineState->dss.stencilZFailOpBack ||
cache->dss.stencilPassOpBack != gpuPipelineState->dss.stencilPassOpBack) {
GL_CHECK(glStencilOpSeparate(GL_BACK,
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilFailOpBack],
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilZFailOpBack],
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilPassOpBack]));
glStencilOpSeparate(GL_BACK,
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilFailOpBack],
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilZFailOpBack],
GLES3_STENCIL_OPS[(int)gpuPipelineState->dss.stencilPassOpBack]);
cache->dss.stencilFailOpBack = gpuPipelineState->dss.stencilFailOpBack;
cache->dss.stencilZFailOpBack = gpuPipelineState->dss.stencilZFailOpBack;
cache->dss.stencilPassOpBack = gpuPipelineState->dss.stencilPassOpBack;
}
if (cache->dss.stencilWriteMaskBack != gpuPipelineState->dss.stencilWriteMaskBack) {
GL_CHECK(glStencilMaskSeparate(GL_BACK, gpuPipelineState->dss.stencilWriteMaskBack));
glStencilMaskSeparate(GL_BACK, gpuPipelineState->dss.stencilWriteMaskBack);
cache->dss.stencilWriteMaskBack = gpuPipelineState->dss.stencilWriteMaskBack;
}
// bind blend state
if (cache->bs.isA2C != gpuPipelineState->bs.isA2C) {
if (cache->bs.isA2C) {
GL_CHECK(glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE));
glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
} else {
GL_CHECK(glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE));
glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
}
cache->bs.isA2C = gpuPipelineState->bs.isA2C;
}
@@ -1827,49 +1823,49 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
cache->bs.blendColor.z != gpuPipelineState->bs.blendColor.z ||
cache->bs.blendColor.w != gpuPipelineState->bs.blendColor.w) {
GL_CHECK(glBlendColor(gpuPipelineState->bs.blendColor.x,
gpuPipelineState->bs.blendColor.y,
gpuPipelineState->bs.blendColor.z,
gpuPipelineState->bs.blendColor.w));
glBlendColor(gpuPipelineState->bs.blendColor.x,
gpuPipelineState->bs.blendColor.y,
gpuPipelineState->bs.blendColor.z,
gpuPipelineState->bs.blendColor.w);
cache->bs.blendColor = gpuPipelineState->bs.blendColor;
}
BlendTarget &cacheTarget = cache->bs.targets[0];
const BlendTarget &target = gpuPipelineState->bs.targets[0];
if (cacheTarget.blend != target.blend) {
if (!cacheTarget.blend) {
GL_CHECK(glEnable(GL_BLEND));
BlendTarget *cacheTarget = cache->bs.targets[0];
const BlendTarget *target = gpuPipelineState->bs.targets[0];
if (cacheTarget->blend != target->blend) {
if (!cacheTarget->blend) {
glEnable(GL_BLEND);
} else {
GL_CHECK(glDisable(GL_BLEND));
glDisable(GL_BLEND);
}
cacheTarget.blend = target.blend;
cacheTarget->blend = target->blend;
}
if (cacheTarget.blendEq != target.blendEq ||
cacheTarget.blendAlphaEq != target.blendAlphaEq) {
GL_CHECK(glBlendEquationSeparate(GLES3_BLEND_OPS[(int)target.blendEq],
GLES3_BLEND_OPS[(int)target.blendAlphaEq]));
cacheTarget.blendEq = target.blendEq;
cacheTarget.blendAlphaEq = target.blendAlphaEq;
if (cacheTarget->blendEq != target->blendEq ||
cacheTarget->blendAlphaEq != target->blendAlphaEq) {
glBlendEquationSeparate(GLES3_BLEND_OPS[(int)target->blendEq],
GLES3_BLEND_OPS[(int)target->blendAlphaEq]);
cacheTarget->blendEq = target->blendEq;
cacheTarget->blendAlphaEq = target->blendAlphaEq;
}
if (cacheTarget.blendSrc != target.blendSrc ||
cacheTarget.blendDst != target.blendDst ||
cacheTarget.blendSrcAlpha != target.blendSrcAlpha ||
cacheTarget.blendDstAlpha != target.blendDstAlpha) {
GL_CHECK(glBlendFuncSeparate(GLES3_BLEND_FACTORS[(int)target.blendSrc],
GLES3_BLEND_FACTORS[(int)target.blendDst],
GLES3_BLEND_FACTORS[(int)target.blendSrcAlpha],
GLES3_BLEND_FACTORS[(int)target.blendDstAlpha]));
cacheTarget.blendSrc = target.blendSrc;
cacheTarget.blendDst = target.blendDst;
cacheTarget.blendSrcAlpha = target.blendSrcAlpha;
cacheTarget.blendDstAlpha = target.blendDstAlpha;
if (cacheTarget->blendSrc != target->blendSrc ||
cacheTarget->blendDst != target->blendDst ||
cacheTarget->blendSrcAlpha != target->blendSrcAlpha ||
cacheTarget->blendDstAlpha != target->blendDstAlpha) {
glBlendFuncSeparate(GLES3_BLEND_FACTORS[(int)target->blendSrc],
GLES3_BLEND_FACTORS[(int)target->blendDst],
GLES3_BLEND_FACTORS[(int)target->blendSrcAlpha],
GLES3_BLEND_FACTORS[(int)target->blendDstAlpha]);
cacheTarget->blendSrc = target->blendSrc;
cacheTarget->blendDst = target->blendDst;
cacheTarget->blendSrcAlpha = target->blendSrcAlpha;
cacheTarget->blendDstAlpha = target->blendDstAlpha;
}
if (cacheTarget.blendColorMask != target.blendColorMask) {
GL_CHECK(glColorMask((GLboolean)(target.blendColorMask & ColorMask::R),
(GLboolean)(target.blendColorMask & ColorMask::G),
(GLboolean)(target.blendColorMask & ColorMask::B),
(GLboolean)(target.blendColorMask & ColorMask::A)));
cacheTarget.blendColorMask = target.blendColorMask;
if (cacheTarget->blendColorMask != target->blendColorMask) {
glColorMask((GLboolean)(target->blendColorMask & ColorMask::R),
(GLboolean)(target->blendColorMask & ColorMask::G),
(GLboolean)(target->blendColorMask & ColorMask::B),
(GLboolean)(target->blendColorMask & ColorMask::A));
cacheTarget->blendColorMask = target->blendColorMask;
}
} // if
@@ -1897,15 +1893,15 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
const vector<int> &dynamicOffsetSetIndices = dynamicOffsetIndices[glBlock.set];
int dynamicOffsetIndex = glBlock.binding < dynamicOffsetSetIndices.size() ? dynamicOffsetSetIndices[glBlock.binding] : -1;
if (dynamicOffsetIndex >= 0) offset += dynamicOffsets[dynamicOffsetIndex];
if (dynamicOffsetIndex >= 0) offset += dynamicOffsets[glBlock.set][dynamicOffsetIndex];
if (cache->glBindUBOs[glBlock.glBinding] != gpuDescriptor.gpuBuffer->glBuffer ||
cache->glBindUBOOffsets[glBlock.glBinding] != offset) {
if (offset) {
GL_CHECK(glBindBufferRange(GL_UNIFORM_BUFFER, glBlock.glBinding, gpuDescriptor.gpuBuffer->glBuffer,
offset, gpuDescriptor.gpuBuffer->size));
glBindBufferRange(GL_UNIFORM_BUFFER, glBlock.glBinding, gpuDescriptor.gpuBuffer->glBuffer,
offset, gpuDescriptor.gpuBuffer->size);
} else {
GL_CHECK(glBindBufferBase(GL_UNIFORM_BUFFER, glBlock.glBinding, gpuDescriptor.gpuBuffer->glBuffer));
glBindBufferBase(GL_UNIFORM_BUFFER, glBlock.glBinding, gpuDescriptor.gpuBuffer->glBuffer);
}
cache->glUniformBuffer = cache->glBindUBOs[glBlock.glBinding] = gpuDescriptor.gpuBuffer->glBuffer;
cache->glBindUBOOffsets[glBlock.glBinding] = offset;
@@ -1934,15 +1930,15 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
GLuint glTexture = gpuDescriptor->gpuTexture->glTexture;
if (cache->glTextures[unit] != glTexture) {
if (cache->texUint != unit) {
GL_CHECK(glActiveTexture(GL_TEXTURE0 + unit));
glActiveTexture(GL_TEXTURE0 + unit);
cache->texUint = unit;
}
GL_CHECK(glBindTexture(gpuDescriptor->gpuTexture->glTarget, glTexture));
glBindTexture(gpuDescriptor->gpuTexture->glTarget, glTexture);
cache->glTextures[unit] = glTexture;
}
if (cache->glSamplers[unit] != gpuDescriptor->gpuSampler->glSampler) {
GL_CHECK(glBindSampler(unit, gpuDescriptor->gpuSampler->glSampler));
glBindSampler(unit, gpuDescriptor->gpuSampler->glSampler);
cache->glSamplers[unit] = gpuDescriptor->gpuSampler->glSampler;
}
}
@@ -1951,34 +1947,33 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
} // if
// bind vao
if (gpuInputAssembler && gpuPipelineState && gpuPipelineState->gpuShader &&
if (gpuInputAssembler && gpuPipelineState->gpuShader &&
(isShaderChanged || gpuInputAssembler != gfxStateCache.gpuInputAssembler)) {
gfxStateCache.gpuInputAssembler = gpuInputAssembler;
if (USE_VAO) {
GLuint hash = gpuPipelineState->gpuShader->glProgram ^ device->getThreadID();
GLuint glVAO = gpuInputAssembler->glVAOs[hash];
GLuint glVAO = gpuInputAssembler->glVAOs[gpuPipelineState->gpuShader->glProgram];
if (!glVAO) {
GL_CHECK(glGenVertexArrays(1, &glVAO));
gpuInputAssembler->glVAOs[hash] = glVAO;
GL_CHECK(glBindVertexArray(glVAO));
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, 0));
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
glGenVertexArrays(1, &glVAO);
gpuInputAssembler->glVAOs[gpuPipelineState->gpuShader->glProgram] = glVAO;
glBindVertexArray(glVAO);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
for (size_t j = 0; j < gpuPipelineState->gpuShader->glInputs.size(); ++j) {
const GLES3GPUInput &gpuInput = gpuPipelineState->gpuShader->glInputs[j];
for (size_t a = 0; a < gpuInputAssembler->attributes.size(); ++a) {
const GLES3GPUAttribute &gpuAttribute = gpuInputAssembler->glAttribs[a];
if (gpuAttribute.name == gpuInput.name) {
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, gpuAttribute.glBuffer));
glBindBuffer(GL_ARRAY_BUFFER, gpuAttribute.glBuffer);
for (uint c = 0; c < gpuAttribute.componentCount; ++c) {
GLint glLoc = gpuInput.glLoc + c;
uint attribOffset = gpuAttribute.offset + gpuAttribute.size * c;
GL_CHECK(glEnableVertexAttribArray(glLoc));
glEnableVertexAttribArray(glLoc);
cache->glEnabledAttribLocs[glLoc] = true;
GL_CHECK(glVertexAttribPointer(glLoc, gpuAttribute.count, gpuAttribute.glType, gpuAttribute.isNormalized, gpuAttribute.stride, BUFFER_OFFSET(attribOffset)));
GL_CHECK(glVertexAttribDivisor(glLoc, gpuAttribute.isInstanced ? 1 : 0));
glVertexAttribPointer(glLoc, gpuAttribute.count, gpuAttribute.glType, gpuAttribute.isNormalized, gpuAttribute.stride, BUFFER_OFFSET(attribOffset));
glVertexAttribDivisor(glLoc, gpuAttribute.isInstanced ? 1 : 0);
}
break;
}
@@ -1986,19 +1981,19 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
}
if (gpuInputAssembler->gpuIndexBuffer) {
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gpuInputAssembler->gpuIndexBuffer->glBuffer));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gpuInputAssembler->gpuIndexBuffer->glBuffer);
}
GL_CHECK(glBindVertexArray(0));
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, 0));
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
cache->glVAO = 0;
cache->glArrayBuffer = 0;
cache->glElementArrayBuffer = 0;
}
if (cache->glVAO != glVAO) {
GL_CHECK(glBindVertexArray(glVAO));
glBindVertexArray(glVAO);
cache->glVAO = glVAO;
}
} else {
@@ -2012,18 +2007,18 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
const GLES3GPUAttribute &gpuAttribute = gpuInputAssembler->glAttribs[a];
if (gpuAttribute.name == gpuInput.name) {
if (cache->glArrayBuffer != gpuAttribute.glBuffer) {
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, gpuAttribute.glBuffer));
glBindBuffer(GL_ARRAY_BUFFER, gpuAttribute.glBuffer);
cache->glArrayBuffer = gpuAttribute.glBuffer;
}
for (uint c = 0; c < gpuAttribute.componentCount; ++c) {
GLint glLoc = gpuInput.glLoc + c;
uint attribOffset = gpuAttribute.offset + gpuAttribute.size * c;
GL_CHECK(glEnableVertexAttribArray(glLoc));
glEnableVertexAttribArray(glLoc);
cache->glCurrentAttribLocs[glLoc] = true;
cache->glEnabledAttribLocs[glLoc] = true;
GL_CHECK(glVertexAttribPointer(glLoc, gpuAttribute.count, gpuAttribute.glType, gpuAttribute.isNormalized, gpuAttribute.stride, BUFFER_OFFSET(attribOffset)));
GL_CHECK(glVertexAttribDivisor(glLoc, gpuAttribute.isInstanced ? 1 : 0));
glVertexAttribPointer(glLoc, gpuAttribute.count, gpuAttribute.glType, gpuAttribute.isNormalized, gpuAttribute.stride, BUFFER_OFFSET(attribOffset));
glVertexAttribDivisor(glLoc, gpuAttribute.isInstanced ? 1 : 0);
}
break;
}
@@ -2032,53 +2027,53 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
if (gpuInputAssembler->gpuIndexBuffer) {
if (cache->glElementArrayBuffer != gpuInputAssembler->gpuIndexBuffer->glBuffer) {
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gpuInputAssembler->gpuIndexBuffer->glBuffer));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gpuInputAssembler->gpuIndexBuffer->glBuffer);
cache->glElementArrayBuffer = gpuInputAssembler->gpuIndexBuffer->glBuffer;
}
}
for (uint a = 0; a < cache->glCurrentAttribLocs.size(); ++a) {
if (cache->glEnabledAttribLocs[a] != cache->glCurrentAttribLocs[a]) {
GL_CHECK(glDisableVertexAttribArray(a));
glDisableVertexAttribArray(a);
cache->glEnabledAttribLocs[a] = false;
}
}
}
} // if
if (gpuPipelineState && !gpuPipelineState->dynamicStates.empty()) {
if (gpuPipelineState) {
for (DynamicStateFlagBit dynamicState : gpuPipelineState->dynamicStates) {
switch (dynamicState) {
case DynamicStateFlagBit::VIEWPORT:
if (cache->viewport != viewport) {
GL_CHECK(glViewport(viewport.left, viewport.top, viewport.width, viewport.height));
glViewport(viewport.left, viewport.top, viewport.width, viewport.height);
cache->viewport = viewport;
}
break;
case DynamicStateFlagBit::SCISSOR:
if (cache->scissor != scissor) {
GL_CHECK(glScissor(scissor.x, scissor.y, scissor.width, scissor.height));
glScissor(scissor.x, scissor.y, scissor.width, scissor.height);
cache->scissor = scissor;
}
break;
case DynamicStateFlagBit::LINE_WIDTH:
if (cache->rs.lineWidth != lineWidth) {
GL_CHECK(glLineWidth(lineWidth));
glLineWidth(lineWidth);
cache->rs.lineWidth = lineWidth;
}
break;
case DynamicStateFlagBit::DEPTH_BIAS:
if (cache->rs.depthBiasEnabled != depthBiasEnabled) {
if (depthBiasEnabled)
GL_CHECK(glEnable(GL_POLYGON_OFFSET_FILL));
glEnable(GL_POLYGON_OFFSET_FILL);
else
GL_CHECK(glDisable(GL_POLYGON_OFFSET_FILL));
glDisable(GL_POLYGON_OFFSET_FILL);
cache->rs.depthBiasEnabled = depthBiasEnabled;
}
if ((cache->rs.depthBias != depthBias.constant) ||
(cache->rs.depthBiasSlop != depthBias.slope)) {
GL_CHECK(glPolygonOffset(depthBias.constant, depthBias.slope));
glPolygonOffset(depthBias.constant, depthBias.slope);
cache->rs.depthBias = depthBias.constant;
cache->rs.depthBiasSlop = depthBias.slope;
}
@@ -2088,10 +2083,10 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
(cache->bs.blendColor.y != gpuPipelineState->bs.blendColor.y) ||
(cache->bs.blendColor.z != gpuPipelineState->bs.blendColor.z) ||
(cache->bs.blendColor.w != gpuPipelineState->bs.blendColor.w)) {
GL_CHECK(glBlendColor(gpuPipelineState->bs.blendColor.x,
gpuPipelineState->bs.blendColor.y,
gpuPipelineState->bs.blendColor.z,
gpuPipelineState->bs.blendColor.w));
glBlendColor(gpuPipelineState->bs.blendColor.x,
gpuPipelineState->bs.blendColor.y,
gpuPipelineState->bs.blendColor.z,
gpuPipelineState->bs.blendColor.w);
cache->bs.blendColor = gpuPipelineState->bs.blendColor;
}
break;
@@ -2099,20 +2094,20 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
switch (stencilWriteMask.face) {
case StencilFace::FRONT:
if (cache->dss.stencilWriteMaskFront != stencilWriteMask.writeMask) {
GL_CHECK(glStencilMaskSeparate(GL_FRONT, stencilWriteMask.writeMask));
glStencilMaskSeparate(GL_FRONT, stencilWriteMask.writeMask);
cache->dss.stencilWriteMaskFront = stencilWriteMask.writeMask;
}
break;
case StencilFace::BACK:
if (cache->dss.stencilWriteMaskBack != stencilWriteMask.writeMask) {
GL_CHECK(glStencilMaskSeparate(GL_BACK, stencilWriteMask.writeMask));
glStencilMaskSeparate(GL_BACK, stencilWriteMask.writeMask);
cache->dss.stencilWriteMaskBack = stencilWriteMask.writeMask;
}
break;
case StencilFace::ALL:
if ((cache->dss.stencilWriteMaskFront != stencilWriteMask.writeMask) ||
(cache->dss.stencilWriteMaskBack != stencilWriteMask.writeMask)) {
GL_CHECK(glStencilMask(stencilWriteMask.writeMask));
glStencilMask(stencilWriteMask.writeMask);
cache->dss.stencilWriteMaskFront = stencilWriteMask.writeMask;
cache->dss.stencilWriteMaskBack = stencilWriteMask.writeMask;
}
@@ -2124,10 +2119,10 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
case StencilFace::FRONT:
if ((cache->dss.stencilRefFront != (uint)stencilCompareMask.refrence) ||
(cache->dss.stencilReadMaskFront != stencilCompareMask.compareMask)) {
GL_CHECK(glStencilFuncSeparate(GL_FRONT,
GLES3_CMP_FUNCS[(int)cache->dss.stencilFuncFront],
stencilCompareMask.refrence,
stencilCompareMask.compareMask));
glStencilFuncSeparate(GL_FRONT,
GLES3_CMP_FUNCS[(int)cache->dss.stencilFuncFront],
stencilCompareMask.refrence,
stencilCompareMask.compareMask);
cache->dss.stencilRefFront = stencilCompareMask.refrence;
cache->dss.stencilReadMaskFront = stencilCompareMask.compareMask;
}
@@ -2135,10 +2130,10 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
case StencilFace::BACK:
if ((cache->dss.stencilRefBack != (uint)stencilCompareMask.refrence) ||
(cache->dss.stencilReadMaskBack != stencilCompareMask.compareMask)) {
GL_CHECK(glStencilFuncSeparate(GL_BACK,
GLES3_CMP_FUNCS[(int)cache->dss.stencilFuncBack],
stencilCompareMask.refrence,
stencilCompareMask.compareMask));
glStencilFuncSeparate(GL_BACK,
GLES3_CMP_FUNCS[(int)cache->dss.stencilFuncBack],
stencilCompareMask.refrence,
stencilCompareMask.compareMask);
cache->dss.stencilRefBack = stencilCompareMask.refrence;
cache->dss.stencilReadMaskBack = stencilCompareMask.compareMask;
}
@@ -2148,14 +2143,14 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
(cache->dss.stencilReadMaskFront != stencilCompareMask.compareMask) ||
(cache->dss.stencilRefBack != (uint)stencilCompareMask.refrence) ||
(cache->dss.stencilReadMaskBack != stencilCompareMask.compareMask)) {
GL_CHECK(glStencilFuncSeparate(GL_FRONT,
GLES3_CMP_FUNCS[(int)cache->dss.stencilFuncFront],
stencilCompareMask.refrence,
stencilCompareMask.compareMask));
GL_CHECK(glStencilFuncSeparate(GL_BACK,
GLES3_CMP_FUNCS[(int)cache->dss.stencilFuncBack],
stencilCompareMask.refrence,
stencilCompareMask.compareMask));
glStencilFuncSeparate(GL_FRONT,
GLES3_CMP_FUNCS[(int)cache->dss.stencilFuncFront],
stencilCompareMask.refrence,
stencilCompareMask.compareMask);
glStencilFuncSeparate(GL_BACK,
GLES3_CMP_FUNCS[(int)cache->dss.stencilFuncBack],
stencilCompareMask.refrence,
stencilCompareMask.compareMask);
cache->dss.stencilRefFront = stencilCompareMask.refrence;
cache->dss.stencilReadMaskFront = stencilCompareMask.compareMask;
cache->dss.stencilRefBack = stencilCompareMask.refrence;
@@ -2173,7 +2168,6 @@ void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipeli
}
void GLES3CmdFuncDraw(GLES3Device *device, DrawInfo &drawInfo) {
GLES3ObjectCache &gfxStateCache = device->stateCache()->gfxStateCache;
GLES3GPUPipelineState *gpuPipelineState = gfxStateCache.gpuPipelineState;
GLES3GPUInputAssembler *gpuInputAssembler = gfxStateCache.gpuInputAssembler;
GLenum glPrimitive = gfxStateCache.glPrimitive;
@@ -2185,16 +2179,16 @@ void GLES3CmdFuncDraw(GLES3Device *device, DrawInfo &drawInfo) {
uint8_t *offset = 0;
offset += drawInfo.firstIndex * gpuInputAssembler->gpuIndexBuffer->stride;
if (drawInfo.instanceCount == 0) {
GL_CHECK(glDrawElements(glPrimitive, drawInfo.indexCount, gpuInputAssembler->glIndexType, offset));
glDrawElements(glPrimitive, drawInfo.indexCount, gpuInputAssembler->glIndexType, offset);
} else {
GL_CHECK(glDrawElementsInstanced(glPrimitive, drawInfo.indexCount, gpuInputAssembler->glIndexType, offset, drawInfo.instanceCount));
glDrawElementsInstanced(glPrimitive, drawInfo.indexCount, gpuInputAssembler->glIndexType, offset, drawInfo.instanceCount);
}
}
} else if (drawInfo.vertexCount > 0) {
if (drawInfo.instanceCount == 0) {
GL_CHECK(glDrawArrays(glPrimitive, drawInfo.firstIndex, drawInfo.vertexCount));
glDrawArrays(glPrimitive, drawInfo.firstIndex, drawInfo.vertexCount);
} else {
GL_CHECK(glDrawArraysInstanced(glPrimitive, drawInfo.firstIndex, drawInfo.vertexCount, drawInfo.instanceCount));
glDrawArraysInstanced(glPrimitive, drawInfo.firstIndex, drawInfo.vertexCount, drawInfo.instanceCount);
}
}
} else {
@@ -2205,16 +2199,16 @@ void GLES3CmdFuncDraw(GLES3Device *device, DrawInfo &drawInfo) {
uint8_t *offset = 0;
offset += draw.firstIndex * gpuInputAssembler->gpuIndexBuffer->stride;
if (draw.instanceCount == 0) {
GL_CHECK(glDrawElements(glPrimitive, draw.indexCount, gpuInputAssembler->glIndexType, offset));
glDrawElements(glPrimitive, draw.indexCount, gpuInputAssembler->glIndexType, offset);
} else {
GL_CHECK(glDrawElementsInstanced(glPrimitive, draw.indexCount, gpuInputAssembler->glIndexType, offset, draw.instanceCount));
glDrawElementsInstanced(glPrimitive, draw.indexCount, gpuInputAssembler->glIndexType, offset, draw.instanceCount);
}
}
} else if (draw.vertexCount > 0) {
if (draw.instanceCount == 0) {
GL_CHECK(glDrawArrays(glPrimitive, draw.firstIndex, draw.vertexCount));
glDrawArrays(glPrimitive, draw.firstIndex, draw.vertexCount);
} else {
GL_CHECK(glDrawArraysInstanced(glPrimitive, draw.firstIndex, draw.vertexCount, draw.instanceCount));
glDrawArraysInstanced(glPrimitive, draw.firstIndex, draw.vertexCount, draw.instanceCount);
}
}
}
@@ -2223,7 +2217,6 @@ void GLES3CmdFuncDraw(GLES3Device *device, DrawInfo &drawInfo) {
}
void GLES3CmdFuncUpdateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer, const void *buffer, uint offset, uint size) {
GLES3ObjectCache &gfxStateCache = device->stateCache()->gfxStateCache;
if (gpuBuffer->usage & BufferUsageBit::INDIRECT) {
memcpy((uint8_t *)gpuBuffer->indirects.data() + offset, buffer, size);
} else if (gpuBuffer->usage & BufferUsageBit::TRANSFER_SRC) {
@@ -2232,33 +2225,36 @@ void GLES3CmdFuncUpdateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer, co
switch (gpuBuffer->glTarget) {
case GL_ARRAY_BUFFER: {
if (device->stateCache()->glVAO) {
GL_CHECK(glBindVertexArray(0));
glBindVertexArray(0);
device->stateCache()->glVAO = 0;
gfxStateCache.gpuInputAssembler = nullptr;
}
if (device->stateCache()->glArrayBuffer != gpuBuffer->glBuffer) {
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, gpuBuffer->glBuffer));
glBindBuffer(GL_ARRAY_BUFFER, gpuBuffer->glBuffer);
device->stateCache()->glArrayBuffer = gpuBuffer->glBuffer;
}
GL_CHECK(glBufferSubData(GL_ARRAY_BUFFER, offset, size, buffer));
glBufferSubData(GL_ARRAY_BUFFER, offset, size, buffer);
break;
}
case GL_ELEMENT_ARRAY_BUFFER: {
if (device->stateCache()->glVAO) {
GL_CHECK(glBindVertexArray(0));
glBindVertexArray(0);
device->stateCache()->glVAO = 0;
gfxStateCache.gpuInputAssembler = nullptr;
}
if (device->stateCache()->glElementArrayBuffer != gpuBuffer->glBuffer) {
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gpuBuffer->glBuffer));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gpuBuffer->glBuffer);
device->stateCache()->glElementArrayBuffer = gpuBuffer->glBuffer;
}
GL_CHECK(glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, size, buffer));
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, size, buffer);
break;
}
case GFXCmdType::COPY_BUFFER_TO_TEXTURE: {
GLES3CmdCopyBufferToTexture *cmd = cmdPackage->copyBufferToTextureCmds[cmdIdx];
GLES3CmdFuncCopyBuffersToTexture(device, cmd->buffers, cmd->gpuTexture, cmd->regions, cmd->count);
case GL_UNIFORM_BUFFER: {
if (device->stateCache()->glUniformBuffer != gpuBuffer->glBuffer) {
glBindBuffer(GL_UNIFORM_BUFFER, gpuBuffer->glBuffer);
device->stateCache()->glUniformBuffer = gpuBuffer->glBuffer;
}
glBufferSubData(GL_UNIFORM_BUFFER, offset, size, buffer);
break;
}
default:
@@ -2477,5 +2473,50 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmdPackage) {
}
}
void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmdPackage) {
static uint cmdIndices[(int)GFXCmdType::COUNT] = {0};
memset(cmdIndices, 0, sizeof(cmdIndices));
for (uint i = 0; i < cmdPackage->cmds.size(); ++i) {
GFXCmdType cmdType = cmdPackage->cmds[i];
uint &cmdIdx = cmdIndices[(int)cmdType];
switch (cmdType) {
case GFXCmdType::BEGIN_RENDER_PASS: {
GLES3CmdBeginRenderPass *cmd = cmdPackage->beginRenderPassCmds[cmdIdx];
GLES3CmdFuncBeginRenderPass(device, cmd->gpuRenderPass, cmd->gpuFBO, cmd->renderArea, cmd->numClearColors, cmd->clearColors, cmd->clearDepth, cmd->clearStencil);
break;
}
case GFXCmdType::END_RENDER_PASS: {
GLES3CmdFuncEndRenderPass(device);
break;
}
case GFXCmdType::BIND_STATES: {
GLES3CmdBindStates *cmd = cmdPackage->bindStatesCmds[cmdIdx];
GLES3CmdFuncBindState(device, cmd->gpuPipelineState, cmd->gpuInputAssembler, cmd->gpuDescriptorSets, cmd->dynamicOffsets, cmd->viewport, cmd->scissor, cmd->lineWidth, cmd->depthBiasEnabled, cmd->depthBias, cmd->blendConstants, cmd->depthBounds, cmd->stencilWriteMask, cmd->stencilCompareMask);
break;
} // case BIND_STATES
case GFXCmdType::DRAW: {
GLES3CmdDraw *cmd = cmdPackage->drawCmds[cmdIdx];
GLES3CmdFuncDraw(device, cmd->drawInfo);
break;
}
case GFXCmdType::UPDATE_BUFFER: {
GLES3CmdUpdateBuffer *cmd = cmdPackage->updateBufferCmds[cmdIdx];
GLES3CmdFuncUpdateBuffer(device, cmd->gpuBuffer, cmd->buffer, cmd->offset, cmd->size);
break;
}
case GFXCmdType::COPY_BUFFER_TO_TEXTURE: {
GLES3CmdCopyBufferToTexture *cmd = cmdPackage->copyBufferToTextureCmds[cmdIdx];
GLES3CmdFuncCopyBuffersToTexture(device, cmd->buffers, cmd->gpuTexture, cmd->regions, cmd->count);
break;
}
default:
break;
}
cmdIdx++;
}
}
} // namespace gfx
} // namespace cc
@@ -31,7 +31,18 @@ namespace gfx {
class GLES3Device;
struct GLES3DepthBias final {
struct GLES3ObjectCache {
size_t numClearColors = 0u;
GLES3GPURenderPass *gpuRenderPass = nullptr;
GLES3GPUFramebuffer *gpuFramebuffer = nullptr;
GLES3GPUPipelineState *gpuPipelineState = nullptr;
GLES3GPUInputAssembler *gpuInputAssembler = nullptr;
bool reverseCW = false;
GLenum glPrimitive = 0;
GLenum invalidAttachments[GFX_MAX_ATTACHMENTS];
};
struct GLES3DepthBias {
float constant = 0.0f;
float clamp = 0.0f;
float slope = 0.0f;
@@ -104,7 +115,7 @@ public:
GLES3GPUPipelineState *gpuPipelineState = nullptr;
GLES3GPUInputAssembler *gpuInputAssembler = nullptr;
vector<GLES3GPUDescriptorSet *> gpuDescriptorSets;
vector<uint> dynamicOffsets;
vector<const uint *> dynamicOffsets;
Viewport viewport;
Rect scissor;
float lineWidth = 1.0f;
@@ -231,7 +242,7 @@ CC_GLES3_API void GLES3CmdFuncBeginRenderPass(GLES3Device *device, GLES3GPURende
const Rect &renderArea, size_t numClearColors, const Color *clearColors, float clearDepth, int clearStencil);
CC_GLES3_API void GLES3CmdFuncEndRenderPass(GLES3Device *device);
CC_GLES3_API void GLES3CmdFuncBindState(GLES3Device *device, GLES3GPUPipelineState *gpuPipelineState, GLES3GPUInputAssembler *gpuInputAssembler,
vector<GLES3GPUDescriptorSet *> &gpuDescriptorSets, vector<uint> &dynamicOffsets,
vector<GLES3GPUDescriptorSet *> &gpuDescriptorSets, vector<const uint *> &dynamicOffsets,
Viewport &viewport, Rect &scissor, float lineWidth, bool depthBiasEnabled, GLES3DepthBias &depthBias, Color &blendConstants,
GLES3DepthBounds &depthBounds, GLES3StencilWriteMask &stencilWriteMask, GLES3StencilCompareMask &stencilCompareMask);
CC_GLES3_API void GLES3CmdFuncDraw(GLES3Device *device, DrawInfo &drawInfo);
+32 -15
View File
@@ -25,6 +25,7 @@ THE SOFTWARE.
#include "GLES3Buffer.h"
#include "GLES3CommandBuffer.h"
#include "GLES3PrimaryCommandBuffer.h"
#include "GLES3Context.h"
#include "GLES3DescriptorSet.h"
#include "GLES3DescriptorSetLayout.h"
@@ -79,7 +80,7 @@ bool GLES3Device::initialize(const DeviceInfo &info) {
destroy();
return false;
}
bindRenderContext(true);
_context = _initContext;
String extStr = (const char *)glGetString(GL_EXTENSIONS);
_extensions = StringUtil::Split(extStr, " ");
@@ -171,9 +172,6 @@ bool GLES3Device::initialize(const DeviceInfo &info) {
_gpuStateCache->initialize(_maxTextureUnits, _maxUniformBufferBindings, _maxVertexAttributes);
_initContext->MakeCurrent(false);
_context = _initContext;
return true;
}
@@ -216,22 +214,41 @@ void GLES3Device::present() {
queue->_numTriangles = 0;
}
void GLES3Device::makeCurrent() {
if (!_renderContext) {
ContextInfo ctxInfo;
ctxInfo.windowHandle = _windowHandle;
ctxInfo.sharedCtx = _initContext;
_renderContext = CC_NEW(GLES3Context(this));
_renderContext->initialize(ctxInfo);
_context = _renderContext;
void GLES3Device::setImmediateMode(bool immediateMode) {
if (immediateMode) {
_renderContext->MakeCurrent(false);
_initContext->MakeCurrent();
} else {
_renderContext->MakeCurrent();
_initContext->MakeCurrent(false);
/*if (!_renderContext) {
ENCODE_COMMAND_1(
getMainEncoder(),
DeviceInitThread,
device, this,
{
ContextInfo ctxInfo;
ctxInfo.windowHandle = _windowHandle;
ctxInfo.sharedCtx = _initContext;
device->_renderContext = CC_NEW(GLES3Context(device));
device->_renderContext->initialize(ctxInfo);
device->_context = device->_renderContext;
});
} else {
ENCODE_COMMAND_1(
getMainEncoder(),
DeviceInitThread,
device, this,
{
_renderContext->MakeCurrent();
});
}*/
}
}
CommandBuffer *GLES3Device::createCommandBuffer() {
return CC_NEW(GLES3CommandBuffer(this));
return CC_NEW(GLES3PrimaryCommandBuffer(this));
}
Fence *GLES3Device::createFence() {
@@ -72,7 +72,7 @@ public:
virtual PipelineLayout *createPipelineLayout() override;
virtual PipelineState *createPipelineState() override;
virtual void copyBuffersToTexture(const uint8_t *const *buffers, Texture *dst, const BufferTextureCopy *regions, uint count) override;
virtual void makeCurrent() override;
virtual void setImmediateMode(bool immediateMode) override;
CC_INLINE GLES3GPUStateCache *stateCache() const { return _gpuStateCache; }
CC_INLINE GLES3GPUStagingBufferPool *stagingBufferPool() const { return _gpuStagingBufferPool; }
@@ -55,7 +55,7 @@ bool GLES3PipelineLayout::initialize(const PipelineLayoutInfo &info) {
for (uint j = 0u; j < dynamicCount; j++) {
uint binding = gpuSetLayout->dynamicBindings[j];
if (indices[binding] < 0) indices[binding] = offset + j;
if (indices[binding] < 0) indices[binding] = j;
}
_gpuPipelineLayout->dynamicOffsetOffsets.push_back(offset);
_gpuPipelineLayout->setLayouts.push_back(gpuSetLayout);
@@ -1,26 +1,3 @@
/****************************************************************************
Copyright (c) 2020 Xiamen Yaji Software Co., Ltd.
http://www.cocos2d-x.org
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 "GLES3Std.h"
#include "GLES3Buffer.h"
@@ -43,7 +20,7 @@ GLES3PrimaryCommandBuffer::GLES3PrimaryCommandBuffer(Device *device)
GLES3PrimaryCommandBuffer::~GLES3PrimaryCommandBuffer() {
}
void GLES3PrimaryCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fbo, const Rect &renderArea, const Color *colors, float depth, int stencil, bool fromSecondaryCB) {
void GLES3PrimaryCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fbo, const Rect &renderArea, const Color *colors, float depth, int stencil) {
_isInRenderPass = true;
GLES3GPURenderPass *gpuRenderPass = ((GLES3RenderPass *)renderPass)->gpuRenderPass();
GLES3GPUFramebuffer *gpuFramebuffer = ((GLES3Framebuffer *)fbo)->gpuFBO();
@@ -62,18 +39,7 @@ void GLES3PrimaryCommandBuffer::draw(InputAssembler *ia) {
(_type == CommandBufferType::SECONDARY)) {
if (_isStateInvalid) {
vector<uint> &dynamicOffsetOffsets = _curGPUPipelineState->gpuPipelineLayout->dynamicOffsetOffsets;
vector<uint> &dynamicOffsets = _curGPUPipelineState->gpuPipelineLayout->dynamicOffsets;
for (size_t i = 0u; i < _curDynamicOffsets.size(); i++) {
size_t count = dynamicOffsetOffsets[i + 1] - dynamicOffsetOffsets[i];
//CCASSERT(_curDynamicOffsets[i].size() >= count, "missing dynamic offsets?");
count = std::min(count, _curDynamicOffsets[i].size());
if (count) memcpy(&dynamicOffsets[dynamicOffsetOffsets[i]], _curDynamicOffsets[i].data(), count * sizeof(uint));
}
GLES3CmdFuncBindState((GLES3Device *)_device, _curGPUPipelineState, _curGPUInputAssember, _curGPUDescriptorSets, dynamicOffsets,
_curViewport, _curScissor, _curLineWidth, false, _curDepthBias, _curBlendConstants, _curDepthBounds, _curStencilWriteMask, _curStencilCompareMask);
_isStateInvalid = false;
BindStates();
}
DrawInfo drawInfo;
@@ -102,13 +68,13 @@ void GLES3PrimaryCommandBuffer::draw(InputAssembler *ia) {
}
}
void GLES3PrimaryCommandBuffer::updateBuffer(Buffer *buff, const void *data, uint size) {
void GLES3PrimaryCommandBuffer::updateBuffer(Buffer *buff, const void *data, uint size, uint offset) {
if ((_type == CommandBufferType::PRIMARY && !_isInRenderPass) ||
(_type == CommandBufferType::SECONDARY)) {
GLES3GPUBuffer *gpuBuffer = ((GLES3Buffer *)buff)->gpuBuffer();
if (gpuBuffer) {
GLES3CmdFuncUpdateBuffer((GLES3Device *)_device, gpuBuffer, data, 0u, size);
GLES3CmdFuncUpdateBuffer((GLES3Device *)_device, gpuBuffer, data, offset, size);
}
} else {
CC_LOG_ERROR("Command 'updateBuffer' must be recorded outside a render pass.");
@@ -131,18 +97,20 @@ void GLES3PrimaryCommandBuffer::copyBuffersToTexture(const uint8_t *const *buffe
void GLES3PrimaryCommandBuffer::execute(const CommandBuffer *const *cmdBuffs, uint32_t count) {
for (uint i = 0; i < count; ++i) {
GLES3PrimaryCommandBuffer *cmdBuff = (GLES3PrimaryCommandBuffer *)cmdBuffs[i];
GLES3CmdPackage *cmdPackage = cmdBuff->_pendingPackages.front();
GLES3CmdFuncExecuteCmds((GLES3Device *)_device, cmdBuff->_cmdPackage);
GLES3CmdFuncExecuteCmds((GLES3Device *)_device, cmdPackage);
_numDrawCalls += cmdBuff->_numDrawCalls;
_numInstances += cmdBuff->_numInstances;
_numTriangles += cmdBuff->_numTriangles;
cmdBuff->_pendingPackages.pop();
cmdBuff->_freePackages.push(cmdPackage);
_numDrawCalls += cmdBuff->getNumDrawCalls();
_numInstances += cmdBuff->getNumInstances();
_numTriangles += cmdBuff->getNumTris();
}
}
void GLES3PrimaryCommandBuffer::BindStates() {
GLES3CmdFuncBindState((GLES3Device *)_device, _curGPUPipelineState, _curGPUInputAssember, _curGPUDescriptorSets, _curDynamicOffsets,
_curViewport, _curScissor, _curLineWidth, false, _curDepthBias, _curBlendConstants, _curDepthBounds, _curStencilWriteMask, _curStencilCompareMask);
_isStateInvalid = false;
}
} // namespace gfx
} // namespace cc
@@ -1,26 +1,3 @@
/****************************************************************************
Copyright (c) 2020 Xiamen Yaji Software Co., Ltd.
http://www.cocos2d-x.org
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.
****************************************************************************/
#ifndef CC_GFXGLES3_PRIMARY_COMMAND_BUFFER_H_
#define CC_GFXGLES3_PRIMARY_COMMAND_BUFFER_H_
@@ -29,19 +6,24 @@ THE SOFTWARE.
namespace cc {
namespace gfx {
class CC_GLES3_API GLES3PrimaryCommandBuffer final : public GLES3CommandBuffer {
class CC_GLES3_API GLES3PrimaryCommandBuffer : public GLES3CommandBuffer {
friend class GLES3Queue;
public:
GLES3PrimaryCommandBuffer(Device *device);
~GLES3PrimaryCommandBuffer();
virtual void beginRenderPass(RenderPass *renderPass, Framebuffer *fbo, const Rect &renderArea, const Color *colors, float depth, int stencil, bool fromSecondaryCB) override;
virtual void beginRenderPass(RenderPass *renderPass, Framebuffer *fbo, const Rect &renderArea, const Color *colors, float depth, int stencil) override;
virtual void endRenderPass() override;
virtual void draw(InputAssembler *ia) override;
virtual void updateBuffer(Buffer *buff, const void *data, uint size) override;
virtual void updateBuffer(Buffer *buff, const void *data, uint size, uint offset) override;
virtual void copyBuffersToTexture(const uint8_t *const *buffers, Texture *texture, const BufferTextureCopy *regions, uint count) override;
virtual void execute(const CommandBuffer *const *cmdBuffs, uint32_t count) override;
protected:
virtual void BindStates() override;
private:
};
} // namespace gfx
+5 -11
View File
@@ -48,17 +48,11 @@ void GLES3Queue::destroy() {
void GLES3Queue::submit(const CommandBuffer *const *cmdBuffs, uint count, Fence *fence) {
if (!_isAsync) {
for (uint i = 0; i < count; ++i) {
GLES3CommandBuffer *cmdBuff = (GLES3CommandBuffer *)cmdBuffs[i];
GLES3CmdPackage *cmdPackage = cmdBuff->_pendingPackages.front();
GLES3CmdFuncExecuteCmds((GLES3Device *)_device, cmdPackage);
_numDrawCalls += cmdBuff->_numDrawCalls;
_numInstances += cmdBuff->_numInstances;
_numTriangles += cmdBuff->_numTriangles;
cmdBuff->_pendingPackages.pop();
cmdBuff->_freePackages.push(cmdPackage);
GLES3CommandBuffer *cmdBuffer = (GLES3CommandBuffer *)cmdBuffs[i];
//GLES3CmdFuncExecuteCmds((GLES3Device *)_device, cmdBuffer->_cmdPackage);
_numDrawCalls += cmdBuffer->_numDrawCalls;
_numInstances += cmdBuffer->_numInstances;
_numTriangles += cmdBuffer->_numTriangles;
}
}
}