void GLView::handleTouchesBegin(int num, intptr_t ids[], float xs[], float ys[])
{
intptr_t id = 0;
float x = 0.0f;
float y = 0.0f;
int unusedIndex = 0;
EventTouch touchEvent;
for (int i = 0; i < num; ++i)
{
id = ids[i];
x = xs[i];
y = ys[i];
auto iter = g_touchIdReorderMap.find(id);
// it is a new touch
if (iter == g_touchIdReorderMap.end())
{
unusedIndex = getUnUsedIndex();
// The touches is more than MAX_TOUCHES ?
if (unusedIndex == -1) {
CCLOG("The touches is more than MAX_TOUCHES, unusedIndex = %d", unusedIndex);
continue;
}
Touch* touch = g_touches[unusedIndex] = new (std::nothrow) Touch();
touch->setTouchInfo(unusedIndex, (x - _viewPortRect.origin.x) / _scaleX,
(y - _viewPortRect.origin.y) / _scaleY);
CCLOGINFO("x = %f y = %f", touch->getLocationInView().x, touch->getLocationInView().y);
g_touchIdReorderMap.insert(std::make_pair(id, unusedIndex));
touchEvent._touches.push_back(touch);
}
}
if (touchEvent._touches.size() == 0)
{
CCLOG("touchesBegan: size = 0");
return;
}
touchEvent._eventCode = EventTouch::EventCode::BEGAN;
auto dispatcher = Director::getInstance()->getEventDispatcher();
dispatcher->dispatchEvent(&touchEvent);
}
// check if the touch was on one of the flipper buttons
void PinballRUBELayer::onTouchesBegan(const std::vector<Touch *> &touches, cocos2d::Event *event)
{
// Calling the superclass handles the mouse joint dragging for the launcher,
// but it also allows the user to grab the ball, and zoom and pan the scene.
// For a real application you would want to implement a better method here.
// RUBELayer::onTouchesBegan(touches, event);
for (auto it = touches.begin(); it != touches.end(); ++it)
{
Touch* touch = (Touch*)*it;
Point screenPos = touch->getLocationInView();
b2Vec2 worldPos = screenToWorld(screenPos);
CCLOG("Touch began at x: %f y: %f", screenPos.x, screenPos.y);
// Make a small box around the touched point to query for overlapping fixtures
b2AABB aabb;
b2Vec2 d(0.001f, 0.001f);
aabb.lowerBound = worldPos - d;
aabb.upperBound = worldPos + d;
// Query the world for overlapping fixtures (the TouchDownQueryCallback simply
// looks for any fixture that contains the touched point)
TouchDownQueryCallback callback(worldPos);
m_world->QueryAABB(&callback, aabb);
// if the touched fixture was one of the flipper buttons, set that touch as
// the current touch for that button
if (callback.m_fixture == m_leftFlipperButtonFixture)
m_leftFlipperTouch = touch;
if (callback.m_fixture == m_rightFlipperButtonFixture)
m_rightFlipperTouch = touch;
}
}
// Override this to find the body that was touched and remove it.
void DestroyBodyLayer::onTouchesBegan(const std::vector<Touch*>& touches, Event *unused_event)
{
Touch *touch = (Touch*)touches[0];
Point screenPos = touch->getLocationInView();
b2Vec2 worldPos = screenToWorld(screenPos);
// Make a small box around the touched point to query for overlapping fixtures
b2AABB aabb;
b2Vec2 d(0.001f, 0.001f);
aabb.lowerBound = worldPos - d;
aabb.upperBound = worldPos + d;
// Query the world for overlapping fixtures (the TouchDownQueryCallback simply
// looks for any fixture that contains the touched point)
TouchDownQueryCallback callback(worldPos);
m_world->QueryAABB(&callback, aabb);
// Check if we found something, and it was a dynamic body (could also destroy static
// bodies but we want to keep the pinch-zoom and pan from the superclass, and it's
// hard not to touch the ground body in this scene)
if (callback.m_fixture && callback.m_fixture->GetBody()->GetType() == b2_dynamicBody)
{
b2Body* touchedBody = callback.m_fixture->GetBody();
removeBodyFromWorld(touchedBody);
}
}
void HoleDemo::onTouchesBegan(const std::vector<Touch*>& touches, Event* event)
{
Touch *touch = (Touch *)touches[0];
Vec2 point = _outerClipper->convertToNodeSpace(Director::getInstance()->convertToGL(touch->getLocationInView()));
auto rect = Rect(0, 0, _outerClipper->getContentSize().width, _outerClipper->getContentSize().height);
if (!rect.containsPoint(point)) return;
this->pokeHoleAtPoint(point);
}
int LuaEngine::handleTouchesEvent(void* data)
{
if (NULL == data)
return 0;
TouchesScriptData* touchesScriptData = static_cast<TouchesScriptData*>(data);
if (NULL == touchesScriptData->nativeObject || NULL == touchesScriptData->touches)
return 0;
int handler = ScriptHandlerMgr::getInstance()->getObjectHandler((void*)touchesScriptData->nativeObject, ScriptHandlerMgr::kTouchesHandler);
if (0 == handler)
return 0;
switch (touchesScriptData->actionType)
{
case CCTOUCHBEGAN:
_stack->pushString("began");
break;
case CCTOUCHMOVED:
_stack->pushString("moved");
break;
case CCTOUCHENDED:
_stack->pushString("ended");
break;
case CCTOUCHCANCELLED:
_stack->pushString("cancelled");
break;
default:
return 0;
}
Director* pDirector = Director::getInstance();
lua_State *L = _stack->getLuaState();
int ret = 0;
lua_newtable(L);
int i = 1;
for (SetIterator it = touchesScriptData->touches->begin(); it != touchesScriptData->touches->end(); ++it)
{
Touch* pTouch = static_cast<Touch*>(*it);
Point pt = pDirector->convertToGL(pTouch->getLocationInView());
lua_pushnumber(L, pt.x);
lua_rawseti(L, -2, i++);
lua_pushnumber(L, pt.y);
lua_rawseti(L, -2, i++);
lua_pushinteger(L, pTouch->getID());
lua_rawseti(L, -2, i++);
}
ret = _stack->executeFunctionByHandler(handler, 2);
_stack->clean();
return ret;
}
void ScrollViewDemo::onTouchesBegan(const std::vector<Touch*>& touches, Event *event)
{
Touch *touch = touches[0];
auto clipper = this->getChildByTag(kTagClipperNode);
Vec2 point = clipper->convertToNodeSpace(Director::getInstance()->convertToGL(touch->getLocationInView()));
auto rect = Rect(0, 0, clipper->getContentSize().width, clipper->getContentSize().height);
_scrolling = rect.containsPoint(point);
_lastPoint = point;
}
void ScrollViewDemo::onTouchesMoved(const std::vector<Touch*>& touches, Event *event)
{
if (!_scrolling) return;
Touch *touch = touches[0];
auto clipper = this->getChildByTag(kTagClipperNode);
auto point = clipper->convertToNodeSpace(Director::getInstance()->convertToGL(touch->getLocationInView()));
Vec2 diff = point - _lastPoint;
auto content = clipper->getChildByTag(kTagContentNode);
content->setPosition(content->getPosition() + diff);
_lastPoint = point;
}
int LuaEngine::handleTouchEvent(void* data)
{
if (NULL == data)
return 0;
TouchScriptData* touchScriptData = static_cast<TouchScriptData*>(data);
if (NULL == touchScriptData->nativeObject || NULL == touchScriptData->touch)
return 0;
int handler = ScriptHandlerMgr::getInstance()->getObjectHandler((void*)touchScriptData->nativeObject, ScriptHandlerMgr::HandlerType::TOUCHES);
if (0 == handler)
return 0;
switch (touchScriptData->actionType)
{
case EventTouch::EventCode::BEGAN:
_stack->pushString("began");
break;
case EventTouch::EventCode::MOVED:
_stack->pushString("moved");
break;
case EventTouch::EventCode::ENDED:
_stack->pushString("ended");
break;
case EventTouch::EventCode::CANCELLED:
_stack->pushString("cancelled");
break;
default:
return 0;
}
int ret = 0;
Touch* touch = touchScriptData->touch;
if (NULL != touch) {
const cocos2d::Vec2 pt = Director::getInstance()->convertToGL(touch->getLocationInView());
_stack->pushFloat(pt.x);
_stack->pushFloat(pt.y);
const cocos2d::Vec2 prev_pt = Director::getInstance()->convertToGL(touch->getPreviousLocationInView());
_stack->pushFloat(prev_pt.x);
_stack->pushFloat(prev_pt.y);
ret = _stack->executeFunctionByHandler(handler, 5);
}
_stack->clean();
return ret;
}
bool BallSprite::isInCircle(Touch touch) {
const Vec2 bpos = this->getPosition();
Director* pDirector = CCDirector::getInstance();
Point touchPoint = pDirector -> convertToGL(touch.getLocationInView());
float dist = touchPoint.getDistance(bpos);
if(dist <= getBallRadius()) {
return true;
}
else {
return false;
}
}
void GravityCtrlLayer::onTouchesMoved(const std::vector<cocos2d::Touch*>& touches, cocos2d::Event *unused_event) {
if (getState() == State::Active) {
Touch* touch = touches[0];
Point screenPos = touch->getLocationInView();
m_isCancelled = checkIsCancelled(screenPos);
if (m_isCancelled) {
m_wheelCtrl->cancel();
} else {
float angle = CMath::getAngle(m_center->x, m_center->y, screenPos.x, 1080 - screenPos.y);
cocos2d::log("angle for gravity: %f", angle);
m_wheelCtrl->setTargetAngle(angle);
}
}
}
int LuaEngine::executeLayerTouchesEvent(Layer* pLayer, int eventType, Set *pTouches)
{
TouchScriptHandlerEntry* pScriptHandlerEntry = pLayer->getScriptTouchHandlerEntry();
if (!pScriptHandlerEntry) return 0;
int nHandler = pScriptHandlerEntry->getHandler();
if (!nHandler) return 0;
switch (eventType)
{
case CCTOUCHBEGAN:
_stack->pushString("began");
break;
case CCTOUCHMOVED:
_stack->pushString("moved");
break;
case CCTOUCHENDED:
_stack->pushString("ended");
break;
case CCTOUCHCANCELLED:
_stack->pushString("cancelled");
break;
default:
return 0;
}
Director* pDirector = Director::sharedDirector();
lua_State *L = _stack->getLuaState();
lua_newtable(L);
int i = 1;
for (SetIterator it = pTouches->begin(); it != pTouches->end(); ++it)
{
Touch* pTouch = (Touch*)*it;
Point pt = pDirector->convertToGL(pTouch->getLocationInView());
lua_pushnumber(L, pt.x);
lua_rawseti(L, -2, i++);
lua_pushnumber(L, pt.y);
lua_rawseti(L, -2, i++);
lua_pushinteger(L, pTouch->getID());
lua_rawseti(L, -2, i++);
}
int ret = _stack->executeFunctionByHandler(nHandler, 2);
_stack->clean();
return ret;
}
// record when the user touches the left/right sides of the screen
void PlanetCuteRUBELayer::onTouchesBegan(const std::vector<Touch*>& touches, Event* event)
{
Size s = Director::getInstance()->getWinSize();
int middleOfScreen = s.width / 2;
for (auto it = touches.begin(); it != touches.end(); ++it) {
Touch* touch = (Touch*)*it;
// if the touch location was on a side of the screen that we don't already
// have a touch for, set that touch as the current touch for that side
Point screenPos = touch->getLocationInView();
if ( !m_leftTouch && screenPos.x < middleOfScreen )
m_leftTouch = touch;
if ( !m_rightTouch && screenPos.x > middleOfScreen )
m_rightTouch = touch;
}
}
int LuaEngine::executeNodeTouchesEvent(Node* pNode, int eventType, const std::vector<Touch*>& touches, int phase)
{
CCScriptEventListenersForEvent *listeners = getListeners(pNode, phase == NODE_TOUCH_CAPTURING_PHASE ? NODE_TOUCH_CAPTURE_EVENT : NODE_TOUCH_EVENT);
if (!listeners) return 1;
_stack->clean();
LuaValueDict event;
switch (eventType)
{
case CCTOUCHBEGAN:
event["name"] = LuaValue::stringValue("began");
break;
case CCTOUCHMOVED:
event["name"] = LuaValue::stringValue("moved");
break;
case CCTOUCHENDED:
event["name"] = LuaValue::stringValue("ended");
break;
case CCTOUCHCANCELLED:
event["name"] = LuaValue::stringValue("cancelled");
break;
case CCTOUCHADDED:
event["name"] = LuaValue::stringValue("added");
break;
case CCTOUCHREMOVED:
event["name"] = LuaValue::stringValue("removed");
break;
default:
return 0;
}
event["mode"] = LuaValue::intValue((int)Touch::DispatchMode::ALL_AT_ONCE);
switch (phase)
{
case NODE_TOUCH_CAPTURING_PHASE:
event["phase"] = LuaValue::stringValue("capturing");
break;
case NODE_TOUCH_TARGETING_PHASE:
event["phase"] = LuaValue::stringValue("targeting");
break;
default:
event["phase"] = LuaValue::stringValue("unknown");
}
LuaValueDict points;
Director* pDirector = Director::getInstance();
char touchId[16];
for (auto touchIt = touches.begin(); touchIt != touches.end(); ++touchIt)
{
LuaValueDict point;
Touch* pTouch = (Touch*)*touchIt;
sprintf(touchId, "%d", pTouch->getID());
point["id"] = LuaValue::stringValue(touchId);
const Point pt = pDirector->convertToGL(pTouch->getLocationInView());
point["x"] = LuaValue::floatValue(pt.x);
point["y"] = LuaValue::floatValue(pt.y);
const Point prev = pDirector->convertToGL(pTouch->getPreviousLocationInView());
point["prevX"] = LuaValue::floatValue(prev.x);
point["prevY"] = LuaValue::floatValue(prev.y);
points[touchId] = LuaValue::dictValue(point);
}
event["points"] = LuaValue::dictValue(points);
_stack->pushLuaValueDict(event);
bool flagNeedClean = false;
for (auto it=listeners->begin(); it!=listeners->end(); ++it)
{
if ((*it)->removed) {
flagNeedClean = true;
continue;
}
_stack->copyValue(1);
_stack->executeFunctionByHandler((*it)->listener, 1);
_stack->settop(1);
}
cleanListeners(listeners, pNode, flagNeedClean);
_stack->clean();
return 1;
}
inline Point locationInGLFromTouch(Touch& touch)
{
auto director = Director::getInstance();
return director->convertToGL(touch.getLocationInView());
}
int LuaEventNode::executeScriptTouchHandler(int nEventType, const std::vector<Touch*>& touches, int phase /* = NODE_TOUCH_TARGETING_PHASE */)
{
auto stack = initExecParam(this->getActiveNode(), phase);
if (!stack)
{
return 0;
}
LuaValueDict event;
switch (nEventType)
{
case CCTOUCHBEGAN:
event["name"] = LuaValue::stringValue("began");
break;
case CCTOUCHMOVED:
event["name"] = LuaValue::stringValue("moved");
break;
case CCTOUCHENDED:
event["name"] = LuaValue::stringValue("ended");
break;
case CCTOUCHCANCELLED:
event["name"] = LuaValue::stringValue("cancelled");
break;
case CCTOUCHADDED:
event["name"] = LuaValue::stringValue("added");
break;
case CCTOUCHREMOVED:
event["name"] = LuaValue::stringValue("removed");
break;
default:
return 0;
}
event["mode"] = LuaValue::intValue((int)Touch::DispatchMode::ALL_AT_ONCE);
switch (phase)
{
case NODE_TOUCH_CAPTURING_PHASE:
event["phase"] = LuaValue::stringValue("capturing");
break;
case NODE_TOUCH_TARGETING_PHASE:
event["phase"] = LuaValue::stringValue("targeting");
break;
default:
event["phase"] = LuaValue::stringValue("unknown");
}
LuaValueDict points;
Director* pDirector = Director::getInstance();
char touchId[16];
for (auto touchIt = touches.begin(); touchIt != touches.end(); ++touchIt)
{
LuaValueDict point;
Touch* pTouch = (Touch*)*touchIt;
sprintf(touchId, "%d", pTouch->getID());
point["id"] = LuaValue::stringValue(touchId);
const Point pt = pDirector->convertToGL(pTouch->getLocationInView());
point["x"] = LuaValue::floatValue(pt.x);
point["y"] = LuaValue::floatValue(pt.y);
const Point prev = pDirector->convertToGL(pTouch->getPreviousLocationInView());
point["prevX"] = LuaValue::floatValue(prev.x);
point["prevY"] = LuaValue::floatValue(prev.y);
points[touchId] = LuaValue::dictValue(point);
}
event["points"] = LuaValue::dictValue(points);
return callNodeEventDispatcher(stack, event);
}
bool TouchPool::handleTouch(TouchTrigger::TouchAction action,int num,intptr_t ids[],float xs[],float ys[])
{
intptr_t id = 0;
float x = 0.0f;
float y = 0.0f;
int unusedIndex = 0;
TouchTrigger touchTrigger;
for(int i=0;i<num;i++)
{
id = ids[i];
x = xs[i];
y = ys[i];
auto iter = _touchIdReorderMap.find(id);
// it is a new touch
if (iter == _touchIdReorderMap.end())
{
if(action != TouchTrigger::TouchAction::DOWN)
{
FKLOG("if the index doesn't exist, it is an error");
continue;
}
FKLOG("id = %ld",(long int) id);
unusedIndex = getUnUsedIndex();
// The touches is more than MAX_TOUCHES ?
if (unusedIndex == -1) {
FKLOG("The touches is more than MAX_TOUCHES, unusedIndex = %d", unusedIndex);
continue;
}
Touch* touch = _touches[unusedIndex] = new (std::nothrow) Touch();
touch->setTouchInfo(unusedIndex, x, y);
FKLOG("x = %f y = %f", touch->getLocationInView().x, touch->getLocationInView().y);
_touchIdReorderMap.insert(std::make_pair(id, unusedIndex));
touchTrigger._touches.push_back(touch);
}
else
{
FKLOG("unusedindex = %d", iter->second);
FKLOG("other x = %f y = %f", x, y);
Touch* touch = _touches[iter->second];
if (touch)
{
touch->setTouchInfo(iter->second, x, y);
touchTrigger._touches.push_back(touch);
if(action == TouchTrigger::TouchAction::UP || action == TouchTrigger::TouchAction::CANCEL)
{
_touches[iter->second] = nullptr;
removeUsedIndexBit(iter->second);
_touchIdReorderMap.erase(id);
}
}
else
{
// It is error, should return.
FKLOG("Moving touches with id: %ld error", (long int)id);
return false;
}
}
}
if (touchTrigger._touches.size() == 0)
{
FKLOG("touches: size = 0");
return false;
}
touchTrigger.setAction(action);
bool result = dispatchTouch(&touchTrigger);
if(action == TouchTrigger::TouchAction::UP || action == TouchTrigger::TouchAction::CANCEL)
{
for (auto& touch : touchTrigger._touches)
{
// release the touch object.
touch->release();
}
}
return result;
}
