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; }