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; }
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); } } } }
void gkButtonNode::update(gkScalar tick) { bool isPressed = isButtonDown(); SET_SOCKET_VALUE(IS_DOWN, isPressed); SET_SOCKET_VALUE(NOT_IS_DOWN, !isPressed); if (isPressed && !m_pressed) { m_pressed = true; SET_SOCKET_VALUE(PRESS, true); SET_SOCKET_VALUE(RELEASE, false); } else if (!isPressed && m_pressed) { m_pressed = false; SET_SOCKET_VALUE(PRESS, false); SET_SOCKET_VALUE(RELEASE, true); } else { SET_SOCKET_VALUE(PRESS, false); SET_SOCKET_VALUE(RELEASE, false); } }
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 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 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 } }
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 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 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; }
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(); }
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; }
void gkCharacterNode::update_state(gkScalar tick) { STATE aiState = GET_SOCKET_VALUE(INPUT_AI_STATE); SET_SOCKET_VALUE(OUTPUT_AI_STATE, aiState); gkStateMachineNode::update(tick); if (aiState == NULL_STATE) { if (GET_SOCKET_VALUE(ENABLE_ROTATION) && m_currentStateData->m_allow_rotation) { m_obj->setOrientation(GET_SOCKET_VALUE(ROTATION_VALUE)); } if (GET_SOCKET_VALUE(JUMP)) { gkScalar jumpSpeed = GET_SOCKET_VALUE(JUMP_SPEED); const gkGameObjectProperties& props = m_obj->getProperties(); const gkPhysicsProperties& phy = props.m_physics; if (m_obj->getAttachedCharacter()) { m_obj->getAttachedCharacter()->getCharacterController()->setJumpSpeed(phy.m_mass * jumpSpeed); m_obj->getAttachedCharacter()->getCharacterController()->jump(); } else { m_obj->applyForce(gkVector3::UNIT_Z * phy.m_mass * jumpSpeed); } } StateData* state = m_currentStateData; while (state->m_usePreviousVelocity && state->m_previous) state = state->m_previous; m_obj->setLinearVelocity(m_forward * state->m_velocity, TRANSFORM_LOCAL); } SET_SOCKET_VALUE(POSITION, m_obj->getPosition()); SET_SOCKET_VALUE(ROTATION, m_obj->getOrientation()); { // FALL TEST m_falling = false; if (m_obj->getAttachedCharacter()) { m_falling = !m_obj->getAttachedCharacter()->getCharacterController()->onGround(); } else { const gkVector3& velocity = m_obj->getLinearVelocity(); m_falling = velocity.z < 0; } SET_SOCKET_VALUE(FALLING, m_falling); SET_SOCKET_VALUE(NOT_FALLING, !m_falling); } { // GRAVITY gkScalar gravity = GET_SOCKET_VALUE(GRAVITY); if (m_obj->getAttachedCharacter()) { m_obj->getAttachedCharacter()->getCharacterController()->setGravity(gravity); } else { m_obj->getAttachedBody()->getBody()->setGravity(btVector3(0, 0, -gravity)); } } }