Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
axmol/cocos/renderer/CCRenderState.cpp

942 lines
27 KiB
C++
Raw Blame History

/****************************************************************************
Copyright (c) 2015 Chukong Technologies Inc.
Copyright (c) 2014 GamePlay3D team
http://www.cocos2d-x.org
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Ideas taken from:
- GamePlay3D: http://gameplay3d.org/
- OGRE3D: http://www.ogre3d.org/
- Qt3D: http://qt-project.org/
****************************************************************************/
#include "CCRenderState.h"
#include <string>
#include "renderer/CCTexture2D.h"
#include "renderer/CCPass.h"
#include "renderer/ccGLStateCache.h"
NS_CC_BEGIN
RenderState::StateBlock* RenderState::StateBlock::_defaultState = nullptr;
// Render state override bits
enum
{
RS_BLEND = (1 << 0),
RS_BLEND_FUNC = (1 << 1),
RS_CULL_FACE = (1 << 2),
RS_DEPTH_TEST = (1 << 3),
RS_DEPTH_WRITE = (1 << 4),
RS_DEPTH_FUNC = (1 << 5),
RS_CULL_FACE_SIDE = (1 << 6),
RS_STENCIL_TEST = (1 << 7),
RS_STENCIL_WRITE = (1 << 8),
RS_STENCIL_FUNC = (1 << 9),
RS_STENCIL_OP = (1 << 10),
RS_FRONT_FACE = (1 << 11),
RS_ALL_ONES = 0xFFFFFFFF,
};
RenderState::RenderState()
: _textures()
, _hash(0)
, _hashDirty(true)
, _parent(nullptr)
{
_state = StateBlock::create();
CC_SAFE_RETAIN(_state);
}
RenderState::~RenderState()
{
CC_SAFE_RELEASE(_state);
}
void RenderState::initialize()
{
if (StateBlock::_defaultState == NULL)
{
StateBlock::_defaultState = StateBlock::create();
CC_SAFE_RETAIN(StateBlock::_defaultState);
}
}
void RenderState::finalize()
{
CC_SAFE_RELEASE_NULL(StateBlock::_defaultState);
}
bool RenderState::init(RenderState* parent)
{
CCASSERT(!_parent, "Cannot reinitialize Render State");
CCASSERT(parent, "parent must be non-null");
// Weak reference
_parent = parent;
return true;
}
std::string RenderState::getName() const
{
return _name;
}
const Vector<Texture2D*>& RenderState::getTextures() const
{
return _textures;
}
void RenderState::setTexture(Texture2D* texture)
{
if (_textures.size() > 0)
_textures.replace(0, texture);
else
_textures.pushBack(texture);
}
Texture2D* RenderState::getTexture() const
{
if (_textures.size() > 0)
return _textures.at(0);
return nullptr;
}
void RenderState::bind(Pass* pass)
{
CC_ASSERT(pass);
if (_textures.size() > 0)
GL::bindTexture2D(_textures.at(0)->getName());
// Get the combined modified state bits for our RenderState hierarchy.
long stateOverrideBits = _state ? _state->_bits : 0;
RenderState* rs = _parent;
while (rs)
{
if (rs->_state)
{
stateOverrideBits |= rs->_state->_bits;
}
rs = rs->_parent;
}
// Restore renderer state to its default, except for explicitly specified states
StateBlock::restore(stateOverrideBits);
// Apply renderer state for the entire hierarchy, top-down.
rs = NULL;
while ((rs = getTopmost(rs)))
{
if (rs->_state)
{
rs->_state->bindNoRestore();
}
}
}
RenderState* RenderState::getTopmost(RenderState* below)
{
RenderState* rs = this;
if (rs == below)
{
// Nothing below ourself.
return NULL;
}
while (rs)
{
if (rs->_parent == below || rs->_parent == NULL)
{
// Stop traversing up here.
return rs;
}
rs = rs->_parent;
}
return NULL;
}
RenderState::StateBlock* RenderState::getStateBlock() const
{
return _state;
}
void RenderState::cloneInto(RenderState* renderState) const
{
CCASSERT(renderState, "must be non nill");
// Clone our state block
if (_state)
{
_state->cloneInto(renderState->getStateBlock());
}
renderState->_name = _name;
renderState->_textures = _textures;
// weak ref. don't retain
renderState->_parent = _parent;
}
//
// StateBlock
//
RenderState::StateBlock* RenderState::StateBlock::create()
{
auto state = new (std::nothrow) RenderState::StateBlock();
if (state)
{
state->autorelease();
}
return state;
}
//
// The defaults are based on GamePlay3D defaults, with the following chagnes
// _depthWriteEnabled is FALSE
// _depthTestEnabled is TRUE
// _blendEnabled is TRUE
RenderState::StateBlock::StateBlock()
: _cullFaceEnabled(false)
, _depthTestEnabled(true), _depthWriteEnabled(false), _depthFunction(RenderState::DEPTH_LESS)
, _blendEnabled(true), _blendSrc(RenderState::BLEND_ONE), _blendDst(RenderState::BLEND_ZERO)
, _cullFaceSide(CULL_FACE_SIDE_BACK), _frontFace(FRONT_FACE_CCW)
, _stencilTestEnabled(false), _stencilWrite(RS_ALL_ONES)
, _stencilFunction(RenderState::STENCIL_ALWAYS), _stencilFunctionRef(0), _stencilFunctionMask(RS_ALL_ONES)
, _stencilOpSfail(RenderState::STENCIL_OP_KEEP), _stencilOpDpfail(RenderState::STENCIL_OP_KEEP), _stencilOpDppass(RenderState::STENCIL_OP_KEEP)
, _bits(0L)
{
}
RenderState::StateBlock::~StateBlock()
{
}
void RenderState::StateBlock::bind()
{
// When the public bind() is called with no RenderState object passed in,
// we assume we are being called to bind the state of a single StateBlock,
// irrespective of whether it belongs to a hierarchy of RenderStates.
// Therefore, we call restore() here with only this StateBlock's override
// bits to restore state before applying the new state.
StateBlock::restore(_bits);
bindNoRestore();
}
void RenderState::StateBlock::bindNoRestore()
{
CC_ASSERT(_defaultState);
// Update any state that differs from _defaultState and flip _defaultState bits
if ((_bits & RS_BLEND) && (_blendEnabled != _defaultState->_blendEnabled))
{
if (_blendEnabled)
glEnable(GL_BLEND);
else
glDisable(GL_BLEND);
_defaultState->_blendEnabled = _blendEnabled;
}
if ((_bits & RS_BLEND_FUNC) && (_blendSrc != _defaultState->_blendSrc || _blendDst != _defaultState->_blendDst))
{
GL::blendFunc((GLenum)_blendSrc, (GLenum)_blendDst);
_defaultState->_blendSrc = _blendSrc;
_defaultState->_blendDst = _blendDst;
}
if ((_bits & RS_CULL_FACE) && (_cullFaceEnabled != _defaultState->_cullFaceEnabled))
{
if (_cullFaceEnabled)
glEnable(GL_CULL_FACE);
else
glDisable(GL_CULL_FACE);
_defaultState->_cullFaceEnabled = _cullFaceEnabled;
}
if ((_bits & RS_CULL_FACE_SIDE) && (_cullFaceSide != _defaultState->_cullFaceSide))
{
glCullFace((GLenum)_cullFaceSide);
_defaultState->_cullFaceSide = _cullFaceSide;
}
if ((_bits & RS_FRONT_FACE) && (_frontFace != _defaultState->_frontFace))
{
glFrontFace((GLenum)_frontFace);
_defaultState->_frontFace = _frontFace;
}
if ((_bits & RS_DEPTH_TEST) && (_depthTestEnabled != _defaultState->_depthTestEnabled))
{
if (_depthTestEnabled)
glEnable(GL_DEPTH_TEST);
else
glDisable(GL_DEPTH_TEST);
_defaultState->_depthTestEnabled = _depthTestEnabled;
}
if ((_bits & RS_DEPTH_WRITE) && (_depthWriteEnabled != _defaultState->_depthWriteEnabled))
{
glDepthMask(_depthWriteEnabled ? GL_TRUE : GL_FALSE);
_defaultState->_depthWriteEnabled = _depthWriteEnabled;
}
if ((_bits & RS_DEPTH_FUNC) && (_depthFunction != _defaultState->_depthFunction))
{
glDepthFunc((GLenum)_depthFunction);
_defaultState->_depthFunction = _depthFunction;
}
if ((_bits & RS_STENCIL_TEST) && (_stencilTestEnabled != _defaultState->_stencilTestEnabled))
{
if (_stencilTestEnabled)
glEnable(GL_STENCIL_TEST);
else
glDisable(GL_STENCIL_TEST);
_defaultState->_stencilTestEnabled = _stencilTestEnabled;
}
if ((_bits & RS_STENCIL_WRITE) && (_stencilWrite != _defaultState->_stencilWrite))
{
glStencilMask(_stencilWrite);
_defaultState->_stencilWrite = _stencilWrite;
}
if ((_bits & RS_STENCIL_FUNC) && (_stencilFunction != _defaultState->_stencilFunction ||
_stencilFunctionRef != _defaultState->_stencilFunctionRef ||
_stencilFunctionMask != _defaultState->_stencilFunctionMask))
{
glStencilFunc((GLenum)_stencilFunction, _stencilFunctionRef, _stencilFunctionMask);
_defaultState->_stencilFunction = _stencilFunction;
_defaultState->_stencilFunctionRef = _stencilFunctionRef;
_defaultState->_stencilFunctionMask = _stencilFunctionMask;
}
if ((_bits & RS_STENCIL_OP) && (_stencilOpSfail != _defaultState->_stencilOpSfail ||
_stencilOpDpfail != _defaultState->_stencilOpDpfail ||
_stencilOpDppass != _defaultState->_stencilOpDppass))
{
glStencilOp((GLenum)_stencilOpSfail, (GLenum)_stencilOpDpfail, (GLenum)_stencilOpDppass);
_defaultState->_stencilOpSfail = _stencilOpSfail;
_defaultState->_stencilOpDpfail = _stencilOpDpfail;
_defaultState->_stencilOpDppass = _stencilOpDppass;
}
_defaultState->_bits |= _bits;
}
void RenderState::StateBlock::restore(long stateOverrideBits)
{
CC_ASSERT(_defaultState);
// If there is no state to restore (i.e. no non-default state), do nothing.
if (_defaultState->_bits == 0)
{
return;
}
// Restore any state that is not overridden and is not default
if (!(stateOverrideBits & RS_BLEND) && (_defaultState->_bits & RS_BLEND))
{
glEnable(GL_BLEND);
_defaultState->_bits &= ~RS_BLEND;
_defaultState->_blendEnabled = true;
}
if (!(stateOverrideBits & RS_BLEND_FUNC) && (_defaultState->_bits & RS_BLEND_FUNC))
{
GL::blendFunc(GL_ONE, GL_ZERO);
_defaultState->_bits &= ~RS_BLEND_FUNC;
_defaultState->_blendSrc = RenderState::BLEND_ONE;
_defaultState->_blendDst = RenderState::BLEND_ZERO;
}
if (!(stateOverrideBits & RS_CULL_FACE) && (_defaultState->_bits & RS_CULL_FACE))
{
glDisable(GL_CULL_FACE);
_defaultState->_bits &= ~RS_CULL_FACE;
_defaultState->_cullFaceEnabled = false;
}
if (!(stateOverrideBits & RS_CULL_FACE_SIDE) && (_defaultState->_bits & RS_CULL_FACE_SIDE))
{
glCullFace((GLenum)GL_BACK);
_defaultState->_bits &= ~RS_CULL_FACE_SIDE;
_defaultState->_cullFaceSide = RenderState::CULL_FACE_SIDE_BACK;
}
if (!(stateOverrideBits & RS_FRONT_FACE) && (_defaultState->_bits & RS_FRONT_FACE))
{
glFrontFace((GLenum)GL_CCW);
_defaultState->_bits &= ~RS_FRONT_FACE;
_defaultState->_frontFace = RenderState::FRONT_FACE_CCW;
}
if (!(stateOverrideBits & RS_DEPTH_TEST) && (_defaultState->_bits & RS_DEPTH_TEST))
{
glEnable(GL_DEPTH_TEST);
_defaultState->_bits &= ~RS_DEPTH_TEST;
_defaultState->_depthTestEnabled = true;
}
if (!(stateOverrideBits & RS_DEPTH_WRITE) && (_defaultState->_bits & RS_DEPTH_WRITE))
{
glDepthMask(GL_FALSE);
_defaultState->_bits &= ~RS_DEPTH_WRITE;
_defaultState->_depthWriteEnabled = false;
}
if (!(stateOverrideBits & RS_DEPTH_FUNC) && (_defaultState->_bits & RS_DEPTH_FUNC))
{
glDepthFunc((GLenum)GL_LESS);
_defaultState->_bits &= ~RS_DEPTH_FUNC;
_defaultState->_depthFunction = RenderState::DEPTH_LESS;
}
if (!(stateOverrideBits & RS_STENCIL_TEST) && (_defaultState->_bits & RS_STENCIL_TEST))
{
glDisable(GL_STENCIL_TEST);
_defaultState->_bits &= ~RS_STENCIL_TEST;
_defaultState->_stencilTestEnabled = false;
}
if (!(stateOverrideBits & RS_STENCIL_WRITE) && (_defaultState->_bits & RS_STENCIL_WRITE))
{
glStencilMask(RS_ALL_ONES);
_defaultState->_bits &= ~RS_STENCIL_WRITE;
_defaultState->_stencilWrite = RS_ALL_ONES;
}
if (!(stateOverrideBits & RS_STENCIL_FUNC) && (_defaultState->_bits & RS_STENCIL_FUNC))
{
glStencilFunc((GLenum)RenderState::STENCIL_ALWAYS, 0, RS_ALL_ONES);
_defaultState->_bits &= ~RS_STENCIL_FUNC;
_defaultState->_stencilFunction = RenderState::STENCIL_ALWAYS;
_defaultState->_stencilFunctionRef = 0;
_defaultState->_stencilFunctionMask = RS_ALL_ONES;
}
if (!(stateOverrideBits & RS_STENCIL_OP) && (_defaultState->_bits & RS_STENCIL_OP))
{
glStencilOp((GLenum)RenderState::STENCIL_OP_KEEP, (GLenum)RenderState::STENCIL_OP_KEEP, (GLenum)RenderState::STENCIL_OP_KEEP);
_defaultState->_bits &= ~RS_STENCIL_OP;
_defaultState->_stencilOpSfail = RenderState::STENCIL_OP_KEEP;
_defaultState->_stencilOpDpfail = RenderState::STENCIL_OP_KEEP;
_defaultState->_stencilOpDppass = RenderState::STENCIL_OP_KEEP;
}
}
void RenderState::StateBlock::enableDepthWrite()
{
CC_ASSERT(_defaultState);
// Internal method used to restore depth writing before a
// clear operation. This is necessary if the last code to draw before the
// next frame leaves depth writing disabled.
if (!_defaultState->_depthWriteEnabled)
{
glDepthMask(GL_TRUE);
_defaultState->_bits &= ~RS_DEPTH_WRITE;
_defaultState->_depthWriteEnabled = true;
}
}
void RenderState::StateBlock::cloneInto(StateBlock* state) const
{
CC_ASSERT(state);
state->_cullFaceEnabled = _cullFaceEnabled;
state->_depthTestEnabled = _depthTestEnabled;
state->_depthWriteEnabled = _depthWriteEnabled;
state->_depthFunction = _depthFunction;
state->_blendEnabled = _blendEnabled;
state->_blendSrc = _blendSrc;
state->_blendDst = _blendDst;
state->_cullFaceSide = _cullFaceSide;
state->_frontFace = _frontFace;
state->_stencilTestEnabled = _stencilTestEnabled;
state->_stencilWrite = _stencilWrite;
state->_stencilFunction = _stencilFunction;
state->_stencilFunctionRef = _stencilFunctionRef;
state->_stencilFunctionMask = _stencilFunctionMask;
state->_stencilOpSfail = _stencilOpSfail;
state->_stencilOpDpfail = _stencilOpDpfail;
state->_stencilOpDppass = _stencilOpDppass;
state->_bits = _bits;
}
static bool parseBoolean(const std::string& value)
{
return (value.compare("true")==0);
}
static int parseInt(const std::string& value)
{
// Android NDK 10 doesn't support std::stoi a/ std::stoul
#if CC_TARGET_PLATFORM != CC_PLATFORM_ANDROID
return std::stoi(value);
#else
return atoi(value.c_str());
#endif
}
static unsigned int parseUInt(const std::string& value)
{
// Android NDK 10 doesn't support std::stoi a/ std::stoul
#if CC_TARGET_PLATFORM != CC_PLATFORM_ANDROID
return (unsigned int)std::stoul(value);
#else
return (unsigned int)atoi(value.c_str());
#endif
}
static RenderState::Blend parseBlend(const std::string& value)
{
// Convert the string to uppercase for comparison.
std::string upper(value);
std::transform(upper.begin(), upper.end(), upper.begin(), (int(*)(int))toupper);
if (upper == "ZERO")
return RenderState::BLEND_ZERO;
else if (upper == "ONE")
return RenderState::BLEND_ONE;
else if (upper == "SRC_COLOR")
return RenderState::BLEND_SRC_COLOR;
else if (upper == "ONE_MINUS_SRC_COLOR")
return RenderState::BLEND_ONE_MINUS_SRC_COLOR;
else if (upper == "DST_COLOR")
return RenderState::BLEND_DST_COLOR;
else if (upper == "ONE_MINUS_DST_COLOR")
return RenderState::BLEND_ONE_MINUS_DST_COLOR;
else if (upper == "SRC_ALPHA")
return RenderState::BLEND_SRC_ALPHA;
else if (upper == "ONE_MINUS_SRC_ALPHA")
return RenderState::BLEND_ONE_MINUS_SRC_ALPHA;
else if (upper == "DST_ALPHA")
return RenderState::BLEND_DST_ALPHA;
else if (upper == "ONE_MINUS_DST_ALPHA")
return RenderState::BLEND_ONE_MINUS_DST_ALPHA;
else if (upper == "CONSTANT_ALPHA")
return RenderState::BLEND_CONSTANT_ALPHA;
else if (upper == "ONE_MINUS_CONSTANT_ALPHA")
return RenderState::BLEND_ONE_MINUS_CONSTANT_ALPHA;
else if (upper == "SRC_ALPHA_SATURATE")
return RenderState::BLEND_SRC_ALPHA_SATURATE;
else
{
CCLOG("Unsupported blend value (%s). (Will default to BLEND_ONE if errors are treated as warnings)", value.c_str());
return RenderState::BLEND_ONE;
}
}
static RenderState::DepthFunction parseDepthFunc(const std::string& value)
{
// Convert string to uppercase for comparison
std::string upper(value);
std::transform(upper.begin(), upper.end(), upper.begin(), (int(*)(int))toupper);
if (upper == "NEVER")
return RenderState::DEPTH_NEVER;
else if (upper == "LESS")
return RenderState::DEPTH_LESS;
else if (upper == "EQUAL")
return RenderState::DEPTH_EQUAL;
else if (upper == "LEQUAL")
return RenderState::DEPTH_LEQUAL;
else if (upper == "GREATER")
return RenderState::DEPTH_GREATER;
else if (upper == "NOTEQUAL")
return RenderState::DEPTH_NOTEQUAL;
else if (upper == "GEQUAL")
return RenderState::DEPTH_GEQUAL;
else if (upper == "ALWAYS")
return RenderState::DEPTH_ALWAYS;
else
{
CCLOG("Unsupported depth function value (%s). Will default to DEPTH_LESS if errors are treated as warnings)", value.c_str());
return RenderState::DEPTH_LESS;
}
}
static RenderState::CullFaceSide parseCullFaceSide(const std::string& value)
{
// Convert string to uppercase for comparison
std::string upper(value);
std::transform(upper.begin(), upper.end(), upper.begin(), (int(*)(int))toupper);
if (upper == "BACK")
return RenderState::CULL_FACE_SIDE_BACK;
else if (upper == "FRONT")
return RenderState::CULL_FACE_SIDE_FRONT;
else if (upper == "FRONT_AND_BACK")
return RenderState::CULL_FACE_SIDE_FRONT_AND_BACK;
else
{
CCLOG("Unsupported cull face side value (%s). Will default to BACK if errors are treated as warnings.", value.c_str());
return RenderState::CULL_FACE_SIDE_BACK;
}
}
static RenderState::FrontFace parseFrontFace(const std::string& value)
{
// Convert string to uppercase for comparison
std::string upper(value);
std::transform(upper.begin(), upper.end(), upper.begin(), (int(*)(int))toupper);
if (upper == "CCW")
return RenderState::FRONT_FACE_CCW;
else if (upper == "CW")
return RenderState::FRONT_FACE_CW;
else
{
CCLOG("Unsupported front face side value (%s). Will default to CCW if errors are treated as warnings.", value.c_str());
return RenderState::FRONT_FACE_CCW;
}
}
static RenderState::StencilFunction parseStencilFunc(const std::string& value)
{
// Convert string to uppercase for comparison
std::string upper(value);
std::transform(upper.begin(), upper.end(), upper.begin(), (int(*)(int))toupper);
if (upper == "NEVER")
return RenderState::STENCIL_NEVER;
else if (upper == "LESS")
return RenderState::STENCIL_LESS;
else if (upper == "EQUAL")
return RenderState::STENCIL_EQUAL;
else if (upper == "LEQUAL")
return RenderState::STENCIL_LEQUAL;
else if (upper == "GREATER")
return RenderState::STENCIL_GREATER;
else if (upper == "NOTEQUAL")
return RenderState::STENCIL_NOTEQUAL;
else if (upper == "GEQUAL")
return RenderState::STENCIL_GEQUAL;
else if (upper == "ALWAYS")
return RenderState::STENCIL_ALWAYS;
else
{
CCLOG("Unsupported stencil function value (%s). Will default to STENCIL_ALWAYS if errors are treated as warnings)", value.c_str());
return RenderState::STENCIL_ALWAYS;
}
}
static RenderState::StencilOperation parseStencilOp(const std::string& value)
{
// Convert string to uppercase for comparison
std::string upper(value);
std::transform(upper.begin(), upper.end(), upper.begin(), (int(*)(int))toupper);
if (upper == "KEEP")
return RenderState::STENCIL_OP_KEEP;
else if (upper == "ZERO")
return RenderState::STENCIL_OP_ZERO;
else if (upper == "REPLACE")
return RenderState::STENCIL_OP_REPLACE;
else if (upper == "INCR")
return RenderState::STENCIL_OP_INCR;
else if (upper == "DECR")
return RenderState::STENCIL_OP_DECR;
else if (upper == "INVERT")
return RenderState::STENCIL_OP_INVERT;
else if (upper == "INCR_WRAP")
return RenderState::STENCIL_OP_INCR_WRAP;
else if (upper == "DECR_WRAP")
return RenderState::STENCIL_OP_DECR_WRAP;
else
{
CCLOG("Unsupported stencil operation value (%s). Will default to STENCIL_OP_KEEP if errors are treated as warnings)", value.c_str());
return RenderState::STENCIL_OP_KEEP;
}
}
void RenderState::StateBlock::setState(const std::string& name, const std::string& value)
{
if (name.compare("blend") == 0)
{
setBlend(parseBoolean(value));
}
else if (name.compare("blendSrc") == 0)
{
setBlendSrc(parseBlend(value));
}
else if (name.compare("blendDst") == 0)
{
setBlendDst(parseBlend(value));
}
else if (name.compare("cullFace") == 0)
{
setCullFace(parseBoolean(value));
}
else if (name.compare("cullFaceSide") == 0)
{
setCullFaceSide(parseCullFaceSide(value));
}
else if (name.compare("frontFace") == 0)
{
setFrontFace(parseFrontFace(value));
}
else if (name.compare("depthTest") == 0)
{
setDepthTest(parseBoolean(value));
}
else if (name.compare("depthWrite") == 0)
{
setDepthWrite(parseBoolean(value));
}
else if (name.compare("depthFunc") == 0)
{
setDepthFunction(parseDepthFunc(value));
}
else if (name.compare("stencilTest") == 0)
{
setStencilTest(parseBoolean(value));
}
else if (name.compare("stencilWrite") == 0)
{
setStencilWrite(parseUInt(value));
}
else if (name.compare("stencilFunc") == 0)
{
setStencilFunction(parseStencilFunc(value), _stencilFunctionRef, _stencilFunctionMask);
}
else if (name.compare("stencilFuncRef") == 0)
{
setStencilFunction(_stencilFunction, parseInt(value), _stencilFunctionMask);
}
else if (name.compare("stencilFuncMask") == 0)
{
setStencilFunction(_stencilFunction, _stencilFunctionRef, parseUInt(value));
}
else if (name.compare("stencilOpSfail") == 0)
{
setStencilOperation(parseStencilOp(value), _stencilOpDpfail, _stencilOpDppass);
}
else if (name.compare("stencilOpDpfail") == 0)
{
setStencilOperation(_stencilOpSfail, parseStencilOp(value), _stencilOpDppass);
}
else if (name.compare("stencilOpDppass") == 0)
{
setStencilOperation(_stencilOpSfail, _stencilOpDpfail, parseStencilOp(value));
}
else
{
CCLOG("Unsupported render state string '%s'.", name.c_str());
}
}
bool RenderState::StateBlock::isDirty() const
{
// XXX
return true;
}
uint32_t RenderState::StateBlock::getHash() const
{
// XXX
return 0x12345678;
}
void RenderState::StateBlock::setBlend(bool enabled)
{
_blendEnabled = enabled;
if (enabled)
{
_bits &= ~RS_BLEND;
}
else
{
_bits |= RS_BLEND;
}
}
void RenderState::StateBlock::setBlendFunc(const BlendFunc& blendFunc)
{
if (blendFunc == BlendFunc::DISABLE)
{
setBlendSrc(BLEND_ONE);
setBlendDst(BLEND_ZERO);
}
else if (blendFunc == BlendFunc::ALPHA_PREMULTIPLIED)
{
setBlendSrc(BLEND_ONE);
setBlendDst(BLEND_ONE_MINUS_SRC_ALPHA);
}
else if (blendFunc == BlendFunc::ALPHA_NON_PREMULTIPLIED)
{
setBlendSrc(BLEND_SRC_ALPHA);
setBlendDst(BLEND_ONE_MINUS_SRC_ALPHA);
}
else if (blendFunc == BlendFunc::ADDITIVE)
{
setBlendSrc(BLEND_SRC_ALPHA);
setBlendDst(BLEND_ONE);
}
}
void RenderState::StateBlock::setBlendSrc(Blend blend)
{
_blendSrc = blend;
if (_blendSrc == BLEND_ONE && _blendDst == BLEND_ZERO)
{
// Default blend func
_bits &= ~RS_BLEND_FUNC;
}
else
{
_bits |= RS_BLEND_FUNC;
}
}
void RenderState::StateBlock::setBlendDst(Blend blend)
{
_blendDst = blend;
if (_blendSrc == BLEND_ONE && _blendDst == BLEND_ZERO)
{
// Default blend func
_bits &= ~RS_BLEND_FUNC;
}
else
{
_bits |= RS_BLEND_FUNC;
}
}
void RenderState::StateBlock::setCullFace(bool enabled)
{
_cullFaceEnabled = enabled;
if (!enabled)
{
_bits &= ~RS_CULL_FACE;
}
else
{
_bits |= RS_CULL_FACE;
}
}
void RenderState::StateBlock::setCullFaceSide(CullFaceSide side)
{
_cullFaceSide = side;
if (_cullFaceSide == CULL_FACE_SIDE_BACK)
{
// Default cull side
_bits &= ~RS_CULL_FACE_SIDE;
}
else
{
_bits |= RS_CULL_FACE_SIDE;
}
}
void RenderState::StateBlock::setFrontFace(FrontFace winding)
{
_frontFace = winding;
if (_frontFace == FRONT_FACE_CCW)
{
// Default front face
_bits &= ~RS_FRONT_FACE;
}
else
{
_bits |= RS_FRONT_FACE;
}
}
void RenderState::StateBlock::setDepthTest(bool enabled)
{
_depthTestEnabled = enabled;
if (enabled)
{
_bits &= ~RS_DEPTH_TEST;
}
else
{
_bits |= RS_DEPTH_TEST;
}
}
void RenderState::StateBlock::setDepthWrite(bool enabled)
{
_depthWriteEnabled = enabled;
if (!enabled)
{
_bits &= ~RS_DEPTH_WRITE;
}
else
{
_bits |= RS_DEPTH_WRITE;
}
}
void RenderState::StateBlock::setDepthFunction(DepthFunction func)
{
_depthFunction = func;
if (_depthFunction == DEPTH_LESS)
{
// Default depth function
_bits &= ~RS_DEPTH_FUNC;
}
else
{
_bits |= RS_DEPTH_FUNC;
}
}
void RenderState::StateBlock::setStencilTest(bool enabled)
{
_stencilTestEnabled = enabled;
if (!enabled)
{
_bits &= ~RS_STENCIL_TEST;
}
else
{
_bits |= RS_STENCIL_TEST;
}
}
void RenderState::StateBlock::setStencilWrite(unsigned int mask)
{
_stencilWrite = mask;
if (mask == RS_ALL_ONES)
{
// Default stencil write
_bits &= ~RS_STENCIL_WRITE;
}
else
{
_bits |= RS_STENCIL_WRITE;
}
}
void RenderState::StateBlock::setStencilFunction(StencilFunction func, int ref, unsigned int mask)
{
_stencilFunction = func;
_stencilFunctionRef = ref;
_stencilFunctionMask = mask;
if (func == STENCIL_ALWAYS && ref == 0 && mask == RS_ALL_ONES)
{
// Default stencil function
_bits &= ~RS_STENCIL_FUNC;
}
else
{
_bits |= RS_STENCIL_FUNC;
}
}
void RenderState::StateBlock::setStencilOperation(StencilOperation sfail, StencilOperation dpfail, StencilOperation dppass)
{
_stencilOpSfail = sfail;
_stencilOpDpfail = dpfail;
_stencilOpDppass = dppass;
if (sfail == STENCIL_OP_KEEP && dpfail == STENCIL_OP_KEEP && dppass == STENCIL_OP_KEEP)
{
// Default stencil operation
_bits &= ~RS_STENCIL_OP;
}
else
{
_bits |= RS_STENCIL_OP;
}
}
NS_CC_END
Reference in New Issue View Git Blame Copy Permalink