void AnimCtrlPlayerCharacter::updateAimRotation(Ogre::Radian angleHorizontal, Ogre::Radian angleVertical, unsigned long timeSinceLastFrame) { // This is freaking important! Must be in seconds and an Ogre::Real Ogre::Real secSinceLastFrame = (Ogre::Real) timeSinceLastFrame / 1000.f; // Set manual frame position // --------------------------------------- float prevValue = animPipeline->getAnimManualTimePos( "aim" ); float maxValue = animPipeline->getAnimLength( "aim" ); float aimFrame = interpolateAiming( angleHorizontal.valueDegrees(), 360.f, prevValue, maxValue, 3500.f, secSinceLastFrame ); animPipeline->setAnimManualTimePos( "aim", aimFrame ); animPipeline->setAnimManualTimePos( "aimUp", aimFrame ); animPipeline->setAnimManualTimePos( "aimDown", aimFrame ); // Set blend value // --------------------------------------- // Modify Angle; animated only from 45° (up) to -45° (down) float aimBlend = angleVertical.valueDegrees() - 45.f; aimBlend = std::max( 0.f, aimBlend ); aimBlend = std::min( 90.f, aimBlend ); prevValue = getFlagValue( "aim_vertical2", 0 ) + getFlagValue( "aim_vertical3", 0 ); aimBlend = interpolateAiming( aimBlend, 90.f, prevValue, 2.f, 2000.f, secSinceLastFrame ); // Split up blend value from 0 to 1 into three blend values for the LERP tree float aimBlendTrees = (aimBlend > 1.f) ? 1.f : 0.f; setFlagValue( "aim_vertical1", aimBlendTrees ); float aimBlend2 = std::min( 1.f, aimBlend ); setFlagValue( "aim_vertical2", aimBlend2 ); float aimBlend3 = std::max( 1.f, aimBlend ) - 1.f; setFlagValue( "aim_vertical3", aimBlend3 ); }
VEHA::RotationVector OgrePointSpecification::getLocalRotation() const { Ogre::Quaternion q=_node->getOrientation(); Ogre::Vector3 v; Ogre::Radian a; q.ToAngleAxis(a,v); return VEHA::RotationVector((double)v.x,(double)v.y,(double)v.z,(double)a.valueRadians()); }
VEHA::RotationVector OgrePointSpecification::getGlobalRotation() const { Ogre::Quaternion q=_node->getOrientation(); if(_parent) q=shared_dynamic_cast<OgrePointSpecification>(_parent)->_node->convertLocalToWorldOrientation(q); Ogre::Vector3 v; Ogre::Radian a; q.ToAngleAxis(a,v); return VEHA::RotationVector((double)v.x,(double)v.y,(double)v.z,(double)a.valueRadians()); }
inline void moveCamera() { camera_->rotate(AngleVector(-rotY_.valueDegrees(), rotX_.valueDegrees(), 0.0)); camera_->translate(camera_->getOrientation().yawOrientation * translateVector_); const double maxPitch = 60.0; AngleVector rotation = camera_->getRotation(); const double pitch = rotation.pitch; // Limit the pitch. if(fabs(pitch) > maxPitch) { rotation.pitch = (pitch > 0.0) ? maxPitch : -maxPitch; camera_->setRotation(rotation); } }
void GameObject::yaw(const Ogre::Radian radians) { if (node) node->yaw(radians); btTransform t = body->getCenterOfMassTransform(); t.setRotation(btQuaternion(0, 1, 0, radians.valueRadians())); body->setCenterOfMassTransform(t); }
void Character::yaw(const Ogre::Radian radians) { if (node) node->yaw(radians); btTransform t = body->getCenterOfMassTransform(); t.setRotation(btQuaternion(0, 1, 0, radians.valueRadians())); body->setCenterOfMassTransform(t); changes = changes | (1 << ROTATION_CHANGE); }
gkRadian gkSteering::getAngle(const gkVector3& from, const gkVector3& to) { Ogre::Vector3 from1 = getProjectionOnPlane(from, m_steerAxis); Ogre::Vector3 to1 = getProjectionOnPlane(to, m_steerAxis); Ogre::Quaternion q = from1.getRotationTo(to1); Ogre::Radian angle; Ogre::Vector3 rAxis; q.ToAngleAxis(angle, rAxis); rAxis = angle.valueRadians() * (rAxis * m_steerAxis); angle = rAxis.x + rAxis.y + rAxis.z; return angle; }
// Returns volume for the right ear. // If the sound is directly to the right, that channel gets 254 of intensity. // If the sound is directly in front of us, each channel gets 254/2 of intensity. int SoundManager::calcPanning(Ogre::Camera* mCamera, Ogre::Vector3 soundPosition) { Ogre::Vector3 camDirection = mCamera->getOrientation() * Ogre::Vector3::NEGATIVE_UNIT_Z; Ogre::Vector3 soundDir = soundPosition - mCamera->getPosition(); soundDir.normalise(); // Retrieve the angle made between the sound position and the camera's direction, // which should be pointing forwards. Ogre::Quaternion q = camDirection.getRotationTo(soundDir); Ogre::Radian radians = q.getYaw(); // anything left of the camera returns positive degrees float degrees = radians.valueDegrees(); int leftIntensity; int rightIntensity; // from 0 to -179 it's the right ear. if(degrees <= 0) { //std::cout << "degrees " << degrees << std::endl; degrees *= -1; if(degrees > 90) degrees = 90 - (degrees - 90); // if 91, we subtract 1 and go back to 89 // Intensity can never be 255 because then the effect cancels out. int intensity = (degrees / 90.0) * 254/2 + 254/2; //std::cout << "intensity " << intensity << std::endl; rightIntensity = intensity; leftIntensity = 255 - (rightIntensity); } // from 0 to 179 it's the left ear. else { if(degrees > 90) degrees = 90 - (degrees - 90); int intensity = (degrees / 90) * 254/2 + 254/2; //std::cout << "intensity " << intensity << std::endl; leftIntensity = intensity; rightIntensity = 254 - (leftIntensity); } return rightIntensity; }
void CCameraFeedbackNotifier::calculateEnemyPosition(Vector3 vPosEnemy) { //Obtengo la posición del enemigo Ogre::Vector3 vEnemyPos = vPosEnemy; //Obtengo mi posición (entidad a la que han dañado) Ogre::Vector3 vMyPos = this->_entity->getPosition(); //Obtengo el vector en el que estoy mirando, y me quedo sólo en el plano horizontal (quitando la altura) Vector3 vMyDirVision = _entity->getOrientation()*Vector3::NEGATIVE_UNIT_Z; vMyDirVision = Vector3(vMyDirVision.x,0,vMyDirVision.z); //Obtengo el vector desde el enemigo a mi posición; y me quedo sólo con el plano horizontal (quitando la altura) Vector3 vEnemyDirVision = vPosEnemy - vMyPos; vEnemyDirVision = Vector3(vEnemyDirVision.x, 0, vEnemyDirVision.z); //Ángulo entre ambos vectores Ogre::Radian rad = vMyDirVision.angleBetween(vEnemyDirVision); //Convierto los radianes a float porque en el mensaje mando float float fRadianes = (float)rad.valueRadians(); //Cambio de sistema de coordenadas para tener la posición del enemigo respecto //al jugador. Antonio el crack matemático! ^^ Matrix4 mat; mat.makeTransform(_entity->getPosition(),Vector3::UNIT_SCALE,_entity->getOrientation()); mat.inverse(); Vector3 vec = mat * vPosEnemy; //este vector es la posicion del enemigo respecto a mi if (vec.x > 0) { //El enemigo está a la derecha, así que tengo que multiplicar //por -1 para que se oriente bien la flecha de daño fRadianes *= -1.0f; } //Mando el mensaje std::shared_ptr<Logic::CMessageImpact> impact = std::make_shared<Logic::CMessageImpact>(); impact->setDirectionImpact(fRadianes); _entity->emitMessage(impact); }
Ogre::Vector3 LuaScriptUtilities::QuaternionToRotationDegrees( const Ogre::Quaternion& quaternion) { Ogre::Vector3 angles; Ogre::Radian xAngle; Ogre::Radian yAngle; Ogre::Radian zAngle; Ogre::Matrix3 rotation; quaternion.ToRotationMatrix(rotation); rotation.ToEulerAnglesXYZ(xAngle, yAngle, zAngle); angles.x = xAngle.valueDegrees(); angles.y = yAngle.valueDegrees(); angles.z = zAngle.valueDegrees(); return angles; }
static float sgn(Ogre::Radian a) { if(a.valueRadians() > 0) return 1.0; return -1.0; }
void FieldPlayer::onUpdate(double time_diff) { this->mIsUpdatingAfterChange = (time_diff == 0); mStateMachine->onUpdate(); // Update here mSteeringBehaviors->calculateDrivingForce(); // Apply a small rotation Ogre::Quaternion rotation = getRotation(); Ogre::Vector3 current_velocity = getVelocity(); Ogre::Vector3 current_heading = rotation * Ogre::Vector3(0, 0, 1); float velocity_magnitude = current_velocity.length(); Ogre::Vector3 driving_force = mSteeringBehaviors->getSteeringForce(); btTransform trans = mPhysicsBody->getRigidBody()->getWorldTransform(); btMotionState* motion = mPhysicsBody->getRigidBody()->getMotionState(); if (driving_force.length() > EPS) { Ogre::Radian angle = current_heading.getRotationTo(driving_force).getYaw(); if (angle > Ogre::Radian(mTurnRate)) angle = Ogre::Radian(mTurnRate); if (angle < Ogre::Radian(-mTurnRate)) angle = Ogre::Radian(-mTurnRate); float accumulate_force = current_heading.dotProduct(driving_force); // If at the same line if (fabs(angle.valueRadians()) < 1e-3 && accumulate_force < 0) angle = mTurnRate; rotation = rotation * Ogre::Quaternion(angle, Ogre::Vector3(0, 1, 0)); trans.setRotation(BtOgre::Convert::toBullet(rotation)); velocity_magnitude += accumulate_force; if (velocity_magnitude < 0) velocity_magnitude = 0; } else { velocity_magnitude *= 0.8; } // Is at target if (mIsTurnningAroundAtTarget != Ogre::Radian(0)) { rotation = rotation * Ogre::Quaternion(mIsTurnningAroundAtTarget, Ogre::Vector3(0, 1, 0)); trans.setRotation(BtOgre::Convert::toBullet(rotation)); } if (velocity_magnitude > mMaxSpeed) velocity_magnitude = mMaxSpeed; // About animation if (velocity_magnitude < 1e-6) mMesh->stopAnimation(); else mMesh->playAnimation(); // Set velocity mVelocity = rotation * Ogre::Vector3(0, 0, velocity_magnitude); trans.setOrigin(trans.getOrigin() + BtOgre::Convert::toBullet(mVelocity) * 0.02); motion->setWorldTransform(trans); mIsTurnningAroundAtTarget = Ogre::Radian(0); setDebugText(getStateMachine()->getNameOfCurrentState()); //setDebugText(dt::Utils::toString(getSteering()->getTarget())); //DEBUG_MODE_BEGIN //setDebugText(dt::Utils::toString(getSteering()->getSteeringForce())); //DEBUG_MODE_END dt::Node::onUpdate(time_diff); }
void Turret::Update() { bool PlayerInRoom = false; DynamicObject::Update(); hkpWorldRayCastOutput OutPut; hkpWorldRayCastInput Ray; Player* theplayer = 0; Ogre::Vector3 RayDirection = (mPlayerPos - mPosition).normalisedCopy(); Ray.m_from = hkVector4(mPosition.x + (RayDirection.x * 25) ,mPosition.y + (RayDirection.y * 25) ,mPosition.z + (RayDirection.z * 25)); Ray.m_to = hkVector4(mPlayerPos.x, mPlayerPos.y, mPlayerPos.z); mPhysicsManager->GetPhysicsWorld()->castRay(Ray,OutPut); if(OutPut.hasHit()) { const hkpCollidable* col = OutPut.m_rootCollidable; hkpRigidBody* body = hkpGetRigidBody(col); theplayer = dynamic_cast<Player*> ((BaseObject *)body->getUserData()); if(theplayer != 0) { PlayerInRoom = true; } else { mPlayerInSight = false; mKillTimer = 0; } } Ogre::Vector3 NewDir = Ogre::Vector3(RayDirection.x,0,RayDirection.z); NewDir.normalise(); Ogre::Radian angle = NewDir.angleBetween(ObjectNode->getOrientation() * Ogre::Vector3::UNIT_X); if(PlayerInRoom || !mPlayerInSight) { if(angle.valueDegrees() < 20 || angle.valueDegrees() > -20) { mPlayerInSight = true; } } if(mPlayerInSight) { mRotateValue += angle.valueRadians(); Body->setRotation(hkQuaternion(hkVector4(0,1,0),mRotateValue)); mKillTimer++; if(mKillTimer > 800) { mShutdown = true; //theplayer->OnDeath(); } } else { if(mRotateValue < -2) { mChangeInRotation = 0.001; } else if (mRotateValue > 2) { mChangeInRotation = -0.001; } mRotateValue += mChangeInRotation; Body->setRotation(hkQuaternion(hkVector4(0,1,0),mRotateValue)); } }
bool GraphicsController::onUpdate(const Ogre::Real dt) { using namespace Ogre; //pass int he Skylight SH coefficients //Compute theta and phi and get turbulence Vector3 xyz; Ogre::Quaternion quat(Ogre::Radian(_radianOffset * dt), Ogre::Vector3::UNIT_Z) ; _lightDir = quat * _lightDir; _lightDir.normalise(); xyz = -_lightDir; Ogre::Radian theta = Math::ACos(xyz.y); Ogre::Radian phi = Math::ATan2(xyz.x, xyz.z); const Ogre::String shr("SHC_R_"); const Ogre::String shg("SHC_G_"); const Ogre::String shb("SHC_B_"); //was 4.5 Real turbulence = 3.0; Real ltDist = 500.0; if(xyz.y >= 0.0f) { light->setDirection(-xyz); CalculatePreethamSH(theta.valueRadians(),phi.valueRadians(),turbulence, NUM_OF_BANDS, true, _SHC_R, _SHC_G, _SHC_B, 1.0f); //CalculateSunSH(theta.valueRadians(), phi.valueRadians(), turbulence, NUM_OF_BANDS, _SHC_R, _SHC_G, _SHC_B, 1.0f); Ogre::MaterialPtr matPtr = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName("PRJZ/DirectionLightBuffer")); Ogre::Pass* pass = matPtr->getTechnique(0)->getPass(0); const Ogre::Matrix4& viewMat = _cam->getViewMatrix(true); Ogre::Vector4 xyz4(xyz.x, xyz.y, xyz.z, 0.0f); xyz4 = viewMat * xyz4; if(pass->getVertexProgramParameters()->_findNamedConstantDefinition("dirLightWorld")) pass->getVertexProgramParameters()->setNamedConstant("dirLightWorld", xyz4); } else { Ogre::Vector3 moonxyz = xyz * -1; light->setDirection(-moonxyz); Ogre::Radian theta = Math::ACos(moonxyz.y); Ogre::Radian phi = Math::ATan2(moonxyz.x, moonxyz.z); CalculatePreethamSH(theta.valueRadians(),phi.valueRadians(),turbulence, NUM_OF_BANDS, true, _SHC_R, _SHC_G, _SHC_B, 1.0f); //CalculateSunSH(theta.valueRadians(), phi.valueRadians(), turbulence, NUM_OF_BANDS, _SHC_R, _SHC_G, _SHC_B, 1.0f); const Ogre::Matrix4& viewMat = _cam->getViewMatrix(true); Ogre::Vector4 xyz4(moonxyz.x, moonxyz.y, moonxyz.z, 0.0f); xyz4 = viewMat * xyz4; Ogre::MaterialPtr matPtr = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName("PRJZ/DirectionLightBuffer")); Ogre::Pass* pass = matPtr->getTechnique(0)->getPass(0); if(pass->getVertexProgramParameters()->_findNamedConstantDefinition("dirLightWorld")) pass->getVertexProgramParameters()->setNamedConstant("dirLightWorld", xyz4); } std::vector<Ogre::String> materialNames; materialNames.push_back("PRJZ/Minecraft"); materialNames.push_back("PRJZ/MinecraftCharacter"); materialNames.push_back("PRJZ/Minecraft2"); materialNames.push_back("preview_diffusenormalspecular"); materialNames.push_back("preview2_diffusenormalspecular"); materialNames.push_back("preview3_diffusenormalspecular"); materialNames.push_back("preview_cubemap"); materialNames.push_back("PRJZ/HWBasic"); size_t idx = 0; #define FULL_BAND 1 for(size_t i=0; i < 9; ++i) { String namer = shr+StringConverter::toString(idx); String nameg = shg+StringConverter::toString(idx); String nameb = shb+StringConverter::toString(idx); _setSHParameterMultipleMaterials(i, namer, nameg, nameb, materialNames); idx++; } #if FULL_BAND //Skip band 4th band (or 3rd degree). for(size_t i=16; i < 25; ++i) { String namer = shr+StringConverter::toString(idx); String nameg = shg+StringConverter::toString(idx); String nameb = shb+StringConverter::toString(idx); _setSHParameterMultipleMaterials(i, namer, nameg, nameb, materialNames); idx++; } #endif materialNames.push_back("PRJZ/DirectionLightBuffer"); for(const Ogre::String &materialName : materialNames) //for(auto iter = materialNames.cbegin(); iter != materialNames.cend(); ++iter) { Ogre::MaterialPtr matPtr = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName(materialName)); Ogre::Pass* pass = matPtr->getTechnique(0)->getPass(0); if(pass->getFragmentProgramParameters()->_findNamedConstantDefinition("uLightY")) pass->getFragmentProgramParameters()->setNamedConstant("uLightY", xyz.y); } return true; }
void OGRERendererRacer::update() { mpVehicle = mpApp->mRacer; const cml::vector3d& pos = mpVehicle->mPos; mVehicleNode->setPosition(pos[0], pos[1], pos[2]); Ogre::Quaternion q; const quat& orientation = mpVehicle->getOrientation(); q.w = orientation.as_vector()[0]; q.x = orientation.as_vector()[1]; q.y = orientation.as_vector()[2]; q.z = orientation.as_vector()[3]; if (q != mOrientation) { Ogre::Quaternion transition = q * mOrientation.Inverse(); Ogre::Radian a; Ogre::Vector3 v; transition.ToAngleAxis(a, v); if (a.valueDegrees() > 0.1) { Ogre::Quaternion t2; // TODO 3: Make rotation speed configurable t2.FromAngleAxis(a * 0.05, v); mOrientation = t2 * mOrientation; } else { mOrientation = q; } } //################# BEGIN Construct Sideward thrust roll quaternion ################ // cml::vector3f velDirSidewardComponent = cml::dot(mpVehicle->mDirLeft, mpVehicle->mVelocity) * mpVehicle->mDirLeft; if (mpVehicle->mAddThrustLeft || mpVehicle->mAddThrustRight) { mRollAngle = -mpVehicle->mThrustSideward * 500; } else { mRollAngle *= 0.98; } float dot = cml::dot(mpVehicle->mDirLeft, mpVehicle->mVelocity); mRollAngle = -dot * 50; Ogre::Quaternion qSidewardThrustRoll(Ogre::Degree(mRollAngle), Ogre::Vector3(0, 0, -1)); cml::vector3f g = mpVehicle->getGravity(); cml::vector3f velDirGravityComponent = cml::dot(g, mpVehicle->mVelocity) * g; dot = cml::dot(velDirGravityComponent, g); if (velDirGravityComponent.length() > 0.000001) { mPitchAngle = -cml::sign(dot) * velDirGravityComponent.length() * 500000; } else { if (mpVehicle->mAddThrustForward && mPitchAngle > -7) { mPitchAngle -= 0.1; } else { mPitchAngle *= 0.95; } } Ogre::Quaternion qForwardThrustPitch(Ogre::Degree(mPitchAngle), Ogre::Vector3(1, 0, 0)); //################# END Construct Sideward thrust roll quaternion ################ bool mSidewardThrustRollCamera = false; if (mSidewardThrustRollCamera) { // Roll both vehicle and camera: mVehicleNode->setOrientation(q * qSidewardThrustRoll * qForwardThrustPitch); } else { // Roll only the vehicle, not the camera: mVehicleNode->setOrientation(mOrientation); mVehicleMeshNode->setOrientation(qSidewardThrustRoll * qForwardThrustPitch); } //############# BEGIN Update engine particle emitters #################### // TODO 1: Reimplement bool emit = (mpVehicle->mGameState == 0) && mpVehicle->mThrustForward > 0; mEngineFlameParticleSystem->setEmitting(emit); mEngineSmokeParticleSystem->setEmitting(emit); Ogre::ParticleEmitter* emitter = mEngineFlameParticleSystem->getEmitter(0); emitter->setParticleVelocity(mpVehicle->mThrustForward * 6000); emitter->setEmissionRate(mpVehicle->mThrustForward * 10000); emitter = mEngineSmokeParticleSystem->getEmitter(0); emitter->setEmissionRate(mpVehicle->mThrustForward * 7000); //############# END Update engine particle emitters #################### }