Mat4 AttachNode::getWorldToNodeTransform() const
{
static Mat4 mat;
mat.setIdentity();
auto parent = getParent();
if (parent)
{
mat = parent->getWorldToNodeTransform() * _attachBone->getWorldMat() * getNodeToParentTransform();
}
else
{
mat = _attachBone->getWorldMat() * getNodeToParentTransform();
}
return mat;
}
void Scene::render(Renderer* renderer)
{
auto director = Director::getInstance();
Camera* defaultCamera = nullptr;
const auto& transform = getNodeToParentTransform();
if (_cameraOrderDirty)
{
stable_sort(_cameras.begin(), _cameras.end(), camera_cmp);
_cameraOrderDirty = false;
}
for (const auto& camera : _cameras)
{
if (!camera->isVisible())
continue;
Camera::_visitingCamera = camera;
if (Camera::_visitingCamera->getCameraFlag() == CameraFlag::DEFAULT)
{
defaultCamera = Camera::_visitingCamera;
}
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, Camera::_visitingCamera->getViewProjectionMatrix());
//visit the scene
visit(renderer, transform, 0);
renderer->render();
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
}
Camera::_visitingCamera = nullptr;
}
AffineTransform Node::getNodeToParentAffineTransform() const
{
AffineTransform ret;
GLToCGAffine(getNodeToParentTransform().m, &ret);
return ret;
}
cocos2d::Rect GAFObject::getBoundingBoxForCurrentFrame()
{
cocos2d::Rect result = cocos2d::Rect::ZERO;
bool isFirstObj = true;
for (DisplayList_t::iterator i = m_displayList.begin(), e = m_displayList.end(); i != e; ++i)
{
if (*i == nullptr)
{
continue;
}
GAFSprite* anim = *i;
if (anim->isVisible())
{
cocos2d::Rect bb = anim->getBoundingBox();
if (isFirstObj)
result = bb;
else
result = GAFCCRectUnion(result, bb);
}
isFirstObj = false;
}
return cocos2d::RectApplyTransform(result, getNodeToParentTransform());
}
AffineTransform Node::getNodeToParentAffineTransform() const
{
AffineTransform ret;
kmMat4 ret4 = getNodeToParentTransform();
GLToCGAffine(ret4.mat, &ret);
return ret;
}
const Mat4& Node::getParentToNodeTransform() const
{
if ( _inverseDirty )
{
_inverse = getNodeToParentTransform().getInversed();
_inverseDirty = false;
}
return _inverse;
}
void Skin::setSkinData(const BaseData &var)
{
_skinData = var;
setScaleX(_skinData.scaleX);
setScaleY(_skinData.scaleY);
setRotation(CC_RADIANS_TO_DEGREES(_skinData.skewX));
setPosition(Point(_skinData.x, _skinData.y));
_skinTransform = getNodeToParentTransform();
}
virtual void updateTransform() override
{
if (isDirty())
{
_transformToBatch = getNodeToParentTransform();
Size &size = _rect.size;
float x1 = _offsetPosition.x;
float y1 = _offsetPosition.y;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
if (_flippedX)
{
std::swap(x1, x2);
}
if (_flippedY)
{
std::swap(y1, y2);
}
float x = _transformToBatch.m[12];
float y = _transformToBatch.m[13];
float cr = _transformToBatch.m[0];
float sr = _transformToBatch.m[1];
float cr2 = _transformToBatch.m[5];
float sr2 = -_transformToBatch.m[4];
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
_quad.bl.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(ax), SPRITE_RENDER_IN_SUBPIXEL(ay), _positionZ);
_quad.br.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(bx), SPRITE_RENDER_IN_SUBPIXEL(by), _positionZ);
_quad.tl.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(dx), SPRITE_RENDER_IN_SUBPIXEL(dy), _positionZ);
_quad.tr.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(cx), SPRITE_RENDER_IN_SUBPIXEL(cy), _positionZ);
if (_textureAtlas)
{
_textureAtlas->updateQuad(&_quad, _atlasIndex);
}
_recursiveDirty = false;
setDirty(false);
}
Node::updateTransform();
}
void Skin::setSkinData(const BaseData &var)
{
_skinData = var;
setScaleX(_skinData.scaleX);
setScaleY(_skinData.scaleY);
setRotationSkewX(CC_RADIANS_TO_DEGREES(_skinData.skewX));
setRotationSkewY(CC_RADIANS_TO_DEGREES(-_skinData.skewY));
setPosition(_skinData.x, _skinData.y);
_skinTransform = getNodeToParentTransform();
updateArmatureTransform();
}
void Scene::render(Renderer* renderer)
{
auto director = Director::getInstance();
Camera* defaultCamera = nullptr;
const auto& transform = getNodeToParentTransform();
for (const auto& camera : getCameras())
{
if (!camera->isVisible())
continue;
Camera::_visitingCamera = camera;
if (Camera::_visitingCamera->getCameraFlag() == CameraFlag::DEFAULT)
{
defaultCamera = Camera::_visitingCamera;
}
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, Camera::_visitingCamera->getViewProjectionMatrix());
camera->apply();
//clear background with max depth
camera->clearBackground();
//visit the scene
visit(renderer, transform, 0);
#if CC_USE_NAVMESH
if (_navMesh && _navMeshDebugCamera == camera)
{
_navMesh->debugDraw(renderer);
}
#endif
renderer->render();
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
}
#if CC_USE_3D_PHYSICS && CC_ENABLE_BULLET_INTEGRATION
if (_physics3DWorld && _physics3DWorld->isDebugDrawEnabled())
{
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, _physics3dDebugCamera != nullptr ? _physics3dDebugCamera->getViewProjectionMatrix() : defaultCamera->getViewProjectionMatrix());
_physics3DWorld->debugDraw(renderer);
renderer->render();
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
}
#endif
Camera::_visitingCamera = nullptr;
experimental::FrameBuffer::applyDefaultFBO();
}
void Scene::render(Renderer* renderer)
{
auto director = Director::getInstance();
Camera* defaultCamera = nullptr;
const auto& transform = getNodeToParentTransform();
for (const auto& camera : _cameras)
{
Camera::_visitingCamera = camera;
if (Camera::_visitingCamera->getCameraFlag() == CameraFlag::DEFAULT)
{
defaultCamera = Camera::_visitingCamera;
continue;
}
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, Camera::_visitingCamera->getViewProjectionMatrix());
//visit the scene
visit(renderer, transform, 0);
renderer->render();
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
}
//draw with default camera
if (defaultCamera)
{
Camera::_visitingCamera = defaultCamera;
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, Camera::_visitingCamera->getViewProjectionMatrix());
//visit the scene
visit(renderer, transform, 0);
renderer->render();
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
}
Camera::_visitingCamera = nullptr;
}
void Skin::updateTransform()
{
// If it is not visible, or one of its ancestors is not visible, then do nothing:
if( !_visible)
{
_quad.br.vertices.setZero();
_quad.tl.vertices.setZero();
_quad.tr.vertices.setZero();
_quad.bl.vertices.setZero();
}
else
{
//
// calculate the Quad based on the Affine Matrix
//
Mat4 transform = getNodeToParentTransform();
Size &size = _rect.size;
float x1 = _offsetPosition.x;
float y1 = _offsetPosition.y;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
if (_flippedX)
{
std::swap(x1, x2);
}
if (_flippedY)
{
std::swap(y1, y2);
}
float x = transform.m[12];
float y = transform.m[13];
float cr = transform.m[0];
float sr = transform.m[1];
float cr2 = transform.m[5];
float sr2 = -transform.m[4];
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
_quad.bl.vertices.set(RENDER_IN_SUBPIXEL(ax), RENDER_IN_SUBPIXEL(ay), _positionZ);
_quad.br.vertices.set(RENDER_IN_SUBPIXEL(bx), RENDER_IN_SUBPIXEL(by), _positionZ);
_quad.tl.vertices.set(RENDER_IN_SUBPIXEL(dx), RENDER_IN_SUBPIXEL(dy), _positionZ);
_quad.tr.vertices.set(RENDER_IN_SUBPIXEL(cx), RENDER_IN_SUBPIXEL(cy), _positionZ);
}
// MARMALADE CHANGE: ADDED CHECK FOR nullptr, TO PERMIT SPRITES WITH NO BATCH NODE / TEXTURE ATLAS
if (_textureAtlas)
{
_textureAtlas->updateQuad(&_quad, _textureAtlas->getTotalQuads());
}
}
void Sprite::updateTransform(void)
{
CCASSERT(_batchNode, "updateTransform is only valid when Sprite is being rendered using an SpriteBatchNode");
// recalculate matrix only if it is dirty
if( isDirty() ) {
// If it is not visible, or one of its ancestors is not visible, then do nothing:
if( !_visible || ( _parent && _parent != _batchNode && static_cast<Sprite*>(_parent)->_shouldBeHidden) )
{
_quad.br.vertices = _quad.tl.vertices = _quad.tr.vertices = _quad.bl.vertices = Vertex3F(0,0,0);
_shouldBeHidden = true;
}
else
{
_shouldBeHidden = false;
if( ! _parent || _parent == _batchNode )
{
_transformToBatch = getNodeToParentTransform();
}
else
{
CCASSERT( dynamic_cast<Sprite*>(_parent), "Logic error in Sprite. Parent must be a Sprite");
kmMat4 nodeToParent = getNodeToParentTransform();
kmMat4 parentTransform = static_cast<Sprite*>(_parent)->_transformToBatch;
kmMat4Multiply(&_transformToBatch, &parentTransform, &nodeToParent);
}
//
// calculate the Quad based on the Affine Matrix
//
Size size = _rect.size;
float x1 = _offsetPosition.x;
float y1 = _offsetPosition.y;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
float x = _transformToBatch.mat[12];
float y = _transformToBatch.mat[13];
float cr = _transformToBatch.mat[0];
float sr = _transformToBatch.mat[1];
float cr2 = _transformToBatch.mat[5];
float sr2 = -_transformToBatch.mat[4];
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
_quad.bl.vertices = Vertex3F( RENDER_IN_SUBPIXEL(ax), RENDER_IN_SUBPIXEL(ay), _positionZ );
_quad.br.vertices = Vertex3F( RENDER_IN_SUBPIXEL(bx), RENDER_IN_SUBPIXEL(by), _positionZ );
_quad.tl.vertices = Vertex3F( RENDER_IN_SUBPIXEL(dx), RENDER_IN_SUBPIXEL(dy), _positionZ );
_quad.tr.vertices = Vertex3F( RENDER_IN_SUBPIXEL(cx), RENDER_IN_SUBPIXEL(cy), _positionZ );
}
// MARMALADE CHANGE: ADDED CHECK FOR nullptr, TO PERMIT SPRITES WITH NO BATCH NODE / TEXTURE ATLAS
if (_textureAtlas)
{
_textureAtlas->updateQuad(&_quad, _atlasIndex);
}
_recursiveDirty = false;
setDirty(false);
}
// MARMALADE CHANGED
// recursively iterate over children
/* if( _hasChildren )
{
// MARMALADE: CHANGED TO USE Node*
// NOTE THAT WE HAVE ALSO DEFINED virtual Node::updateTransform()
arrayMakeObjectsPerformSelector(_children, updateTransform, Sprite*);
}*/
Node::updateTransform();
}
cocos2d::Rect DBCCArmatureNode::getBoundingBox() const
{
auto rect = _armature->getCCBoundingBox();
return cocos2d::RectApplyTransform(rect, getNodeToParentTransform());
}
void Sprite::updateTransform()
{
CCASSERT(_batchNode, "updateTransform is only valid when Sprite is being rendered using an SpriteBatchNode");
// recalculate matrix only if it is dirty
if( isDirty() ) {
// If it is not visible, or one of its ancestors is not visible, then do nothing:
if( !_visible || ( _parent && _parent != _batchNode && static_cast<Sprite*>(_parent)->_shouldBeHidden) )
{
_quad.br.vertices.setZero();
_quad.tl.vertices.setZero();
_quad.tr.vertices.setZero();
_quad.bl.vertices.setZero();
_shouldBeHidden = true;
}
else
{
_shouldBeHidden = false;
if( ! _parent || _parent == _batchNode )
{
_transformToBatch = getNodeToParentTransform();
}
else
{
CCASSERT( dynamic_cast<Sprite*>(_parent), "Logic error in Sprite. Parent must be a Sprite");
const Mat4 &nodeToParent = getNodeToParentTransform();
Mat4 &parentTransform = static_cast<Sprite*>(_parent)->_transformToBatch;
_transformToBatch = parentTransform * nodeToParent;
}
//
// calculate the Quad based on the Affine Matrix
//
Size &size = _rect.size;
float x1 = _offsetPosition.x;
float y1 = _offsetPosition.y;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
float x = _transformToBatch.m[12];
float y = _transformToBatch.m[13];
float cr = _transformToBatch.m[0];
float sr = _transformToBatch.m[1];
float cr2 = _transformToBatch.m[5];
float sr2 = -_transformToBatch.m[4];
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
_quad.bl.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(ax), SPRITE_RENDER_IN_SUBPIXEL(ay), _positionZ);
_quad.br.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(bx), SPRITE_RENDER_IN_SUBPIXEL(by), _positionZ);
_quad.tl.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(dx), SPRITE_RENDER_IN_SUBPIXEL(dy), _positionZ);
_quad.tr.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(cx), SPRITE_RENDER_IN_SUBPIXEL(cy), _positionZ);
setTextureCoords(_rect);
}
// MARMALADE CHANGE: ADDED CHECK FOR nullptr, TO PERMIT SPRITES WITH NO BATCH NODE / TEXTURE ATLAS
if (_textureAtlas)
{
_textureAtlas->updateQuad(&_quad, _atlasIndex);
}
_recursiveDirty = false;
setDirty(false);
}
Node::updateTransform();
}
Vec3 DirectionLight::getDirection() const
{
Mat4 mat = getNodeToParentTransform();
return Vec3(-mat.m[8], -mat.m[9], -mat.m[10]);
}
bool Sprite::updateTransform(fzV4_T2_C4_Quad **quadp)
{
FZ_ASSERT( m_mode == kFZSprite_BatchRendering, "Sprite mode is not kFZSprite_BatchRendering.");
if(!m_isVisible)
return false;
fzV4_T2_C4_Quad *quad = *quadp;
++(*quadp);
FZ_ASSERT( quad != NULL, "Quad cannot be NULL.");
if( mode.B.p_currentQuad != quad) {
mode.B.p_currentQuad = quad;
m_dirtyFlags |= kFZDirty_transform_absolute | kFZDirty_color | kFZDirty_texcoords;
}else if(m_dirtyFlags == 0)
return false;
// UPDATING ABSOLUTE TRANSFORM
if( m_dirtyFlags & kFZDirty_transform_absolute )
{
register fzVec4 output[4];
#if FZ_SPRITE_CHILDREN || 1
fzMath_mat4Multiply(MS::getMatrix(), getNodeToParentTransform(), m_transformMV);
fzMath_mat4Vec4(m_transformMV, (float*)m_vertices, (float*)output);
#else
fzMath_mat4Vec4Affine(MS::getMatrix(), getNodeToParentTransform(), m_vertices, (float*)output);
#endif
quad->bl.vertex = output[0];
quad->br.vertex = output[1];
quad->tl.vertex = output[2];
quad->tr.vertex = output[3];
}
// UPDATING TEXTURE COORDS
if( m_dirtyFlags & kFZDirty_texcoords ) {
quad->bl.texCoord = m_texCoords[0];
quad->br.texCoord = m_texCoords[1];
quad->tl.texCoord = m_texCoords[2];
quad->tr.texCoord = m_texCoords[3];
}
// UPDATING RECURSIVE OPACITY
if(m_dirtyFlags & kFZDirty_opacity) {
m_cachedOpacity = p_parent->getCachedOpacity() * m_opacity;
m_dirtyFlags |= kFZDirty_color;
}
if(m_dirtyFlags & kFZDirty_color) {
const GLubyte cachedAlpha = static_cast<GLubyte>(m_cachedOpacity * m_alpha);
const fzColor4B color4(m_color.r, m_color.g, m_color.b, cachedAlpha);
quad->bl.color = color4;
quad->br.color = color4;
quad->tl.color = color4;
quad->tr.color = color4;
}
#if FZ_SPRITE_CHILDREN
Sprite *child = static_cast<Sprite*>(m_children.front());
if(child) {
unsigned char flags = m_dirtyFlags & kFZDirty_recursive;
MS::pushMatrix(m_transformMV);
for(; child; child = static_cast<Sprite*>(child->next())) {
child->makeDirty(flags);
child->updateTransform(quadp);
}
MS::pop();
}
#endif
m_dirtyFlags = 0;
return true;
}
