void gkCollisionNode::update(gkScalar tick)
{
SET_SOCKET_VALUE(HAS_COLLIDED, false);
if (m_timer.getTimeMilliseconds() > 300)
{
SET_SOCKET_VALUE(NOT_HAS_COLLIDED, true);
m_timer.reset();
}
if (GET_SOCKET_VALUE(ENABLE))
{
#ifdef OGREKIT_USE_PHYSICS
m_object->enableContactProcessing(true);
gkContactInfo c;
if (m_object->collidesWith(GET_SOCKET_VALUE(COLLIDES_WITH), &c))
{
SET_SOCKET_VALUE(CONTACT_POSITION, gkVector3(c.point.getPositionWorldOnA()));
SET_SOCKET_VALUE(COLLIDED_OBJ, c.collider->getObject());
SET_SOCKET_VALUE(HAS_COLLIDED, true);
SET_SOCKET_VALUE(NOT_HAS_COLLIDED, false);
m_timer.reset();
}
#endif
}
else
{
#ifdef OGREKIT_USE_PHYSICS
m_object->enableContactProcessing(false);
#endif
}
}
bool gkScreenRayTestNode::evaluate(gkScalar tick)
{
if (GET_SOCKET_VALUE(ENABLE))
{
gkCam2ViewportRay ray(GET_SOCKET_VALUE(SCREEN_X), GET_SOCKET_VALUE(SCREEN_Y));
gkRayTest rayTest;
if (rayTest.collides(ray))
{
btCollisionObject* pCol = rayTest.getCollisionObject();
gkGameObject* pObj = gkPhysicsController::castObject(pCol);
SET_SOCKET_VALUE(HIT_POSITION, rayTest.getHitPoint());
SET_SOCKET_VALUE(HIT_OBJ, pObj);
SET_SOCKET_VALUE(HIT_NAME, pObj->getName());
SET_SOCKET_VALUE(HIT, true);
SET_SOCKET_VALUE(NOT_HIT, false);
}
else
{
SET_SOCKET_VALUE(HIT, false);
SET_SOCKET_VALUE(NOT_HIT, true);
SET_SOCKET_VALUE(HIT_OBJ, 0);
SET_SOCKET_VALUE(HIT_NAME, "");
SET_SOCKET_VALUE(HIT_POSITION, gkVector3::ZERO);
}
}
return false;
}
bool gkMouseNode::evaluate(gkScalar tick)
{
gkMouse* dev = gkWindowSystem::getSingleton().getMouse();
gkScalar x = 0, y = 0;
gkScalar x_scale = GET_SOCKET_VALUE(SCALE_X);
gkScalar y_scale = GET_SOCKET_VALUE(SCALE_Y);
if (dev->moved)
{
if (GET_SOCKET(REL_X)->isConnected()) x = dev->relative.x * x_scale;
if (GET_SOCKET(REL_Y)->isConnected()) y = dev->relative.y * y_scale;
}
if (GET_SOCKET(ABS_X)->isConnected()) SET_SOCKET_VALUE(ABS_X, dev->position.x * x_scale);
if (GET_SOCKET(ABS_Y)->isConnected()) SET_SOCKET_VALUE(ABS_Y, dev->position.y * y_scale);
SET_SOCKET_VALUE(REL_X, x);
SET_SOCKET_VALUE(REL_Y, y);
SET_SOCKET_VALUE(MOTION, dev->moved);
SET_SOCKET_VALUE(WHEEL, dev->wheelDelta);
SET_SOCKET_VALUE(WHEEL_MOTION, dev->wheelDelta ? true : false);
return false;
}
void gkCharacterNode::update_animation(STATE previousTickState)
{
if (m_currentStateData->m_state != previousTickState)
{
SET_SOCKET_VALUE(ANIM_HAS_REACHED_END, false);
SET_SOCKET_VALUE(ANIM_NOT_HAS_REACHED_END, true);
SET_SOCKET_VALUE(ANIM_TIME_POSITION, 0);
//gkLogMessage(m_currentStateData->m_state << ":" << m_currentStateData->m_animName);
}
if (!GET_SOCKET_VALUE(ANIM_HAS_REACHED_END))
{
m_ent->playAnimation(m_currentStateData->m_animName, GET_SOCKET_VALUE(ANIM_BLEND_FRAMES));
gkAnimationPlayer* pAct = m_ent->getAnimationPlayer(m_currentStateData->m_animName);
GK_ASSERT(pAct);
gkScalar time = pAct->getTimePosition();
SET_SOCKET_VALUE(ANIM_TIME_POSITION, time);
if (time >= pAct->getLength())
{
SET_SOCKET_VALUE(ANIM_HAS_REACHED_END, true);
SET_SOCKET_VALUE(ANIM_NOT_HAS_REACHED_END, false);
}
}
else if (m_currentStateData->m_loop)
{
m_ent->playAnimation(m_currentStateData->m_animName, GET_SOCKET_VALUE(ANIM_BLEND_FRAMES));
}
}
void gkRayTestNode::update(gkScalar tick)
{
SET_SOCKET_VALUE(HIT, false);
SET_SOCKET_VALUE(NOT_HIT, true);
SET_SOCKET_VALUE(HIT_OBJ, 0);
SET_SOCKET_VALUE(HIT_NAME, "");
SET_SOCKET_VALUE(HIT_POSITION, gkVector3::ZERO);
if (GET_SOCKET_VALUE(ENABLE))
{
gkVector3 origin = m_object->getPosition() + GET_SOCKET_VALUE(RAY_ORIGIN_OFFSET);
gkVector3 dir = m_object->getOrientation() * GET_SOCKET_VALUE(RAY_DIRECTION);
Ogre::Ray ray(origin, dir);
gkRayTest rayTest;
if (rayTest.collides(ray))
{
btCollisionObject* pCol = rayTest.getCollisionObject();
gkGameObject* pObj = gkPhysicsController::castObject(pCol);
if (pObj != m_object)
{
SET_SOCKET_VALUE(HIT_POSITION, rayTest.getHitPoint());
SET_SOCKET_VALUE(HIT_OBJ, pObj);
SET_SOCKET_VALUE(HIT_NAME, pObj->getName());
SET_SOCKET_VALUE(HIT, true);
SET_SOCKET_VALUE(NOT_HIT, false);
}
}
}
}
bool AaScrollBarLogic::evaluate(gkScalar tick)
{
if (GET_SOCKET_VALUE(ENABLE) == ALLAPP)
{
if (GET_SOCKET_VALUE(MOUSE_HIT))
{
Ogre::RaySceneQueryResult gameObjectArray= getGkScene()->getOgreRayTest();
scrollBarDrag(gameObjectArray);
scrollBarTrack(gameObjectArray);
}
}
return true;
}
void AppMarketLogic::openAppMarketNormal()
{
if (GET_SOCKET_VALUE(ENABLE) == NORMAL)
{
}
}
void SetBackgroundLogic::changeBackground()
{
if (GET_SOCKET_VALUE(OK_KEY))
{
mWallpaperView->setWallpaper(mWallpaperView->getWallPaperThumbIndex());
}
}
void gkBulletSerializeNode::update(gkScalar tick)
{
if (GET_SOCKET_VALUE(SERIALIZE) && m_fileName != "")
{
gkEngine::getSingleton().getActiveScene()->getDynamicsWorld()->exportBullet(m_fileName);
}
}
bool FocusMoveLogic::evaluate(gkScalar tick)
{
if (GET_SOCKET_VALUE(ENABLE))
{
if (GET_SOCKET_VALUE(FOCUS_FLY_LEFT))
{
if (mLauncherScene->blockFocusTranslation(LEFT))
{
SET_SOCKET_VALUE(SCENE_MOVE_LEFT, true);
}
else
{
SET_SOCKET_VALUE(SCENE_MOVE_LEFT, false);
}
}
if(GET_SOCKET_VALUE(FOCUS_FLY_RIGHT))
{
if (mLauncherScene->blockFocusTranslation(RIGHT))
{
SET_SOCKET_VALUE(SCENE_MOVE_RIGHT, true);
}
else
{
SET_SOCKET_VALUE(SCENE_MOVE_RIGHT, false);
}
}
if(GET_SOCKET_VALUE(FOCUS_FLY_UP))
{
mLauncherScene->blockFocusTranslation(UP);
}
if(GET_SOCKET_VALUE(FOCUS_FLY_DOWN))
{
mLauncherScene->blockFocusTranslation(DOWN);
}
}
return false;
}
bool gkVariableNode::evaluate(gkScalar tick)
{
if (!m_prop) return false;
SET_SOCKET_VALUE(RESULT, *m_prop);
if (!GET_SOCKET(SET)->isLinked() && !GET_SOCKET(VALUE)->isLinked())
{
// variable will not change
return false;
}
if (GET_SOCKET_VALUE(SET))
m_prop->setValue(GET_SOCKET_VALUE(VALUE));
return false;
}
void gkVariableNode::initialize()
{
if (!m_varName.empty())
{
gkGameObject* ob = GET_SOCKET(SET)->getGameObject();
if (ob != 0)
{
if (!ob->hasVariable(m_varName))
m_prop = ob->createVariable(m_varName, m_debug);
else
m_prop = ob->getVariable(m_varName);
if (m_prop && GET_SOCKET_VALUE(SET))
m_prop->setValue(GET_SOCKET_VALUE(VALUE));
}
}
}
Ogre::Ray gkGrabNode::GetRay()
{
gkVector3 dir = m_target->getOrientation() * GET_SOCKET_VALUE(GRAB_DIRECTION);
Ogre::Ray ray(m_target->getPosition(), dir);
return ray;
}
void gkGrabNode::update(gkScalar tick)
{
gkPickNode::update(tick);
if (GET_SOCKET_VALUE(THROW_OBJECT))
{
ThrowObject();
}
}
bool gkGrabNode::evaluate(gkScalar tick)
{
m_target = GET_SOCKET_VALUE(TARGET);
if (m_target && !m_target->isInstanced())
{
ReleasePick();
}
if (GET_SOCKET_VALUE(THROWED))
{
SET_SOCKET_VALUE(THROWED, false);
}
bool enable = gkPickNode::evaluate(tick);
return enable && m_target && m_target->isInstanced();
}
bool AaMenuLoigc::evaluate(gkScalar tick)
{
if (GET_SOCKET_VALUE(ENABLE_AaMENU) == ALLAPP)
{
if ( GET_SOCKET_VALUE(OPEN_AaMENU) )
{
mAaMenuIsOpen = !mAaMenuIsOpen;
}
return true;
}
else
{
// mAabridge->setMenuVisible(false);
mAaMenuIsOpen = false;
return false;
}
}
gkVector3 gkGrabNode::GetPivotPosition()
{
gkVector3 newPivotB = gkPickNode::GetPivotPosition();
gkVector3 offsetPos = m_target->getOrientation() * GET_SOCKET_VALUE(RELATED_OFFSET_POSITION);
newPivotB += offsetPos;
return newPivotB;
}
bool gkRayTestNode::evaluate(gkScalar tick)
{
m_object = GET_SOCKET_VALUE(TARGET);
if (m_object && !m_object->isInstanced())
{
m_object = 0;
}
return m_object != 0;
}
bool gkButtonNode::evaluate(gkScalar tick)
{
bool ok = GET_SOCKET_VALUE(UPDATED);
if (ok && ++m_counter > m_delay)
{
m_counter = 0;
}
return ok && !m_counter;
}
bool SetBackgroundLogic::evaluate(gkScalar tick)
{
if (GET_SOCKET_VALUE(ENABLE) == SET_BACKGROUND)
{
enterSetBackground();
quitSetBackground();
focusMove();
changeBackground();
}
return false;
}
void AppMarketLogic::openAppMarketAa()
{
if (GET_SOCKET_VALUE(ENABLE) == ALLAPP)
{
if (GET_SOCKET_VALUE(MOUSE_HIT))
{
Ogre::RaySceneQueryResult gameObjectArray= getGkScene()->getOgreRayTest();
if (mAabridge->isHitAppMarketButton(gameObjectArray))
{
MYLOGI("key open app market\n");
sendMessage();
}
}
else if (mAabridge->isFocusOnMarket() && GET_SOCKET_VALUE(OK_KEY))
{
MYLOGI("key open app market\n");
sendMessage();
}
}
}
void SetBackgroundLogic::quitSetBackground()
{
if (GET_SOCKET_VALUE(QUIT_KEY))
{
if (isSetBackground)
{
mWallpaperView->setViewVisible(false);
mStateMachineLogic->setCurrentState(NORMAL);
}
isSetBackground = false;
}
}
void AaScrollBarLogic::scrollBarDrag(Ogre::RaySceneQueryResult& gameObjectArray)
{
if (mAabridge->isHitScrollBar(gameObjectArray))
{
if (GET_SOCKET_VALUE(IS_MOUSE_DRAG).m_DargState == DragEvent::DragMove)
{
float x = GET_SOCKET_VALUE(IS_MOUSE_DRAG).m_DargDistance.x;
float y = GET_SOCKET_VALUE(IS_MOUSE_DRAG).m_DargDistance.y;
// float windowWidth = Aabridge::getScene()->getDisplayWindow()->getRequestedWidth();
// float windowHeight = Aabridge::getScene()->getDisplayWindow()->getRequestedHeight();
//
// MYLOGI("%f, %f\n", x, y);
// MYLOGI("%f, %f\n", windowWidth, windowHeight);
// MYLOGI("%f, %f\n", x/windowWidth, y/windowHeight);
}
}
}
void gkGrabNode::ThrowObject()
{
gkVector3 vel = GET_SOCKET_VALUE(THROW_VEL);
if (m_pickedBody && vel != gkVector3::ZERO)
{
#ifdef OGREKIT_USE_PHYSICS
m_pickedBody->setLinearVelocity(m_target->getOrientation() * vel);
#endif
ReleasePick();
SET_SOCKET_VALUE(THROWED, true);
}
}
bool gkCollisionNode::evaluate(gkScalar tick)
{
gkGameObject* pObj = GET_SOCKET_VALUE(TARGET);
m_object = 0;
#ifdef OGREKIT_USE_PHYSICS
if (pObj && pObj->isInstanced())
{
m_object = pObj->getPhysicsController();
}
#endif
return m_object != 0;
}
void SetBackgroundLogic::focusMove()
{
if (GET_SOCKET_VALUE(LEFT_KEY))
{
mWallpaperView->moveFocus(LEFT);
}
else if (GET_SOCKET_VALUE(RIGHT_KEY))
{
mWallpaperView->moveFocus(RIGHT);
}
else if (GET_SOCKET_VALUE(UP_KEY))
{
mWallpaperView->moveFocus(UP);
}
else if (GET_SOCKET_VALUE(DOWN_KEY))
{
mWallpaperView->moveFocus(DOWN);
}
else if (GET_SOCKET_VALUE(OK_KEY))
{
if(mWallpaperView->isFocusOnWpSetButton())
mWallpaperView->setWallpaper(mWallpaperView->getWallPaperThumbIndex());
}
}
void gkCameraNode::calculateNewPosition(const gkVector3& currentPosition, gkScalar rayLength, gkScalar tick)
{
gkVector3 oDir = gkVector3::NEGATIVE_UNIT_Z * rayLength;
gkVector3 tmpPosition = m_center - m_target->getOrientation() * oDir;
bool newPosSet = false;
if (GET_SOCKET_VALUE(AVOID_BLOCKING))
{
gkVector3 direction = tmpPosition - m_center;
Ogre::Ray ray(m_center, direction);
gkSweptTest::AVOID_LIST avoidList;
avoidList.insert(m_centerObj->getPhysicsController()->getCollisionObject());
gkSweptTest sweptTest(avoidList);
gkScalar blokingRadius = GET_SOCKET_VALUE(BLOCKING_RADIUS);
if (sweptTest.collides(ray, blokingRadius))
{
gkVector3 displacement = (sweptTest.getHitPoint() - currentPosition) * 0.9f;
m_target->setPosition(currentPosition + (displacement + sweptTest.getSliding()) * tick);
newPosSet = true;
}
}
if (!newPosSet)
{
m_target->setPosition(tmpPosition);
}
}
bool gkCameraNode::evaluate(gkScalar tick)
{
m_centerObj = GET_SOCKET_VALUE(CENTER_OBJ);
if (m_target != GET_SOCKET_VALUE(TARGET))
{
m_radiusIdealIsSet = false;
m_oldRadiusIsSet = false;
m_target = GET_SOCKET_VALUE(TARGET);
m_rollNode = gkQuaternion(gkDegree(GET_SOCKET_VALUE(INITIAL_ROLL)), gkVector3::UNIT_Z);
m_pitchNode = gkQuaternion(gkDegree(GET_SOCKET_VALUE(INITIAL_PITCH)), gkVector3::UNIT_X);
m_oldCenter = m_center = GET_SOCKET_VALUE(CENTER_POSITION);
}
bool update = GET_SOCKET_VALUE(UPDATE);
return update && m_centerObj && m_target && m_centerObj->isInstanced() && m_target->isInstanced();
}
void gkCameraNode::update(gkScalar tick)
{
gkQuaternion rollNode = m_rollNode * gkQuaternion(Ogre::Angle(-GET_SOCKET_VALUE(REL_X)), gkVector3::UNIT_Z);
gkScalar rollDegrees = rollNode.getRoll().valueDegrees();
if (rollDegrees >= GET_SOCKET_VALUE(MIN_ROLL) && rollDegrees <= GET_SOCKET_VALUE(MAX_ROLL))
{
m_rollNode = rollNode;
}
gkQuaternion pitchNode = m_pitchNode * gkQuaternion(Ogre::Angle(-GET_SOCKET_VALUE(REL_Y)), gkVector3::UNIT_X);
gkScalar pitchDegrees = pitchNode.getPitch().valueDegrees();
if (pitchDegrees >= GET_SOCKET_VALUE(MIN_PITCH) && pitchDegrees <= GET_SOCKET_VALUE(MAX_PITCH))
{
m_pitchNode = pitchNode;
}
m_target->setOrientation(m_rollNode * m_pitchNode);
if (m_center != GET_SOCKET_VALUE(CENTER_POSITION))
{
m_oldCenter = m_center;
m_center = GET_SOCKET_VALUE(CENTER_POSITION);
}
gkVector3 currentPosition = m_target->getPosition();
Ogre::Vector3 dir;
{
gkVector3 newZPosition = currentPosition;
if (GET_SOCKET_VALUE(REL_Z))
{
newZPosition.z += newZPosition.z * GET_SOCKET_VALUE(REL_Z) * 0.5;
m_radiusIdealIsSet = false;
}
if (GET_SOCKET_VALUE(KEEP_DISTANCE))
{
dir = m_oldCenter - newZPosition;
m_oldCenter = m_center;
}
else
{
dir = m_center - newZPosition;
}
}
gkScalar radius = dir.length();
if (!m_radiusIdealIsSet)
{
m_idealRadius = radius;
m_radiusIdealIsSet = true;
}
if (!m_oldRadiusIsSet)
{
m_oldRadius = radius;
m_oldRadiusIsSet = true;
}
gkScalar stretch = (radius - m_idealRadius) * GET_SOCKET_VALUE(STIFNESS);
gkScalar damp = (radius - m_oldRadius) * GET_SOCKET_VALUE(DAMPING);
radius += -stretch * tick - damp;
gkScalar minZ = GET_SOCKET_VALUE(MIN_Z);
gkScalar maxZ = GET_SOCKET_VALUE(MAX_Z);
if (radius < minZ)
{
radius = minZ;
}
else if (radius > maxZ)
{
radius = maxZ;
}
m_oldRadius = radius;
calculateNewPosition(currentPosition, radius, tick);
SET_SOCKET_VALUE(CURRENT_ROLL, m_rollNode);
SET_SOCKET_VALUE(CURRENT_PITCH, m_pitchNode);
}
bool VariableOpNode::evaluate(gkScalar tick)
{
if (!m_prop || !GET_SOCKET_VALUE(SET))
return false;
gkScalar a = m_prop->getValueReal();
gkScalar b = GET_SOCKET_VALUE(VALUE).getValueReal();
gkScalar d = 0.0;
switch (m_function)
{
case MTH_NO_FUNC:
d = 0.0;
break;
case MTH_ADD:
d = a + b;
break;
case MTH_SUBTRACT:
d = a - b;
break;
case MTH_MULTIPLY:
d = a * b;
break;
case MTH_DIVIDE:
d = (b == 0.0) ? 0.0 : a / b;
break;
case MTH_SINE:
{
d = gkMath::Sin(gkRadian(a));
if (m_deg) d = d * gkMath::fRad2Deg;
}
break;
case MTH_COSINE:
{
d = gkMath::Cos(gkRadian(a));
if (m_deg) d = d * gkMath::fRad2Deg;
}
break;
case MTH_TANGENT:
{
d = gkMath::Tan(gkRadian(a));
if (m_deg) d = d * gkMath::fRad2Deg;
}
break;
case MTH_ARCSINE:
{
if (a <= 1 && a >= -1)
d = gkMath::ASin(a).valueRadians();
else
d = 0.0;
if (m_deg) d = d * gkMath::fRad2Deg;
}
break;
case MTH_ARCCOSINE:
{
a = gkRadian(a).valueRadians();
b = gkRadian(b).valueRadians();
if (a <= 1 && a >= -1)
d = gkMath::ACos(a).valueRadians();
else
d = 0.0;
if (m_deg) d = d * gkMath::fRad2Deg;
}
break;
case MTH_ARCTANGENT:
{
a = gkRadian(a).valueRadians();
d = gkMath::ATan(a).valueRadians();
if (m_deg) d = d * gkMath::fRad2Deg;
}
break;
case MTH_POWER:
d = a > 0 ? gkMath::Pow(a, b) : 0.0;
break;
case MTH_LOGARITHM:
{
if (a > 0 && b > 0)
d = gkMath::Log(a) / gkMath::Log(b);
else d = 0.0;
}
break;
case MTH_MINIMUM:
{
d = (a < b) ? a : b;
}
break;
case MTH_MAXIMUM:
{
d = (a > b) ? a : b;
}
break;
case MTH_ROUND:
{
gkScalar base = gkMath::Floor(a);
gkScalar dec = base - a;
d = dec > 0.5 ? base + 1 : base;
}
break;
case MTH_LESS_THAN:
{
d = (a < b) ? 1.0 : 0.0;
}
break;
case MTH_GREATER_THAN:
{
d = (a > b) ? 1.0 : 0.0;
}
break;
case MTH_SQRT:
{
d = gkMath::Sqrt(a);
}
break;
case MTH_SQR:
{
d = a * a;
}
break;
default:
break;
}
if (gkFuzzy(d)) d = 0.0;
if (gkNan(d)) d = 0.0;
if (!gkFinite(d)) d = 0.0;
m_prop->setValue(d);
SET_SOCKET_VALUE(RESULT, *m_prop);
return false;
}
