From 9abe2c38cfd79c1f12608e50a97a701970613cf2 Mon Sep 17 00:00:00 2001 From: halx99 Date: Wed, 1 Sep 2021 11:11:32 +0800 Subject: [PATCH] Revert unexpected layer changes --- cocos/2d/CCLayer.cpp | 534 ++++++++++++++++++++++++++++++++----------- cocos/2d/CCLayer.h | 167 +++++++++++++- 2 files changed, 559 insertions(+), 142 deletions(-) diff --git a/cocos/2d/CCLayer.cpp b/cocos/2d/CCLayer.cpp index d6685f2184..f4d07e01b4 100644 --- a/cocos/2d/CCLayer.cpp +++ b/cocos/2d/CCLayer.cpp @@ -4,9 +4,8 @@ Copyright (c) 2010-2012 cocos2d-x.org Copyright (c) 2011 Zynga Inc. Copyright (c) 2013-2016 Chukong Technologies Inc. Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd. -Copyright (c) Bytedance Inc. - -https://adxe.org + +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 @@ -47,30 +46,40 @@ THE SOFTWARE. #include "renderer/backend/ProgramState.h" #if (CC_TARGET_PLATFORM == CC_PLATFORM_MAC) -# include "platform/desktop/CCGLViewImpl-desktop.h" +#include "platform/desktop/CCGLViewImpl-desktop.h" #endif NS_CC_BEGIN // Layer Layer::Layer() +: _touchEnabled(false) +, _accelerometerEnabled(false) +, _keyboardEnabled(false) +, _touchListener(nullptr) +, _keyboardListener(nullptr) +, _accelerationListener(nullptr) +, _touchMode(Touch::DispatchMode::ALL_AT_ONCE) +, _swallowsTouches(true) { _ignoreAnchorPointForPosition = true; setAnchorPoint(Vec2(0.5f, 0.5f)); } -Layer::~Layer() {} +Layer::~Layer() +{ + +} bool Layer::init() { - Sprite::init(); setContentSize(_director->getWinSize()); return true; } -Layer* Layer::create() +Layer *Layer::create() { - Layer* ret = new (std::nothrow) Layer(); + Layer *ret = new (std::nothrow) Layer(); if (ret && ret->init()) { ret->autorelease(); @@ -83,13 +92,204 @@ Layer* Layer::create() } } +int Layer::executeScriptTouchHandler(EventTouch::EventCode eventType, Touch* touch, Event* event) +{ +#if CC_ENABLE_SCRIPT_BINDING + TouchScriptData data(eventType, this, touch, event); + ScriptEvent scriptEvent(kTouchEvent, &data); + return ScriptEngineManager::sendEventToLua(scriptEvent); +#else + CC_UNUSED_PARAM(eventType); + CC_UNUSED_PARAM(touch); + CC_UNUSED_PARAM(event); + return 0; +#endif +} + +int Layer::executeScriptTouchesHandler(EventTouch::EventCode eventType, const std::vector& touches, Event* event) +{ +#if CC_ENABLE_SCRIPT_BINDING + TouchesScriptData data(eventType, this, touches, event); + ScriptEvent scriptEvent(kTouchesEvent, &data); + return ScriptEngineManager::sendEventToLua(scriptEvent); +#else + CC_UNUSED_PARAM(eventType); + CC_UNUSED_PARAM(touches); + CC_UNUSED_PARAM(event); + return 0; +#endif +} + + +void Layer::onAcceleration(Acceleration* acc, Event* /*unused_event*/) +{ +#if CC_ENABLE_SCRIPT_BINDING + BasicScriptData data(this,(void*)acc); + ScriptEvent event(kAccelerometerEvent,&data); + ScriptEngineManager::sendEventToLua(event); +#else + CC_UNUSED_PARAM(acc); +#endif +} + +void Layer::onKeyPressed(EventKeyboard::KeyCode /*keyCode*/, Event* /*unused_event*/) +{ +} + +void Layer::onKeyReleased(EventKeyboard::KeyCode keyCode, Event* /*unused_event*/) +{ +#if CC_ENABLE_SCRIPT_BINDING + KeypadScriptData data(keyCode, this); + ScriptEvent event(kKeypadEvent,&data); + ScriptEngineManager::sendEventToLua(event); +#else + CC_UNUSED_PARAM(keyCode); +#endif +} + +/// Callbacks + +bool Layer::onTouchBegan(Touch *touch, Event *event) +{ +#if CC_ENABLE_SCRIPT_BINDING + return executeScriptTouchHandler(EventTouch::EventCode::BEGAN, touch, event) == 0 ? false : true; +#else + CC_UNUSED_PARAM(touch); + CC_UNUSED_PARAM(event); + CCASSERT(false, "Layer#ccTouchBegan override me"); + return true; +#endif +} + +void Layer::onTouchMoved(Touch *touch, Event *event) +{ +#if CC_ENABLE_SCRIPT_BINDING + executeScriptTouchHandler(EventTouch::EventCode::MOVED, touch, event); +#else + CC_UNUSED_PARAM(touch); + CC_UNUSED_PARAM(event); +#endif +} + +void Layer::onTouchEnded(Touch *touch, Event *event) +{ +#if CC_ENABLE_SCRIPT_BINDING + executeScriptTouchHandler(EventTouch::EventCode::ENDED, touch, event); +#else + CC_UNUSED_PARAM(touch); + CC_UNUSED_PARAM(event); +#endif +} + +void Layer::onTouchCancelled(Touch *touch, Event *event) +{ +#if CC_ENABLE_SCRIPT_BINDING + executeScriptTouchHandler(EventTouch::EventCode::CANCELLED, touch, event); +#else + CC_UNUSED_PARAM(touch); + CC_UNUSED_PARAM(event); +#endif +} + +void Layer::onTouchesBegan(const std::vector& touches, Event *event) +{ +#if CC_ENABLE_SCRIPT_BINDING + executeScriptTouchesHandler(EventTouch::EventCode::BEGAN, touches, event); +#else + CC_UNUSED_PARAM(touches); + CC_UNUSED_PARAM(event); +#endif +} + +void Layer::onTouchesMoved(const std::vector& touches, Event *event) +{ +#if CC_ENABLE_SCRIPT_BINDING + executeScriptTouchesHandler(EventTouch::EventCode::MOVED, touches, event); +#else + CC_UNUSED_PARAM(touches); + CC_UNUSED_PARAM(event); +#endif +} + +void Layer::onTouchesEnded(const std::vector& touches, Event *event) +{ +#if CC_ENABLE_SCRIPT_BINDING + executeScriptTouchesHandler(EventTouch::EventCode::ENDED, touches, event); +#else + CC_UNUSED_PARAM(touches); + CC_UNUSED_PARAM(event); +#endif +} + +void Layer::onTouchesCancelled(const std::vector& touches, Event *event) +{ +#if CC_ENABLE_SCRIPT_BINDING + executeScriptTouchesHandler(EventTouch::EventCode::CANCELLED, touches, event); +#else + CC_UNUSED_PARAM(touches); + CC_UNUSED_PARAM(event); +#endif +} + std::string Layer::getDescription() const { return StringUtils::format("", _tag); } /// LayerColor -LayerColor::LayerColor() {} + +LayerColor::LayerColor() +{ + // default blend function + _blendFunc = BlendFunc::ALPHA_PREMULTIPLIED; + + auto& pipelinePS = _customCommand.getPipelineDescriptor().programState; + auto* program = backend::Program::getBuiltinProgram(backend::ProgramType::POSITION_COLOR); + + //!!! LayerColor private programState don't want affect by Node::_programState, so store at _customCommand + pipelinePS = new backend::ProgramState(program); + + auto vertexLayout = pipelinePS->getVertexLayout(); + const auto& attributeInfo = pipelinePS->getProgram()->getActiveAttributes(); + auto iter = attributeInfo.find("a_position"); + if(iter != attributeInfo.end()) + { + vertexLayout->setAttribute("a_position", iter->second.location, backend::VertexFormat::FLOAT3, 0, false); + } + iter = attributeInfo.find("a_color"); + if(iter != attributeInfo.end()) + { + vertexLayout->setAttribute("a_color", iter->second.location, backend::VertexFormat::FLOAT4, sizeof(_vertexData[0].vertices), false); + } + vertexLayout->setLayout(sizeof(_vertexData[0])); + + _mvpMatrixLocation = pipelinePS->getUniformLocation("u_MVPMatrix"); + + _customCommand.createIndexBuffer(CustomCommand::IndexFormat::U_SHORT, 6, CustomCommand::BufferUsage::STATIC); + unsigned short indices[] = {0, 1, 2, 2, 1, 3}; + _customCommand.updateIndexBuffer(indices, sizeof(indices)); + + _customCommand.createVertexBuffer(sizeof(_vertexData[0]), 4, CustomCommand::BufferUsage::DYNAMIC); + + _customCommand.setDrawType(CustomCommand::DrawType::ELEMENT); + _customCommand.setPrimitiveType(CustomCommand::PrimitiveType::TRIANGLE); +} + +LayerColor::~LayerColor() +{ + CC_SAFE_RELEASE_NULL(_customCommand.getPipelineDescriptor().programState); +} + +/// blendFunc getter +const BlendFunc &LayerColor::getBlendFunc() const +{ + return _blendFunc; +} +/// blendFunc setter +void LayerColor::setBlendFunc(const BlendFunc &var) +{ + _blendFunc = var; +} LayerColor* LayerColor::create() { @@ -105,10 +305,10 @@ LayerColor* LayerColor::create() return ret; } -LayerColor* LayerColor::create(const Color4B& color, float width, float height) +LayerColor * LayerColor::create(const Color4B& color, float width, float height) { - LayerColor* layer = new (std::nothrow) LayerColor(); - if (layer && layer->initWithColor(color, width, height)) + LayerColor * layer = new (std::nothrow) LayerColor(); + if( layer && layer->initWithColor(color,width,height)) { layer->autorelease(); return layer; @@ -117,10 +317,10 @@ LayerColor* LayerColor::create(const Color4B& color, float width, float height) return nullptr; } -LayerColor* LayerColor::create(const Color4B& color) +LayerColor * LayerColor::create(const Color4B& color) { - LayerColor* layer = new (std::nothrow) LayerColor(); - if (layer && layer->initWithColor(color)) + LayerColor * layer = new (std::nothrow) LayerColor(); + if(layer && layer->initWithColor(color)) { layer->autorelease(); return layer; @@ -132,22 +332,30 @@ LayerColor* LayerColor::create(const Color4B& color) bool LayerColor::init() { Size s = _director->getWinSize(); - return initWithColor(Color4B(0, 0, 0, 0), s.width, s.height); + return initWithColor(Color4B(0,0,0,0), s.width, s.height); } bool LayerColor::initWithColor(const Color4B& color, float w, float h) { - if (Sprite::init()) + if (Layer::init()) { - // Anchor behavior same with Layer - _ignoreAnchorPointForPosition = true; - setAnchorPoint(Vec2(0.5f, 0.5f)); - const Rect defaultRect{0.f, 0.f, 2.f, 2.f}; - setTextureRect(defaultRect, false, defaultRect.size); + // default blend function + _blendFunc = BlendFunc::ALPHA_NON_PREMULTIPLIED; + + _displayedColor.r = _realColor.r = color.r; + _displayedColor.g = _realColor.g = color.g; + _displayedColor.b = _realColor.b = color.b; + _displayedOpacity = _realOpacity = color.a; + + for (size_t i = 0; isetContentSize(Size(w, h)); } @@ -175,17 +394,57 @@ void LayerColor::changeHeight(float h) this->setContentSize(Size(_contentSize.width, h)); } +void LayerColor::updateColor() +{ + for (int i = 0; i < 4; i++ ) + { + _vertexData[i].colors.r = _displayedColor.r / 255.0f; + _vertexData[i].colors.g = _displayedColor.g / 255.0f; + _vertexData[i].colors.b = _displayedColor.b / 255.0f; + _vertexData[i].colors.a = _displayedOpacity / 255.0f; + } +} + +void LayerColor::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags) +{ + _customCommand.init(_globalZOrder, _blendFunc); + renderer->addCommand(&_customCommand); + + cocos2d::Mat4 projectionMat = _director->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION); + auto& pipelineDescriptor = _customCommand.getPipelineDescriptor(); + pipelineDescriptor.programState->setUniform(_mvpMatrixLocation, projectionMat.m, sizeof(projectionMat.m)); + + for(int i = 0; i < 4; ++i) + { + Vec4 pos; + pos.x = _squareVertices[i].x; pos.y = _squareVertices[i].y; pos.z = _positionZ; + pos.w = 1; + _modelViewTransform.transformVector(&pos); + _vertexData[i].vertices = Vec3(pos.x,pos.y,pos.z)/pos.w; + } + updateVertexBuffer(); +} + +void LayerColor::updateVertexBuffer() +{ + _customCommand.updateVertexBuffer(_vertexData, sizeof(_vertexData)); +} + // // LayerGradient // -LayerGradient::LayerGradient() {} +LayerGradient::LayerGradient() +{ +} -LayerGradient::~LayerGradient() {} +LayerGradient::~LayerGradient() +{ +} LayerGradient* LayerGradient::create(const Color4B& start, const Color4B& end) { - LayerGradient* layer = new (std::nothrow) LayerGradient(); - if (layer && layer->initWithColor(start, end)) + LayerGradient * layer = new (std::nothrow) LayerGradient(); + if( layer && layer->initWithColor(start, end)) { layer->autorelease(); return layer; @@ -196,8 +455,8 @@ LayerGradient* LayerGradient::create(const Color4B& start, const Color4B& end) LayerGradient* LayerGradient::create(const Color4B& start, const Color4B& end, const Vec2& v) { - LayerGradient* layer = new (std::nothrow) LayerGradient(); - if (layer && layer->initWithColor(start, end, v)) + LayerGradient * layer = new (std::nothrow) LayerGradient(); + if( layer && layer->initWithColor(start, end, v)) { layer->autorelease(); return layer; @@ -232,13 +491,13 @@ bool LayerGradient::initWithColor(const Color4B& start, const Color4B& end) bool LayerGradient::initWithColor(const Color4B& start, const Color4B& end, const Vec2& v) { - _endColor.r = end.r; - _endColor.g = end.g; - _endColor.b = end.b; + _endColor.r = end.r; + _endColor.g = end.g; + _endColor.b = end.b; - _endOpacity = end.a; - _startOpacity = start.a; - _alongVector = v; + _endOpacity = end.a; + _startOpacity = start.a; + _alongVector = v; _compressedInterpolation = true; @@ -247,6 +506,8 @@ bool LayerGradient::initWithColor(const Color4B& start, const Color4B& end, cons void LayerGradient::updateColor() { + LayerColor::updateColor(); + float h = _alongVector.getLength(); if (h == 0) return; @@ -257,48 +518,46 @@ void LayerGradient::updateColor() // Compressed Interpolation mode if (_compressedInterpolation) { - float h2 = 1 / (fabsf(u.x) + fabsf(u.y)); - u = u * (h2 * (float)c); + float h2 = 1 / ( fabsf(u.x) + fabsf(u.y) ); + u = u * (h2 * (float)c); } float opacityf = (float)_displayedOpacity / 255.0f; - Color4F S(_displayedColor.r / 255.0f, _displayedColor.g / 255.0f, _displayedColor.b / 255.0f, - _startOpacity * opacityf / 255.0f); + Color4F S( + _displayedColor.r / 255.0f, + _displayedColor.g / 255.0f, + _displayedColor.b / 255.0f, + _startOpacity * opacityf / 255.0f + ); - Color4F E(_endColor.r / 255.0f, _endColor.g / 255.0f, _endColor.b / 255.0f, _endOpacity * opacityf / 255.0f); + Color4F E( + _endColor.r / 255.0f, + _endColor.g / 255.0f, + _endColor.b / 255.0f, + _endOpacity * opacityf / 255.0f + ); // (-1, -1) - _quad.bl.colors.r = (E.r + (S.r - E.r) * ((c + u.x + u.y) / (2.0f * c))) * 255; - _quad.bl.colors.g = (E.g + (S.g - E.g) * ((c + u.x + u.y) / (2.0f * c))) * 255; - _quad.bl.colors.b = (E.b + (S.b - E.b) * ((c + u.x + u.y) / (2.0f * c))) * 255; - _quad.bl.colors.a = (E.a + (S.a - E.a) * ((c + u.x + u.y) / (2.0f * c))) * 255; - // (1, -1) - _quad.br.colors.r = (E.r + (S.r - E.r) * ((c - u.x + u.y) / (2.0f * c))) * 255; - _quad.br.colors.g = (E.g + (S.g - E.g) * ((c - u.x + u.y) / (2.0f * c))) * 255; - _quad.br.colors.b = (E.b + (S.b - E.b) * ((c - u.x + u.y) / (2.0f * c))) * 255; - _quad.br.colors.a = (E.a + (S.a - E.a) * ((c - u.x + u.y) / (2.0f * c))) * 255; - // (-1, 1) - _quad.tl.colors.r = (E.r + (S.r - E.r) * ((c + u.x - u.y) / (2.0f * c))) * 255; - _quad.tl.colors.g = (E.g + (S.g - E.g) * ((c + u.x - u.y) / (2.0f * c))) * 255; - _quad.tl.colors.b = (E.b + (S.b - E.b) * ((c + u.x - u.y) / (2.0f * c))) * 255; - _quad.tl.colors.a = (E.a + (S.a - E.a) * ((c + u.x - u.y) / (2.0f * c))) * 255; - // (1, 1) - _quad.tr.colors.r = (E.r + (S.r - E.r) * ((c - u.x - u.y) / (2.0f * c))) * 255; - _quad.tr.colors.g = (E.g + (S.g - E.g) * ((c - u.x - u.y) / (2.0f * c))) * 255; - _quad.tr.colors.b = (E.b + (S.b - E.b) * ((c - u.x - u.y) / (2.0f * c))) * 255; - _quad.tr.colors.a = (E.a + (S.a - E.a) * ((c - u.x - u.y) / (2.0f * c))) * 255; - - // renders using batch node - if (_renderMode == RenderMode::QUAD_BATCHNODE) - { - if (_atlasIndex != INDEX_NOT_INITIALIZED) - _textureAtlas->updateQuad(&_quad, _atlasIndex); - else - // no need to set it recursively - // update dirty_, don't update recursiveDirty_ - setDirty(true); - } + _vertexData[0].colors.r = E.r + (S.r - E.r) * ((c + u.x + u.y) / (2.0f * c)); + _vertexData[0].colors.g = E.g + (S.g - E.g) * ((c + u.x + u.y) / (2.0f * c)); + _vertexData[0].colors.b = E.b + (S.b - E.b) * ((c + u.x + u.y) / (2.0f * c)); + _vertexData[0].colors.a = E.a + (S.a - E.a) * ((c + u.x + u.y) / (2.0f * c)); + // (1, -1) + _vertexData[1].colors.r = E.r + (S.r - E.r) * ((c - u.x + u.y) / (2.0f * c)); + _vertexData[1].colors.g = E.g + (S.g - E.g) * ((c - u.x + u.y) / (2.0f * c)); + _vertexData[1].colors.b = E.b + (S.b - E.b) * ((c - u.x + u.y) / (2.0f * c)); + _vertexData[1].colors.a = E.a + (S.a - E.a) * ((c - u.x + u.y) / (2.0f * c)); + // (-1, 1) + _vertexData[2].colors.r = E.r + (S.r - E.r) * ((c + u.x - u.y) / (2.0f * c)); + _vertexData[2].colors.g = E.g + (S.g - E.g) * ((c + u.x - u.y) / (2.0f * c)); + _vertexData[2].colors.b = E.b + (S.b - E.b) * ((c + u.x - u.y) / (2.0f * c)); + _vertexData[2].colors.a = E.a + (S.a - E.a) * ((c + u.x - u.y) / (2.0f * c)); + // (1, 1) + _vertexData[3].colors.r = E.r + (S.r - E.r) * ((c - u.x - u.y) / (2.0f * c)); + _vertexData[3].colors.g = E.g + (S.g - E.g) * ((c - u.x - u.y) / (2.0f * c)); + _vertexData[3].colors.b = E.b + (S.b - E.b) * ((c - u.x - u.y) / (2.0f * c)); + _vertexData[3].colors.a = E.a + (S.a - E.a) * ((c - u.x - u.y) / (2.0f * c)); } const Color3B& LayerGradient::getStartColor() const @@ -374,11 +633,7 @@ std::string LayerGradient::getDescription() const /** * LayerRadialGradient */ -LayerRadialGradient* LayerRadialGradient::create(const Color4B& startColor, - const Color4B& endColor, - float radius, - const Vec2& center, - float expand) +LayerRadialGradient* LayerRadialGradient::create(const Color4B& startColor, const Color4B& endColor, float radius, const Vec2& center, float expand) { auto layerGradient = new LayerRadialGradient(); if (layerGradient && layerGradient->initWithColor(startColor, endColor, radius, center, expand)) @@ -386,7 +641,7 @@ LayerRadialGradient* LayerRadialGradient::create(const Color4B& startColor, layerGradient->autorelease(); return layerGradient; } - + delete layerGradient; return nullptr; } @@ -394,12 +649,12 @@ LayerRadialGradient* LayerRadialGradient::create(const Color4B& startColor, LayerRadialGradient* LayerRadialGradient::create() { auto layerGradient = new LayerRadialGradient(); - if (layerGradient && layerGradient->initWithColor(Color4B::BLACK, Color4B::BLACK, 0, Vec2(0, 0), 0)) + if (layerGradient && layerGradient->initWithColor(Color4B::BLACK, Color4B::BLACK, 0, Vec2(0,0), 0)) { layerGradient->autorelease(); return layerGradient; } - + delete layerGradient; return nullptr; } @@ -407,27 +662,26 @@ LayerRadialGradient* LayerRadialGradient::create() LayerRadialGradient::LayerRadialGradient() { auto& pipelinePS = _customCommand.getPipelineDescriptor().programState; - auto* program = backend::Program::getBuiltinProgram(backend::ProgramType::LAYER_RADIA_GRADIENT); + auto* program = backend::Program::getBuiltinProgram(backend::ProgramType::LAYER_RADIA_GRADIENT); //!!! LayerRadialGradient private programState don't want affect by Node::_programState, so store at _customCommand - pipelinePS = new backend::ProgramState(program); - _mvpMatrixLocation = pipelinePS->getUniformLocation("u_MVPMatrix"); + pipelinePS = new backend::ProgramState(program); + _mvpMatrixLocation = pipelinePS->getUniformLocation("u_MVPMatrix"); _startColorLocation = pipelinePS->getUniformLocation("u_startColor"); - _endColorLocation = pipelinePS->getUniformLocation("u_endColor"); - _centerLocation = pipelinePS->getUniformLocation("u_center"); - _radiusLocation = pipelinePS->getUniformLocation("u_radius"); - _expandLocation = pipelinePS->getUniformLocation("u_expand"); + _endColorLocation = pipelinePS->getUniformLocation("u_endColor"); + _centerLocation = pipelinePS->getUniformLocation("u_center"); + _radiusLocation = pipelinePS->getUniformLocation("u_radius"); + _expandLocation = pipelinePS->getUniformLocation("u_expand"); - auto vertexLayout = pipelinePS->getVertexLayout(); + auto vertexLayout = pipelinePS->getVertexLayout(); const auto& attributeInfo = pipelinePS->getProgram()->getActiveAttributes(); - auto iter = attributeInfo.find("a_position"); - if (iter != attributeInfo.end()) + auto iter = attributeInfo.find("a_position"); + if(iter != attributeInfo.end()) { vertexLayout->setAttribute("a_position", iter->second.location, backend::VertexFormat::FLOAT2, 0, false); } vertexLayout->setLayout(sizeof(_vertices[0])); - _customCommand.createVertexBuffer(sizeof(_vertices[0]), sizeof(_vertices) / sizeof(_vertices[0]), - CustomCommand::BufferUsage::STATIC); + _customCommand.createVertexBuffer(sizeof(_vertices[0]), sizeof(_vertices) / sizeof(_vertices[0]), CustomCommand::BufferUsage::STATIC); _customCommand.setDrawType(CustomCommand::DrawType::ARRAY); _customCommand.setPrimitiveType(CustomCommand::PrimitiveType::TRIANGLE_STRIP); } @@ -437,43 +691,39 @@ LayerRadialGradient::~LayerRadialGradient() CC_SAFE_RELEASE_NULL(_customCommand.getPipelineDescriptor().programState); } -bool LayerRadialGradient::initWithColor(const cocos2d::Color4B& startColor, - const cocos2d::Color4B& endColor, - float radius, - const Vec2& center, - float expand) +bool LayerRadialGradient::initWithColor(const cocos2d::Color4B &startColor, const cocos2d::Color4B &endColor, float radius, const Vec2& center, float expand) { // should do it before Layer::init() for (int i = 0; i < 4; ++i) _vertices[i] = {0.0f, 0.0f}; - + if (Layer::init()) { convertColor4B24F(_startColorRend, startColor); _startColor = startColor; - + convertColor4B24F(_endColorRend, endColor); _endColor = endColor; - + _expand = expand; - + setRadius(radius); setCenter(center); - + return true; } - + return false; } -void LayerRadialGradient::draw(Renderer* renderer, const Mat4& transform, uint32_t flags) +void LayerRadialGradient::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags) { _customCommand.init(_globalZOrder, _blendFunc); renderer->addCommand(&_customCommand); const auto& projectionMat = _director->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION); - auto programState = _customCommand.getPipelineDescriptor().programState; - Mat4 finalMat = projectionMat * transform; + auto programState = _customCommand.getPipelineDescriptor().programState; + Mat4 finalMat = projectionMat * transform; programState->setUniform(_mvpMatrixLocation, finalMat.m, sizeof(finalMat.m)); programState->setUniform(_startColorLocation, &_startColorRend, sizeof(_startColorRend)); @@ -497,7 +747,7 @@ void LayerRadialGradient::setContentSize(const Size& size) void LayerRadialGradient::setStartOpacity(uint8_t opacity) { _startColorRend.a = opacity / 255.0f; - _startColor.a = opacity; + _startColor.a = opacity; } uint8_t LayerRadialGradient::getStartOpacity() const @@ -508,7 +758,7 @@ uint8_t LayerRadialGradient::getStartOpacity() const void LayerRadialGradient::setEndOpacity(uint8_t opacity) { _endColorRend.a = opacity / 255.0f; - _endColor.a = opacity; + _endColor.a = opacity; } uint8_t LayerRadialGradient::getEndOpacity() const @@ -551,7 +801,7 @@ void LayerRadialGradient::setStartColor(const Color3B& color) setStartColor(Color4B(color)); } -void LayerRadialGradient::setStartColor(const cocos2d::Color4B& color) +void LayerRadialGradient::setStartColor(const cocos2d::Color4B &color) { _startColor = color; convertColor4B24F(_startColorRend, _startColor); @@ -572,7 +822,7 @@ void LayerRadialGradient::setEndColor(const Color3B& color) setEndColor(Color4B(color)); } -void LayerRadialGradient::setEndColor(const cocos2d::Color4B& color) +void LayerRadialGradient::setEndColor(const cocos2d::Color4B &color) { _endColor = color; convertColor4B24F(_endColorRend, _endColor); @@ -588,6 +838,16 @@ Color3B LayerRadialGradient::getEndColor3B() const return Color3B(_endColor); } +void LayerRadialGradient::setBlendFunc(const BlendFunc& blendFunc) +{ + _blendFunc = blendFunc; +} + +BlendFunc LayerRadialGradient::getBlendFunc() const +{ + return _blendFunc; +} + void LayerRadialGradient::convertColor4B24F(Color4F& outColor, const Color4B& inColor) { outColor.r = inColor.r / 255.0f; @@ -596,25 +856,28 @@ void LayerRadialGradient::convertColor4B24F(Color4F& outColor, const Color4B& in outColor.a = inColor.a / 255.0f; } + /// MultiplexLayer -LayerMultiplex::LayerMultiplex() : _enabledLayer(0) {} +LayerMultiplex::LayerMultiplex() +: _enabledLayer(0) +{ +} LayerMultiplex::~LayerMultiplex() { - for (const auto& layer : _layers) - { + for(const auto &layer : _layers) { layer->cleanup(); } } -LayerMultiplex* LayerMultiplex::create(Layer* layer, ...) +LayerMultiplex * LayerMultiplex::create(Layer * layer, ...) { va_list args; - va_start(args, layer); + va_start(args,layer); - LayerMultiplex* multiplexLayer = new (std::nothrow) LayerMultiplex(); - if (multiplexLayer && multiplexLayer->initWithLayers(layer, args)) + LayerMultiplex * multiplexLayer = new (std::nothrow) LayerMultiplex(); + if(multiplexLayer && multiplexLayer->initWithLayers(layer, args)) { multiplexLayer->autorelease(); va_end(args); @@ -625,7 +888,7 @@ LayerMultiplex* LayerMultiplex::create(Layer* layer, ...) return nullptr; } -LayerMultiplex* LayerMultiplex::createWithLayer(Layer* layer) +LayerMultiplex * LayerMultiplex::createWithLayer(Layer* layer) { return LayerMultiplex::create(layer, nullptr); } @@ -666,7 +929,7 @@ void LayerMultiplex::addLayer(Layer* layer) { sEngine->retainScriptObject(this, layer); } -#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS +#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS _layers.pushBack(layer); } @@ -680,7 +943,7 @@ bool LayerMultiplex::init() return false; } -bool LayerMultiplex::initWithLayers(Layer* layer, va_list params) +bool LayerMultiplex::initWithLayers(Layer *layer, va_list params) { if (Layer::init()) { @@ -691,20 +954,19 @@ bool LayerMultiplex::initWithLayers(Layer* layer, va_list params) { sEngine->retainScriptObject(this, layer); } -#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS +#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS _layers.pushBack(layer); - Layer* l = va_arg(params, Layer*); - while (l) - { + Layer *l = va_arg(params,Layer*); + while( l ) { #if CC_ENABLE_GC_FOR_NATIVE_OBJECTS if (sEngine) { sEngine->retainScriptObject(this, l); } -#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS +#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS _layers.pushBack(l); - l = va_arg(params, Layer*); + l = va_arg(params,Layer*); } _enabledLayer = 0; @@ -723,7 +985,7 @@ bool LayerMultiplex::initWithArray(const Vector& arrayOfLayers) auto sEngine = ScriptEngineManager::getInstance()->getScriptEngine(); if (sEngine) { - for (const auto& layer : arrayOfLayers) + for (const auto &layer : arrayOfLayers) { if (layer) { @@ -731,7 +993,7 @@ bool LayerMultiplex::initWithArray(const Vector& arrayOfLayers) } } } -#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS +#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS _layers.reserve(arrayOfLayers.size()); _layers.pushBack(arrayOfLayers); @@ -744,24 +1006,24 @@ bool LayerMultiplex::initWithArray(const Vector& arrayOfLayers) void LayerMultiplex::switchTo(int n) { - + switchTo(n, true); } void LayerMultiplex::switchTo(int n, bool cleanup) { - CCASSERT(n < _layers.size(), "Invalid index in MultiplexLayer switchTo message"); - + CCASSERT( n < _layers.size(), "Invalid index in MultiplexLayer switchTo message" ); + this->removeChild(_layers.at(_enabledLayer), cleanup); - + _enabledLayer = n; - + this->addChild(_layers.at(n)); } void LayerMultiplex::switchToAndReleaseMe(int n) { - CCASSERT(n < _layers.size(), "Invalid index in MultiplexLayer switchTo message"); + CCASSERT( n < _layers.size(), "Invalid index in MultiplexLayer switchTo message" ); this->removeChild(_layers.at(_enabledLayer), true); #if CC_ENABLE_GC_FOR_NATIVE_OBJECTS @@ -770,8 +1032,8 @@ void LayerMultiplex::switchToAndReleaseMe(int n) { sEngine->releaseScriptObject(this, _layers.at(_enabledLayer)); } -#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS - +#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS + _layers.replace(_enabledLayer, nullptr); _enabledLayer = n; diff --git a/cocos/2d/CCLayer.h b/cocos/2d/CCLayer.h index d4aa84ed52..7ff96b2122 100644 --- a/cocos/2d/CCLayer.h +++ b/cocos/2d/CCLayer.h @@ -3,9 +3,9 @@ Copyright (c) 2008-2010 Ricardo Quesada Copyright (c) 2010-2012 cocos2d-x.org Copyright (c) 2011 Zynga Inc. Copyright (c) 2013-2016 Chukong Technologies Inc. -Copyright (c) Bytedance Inc. +Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd. -https://adxe.org +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 @@ -28,7 +28,6 @@ THE SOFTWARE. #pragma once #include "2d/CCNode.h" -#include "2d/CCSprite.h" #include "base/CCProtocols.h" #include "renderer/CCCustomCommand.h" @@ -41,13 +40,26 @@ NS_CC_BEGIN * @{ */ +class __Set; +class TouchScriptHandlerEntry; + +class EventListenerTouch; +class EventListenerKeyboard; +class EventListenerAcceleration; + +class Touch; + // // Layer // /** @class Layer - * @brief Layer is a subclass of Node + * @brief Layer is a subclass of Node that implements the TouchEventsDelegate protocol. + +All features from Node are valid, plus the following new features: +- It can receive iPhone Touches +- It can receive Accelerometer input */ -class CC_DLL Layer : public Sprite +class CC_DLL Layer : public Node { public: /** Creates a fullscreen black layer. @@ -56,6 +68,95 @@ public: */ static Layer *create(); + /* Callback function should not be deprecated, it will generate lots of warnings. + Since 'setTouchEnabled' was deprecated, it will make warnings if developer overrides onTouchXXX and invokes setTouchEnabled(true) instead of using EventDispatcher::addEventListenerWithXXX. + */ + /** Callback function for touch began. + * + * @param touch Touch information. + * @param unused_event Event information. + * @return if return false, onTouchMoved, onTouchEnded, onTouchCancelled will never called. + * @js NA + */ + virtual bool onTouchBegan(Touch *touch, Event *unused_event); + /** Callback function for touch moved. + * + * @param touch Touch information. + * @param unused_event Event information. + * @js NA + */ + virtual void onTouchMoved(Touch *touch, Event *unused_event); + /** Callback function for touch ended. + * + * @param touch Touch information. + * @param unused_event Event information. + * @js NA + */ + virtual void onTouchEnded(Touch *touch, Event *unused_event); + /** Callback function for touch cancelled. + * + * @param touch Touch information. + * @param unused_event Event information. + * @js NA + */ + virtual void onTouchCancelled(Touch *touch, Event *unused_event); + + /** Callback function for multiple touches began. + * + * @param touches Touches information. + * @param unused_event Event information. + * @js NA + */ + virtual void onTouchesBegan(const std::vector& touches, Event *unused_event); + /** Callback function for multiple touches moved. + * + * @param touches Touches information. + * @param unused_event Event information. + * @js NA + */ + virtual void onTouchesMoved(const std::vector& touches, Event *unused_event); + /** Callback function for multiple touches ended. + * + * @param touches Touches information. + * @param unused_event Event information. + * @js NA + */ + virtual void onTouchesEnded(const std::vector& touches, Event *unused_event); + /** Callback function for multiple touches cancelled. + * + * @param touches Touches information. + * @param unused_event Event information. + * @js NA + */ + virtual void onTouchesCancelled(const std::vector&touches, Event *unused_event); + + /* Callback function should not be deprecated, it will generate lots of warnings. + Since 'setAccelerometerEnabled' was deprecated, it will make warnings if developer overrides onAcceleration and invokes setAccelerometerEnabled(true) instead of using EventDispatcher::addEventListenerWithXXX. + */ + /** Callback function for acceleration. + * @param acc Acceleration information. + * @param unused_event Event information. + * @js NA + */ + virtual void onAcceleration(Acceleration* acc, Event* unused_event); + + + /* Callback function should not be deprecated, it will generate lots of warnings. + Since 'setKeyboardEnabled' was deprecated, it will make warnings if developer overrides onKeyXXX and invokes setKeyboardEnabled(true) instead of using EventDispatcher::addEventListenerWithXXX. + */ + /** Callback function for key pressed. + * @param keyCode KeyCode information. + * @param event Event information. + * @js NA + */ + virtual void onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event); + /** Callback function for key released. + * @param keyCode KeyCode information. + * @param event Event information. + * @js NA + */ + virtual void onKeyReleased(EventKeyboard::KeyCode keyCode, Event* event); + // Overrides virtual std::string getDescription() const override; @@ -65,6 +166,21 @@ CC_CONSTRUCTOR_ACCESS: virtual bool init() override; +protected: + + int executeScriptTouchHandler(EventTouch::EventCode eventType, Touch* touch, Event* event); + int executeScriptTouchesHandler(EventTouch::EventCode eventType, const std::vector& touches, Event* event); + + bool _touchEnabled; + bool _accelerometerEnabled; + bool _keyboardEnabled; + EventListener* _touchListener; + EventListenerKeyboard* _keyboardListener; + EventListenerAcceleration* _accelerationListener; + + Touch::DispatchMode _touchMode; + bool _swallowsTouches; + private: CC_DISALLOW_COPY_AND_ASSIGN(Layer); @@ -80,7 +196,7 @@ All features from Layer are valid, plus the following new features: - opacity - RGB colors */ -class CC_DLL LayerColor : public Layer +class CC_DLL LayerColor : public Layer, public BlendProtocol { public: @@ -122,12 +238,46 @@ public: */ void changeWidthAndHeight(float w, float h); + // + // Overrides + // + virtual void draw(Renderer *renderer, const Mat4 &transform, uint32_t flags) override; + + virtual void setContentSize(const Size & var) override; + /** BlendFunction. Conforms to BlendProtocol protocol */ + /** + * @lua NA + */ + virtual const BlendFunc& getBlendFunc() const override; + /** + *@code + *When this function bound into js or lua,the parameter will be changed + *In js: var setBlendFunc(var src, var dst) + *In lua: local setBlendFunc(local src, local dst) + *@endcode + */ + virtual void setBlendFunc(const BlendFunc& blendFunc) override; + CC_CONSTRUCTOR_ACCESS: LayerColor(); + virtual ~LayerColor(); + bool init() override; bool initWithColor(const Color4B& color, float width, float height); bool initWithColor(const Color4B& color); +protected: + + virtual void updateColor() override; + void updateVertexBuffer(); + + BlendFunc _blendFunc; + Vec2 _squareVertices[4]; + CustomCommand _customCommand; + + V3F_C4F _vertexData[4]; + + backend::UniformLocation _mvpMatrixLocation; private: CC_DISALLOW_COPY_AND_ASSIGN(LayerColor); @@ -330,6 +480,9 @@ public: Color4B getEndColor() const; Color3B getEndColor3B() const; + void setBlendFunc(const BlendFunc& blendFunc); + BlendFunc getBlendFunc() const; + CC_CONSTRUCTOR_ACCESS: LayerRadialGradient(); virtual ~LayerRadialGradient(); @@ -351,6 +504,8 @@ private: float _expand = 0.f; CustomCommand _customCommand; + BlendFunc _blendFunc = BlendFunc::ALPHA_NON_PREMULTIPLIED; + backend::UniformLocation _mvpMatrixLocation; backend::UniformLocation _startColorLocation; backend::UniformLocation _endColorLocation;