Files
cocos4/native/cocos/renderer/gfx/DeviceGraphics.cpp
T
2019-05-16 19:33:23 +08:00

1161 lines
39 KiB
C++

/****************************************************************************
Copyright (c) 2018 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 "DeviceGraphics.h"
#include "VertexBuffer.h"
#include "IndexBuffer.h"
#include "FrameBuffer.h"
#include "GraphicsHandle.h"
#include "Texture2D.h"
#include "RenderTarget.h"
#include "Program.h"
#include "GFXUtils.h"
#include "platform/CCPlatformConfig.h"
#include "base/CCGLUtils.h"
RENDERER_BEGIN
static_assert(sizeof(int) == sizeof(GLint), "ERROR: GLint isn't equal to int!");
static_assert(sizeof(float) == sizeof(GLfloat), "ERROR: GLfloat isn't equal to float!");
namespace
{
void attach(GLenum location, const RenderTarget* target)
{
if (nullptr != dynamic_cast<const Texture2D*>(target))
{
GL_CHECK(glFramebufferTexture2D(GL_FRAMEBUFFER, location, GL_TEXTURE_2D, target->getHandle(), 0));
}
else
{
GL_CHECK(glFramebufferRenderbuffer(GL_FRAMEBUFFER, location, GL_RENDERBUFFER, target->getHandle()));
}
}
} // namespace {
DeviceGraphics* DeviceGraphics::getInstance()
{
static DeviceGraphics* __instance = nullptr;
if (__instance == nullptr)
__instance = new (std::nothrow) DeviceGraphics();
return __instance;
}
bool DeviceGraphics::supportGLExtension(const std::string& extension) const
{
return (_glExtensions && strstr(_glExtensions, extension.c_str() ) ) ? true : false;
}
void DeviceGraphics::setFrameBuffer(const FrameBuffer* fb)
{
if (fb == _frameBuffer)
return;
RENDERER_SAFE_RELEASE(_frameBuffer);
_frameBuffer = const_cast<FrameBuffer*>(fb);
RENDERER_SAFE_RETAIN(_frameBuffer);
if (nullptr == fb)
{
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, _defaultFbo));
return;
}
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, fb->getHandle()));
int i = 0;
const auto& colorBuffers = fb->getColorBuffers();
for (const auto& colorBuffer : colorBuffers)
attach(GL_COLOR_ATTACHMENT0 + i, colorBuffer);
for (i = static_cast<int>(colorBuffers.size()); i < _caps.maxColorAttatchments; ++i)
{
GL_CHECK(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, 0, 0));
}
if (0 == colorBuffers.size())
{
// If not draw buffer is needed, should invoke this line explicitly, or it will cause
// GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER and GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER error.
// https://stackoverflow.com/questions/28313782/porting-opengl-es-framebuffer-to-opengl
#if (CC_TARGET_PLATFORM == CC_PLATFORM_MAC)
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
#endif
}
if (_frameBuffer->getDepthBuffer())
attach(GL_DEPTH_ATTACHMENT, _frameBuffer->getDepthBuffer());
if (_frameBuffer->getStencilBuffer())
attach(GL_STENCIL_ATTACHMENT, _frameBuffer->getStencilBuffer());
// if (_frameBuffer->getDepthStencilBuffer())
// attach(GL_DEPTH_STENCIL_ATTACHMENT, _frameBuffer->getDepthStencilBuffer());
auto result = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (GL_FRAMEBUFFER_COMPLETE != result)
RENDERER_LOGE("Framebuffer status error: 0x%x", result);
}
void DeviceGraphics::setViewport(int x, int y, int w, int h)
{
if (_vx != x ||
_vy != y ||
_vw != w ||
_vh != h)
{
_vx = x;
_vy = y;
_vw = w;
_vh = h;
GL_CHECK(ccViewport(_vx, _vy, _vw, _vh));
}
}
void DeviceGraphics::setScissor(int x, int y, int w, int h)
{
if (_sx != x ||
_sy != y ||
_sw != w ||
_sh != h)
{
_sx = x;
_sy = y;
_sw = w;
_sh = h;
ccScissor(_sx, _sy, _sw, _sh);
}
}
void DeviceGraphics::clear(uint8_t flags, Color4F *color, double depth, int32_t stencil)
{
GLbitfield mask = 0;
if (flags & ClearFlag::COLOR)
{
mask |= GL_COLOR_BUFFER_BIT;
GL_CHECK(glClearColor(color->r, color->g, color->b, color->a));
}
if (flags & ClearFlag::DEPTH)
{
mask |= GL_DEPTH_BUFFER_BIT;
GL_CHECK(glClearDepth(depth));
GL_CHECK(glEnable(GL_DEPTH_TEST));
GL_CHECK(glDepthMask(GL_TRUE));
GL_CHECK(glDepthFunc(GL_ALWAYS));
}
if (flags & ClearFlag::STENCIL)
{
mask |= GL_STENCIL_BUFFER_BIT;
GL_CHECK(glClearStencil(stencil));
}
GL_CHECK(glClear(mask));
// Restore depth related state.
if (flags & ClearFlag::DEPTH)
{
if (!_currentState.depthTest)
{
GL_CHECK(glDisable(GL_DEPTH_TEST));
}
else
{
if (!_currentState.depthWrite)
{
GL_CHECK(glDepthMask(GL_FALSE));
}
if (_currentState.depthFunc != DepthFunc::ALWAYS)
{
GL_CHECK(glDepthFunc(static_cast<GLenum>(_currentState.depthFunc)));
}
}
}
}
void DeviceGraphics::enableBlend()
{
_nextState.blend = true;
}
void DeviceGraphics::enableDepthTest()
{
_nextState.depthTest = true;
}
void DeviceGraphics::enableDepthWrite()
{
_nextState.depthWrite = true;
}
void DeviceGraphics::enableStencilTest()
{
_nextState.stencilTest = true;
}
void DeviceGraphics::setStencilFunc(StencilFunc func, int ref, unsigned int mask)
{
_nextState.stencilSeparation = false;
_nextState.stencilFuncFront = _nextState.stencilFuncBack = func;
_nextState.stencilRefFront = _nextState.stencilRefBack = ref;
_nextState.stencilMaskFront = _nextState.stencilMaskBack = mask;
}
void DeviceGraphics::setStencilFuncFront(StencilFunc func, int ref, unsigned int mask)
{
_nextState.stencilSeparation = true;
_nextState.stencilFuncFront = func;
_nextState.stencilRefFront = ref;
_nextState.stencilMaskFront = mask;
}
void DeviceGraphics::setStencilFuncBack(StencilFunc func, int ref, unsigned int mask)
{
_nextState.stencilSeparation = true;
_nextState.stencilFuncBack = func;
_nextState.stencilRefBack = ref;
_nextState.stencilMaskBack = mask;
}
void DeviceGraphics::setStencilOp(StencilOp failOp, StencilOp zFailOp, StencilOp zPassOp, unsigned int writeMask)
{
_nextState.stencilFailOpFront = _nextState.stencilFailOpBack = failOp;
_nextState.stencilZFailOpFront = _nextState.stencilZFailOpBack = zFailOp;
_nextState.stencilZPassOpFront = _nextState.stencilZPassOpBack = zPassOp;
_nextState.stencilWriteMaskFront = _nextState.stencilWriteMaskBack = writeMask;
}
void DeviceGraphics::setStencilOpFront(StencilOp failOp, StencilOp zFailOp, StencilOp zPassOp, unsigned int writeMask)
{
_nextState.stencilSeparation = true;
_nextState.stencilFailOpFront = failOp;
_nextState.stencilZFailOpFront = zFailOp;
_nextState.stencilZPassOpFront = zPassOp;
_nextState.stencilWriteMaskFront = writeMask;
}
void DeviceGraphics::setStencilOpBack(StencilOp failOp, StencilOp zFailOp, StencilOp zPassOp, unsigned int writeMask)
{
_nextState.stencilSeparation = true;
_nextState.stencilFailOpBack = failOp;
_nextState.stencilZFailOpBack = zFailOp;
_nextState.stencilZPassOpBack = zPassOp;
_nextState.stencilWriteMaskBack = writeMask;
}
void DeviceGraphics::setDepthFunc(DepthFunc func)
{
_nextState.depthFunc = func;
}
void DeviceGraphics::setBlendColor(uint32_t rgba)
{
_nextState.blendColor = rgba;
}
void DeviceGraphics::setBlendColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
{
_nextState.blendColor = (r << 24) | (g << 16) | (b << 8) | a;
}
void DeviceGraphics::setBlendFunc(BlendFactor src, BlendFactor dst)
{
_nextState.blendSeparation = false;
_nextState.blendSrc = src;
_nextState.blendDst = dst;
}
void DeviceGraphics::setBlendFuncSeparate(BlendFactor srcRGB, BlendFactor dstRGB, BlendFactor srcAlpha, BlendFactor dstAlpha)
{
_nextState.blendSeparation = true;
_nextState.blendSrc = srcRGB;
_nextState.blendDst = dstRGB;
_nextState.blendSrcAlpha = srcAlpha;
_nextState.blendDstAlpha = dstAlpha;
}
void DeviceGraphics::setBlendEquation(BlendOp mode)
{
_nextState.blendSeparation = false;
_nextState.blendEq = mode;
}
void DeviceGraphics::setBlendEquationSeparate(BlendOp modeRGB, BlendOp modeAlpha)
{
_nextState.blendSeparation = true;
_nextState.blendEq = modeRGB;
_nextState.blendAlphaEq = modeAlpha;
}
void DeviceGraphics::setCullMode(CullMode mode)
{
_nextState.cullMode = mode;
}
void DeviceGraphics::setVertexBuffer(int stream, VertexBuffer* buffer, int start /*= 0*/)
{
_nextState.setVertexBuffer(stream, buffer);
_nextState.setVertexBufferOffset(stream, start);
if (_nextState.maxStream < stream) {
_nextState.maxStream = stream;
}
}
void DeviceGraphics::setIndexBuffer(IndexBuffer *buffer)
{
_nextState.setIndexBuffer(buffer);
}
void DeviceGraphics::setProgram(Program *program)
{
_nextState.setProgram(program);
}
void DeviceGraphics::setTexture(const std::string& name, Texture* texture, int slot)
{
if (slot >= _caps.maxTextureUnits)
{
RENDERER_LOGW("Can not set texture %s at stage %d, max texture exceed: %d",
name.c_str(), slot, _caps.maxTextureUnits);
return;
}
_nextState.setTexture(slot, texture);
setUniformi(name, slot);
}
void DeviceGraphics::setTextureArray(const std::string& name, const std::vector<Texture*>& textures, const std::vector<int>& slots)
{
auto len = textures.size();
if (len >= _caps.maxTextureUnits)
{
RENDERER_LOGW("Can not set %d textures for %s, max texture exceed: %d",
(int)len, name.c_str(), _caps.maxTextureUnits);
return;
}
for (size_t i = 0; i < len; ++i)
{
auto slot = slots[i];
_nextState.setTexture(slot, textures[i]);
}
setUniformiv(name, slots.size(), slots.data());
}
void DeviceGraphics::setPrimitiveType(PrimitiveType type)
{
_nextState.primitiveType = type;
}
void DeviceGraphics::draw(size_t base, GLsizei count)
{
commitBlendStates();
commitDepthStates();
commitStencilStates();
commitCullMode();
commitVertexBuffer();
auto nextIndexBuffer = _nextState.getIndexBuffer();
if (_currentState.getIndexBuffer() != nextIndexBuffer)
{
GL_CHECK(ccBindBuffer(GL_ELEMENT_ARRAY_BUFFER, nextIndexBuffer ? nextIndexBuffer->getHandle() : 0));
}
//commit program
bool programDirty = false;
if (_currentState.getProgram() != _nextState.getProgram())
{
if (_nextState.getProgram()->isLinked())
{
GL_CHECK(glUseProgram(_nextState.getProgram()->getHandle()));
}
else
RENDERER_LOGW("Failed to use program: has not linked yet.");
programDirty = true;
}
commitTextures();
//commit uniforms
const auto& uniformsInfo = _nextState.getProgram()->getUniforms();
for (const auto& uniformInfo : uniformsInfo)
{
auto iter = _uniforms.find(uniformInfo.name);
if (_uniforms.end() == iter)
continue;
auto& uniform = iter->second;
if (!programDirty && !uniform.dirty)
continue;
uniform.dirty = false;
uniformInfo.setUniform(uniform.value, uniform.elementType);
}
// draw primitives
if (nextIndexBuffer)
{
GL_CHECK(glDrawElements(ENUM_CLASS_TO_GLENUM(_nextState.primitiveType),
count,
ENUM_CLASS_TO_GLENUM(nextIndexBuffer->getFormat()),
(GLvoid *)(base * nextIndexBuffer->getBytesPerIndex())));
}
else
{
GL_CHECK(glDrawArrays(ENUM_CLASS_TO_GLENUM(_nextState.primitiveType), (GLint)base, count));
}
_drawCalls++;
_currentState = std::move(_nextState);
}
void DeviceGraphics::setUniform(const std::string& name, const void* v, size_t bytes, UniformElementType elementType)
{
auto iter = _uniforms.find(name);
if (iter == _uniforms.end())
{
Uniform uniform(v, bytes, elementType);
_uniforms[name] = std::move(uniform);
}
else
{
auto& uniform = iter->second;
uniform.dirty = true;
uniform.setValue(v, bytes);
}
}
void DeviceGraphics::setUniformi(const std::string& name, int i1)
{
setUniform(name, &i1, sizeof(int), UniformElementType::INT);
}
void DeviceGraphics::setUniformi(const std::string& name, int i1, int i2)
{
int tempValue[] = {i1, i2};
setUniform(name, tempValue, 2 * sizeof(int), UniformElementType::INT);
}
void DeviceGraphics::setUniformi(const std::string& name, int i1, int i2, int i3)
{
int tempValue[] = {i1, i2, i3};
setUniform(name, tempValue, 3 * sizeof(int), UniformElementType::INT);
}
void DeviceGraphics::setUniformi(const std::string& name, int i1, int i2, int i3, int i4)
{
int tempValue[] = {i1, i2, i3, i4};
setUniform(name, tempValue, 4 * sizeof(int), UniformElementType::INT);
}
void DeviceGraphics::setUniformiv(const std::string& name, size_t count, const int* value)
{
setUniform(name, value, count * sizeof(int), UniformElementType::INT);
}
void DeviceGraphics::setUniformf(const std::string& name, float f1)
{
setUniform(name, &f1, sizeof(float), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformf(const std::string& name, float f1, float f2)
{
float tempValue[] = {f1, f2};
setUniform(name, tempValue, 2 * sizeof(float), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformf(const std::string& name, float f1, float f2, float f3)
{
float tempValue[] = {f1, f2, f3};
setUniform(name, tempValue, 3 * sizeof(float), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformf(const std::string& name, float f1, float f2, float f3, float f4)
{
float tempValue[] = {f1, f2, f3, f4};
setUniform(name, tempValue, 4 * sizeof(float), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformfv(const std::string& name, size_t count, const float* value)
{
setUniform(name, value, count * sizeof(float), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformVec2(const std::string& name, const cocos2d::Vec2& value)
{
setUniform(name, &value, sizeof(Vec2), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformVec3(const std::string& name, const cocos2d::Vec3& value)
{
setUniform(name, &value, sizeof(Vec3), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformVec4(const std::string& name, const cocos2d::Vec4& value)
{
setUniform(name, &value, sizeof(Vec4), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformMat2(const std::string& name, float* value)
{
setUniform(name, value, 4 * sizeof(float), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformMat3(const std::string& name, float* value)
{
setUniform(name, value, 9 * sizeof(float), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformMat4(const std::string& name, float* value)
{
setUniform(name, value, 16 * sizeof(float), UniformElementType::FLOAT);
}
void DeviceGraphics::setUniformMat4(const std::string& name, const cocos2d::Mat4& value)
{
setUniform(name, value.m, 16 * sizeof(float), UniformElementType::FLOAT);
}
//
// Priviate funcitons.
//
DeviceGraphics::DeviceGraphics()
: _vx(0)
, _vy(0)
, _vw(0)
, _vh(0)
, _sx(0)
, _sy(0)
, _sw(0)
, _sh(0)
, _frameBuffer(nullptr)
{
_glExtensions = (char *)glGetString(GL_EXTENSIONS);
initCaps();
initStates();
_newAttributes.resize(_caps.maxVertexAttributes);
_enabledAtrributes.resize(_caps.maxVertexAttributes);
// Make sure _currentState and _nextState have enough sapce for textures.
_currentState.setTexture(_caps.maxTextureUnits, nullptr);
_nextState.setTexture(_caps.maxTextureUnits, nullptr);
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &_defaultFbo);
}
DeviceGraphics::~DeviceGraphics()
{
delete _glExtensions;
RENDERER_SAFE_RELEASE(_frameBuffer);
}
void DeviceGraphics::initCaps()
{
GL_CHECK(glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &_caps.maxVextexTextures));
GL_CHECK(glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &_caps.maxVertexAttributes));
// Need to emulate MAX_FRAGMENT/VERTEX_UNIFORM_VECTORS and MAX_VARYING_VECTORS
// because desktop GL's corresponding queries return the number of components
// whereas GLES2 return the number of vectors (each vector has 4 components).
// Therefore, the value returned by desktop GL needs to be divided by 4.
#if (CC_TARGET_PLATFORM == CC_PLATFORM_MAC) || (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
GL_CHECK(glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &_caps.maxFragUniforms));
_caps.maxFragUniforms /= 4;
#else
GL_CHECK(glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &_caps.maxFragUniforms));
#endif
GL_CHECK(glGetIntegerv(GL_MAX_TEXTURE_UNITS, &_caps.maxTextureUnits));
#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
// IDEA: how to get these infomations
_caps.maxColorAttatchments = 1;
_caps.maxDrawBuffers = 1;
#else
GL_CHECK(glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &_caps.maxColorAttatchments));
GL_CHECK(glGetIntegerv(GL_MAX_DRAW_BUFFERS, &_caps.maxDrawBuffers));
#endif
RENDERER_LOGD("Device caps: maxVextexTextures: %d, maxFragUniforms: %d, maxTextureUints: %d, maxVertexAttributes: %d, maxDrawBuffers: %d, maxColorAttatchments: %d",
_caps.maxVextexTextures, _caps.maxFragUniforms, _caps.maxTextureUnits, _caps.maxVertexAttributes, _caps.maxDrawBuffers, _caps.maxColorAttatchments);
}
void DeviceGraphics::initStates()
{
GL_CHECK(glDisable(GL_BLEND));
GL_CHECK(glBlendFunc(GL_ONE, GL_ZERO));
GL_CHECK(glBlendEquation(GL_FUNC_ADD));
GL_CHECK(glBlendColor(1, 1, 1, 1));
GL_CHECK(glColorMask(true, true, true, true));
GL_CHECK(glEnable(GL_CULL_FACE));
GL_CHECK(glCullFace(GL_BACK));
GL_CHECK(glDisable(GL_DEPTH_TEST));
GL_CHECK(glDepthFunc(GL_LESS));
GL_CHECK(glDepthMask(GL_FALSE));
GL_CHECK(glDisable(GL_POLYGON_OFFSET_FILL));
GL_CHECK(glDepthRange(0, 1));
GL_CHECK(glDisable(GL_STENCIL_TEST));
GL_CHECK(glStencilFunc(GL_ALWAYS, 0, 0xff));
GL_CHECK(glStencilMask(0xff));
GL_CHECK(glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP));
GL_CHECK(glClearDepth(1));
GL_CHECK(glClearColor(0, 0, 0, 0));
GL_CHECK(glClearStencil(0));
GL_CHECK(glDisable(GL_SCISSOR_TEST));
}
void DeviceGraphics::restoreTexture(uint32_t index)
{
auto texture = _currentState.getTexture(index);
if (texture)
{
GL_CHECK(glBindTexture(texture->getTarget(), texture->getHandle()));
}
else
{
GL_CHECK(glBindTexture(GL_TEXTURE_2D, 0));
}
}
void DeviceGraphics::restoreIndexBuffer()
{
auto ib = _currentState.getIndexBuffer();
GL_CHECK(ccBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib ? ib->getHandle(): 0));
}
void DeviceGraphics::commitBlendStates()
{
if (_currentState.blend != _nextState.blend)
{
if (!_nextState.blend)
{
glDisable(GL_BLEND);
return;
}
glEnable(GL_BLEND);
if (_nextState.blendSrc == BlendFactor::CONSTANT_COLOR ||
_nextState.blendSrc == BlendFactor::ONE_MINUS_CONSTANT_COLOR ||
_nextState.blendDst == BlendFactor::CONSTANT_COLOR ||
_nextState.blendDst == BlendFactor::ONE_MINUS_CONSTANT_COLOR)
{
GL_CHECK(glBlendColor((_nextState.blendColor >> 24) / 255.f,
(_nextState.blendColor >> 16 & 0xff) / 255.f,
(_nextState.blendColor >> 8 & 0xff) / 255.f,
(_nextState.blendColor & 0xff) / 255.f));
}
if (_nextState.blendSeparation)
{
GL_CHECK(glBlendFuncSeparate(ENUM_CLASS_TO_GLENUM(_nextState.blendSrc),
ENUM_CLASS_TO_GLENUM(_nextState.blendDst),
ENUM_CLASS_TO_GLENUM(_nextState.blendSrcAlpha),
ENUM_CLASS_TO_GLENUM(_nextState.blendDstAlpha)));
GL_CHECK(glBlendEquationSeparate(ENUM_CLASS_TO_GLENUM(_nextState.blendEq),
ENUM_CLASS_TO_GLENUM(_nextState.blendAlphaEq)));
}
else
{
GL_CHECK(glBlendFunc(ENUM_CLASS_TO_GLENUM(_nextState.blendSrc),
ENUM_CLASS_TO_GLENUM(_nextState.blendDst)));
GL_CHECK(glBlendEquation(ENUM_CLASS_TO_GLENUM(_nextState.blendEq)));
}
return;
}
if (_nextState.blend == false)
return;
if (_currentState.blendColor != _nextState.blendColor)
glBlendColor((_nextState.blendColor >> 24) / 255.f,
(_nextState.blendColor >> 16 & 0xff) / 255.f,
(_nextState.blendColor >> 8 & 0xff) / 255.f,
(_nextState.blendColor & 0xff) / 255.f);
if (_currentState.blendSeparation != _nextState.blendSeparation)
{
if (_nextState.blendSeparation)
{
GL_CHECK(glBlendFuncSeparate(ENUM_CLASS_TO_GLENUM(_nextState.blendSrc),
ENUM_CLASS_TO_GLENUM(_nextState.blendDst),
ENUM_CLASS_TO_GLENUM(_nextState.blendSrcAlpha),
ENUM_CLASS_TO_GLENUM(_nextState.blendDstAlpha)));
GL_CHECK(glBlendEquationSeparate(ENUM_CLASS_TO_GLENUM(_nextState.blendEq),
ENUM_CLASS_TO_GLENUM(_nextState.blendAlphaEq)));
}
else
{
GL_CHECK(glBlendFunc(ENUM_CLASS_TO_GLENUM(_nextState.blendSrc),
ENUM_CLASS_TO_GLENUM(_nextState.blendDst)));
GL_CHECK(glBlendEquation(ENUM_CLASS_TO_GLENUM(_nextState.blendEq)));
}
return;
}
if (_nextState.blendSeparation)
{
if (_currentState.blendSrc != _nextState.blendSrc ||
_currentState.blendDst != _nextState.blendDst ||
_currentState.blendSrcAlpha != _nextState.blendSrcAlpha ||
_currentState.blendDstAlpha != _nextState.blendDstAlpha)
{
GL_CHECK(glBlendFuncSeparate(ENUM_CLASS_TO_GLENUM(_nextState.blendSrc),
ENUM_CLASS_TO_GLENUM(_nextState.blendDst),
ENUM_CLASS_TO_GLENUM(_nextState.blendSrcAlpha),
ENUM_CLASS_TO_GLENUM(_nextState.blendDstAlpha)));
}
}
if (_currentState.blendEq != _nextState.blendEq ||
_currentState.blendAlphaEq != _nextState.blendAlphaEq)
{
GL_CHECK(glBlendEquationSeparate(ENUM_CLASS_TO_GLENUM(_nextState.blendEq),
ENUM_CLASS_TO_GLENUM(_nextState.blendAlphaEq)));
}
else
{
if (_currentState.blendSrc != _nextState.blendSrc ||
_currentState.blendDst != _nextState.blendDst)
{
GL_CHECK(glBlendFunc(ENUM_CLASS_TO_GLENUM(_nextState.blendSrc),
ENUM_CLASS_TO_GLENUM(_nextState.blendDst)));
}
if (_currentState.blendEq != _nextState.blendEq)
{
GL_CHECK(glBlendEquation(ENUM_CLASS_TO_GLENUM(_nextState.blendEq)));
}
}
}
void DeviceGraphics::commitDepthStates()
{
if (_currentState.depthTest != _nextState.depthTest)
{
if (!_nextState.depthTest)
{
glDisable(GL_DEPTH_TEST);
return;
}
GL_CHECK(glEnable(GL_DEPTH_TEST));
GL_CHECK(glDepthFunc(ENUM_CLASS_TO_GLENUM(_nextState.depthFunc)));
GL_CHECK(glDepthMask(_nextState.depthWrite ? GL_TRUE : GL_FALSE));
return;
}
if (_currentState.depthWrite != _nextState.depthWrite)
{
GL_CHECK(glDepthMask(_nextState.depthWrite ? GL_TRUE : GL_FALSE));
}
if (!_nextState.depthTest)
{
if (_nextState.depthWrite)
{
_nextState.depthTest = true;
_nextState.depthFunc = DepthFunc::ALWAYS;
GL_CHECK(glEnable(GL_DEPTH_TEST));
GL_CHECK(glDepthFunc(ENUM_CLASS_TO_GLENUM(_nextState.depthFunc)));
}
return;
}
if (_currentState.depthFunc != _nextState.depthFunc)
{
GL_CHECK(glDepthFunc(ENUM_CLASS_TO_GLENUM(_nextState.depthFunc)));
}
}
void DeviceGraphics::commitStencilStates()
{
if (_currentState.stencilTest != _nextState.stencilTest)
{
if (!_nextState.stencilTest)
{
glDisable(GL_STENCIL_TEST);
return;
}
glEnable(GL_STENCIL_TEST);
if (_nextState.stencilSeparation)
{
GL_CHECK(glStencilFuncSeparate(GL_FRONT,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFuncFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilRefFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilMaskFront)));
GL_CHECK(glStencilMaskSeparate(GL_FRONT, ENUM_CLASS_TO_GLENUM(_nextState.stencilWriteMaskFront)));
GL_CHECK(glStencilOpSeparate(GL_FRONT,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZPassOpFront)));
GL_CHECK(glStencilFuncSeparate(GL_BACK,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFuncBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilRefBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilMaskBack)));
GL_CHECK(glStencilMaskSeparate(GL_BACK, ENUM_CLASS_TO_GLENUM(_nextState.stencilWriteMaskBack)));
GL_CHECK(glStencilOpSeparate(GL_BACK,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFailOpBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZFailOpBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZPassOpBack)));
}
else
{
GL_CHECK(glStencilFunc(ENUM_CLASS_TO_GLENUM(_nextState.stencilFuncFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilRefFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilMaskFront)));
GL_CHECK(glStencilMask(ENUM_CLASS_TO_GLENUM(_nextState.stencilWriteMaskFront)));
GL_CHECK(glStencilOp(ENUM_CLASS_TO_GLENUM(_nextState.stencilFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZPassOpFront)));
}
return;
}
if (!_nextState.stencilTest)
return;
if (_currentState.stencilSeparation != _nextState.stencilSeparation)
{
if (_nextState.stencilSeparation)
{
// front
GL_CHECK(glStencilFuncSeparate(GL_FRONT,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFuncFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilRefFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilMaskFront)));
GL_CHECK(glStencilMaskSeparate(GL_FRONT, ENUM_CLASS_TO_GLENUM(_nextState.stencilWriteMaskFront)));
GL_CHECK(glStencilOpSeparate(GL_FRONT,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZPassOpFront)));
// back
GL_CHECK(glStencilFuncSeparate(GL_BACK,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFuncBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilRefBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilMaskBack)));
GL_CHECK(glStencilMaskSeparate(GL_BACK, ENUM_CLASS_TO_GLENUM(_nextState.stencilWriteMaskBack)));
GL_CHECK(glStencilOpSeparate(GL_BACK,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFailOpBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZFailOpBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZPassOpBack)));
}
else
{
GL_CHECK(glStencilFunc(ENUM_CLASS_TO_GLENUM(_nextState.stencilFuncFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilRefFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilMaskFront)));
GL_CHECK(glStencilMask(ENUM_CLASS_TO_GLENUM(_nextState.stencilWriteMaskFront)));
GL_CHECK(glStencilOp(ENUM_CLASS_TO_GLENUM(_nextState.stencilFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZPassOpFront)));
}
return;
}
if (_nextState.stencilSeparation)
{
// font
if (_currentState.stencilFuncFront != _nextState.stencilFuncFront ||
_currentState.stencilRefFront != _nextState.stencilRefFront ||
_currentState.stencilMaskFront != _nextState.stencilMaskFront)
{
GL_CHECK(glStencilFuncSeparate(GL_FRONT,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFuncFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilRefFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilMaskFront)));
}
if (_currentState.stencilWriteMaskFront != _nextState.stencilWriteMaskFront)
{
GL_CHECK(glStencilMaskSeparate(GL_FRONT, ENUM_CLASS_TO_GLENUM(_nextState.stencilWriteMaskFront)));
}
if (_currentState.stencilFailOpFront != _nextState.stencilFailOpFront ||
_currentState.stencilZFailOpFront != _nextState.stencilZFailOpFront ||
_currentState.stencilZPassOpFront != _nextState.stencilZPassOpFront)
{
GL_CHECK(glStencilOpSeparate(GL_FRONT,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZPassOpFront)));
}
// back
if (_currentState.stencilFuncBack != _nextState.stencilFuncBack ||
_currentState.stencilRefBack != _nextState.stencilRefBack ||
_currentState.stencilMaskBack != _nextState.stencilMaskBack)
{
GL_CHECK(glStencilFuncSeparate(GL_BACK,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFuncBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilRefBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilMaskBack)));
}
if (_currentState.stencilWriteMaskBack != _nextState.stencilWriteMaskBack)
GL_CHECK(glStencilMaskSeparate(GL_BACK, ENUM_CLASS_TO_GLENUM(_nextState.stencilWriteMaskBack)));
if (_currentState.stencilFailOpBack != _nextState.stencilFailOpBack ||
_currentState.stencilZFailOpBack != _nextState.stencilZFailOpBack ||
_currentState.stencilZPassOpBack != _nextState.stencilZPassOpBack)
{
GL_CHECK(glStencilOpSeparate(GL_BACK,
ENUM_CLASS_TO_GLENUM(_nextState.stencilFailOpBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZFailOpBack),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZPassOpBack)));
}
}
else
{
if (_currentState.stencilFuncFront != _nextState.stencilFuncFront ||
_currentState.stencilRefFront != _nextState.stencilRefFront ||
_currentState.stencilMaskFront != _nextState.stencilMaskFront)
{
GL_CHECK(glStencilFunc(ENUM_CLASS_TO_GLENUM(_nextState.stencilFuncFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilRefFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilMaskFront)));
}
if (_currentState.stencilWriteMaskFront != _nextState.stencilWriteMaskFront)
{
GL_CHECK(glStencilMask(ENUM_CLASS_TO_GLENUM(_nextState.stencilWriteMaskFront)));
}
if (_currentState.stencilFailOpFront != _nextState.stencilFailOpFront ||
_currentState.stencilZFailOpFront != _nextState.stencilZFailOpFront ||
_currentState.stencilZPassOpFront != _nextState.stencilZPassOpFront)
{
GL_CHECK(glStencilOp(ENUM_CLASS_TO_GLENUM(_nextState.stencilFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZFailOpFront),
ENUM_CLASS_TO_GLENUM(_nextState.stencilZPassOpFront)));
}
}
}
void DeviceGraphics::commitCullMode()
{
if (_currentState.cullMode == _nextState.cullMode)
return;
if (_nextState.cullMode == CullMode::NONE)
{
GL_CHECK(glDisable(GL_CULL_FACE));
return;
}
GL_CHECK(glEnable(GL_CULL_FACE));
GL_CHECK(glCullFace(ENUM_CLASS_TO_GLENUM(_nextState.cullMode)));
}
void DeviceGraphics::commitVertexBuffer()
{
if (-1 == _nextState.maxStream)
{
RENDERER_LOGW("VertexBuffer not assigned, please call setVertexBuffer before every draw.");
return;
}
bool attrsDirty = false;
if (_currentState.maxStream != _nextState.maxStream)
attrsDirty = true;
else if (_currentState.getProgram() != _nextState.getProgram())
attrsDirty = true;
else
{
for (int i = 0; i < _nextState.maxStream + 1; ++i)
{
if (_currentState.getVertexBuffer(i) != _nextState.getVertexBuffer(i) ||
_currentState.getVertexBufferOffset(i) != _nextState.getVertexBufferOffset(i))
{
attrsDirty = true;
break;
}
}
}
if (attrsDirty)
{
for (int i = 0; i < _caps.maxVertexAttributes; ++i)
_newAttributes[i] = 0;
for (int i = 0; i < _nextState.maxStream + 1; ++i)
{
auto vb = _nextState.getVertexBuffer(i);
if (!vb)
continue;
GL_CHECK(ccBindBuffer(GL_ARRAY_BUFFER, vb->getHandle()));
auto vboffset = _nextState.getVertexBufferOffset(i);
const auto& attributes = _nextState.getProgram()->getAttributes();
auto usedAttriLen = attributes.size();
for (int j = 0; j < usedAttriLen; ++j)
{
const auto& attr = attributes[j];
const auto* el = vb->getFormat().getElement(attr.name);
if (!el->isValid())
{
RENDERER_LOGW("Can not find vertex attribute: %s", attr.name.c_str());
continue;
}
if (0 == _enabledAtrributes[attr.location])
{
GL_CHECK(ccEnableVertexAttribArray(attr.location));
_enabledAtrributes[attr.location] = 1;
}
_newAttributes[attr.location] = 1;
// glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
GL_CHECK(ccVertexAttribPointer(attr.location,
el->num,
ENUM_CLASS_TO_GLENUM(el->type),
el->normalize,
el->stride,
(GLvoid*)(el->offset + vboffset * el->stride)));
}
}
// Disable unused attributes.
for (int i = 0; i < _caps.maxVertexAttributes; ++i)
{
if (_enabledAtrributes[i] != _newAttributes[i])
{
GL_CHECK(ccDisableVertexAttribArray(i));
_enabledAtrributes[i] = 0;
}
}
}
}
void DeviceGraphics::commitTextures()
{
const auto& curTextureUnits = _currentState.getTextureUnits();
int curTextureSize = static_cast<int>(curTextureUnits.size());
const auto& nextTextureUnits = _nextState.getTextureUnits();
int capacity = static_cast<int>(nextTextureUnits.size());
for (int i = 0; i < capacity; ++i)
{
if (i >= curTextureSize || curTextureUnits[i] != nextTextureUnits[i])
{
auto texture = nextTextureUnits[i];
if (texture)
{
GL_CHECK(glActiveTexture(GL_TEXTURE0 + i));
GL_CHECK(glBindTexture(texture->getTarget(),
texture->getHandle()));
}
}
}
}
//
// Uniform
//
DeviceGraphics::Uniform::Uniform()
: dirty(true)
, value(nullptr)
, elementType(UniformElementType::FLOAT)
{}
DeviceGraphics::Uniform::Uniform(const void* v, size_t bytes, UniformElementType elementType_)
: dirty(true)
, value(nullptr)
, elementType(elementType_)
{
setValue(v, bytes);
}
DeviceGraphics::Uniform::Uniform(Uniform&& h)
{
if (this == &h)
return;
if (value != nullptr)
{
free(value);
}
value = h.value;
h.value = nullptr;
dirty = h.dirty;
elementType = h.elementType;
}
DeviceGraphics::Uniform::~Uniform()
{
if (value)
{
free(value);
value = nullptr;
}
}
DeviceGraphics::Uniform& DeviceGraphics::Uniform::operator=(Uniform&& h)
{
if (this == &h)
return *this;
dirty = h.dirty;
if (value != nullptr)
{
free(value);
}
value = h.value;
h.value = nullptr;
elementType = h.elementType;
return *this;
}
void DeviceGraphics::Uniform::setValue(const void* v, size_t bytes)
{
if (value)
free(value);
value = malloc(bytes);
memcpy(value, v, bytes);
}
RENDERER_END