void PlanningDisplay::calculateRobotPosition() { if (!displaying_kinematic_path_message_) { return; } tf::Stamped<tf::Pose> pose(tf::Transform(tf::Quaternion(0, 0, 0, 1.0), tf::Vector3(0, 0, 0)), displaying_kinematic_path_message_->trajectory.joint_trajectory.header.stamp, displaying_kinematic_path_message_->trajectory.joint_trajectory.header.frame_id); if (context_->getTFClient()->canTransform(fixed_frame_.toStdString(), displaying_kinematic_path_message_->trajectory.joint_trajectory.header.frame_id, displaying_kinematic_path_message_->trajectory.joint_trajectory.header.stamp)) { try { context_->getTFClient()->transformPose(fixed_frame_.toStdString(), pose, pose); } catch (tf::TransformException& e) { ROS_ERROR( "Error transforming from frame '%s' to frame '%s'", pose.frame_id_.c_str(), fixed_frame_.toStdString().c_str() ); } } Ogre::Vector3 position(pose.getOrigin().x(), pose.getOrigin().y(), pose.getOrigin().z()); double yaw, pitch, roll; pose.getBasis().getEulerYPR(yaw, pitch, roll); Ogre::Matrix3 orientation; orientation.FromEulerAnglesYXZ(Ogre::Radian(yaw), Ogre::Radian(pitch), Ogre::Radian(roll)); robot_->setPosition(position); robot_->setOrientation(orientation); }
void PlanningDisplay::calculateRobotPosition() { tf::Stamped<tf::Pose> pose( btTransform( btQuaternion( 0, 0, 0 ), btVector3( 0, 0, 0 ) ), ros::Time(), displaying_kinematic_path_message_.frame_id ); if (tf_->canTransform(target_frame_, displaying_kinematic_path_message_.frame_id, ros::Time())) { try { tf_->transformPose( target_frame_, pose, pose ); } catch(tf::TransformException& e) { ROS_ERROR( "Error transforming from frame '%s' to frame '%s'\n", pose.frame_id_.c_str(), target_frame_.c_str() ); } } Ogre::Vector3 position( pose.getOrigin().x(), pose.getOrigin().y(), pose.getOrigin().z() ); robotToOgre( position ); btScalar yaw, pitch, roll; pose.getBasis().getEulerZYX( yaw, pitch, roll ); Ogre::Matrix3 orientation; orientation.FromEulerAnglesYXZ( Ogre::Radian( yaw ), Ogre::Radian( pitch ), Ogre::Radian( roll ) ); robot_->setPosition( position ); robot_->setOrientation( orientation ); }
void RobotBase2DPoseDisplay::transformArrow( const std_msgs::RobotBase2DOdom& message, ogre_tools::Arrow* arrow ) { std::string frame_id = message.header.frame_id; if ( frame_id.empty() ) { frame_id = fixed_frame_; } tf::Stamped<tf::Pose> pose( btTransform( btQuaternion( message.pos.th, 0.0f, 0.0f ), btVector3( message.pos.x, message.pos.y, 0.0f ) ), message.header.stamp, message_.header.frame_id ); try { tf_->transformPose( fixed_frame_, pose, pose ); } catch(tf::TransformException& e) { ROS_ERROR( "Error transforming 2d base pose '%s' from frame '%s' to frame '%s'\n", name_.c_str(), message.header.frame_id.c_str(), fixed_frame_.c_str() ); } btScalar yaw, pitch, roll; pose.getBasis().getEulerZYX( yaw, pitch, roll ); Ogre::Matrix3 orient; orient.FromEulerAnglesZXY( Ogre::Radian( roll ), Ogre::Radian( pitch ), Ogre::Radian( yaw ) ); arrow->setOrientation( orient ); Ogre::Vector3 pos( pose.getOrigin().x(), pose.getOrigin().y(), pose.getOrigin().z() ); robotToOgre( pos ); arrow->setPosition( pos ); }
void OrbitOrientedViewController::updateCamera() { float distance = distance_property_->getFloat(); float yaw = yaw_property_->getFloat(); float pitch = pitch_property_->getFloat(); Ogre::Matrix3 rot; reference_orientation_.ToRotationMatrix(rot); Ogre::Radian rollTarget, pitchTarget, yawTarget; rot.ToEulerAnglesXYZ(yawTarget, pitchTarget, rollTarget); yaw += rollTarget.valueRadians(); pitch += pitchTarget.valueRadians(); Ogre::Vector3 focal_point = focal_point_property_->getVector(); float x = distance * cos( yaw ) * cos( pitch ) + focal_point.x; float y = distance * sin( yaw ) * cos( pitch ) + focal_point.y; float z = distance * sin( pitch ) + focal_point.z; Ogre::Vector3 pos( x, y, z ); camera_->setPosition(pos); camera_->setFixedYawAxis(true, target_scene_node_->getOrientation() * Ogre::Vector3::UNIT_Z); camera_->setDirection(target_scene_node_->getOrientation() * (focal_point - pos)); focal_shape_->setPosition( focal_point ); }
void OgrePointSpecification::setLocalOrientation(const Vector3& ori) { Ogre::Matrix3 m; m.FromEulerAnglesXYZ(Ogre::Radian(ori.x),Ogre::Radian(ori.y),Ogre::Radian(ori.z)); Ogre::Quaternion q(m); _node->setOrientation(q); _node->_update(true,true); }
Ogre::Matrix3 Utility::convert_btMatrix3(const btMatrix3x3 &m) { Ogre::Matrix3 mat; mat.SetColumn(0,Utility::convert_btVector3(m[0])); mat.SetColumn(1,Utility::convert_btVector3(m[1])); mat.SetColumn(2,Utility::convert_btVector3(m[2])); return mat; }
Ogre::Quaternion LuaScriptUtilities::QuaternionFromRotationDegrees( Ogre::Real xRotation, Ogre::Real yRotation, Ogre::Real zRotation) { Ogre::Matrix3 matrix; matrix.FromEulerAnglesXYZ( Ogre::Degree(xRotation), Ogre::Degree(yRotation), Ogre::Degree(zRotation)); return Ogre::Quaternion(matrix); }
void OgrePointSpecification::rotate(const Vector3& orientation) { Ogre::Matrix3 m; m.FromEulerAnglesXYZ(Ogre::Radian(orientation.x),Ogre::Radian(orientation.y),Ogre::Radian(orientation.z)); Ogre::Quaternion q(m); _node->rotate(q,Ogre::Node::TS_LOCAL); _node->_update(true,true); }
VEHA::Vector3 OgrePointSpecification::getLocalOrientation() const { Ogre::Quaternion q=_node->getOrientation(); Ogre::Matrix3 m; q.ToRotationMatrix(m); Ogre::Radian x,y,z; m.ToEulerAnglesXYZ(x,y,z); return VEHA::Vector3((double)x.valueRadians(), (double)y.valueRadians(), (double)z.valueRadians()); }
void OgrePointSpecification::setGlobalOrientation(const Vector3& ori) { Ogre::Matrix3 m; m.FromEulerAnglesXYZ(Ogre::Radian(ori.x),Ogre::Radian(ori.y),Ogre::Radian(ori.z)); Ogre::Quaternion q(m); if(_parent) q=shared_dynamic_cast<OgrePointSpecification>(_parent)->_node->convertWorldToLocalOrientation(q); _node->setOrientation(q); _node->_update(true,true); }
//------------------------------------------------------------------------- void AFile::setFrameRotation( Ogre::TransformKeyFrame* key_frame , const Ogre::Vector3& v ) const { Ogre::Quaternion rot; Ogre::Matrix3 mat; mat.FromEulerAnglesZXY( Ogre::Radian(Ogre::Degree( -v.y )), Ogre::Radian(Ogre::Degree( -v.x )), Ogre::Radian(Ogre::Degree( -v.z )) ); rot.FromRotationMatrix( mat ); key_frame->setRotation( rot ); }
VEHA::Vector3 OgrePointSpecification::getGlobalOrientation() const { Ogre::Quaternion q=_node->getOrientation(); if(_parent) q=shared_dynamic_cast<OgrePointSpecification>(_parent)->_node->convertLocalToWorldOrientation(q); Ogre::Matrix3 m; q.ToRotationMatrix(m); Ogre::Radian x,y,z; m.ToEulerAnglesXYZ(x,y,z); return VEHA::Vector3((double)x.valueRadians(), (double)y.valueRadians(), (double)z.valueRadians()); }
void BuildTank::setBadGun(Ogre::Radian theta){ Ogre::Quaternion gunOrientation = mTankGunNode->getOrientation() ; // convert orientation to a matrix Ogre::Matrix3 tGunMatrix3; gunOrientation.ToRotationMatrix( tGunMatrix3 ); Ogre::Vector3 xBasis = Ogre::Vector3(Ogre::Math::Cos(theta),0, - Ogre::Math::Sin(theta)); Ogre::Vector3 yBasis = Ogre::Vector3(0,1,0); Ogre::Vector3 zBasis = Ogre::Vector3(Ogre::Math::Sin(theta),0,Ogre::Math::Cos(theta)); Ogre::Matrix3 rotate; rotate.FromAxes(xBasis, yBasis, zBasis); mGunOrientation = rotate * tGunMatrix3; mTankGunNode->setOrientation(Ogre::Quaternion(mGunOrientation)); }
void CameraSceneNode::SetLookAtPoint(Vec3 lap) { //mOgreSceneNode->lookAt(lap, Ogre::Node::TS_WORLD); Vec3 z = -(lap - GetPosition()); z.normalise(); // z Vec3 x = z.crossProduct(Vec3::NEGATIVE_UNIT_Y); x.normalise(); // x Vec3 y = -x.crossProduct(z); y.normalise(); // y Ogre::Matrix3 R; R.FromAxes(x, y, z); Quat q; q.FromRotationMatrix(R); mOgreSceneNode->setOrientation(q); this->SetOrientation(mOgreSceneNode->getOrientation()*this->GetParent()->GetOrientation().Inverse()); }
//Rotate the tank void BuildTank::yawTank(Ogre::Radian theta) { Ogre::Quaternion orientation = mTankBodyNode->_getDerivedOrientation() ; // convert orientation to a matrix Ogre::Matrix3 matrix3; orientation.ToRotationMatrix( matrix3 ); Ogre::Vector3 xBasis = Ogre::Vector3(Ogre::Math::Cos(theta),0, - Ogre::Math::Sin(theta)); Ogre::Vector3 yBasis = Ogre::Vector3(0,1,0); Ogre::Vector3 zBasis = Ogre::Vector3(Ogre::Math::Sin(theta),0,Ogre::Math::Cos(theta)); Ogre::Matrix3 rotate; rotate.FromAxes(xBasis, yBasis, zBasis); mTankOrientation = rotate * matrix3 ; mTankBodyNode->setOrientation(Ogre::Quaternion(mTankOrientation)); }
void BuildTank::yawTurret(Ogre::Radian theta) { Ogre::Quaternion turretOrientation = mTankTurretNode->getOrientation() ; // convert orientation to a matrix Ogre::Matrix3 yawTMatrix3; turretOrientation.ToRotationMatrix(yawTMatrix3); Ogre::Vector3 xBasis = Ogre::Vector3(Ogre::Math::Cos(theta),0, - Ogre::Math::Sin(theta)); Ogre::Vector3 yBasis = Ogre::Vector3(0,1,0); Ogre::Vector3 zBasis = Ogre::Vector3(Ogre::Math::Sin(theta),0,Ogre::Math::Cos(theta)); Ogre::Matrix3 rotate; rotate.FromAxes(xBasis, yBasis, zBasis); mTurretOrientation = rotate * yawTMatrix3 ; mTankTurretNode->setOrientation(Ogre::Quaternion(mTurretOrientation)); }
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; }
void SimplePlayerComponent::HandleEvent(std::shared_ptr<Event> e) { // do not react to any events if this component is disabled if(!IsEnabled()) return; if(mMouseEnabled && e->GetType() == "DT_MOUSEEVENT") { std::shared_ptr<MouseEvent> m = std::dynamic_pointer_cast<MouseEvent>(e); if(m->GetAction() == MouseEvent::MOVED) { float factor = mMouseSensitivity * -0.01; float dx = m->GetMouseState().X.rel * factor; float dy = m->GetMouseState().Y.rel * factor * (mMouseYInversed ? -1 : 1); if(dx != 0 || dy != 0) { // watch out for da gimbal lock !! Ogre::Matrix3 orientMatrix; GetNode()->GetRotation().ToRotationMatrix(orientMatrix); Ogre::Radian yaw, pitch, roll; orientMatrix.ToEulerAnglesYXZ(yaw, pitch, roll); pitch += Ogre::Radian(dy); yaw += Ogre::Radian(dx); // do not let it look completely vertical, or the yaw will break if(pitch > Ogre::Degree(89.9)) pitch = Ogre::Degree(89.9); if(pitch < Ogre::Degree(-89.9)) pitch = Ogre::Degree(-89.9); orientMatrix.FromEulerAnglesYXZ(yaw, pitch, roll); Ogre::Quaternion rot; rot.FromRotationMatrix(orientMatrix); GetNode()->SetRotation(rot); } } } }
void PoseWithCovarianceVisual::setMessage ( const geometry_msgs::PoseWithCovarianceStamped::ConstPtr& msg ) { Ogre::Vector3 position = Ogre::Vector3 ( msg->pose.pose.position.x, msg->pose.pose.position.y, msg->pose.pose.position.z ); Ogre::Quaternion orientation = Ogre::Quaternion ( msg->pose.pose.orientation.x, msg->pose.pose.orientation.y, msg->pose.pose.orientation.z, msg->pose.pose.orientation.w ); // Arrow points in -Z direction, so rotate the orientation before display. // TODO: is it safe to change Arrow to point in +X direction? Ogre::Quaternion rotation1 = Ogre::Quaternion ( Ogre::Degree( -90 ), Ogre::Vector3::UNIT_Y ); Ogre::Quaternion rotation2 = Ogre::Quaternion ( Ogre::Degree( -180 ), Ogre::Vector3::UNIT_X ); orientation = rotation2 * rotation1 * orientation; pose_->setPosition( position ); pose_->setOrientation( orientation ); Ogre::Matrix3 C = Ogre::Matrix3 ( msg->pose.covariance[6*0 + 0], msg->pose.covariance[6*0 + 1], msg->pose.covariance[6*0 + 5], msg->pose.covariance[6*1 + 0], msg->pose.covariance[6*1 + 1], msg->pose.covariance[6*1 + 5], msg->pose.covariance[6*5 + 0], msg->pose.covariance[6*5 + 1], msg->pose.covariance[6*5 + 5] ); Ogre::Real eigenvalues[3]; Ogre::Vector3 eigenvectors[3]; C.EigenSolveSymmetric(eigenvalues, eigenvectors); if ( eigenvalues[0] < 0 ) { ROS_WARN ( "[PoseWithCovarianceVisual setMessage] eigenvalue[0]: %f < 0 ", eigenvalues[0] ); eigenvalues[0] = 0; } if ( eigenvalues[1] < 0 ) { ROS_WARN ( "[PoseWithCovarianceVisual setMessage] eigenvalue[1]: %f < 0 ", eigenvalues[1] ); eigenvalues[1] = 0; } if ( eigenvalues[2] < 0 ) { ROS_WARN ( "[PoseWithCovarianceVisual setMessage] eigenvalue[2]: %f < 0 ", eigenvalues[2] ); eigenvalues[2] = 0; } variance_->setColor ( color_variance_ ); variance_->setPosition ( position ); variance_->setOrientation ( Ogre::Quaternion ( eigenvectors[0], eigenvectors[1], eigenvectors[2] ) ); variance_->setScale ( Ogre::Vector3 ( 2*sqrt(eigenvalues[0]), 2*sqrt(eigenvalues[1]), 2*sqrt(eigenvalues[2]) ) ); }
void MarkerVisualizer::setCommonValues( const std_msgs::VisualizationMarker& message, ogre_tools::Object* object ) { std::string frame_id = message.header.frame_id; if ( frame_id.empty() ) { frame_id = target_frame_; } libTF::TFPose pose = { message.x, message.y, message.z, message.yaw, message.pitch, message.roll, 0, frame_id }; //printf( "pre transform (%s to %s) yaw: %f, pitch: %f, roll: %f\n", frame_id.c_str(), target_frame_.c_str(), pose.yaw, pose.pitch, pose.roll ); try { pose = tf_client_->transformPose( target_frame_, pose ); } catch(libTF::Exception& e) { printf( "Error transforming marker '%d' from frame '%s' to frame '%s'\n", message.id, frame_id.c_str(), target_frame_.c_str() ); } Ogre::Vector3 position( pose.x, pose.y, pose.z ); robotToOgre( position ); Ogre::Matrix3 orientation; //printf( "post transform yaw: %f, pitch: %f, roll: %f\n", pose.yaw, pose.pitch, pose.roll ); orientation.FromEulerAnglesYXZ( Ogre::Radian( pose.yaw ), Ogre::Radian( pose.pitch ), Ogre::Radian( pose.roll ) ); //Ogre::Matrix3 orientation( ogreMatrixFromRobotEulers( pose.yaw, pose.pitch, pose.roll ) ); Ogre::Vector3 scale( message.xScale, message.yScale, message.zScale ); scaleRobotToOgre( scale ); object->setPosition( position ); object->setOrientation( orientation ); object->setScale( scale ); object->setColor( message.r / 255.0f, message.g / 255.0f, message.b / 255.0f, message.alpha / 255.0f ); object->setUserData( Ogre::Any( (void*)this ) ); }
Ogre::Quaternion RoomSurface::surfaceOrientationForNormal(Ogre::Vector3 normal) { Ogre::Real pi_by_two = Ogre::Math::PI/2.0; Ogre::Matrix3 mat; if (normal == Ogre::Vector3::UNIT_Y) { mat.FromEulerAnglesXYZ(Ogre::Radian(0), Ogre::Radian(0), Ogre::Radian(0)); } else if (normal == Ogre::Vector3::UNIT_X) { mat.FromEulerAnglesXYZ(Ogre::Radian(pi_by_two), Ogre::Radian(0), Ogre::Radian(-pi_by_two)); } else if (normal == -Ogre::Vector3::UNIT_X) { mat.FromEulerAnglesXYZ(Ogre::Radian(pi_by_two), Ogre::Radian(0), Ogre::Radian(pi_by_two)); } else if (normal == Ogre::Vector3::UNIT_Z) { mat.FromEulerAnglesXYZ(Ogre::Radian(pi_by_two), Ogre::Radian(0), Ogre::Radian(0)); } else if (normal == -Ogre::Vector3::UNIT_Z) { // the last component should ideally be Ogre::Radian(2*pi_by_two), however the corresponding // physics constraint has a problem with that. mat.FromEulerAnglesXYZ(Ogre::Radian(pi_by_two), Ogre::Radian(2*pi_by_two), Ogre::Radian(0)); } return Ogre::Quaternion(mat); }
void CameraMan::frameRendered(const Ogre::FrameEvent &evt) { if (mStyle == CS_FREELOOK) { // build our acceleration vector based on keyboard input composite Ogre::Vector3 accel = Ogre::Vector3::ZERO; Ogre::Matrix3 axes = mCamera->getLocalAxes(); if (mGoingForward) accel -= axes.GetColumn(2); if (mGoingBack) accel += axes.GetColumn(2); if (mGoingRight) accel += axes.GetColumn(0); if (mGoingLeft) accel -= axes.GetColumn(0); if (mGoingUp) accel += axes.GetColumn(1); if (mGoingDown) accel -= axes.GetColumn(1); // if accelerating, try to reach top speed in a certain time Ogre::Real topSpeed = mFastMove ? mTopSpeed * 20 : mTopSpeed; if (accel.squaredLength() != 0) { accel.normalise(); mVelocity += accel * topSpeed * evt.timeSinceLastFrame * 10; } // if not accelerating, try to stop in a certain time else mVelocity -= mVelocity * evt.timeSinceLastFrame * 10; Ogre::Real tooSmall = std::numeric_limits<Ogre::Real>::epsilon(); // keep camera velocity below top speed and above epsilon if (mVelocity.squaredLength() > topSpeed * topSpeed) { mVelocity.normalise(); mVelocity *= topSpeed; } else if (mVelocity.squaredLength() < tooSmall * tooSmall) mVelocity = Ogre::Vector3::ZERO; if (mVelocity != Ogre::Vector3::ZERO) mCamera->translate(mVelocity * evt.timeSinceLastFrame); } }
Ogre::Entity* StageFile::GetModel( const StageInfo& info ) { //DumpSettings("exported/" + info.data.name + ".lua"); VectorTexForGen textures; Ogre::MeshPtr mesh = Ogre::MeshManager::getSingleton().create(info.data.name + "export", "General"); Ogre::SkeletonPtr skeleton = Ogre::SkeletonManager::getSingleton().create(info.data.name + "export", "General"); u32 number_of_files = GetU32LE(0); LOGGER->Log("Number of file " + IntToString(number_of_files) + "\n"); Ogre::Bone* root1 = skeleton->createBone( "0", 0 ); Ogre::Bone* root2 = skeleton->createBone( "1", 1 ); root1->addChild( root2 ); Ogre::Animation* anim = skeleton->createAnimation( "Idle", 1 ); Ogre::NodeAnimationTrack* track1 = anim->createNodeTrack( 0, root1 ); track1->removeAllKeyFrames(); Ogre::TransformKeyFrame* frame1 = track1->createNodeKeyFrame( 0 ); Ogre::Matrix3 matrix; matrix.FromEulerAnglesYXZ( Ogre::Radian( Ogre::Degree( 0 ) ), Ogre::Radian( Ogre::Degree( -90 ) ), Ogre::Radian( Ogre::Degree( 0 ) ) ); Ogre::Quaternion rot; rot.FromRotationMatrix( matrix ); frame1->setRotation( rot ); for (u32 i = 1; i < number_of_files - 1; ++i) { int offset_to_vertex = GetU32LE(0x04 + i * 0x04); MeshExtractor(info.data, "ffvii/battle_stage/" + info.data.name, this, offset_to_vertex, textures, mesh, Ogre::StringConverter::toString(i), 1); } // <OGRE> /////////////////////////////// skeleton->optimiseAllAnimations(); Ogre::SkeletonSerializer skeleton_serializer; skeleton_serializer.exportSkeleton(skeleton.getPointer(), "exported/models/ffvii/battle/stages/" + info.data.name + ".skeleton"); // Update bounds Ogre::AxisAlignedBox aabb(-999, -999, -999, 999, 999, 999); mesh->_setBounds(aabb, false); mesh->_setBoundingSphereRadius(999); mesh->setSkeletonName( "models/ffvii/battle/stages/" + info.data.name + ".skeleton" ); Ogre::MeshSerializer ser; ser.exportMesh(mesh.getPointer(), "exported/models/ffvii/battle/stages/" + info.data.name + ".mesh"); // create and export textures for model if( textures.size() > 0 ) { int number_of_files = GetU32LE( 0x00 ); int offset_to_texture = GetU32LE( number_of_files * 0x04 ); Vram* vram = Vram::MakeInstance().release(); LoadTimFileToVram( this, offset_to_texture, vram ); //vram->Save( "qqq" ); CreateTexture( vram, info.data, "exported/models/ffvii/battle/stages/" + info.data.name + ".png", textures ); delete vram; } CreateMaterial("ffvii/battle_stage/" + info.data.name, "exported/models/ffvii/battle/stages/" + info.data.name + ".material", "models/ffvii/battle/stages/" + info.data.name + ".png", "", ""); Ogre::SceneManager* scene_manager = Ogre::Root::getSingleton().getSceneManager( "Scene" ); Ogre::Entity* thisEntity = scene_manager->createEntity( info.data.name, "models/ffvii/battle/stages/" + info.data.name + ".mesh" ); //thisEntity->setDisplaySkeleton(true); //thisEntity->setDebugDisplayEnabled(true); thisEntity->setVisible(false); thisEntity->getAnimationState( "Idle" )->setEnabled( true ); thisEntity->getAnimationState( "Idle" )->setLoop( true ); Ogre::SceneNode* thisSceneNode = scene_manager->getRootSceneNode()->createChildSceneNode(); thisSceneNode->setPosition( 0, 0, 0 ); thisSceneNode->roll( Ogre::Radian( Ogre::Degree( 180.0f ) ) ); thisSceneNode->yaw( Ogre::Radian( Ogre::Degree( 120.0f ) ) ); thisSceneNode->pitch( Ogre::Radian( Ogre::Degree( 90.0f ) ) ); thisSceneNode->attachObject( thisEntity ); return thisEntity; }
void AnimationFile::GetData( std::vector< s16 >& skeleton_length, const Unit& unit, const int offset_to_animations, const int number_of_animation, const int start_animation, Ogre::SkeletonPtr skeleton) { for (int i = 0; i < number_of_animation; ++i) { /*LOGGER->Log(LOGGER_INFO, "Animation Header %02x%02x %02x %02x %02x %02x %02x%02x %02x%02x %02x%02x %02x%02x%02x%02x", GetU8(offset_to_animations + i * 0x10 + 0x00), GetU8(offset_to_animations + i * 0x10 + 0x01), GetU8(offset_to_animations + i * 0x10 + 0x02), GetU8(offset_to_animations + i * 0x10 + 0x03), GetU8(offset_to_animations + i * 0x10 + 0x04), GetU8(offset_to_animations + i * 0x10 + 0x05), GetU8(offset_to_animations + i * 0x10 + 0x06), GetU8(offset_to_animations + i * 0x10 + 0x07), GetU8(offset_to_animations + i * 0x10 + 0x08), GetU8(offset_to_animations + i * 0x10 + 0x09), GetU8(offset_to_animations + i * 0x10 + 0x0A), GetU8(offset_to_animations + i * 0x10 + 0x0B), GetU8(offset_to_animations + i * 0x10 + 0x0C), GetU8(offset_to_animations + i * 0x10 + 0x0D), GetU8(offset_to_animations + i * 0x10 + 0x0E), GetU8(offset_to_animations + i * 0x10 + 0x0F)); */ AnimationHeader header; header.number_of_frames = GetU16LE(offset_to_animations + i * 0x10 + 0x00); header.number_of_bones = GetU8(offset_to_animations + i * 0x10 + 0x02); header.number_of_frames_translation = GetU8(offset_to_animations + i * 0x10 + 0x03); header.number_of_static_translation = GetU8(offset_to_animations + i * 0x10 + 0x04); header.number_of_frames_rotation = GetU8(offset_to_animations + i * 0x10 + 0x05); header.offset_to_frames_translation_data = GetU16LE(offset_to_animations + i * 0x10 + 0x06); header.offset_to_static_translation_data = GetU16LE(offset_to_animations + i * 0x10 + 0x08); header.offset_to_frames_rotation_data = GetU16LE(offset_to_animations + i * 0x10 + 0x0A); header.offset_to_animation_data = GetU32LE(offset_to_animations + i * 0x10 + 0x0C) - 0x80000000; m_AnimationHeaders.push_back(header); } for (size_t i = 0; (i < static_cast<size_t>(number_of_animation)) && (start_animation + i < unit.animations.size()); ++i) { if (unit.animations[start_animation + i] == "" || unit.animations[start_animation + i] == " ") { continue; } /* File file(mpBuffer, m_AnimationHeaders[i].offset_to_animation_data, 0x04 + m_AnimationHeaders[i].number_of_bones * 0x08 + m_AnimationHeaders[i].number_of_frames_translation * m_AnimationHeaders[i].number_of_frames * 0x02 + m_AnimationHeaders[i].number_of_static_translation * 0x02 + m_AnimationHeaders[i].number_of_frames_rotation * m_AnimationHeaders[i].number_of_frames); file.WriteFile(RString((Ogre::String("dump/") + Ogre::String("animation_") + Ogre::StringConverter::toString(i) + Ogre::String("_data")).c_str())); */ Ogre::Animation* anim = skeleton->createAnimation(unit.animations[start_animation + i], (float)(m_AnimationHeaders[i].number_of_frames - 1) / 30.0f); for (u32 j = 0; j < m_AnimationHeaders[i].number_of_frames; ++j) { Frame frame; // root bone Ogre::Bone* root = skeleton->getBone(0); Ogre::NodeAnimationTrack* track; if (j == 0) { track = anim->createNodeTrack(0, root); track->removeAllKeyFrames(); } else { track = anim->getNodeTrack(0); } Ogre::TransformKeyFrame* frame_root = track->createNodeKeyFrame((float)j / 30.0f); Ogre::Quaternion rot; Ogre::Matrix3 mat; mat.FromEulerAnglesZXY(Ogre::Radian(Ogre::Degree(180)), Ogre::Radian(Ogre::Degree(0)), Ogre::Radian(Ogre::Degree(0))); rot.FromRotationMatrix(mat); frame_root->setRotation(rot); for (u32 k = 0; k < m_AnimationHeaders[i].number_of_bones; ++k) { BonePosition position; u8 flag = GetU8(m_AnimationHeaders[i].offset_to_animation_data + 0x04 + k * 0x08 + 0x00); u8 rx = GetU8(m_AnimationHeaders[i].offset_to_animation_data + 0x04 + k * 0x08 + 0x01); u8 ry = GetU8(m_AnimationHeaders[i].offset_to_animation_data + 0x04 + k * 0x08 + 0x02); u8 rz = GetU8(m_AnimationHeaders[i].offset_to_animation_data + 0x04 + k * 0x08 + 0x03); u8 tx = GetU8(m_AnimationHeaders[i].offset_to_animation_data + 0x04 + k * 0x08 + 0x04); u8 ty = GetU8(m_AnimationHeaders[i].offset_to_animation_data + 0x04 + k * 0x08 + 0x05); u8 tz = GetU8(m_AnimationHeaders[i].offset_to_animation_data + 0x04 + k * 0x08 + 0x06); // rotation if (flag & 0x01) { position.rotation_x = 360.0f * GetU8(m_AnimationHeaders[i].offset_to_animation_data + m_AnimationHeaders[i].offset_to_frames_rotation_data + rx * m_AnimationHeaders[i].number_of_frames + j) / 255.0f; } else { position.rotation_x = 360.0f * rx / 255.0f; } if (flag & 0x02) { position.rotation_y = 360.0f * GetU8(m_AnimationHeaders[i].offset_to_animation_data + m_AnimationHeaders[i].offset_to_frames_rotation_data + ry * m_AnimationHeaders[i].number_of_frames + j) / 255.0f; } else { position.rotation_y = 360.0f * ry / 255.0f; } if (flag & 0x04) { position.rotation_z = 360.0f * GetU8(m_AnimationHeaders[i].offset_to_animation_data + m_AnimationHeaders[i].offset_to_frames_rotation_data + rz * m_AnimationHeaders[i].number_of_frames + j) / 255.0f; } else { position.rotation_z = 360.0f * rz / 255.0f; } // translation position.translation_x = 0; position.translation_y = 0; position.translation_z = 0; if (flag & 0x10) { position.translation_x = static_cast<float>( -(s16)GetU16LE(m_AnimationHeaders[i].offset_to_animation_data + m_AnimationHeaders[i].offset_to_frames_translation_data + tx * m_AnimationHeaders[i].number_of_frames * 2 + j * 2)); } else if (tx != 0xFF) { position.translation_x = static_cast<float>(-(s16)GetU16LE(m_AnimationHeaders[i].offset_to_animation_data + m_AnimationHeaders[i].offset_to_static_translation_data + tx * 2)); } if (flag & 0x20) { position.translation_y = static_cast<float>(-(s16)GetU16LE(m_AnimationHeaders[i].offset_to_animation_data + m_AnimationHeaders[i].offset_to_frames_translation_data + ty * m_AnimationHeaders[i].number_of_frames * 2 + j * 2)); } else if (ty != 0xFF) { position.translation_y = static_cast<float>(-(s16)GetU16LE(m_AnimationHeaders[i].offset_to_animation_data + m_AnimationHeaders[i].offset_to_static_translation_data + ty * 2)); } if (flag & 0x40) { position.translation_z = static_cast<float>(-(s16)GetU16LE(m_AnimationHeaders[i].offset_to_animation_data + m_AnimationHeaders[i].offset_to_frames_translation_data + tz * m_AnimationHeaders[i].number_of_frames * 2 + j * 2)); } else if (tz != 0xFF) { position.translation_z = static_cast<float>(-(s16)GetU16LE(m_AnimationHeaders[i].offset_to_animation_data + m_AnimationHeaders[i].offset_to_static_translation_data + tz * 2)); } //LOGGER->Log(LOGGER_INFO, "%d %d", m_AnimationHeaders[i].number_of_frames, j); //LOGGER->Log(LOGGER_INFO, "animation (%f %f %f) (%f %f %f)", position.rotation_x, position.rotation_y, position.rotation_z, position.translation_x, position.translation_y, position.translation_z); frame.bone.push_back(position); Ogre::Bone* bone1 = skeleton->getBone(k * 2 + 1); Ogre::Bone* bone2 = skeleton->getBone(k * 2 + 2); Ogre::NodeAnimationTrack* track1; Ogre::NodeAnimationTrack* track2; if (j == 0) { track1 = anim->createNodeTrack(k * 2 + 1, bone1); track1->removeAllKeyFrames(); track2 = anim->createNodeTrack(k * 2 + 2, bone2); track2->removeAllKeyFrames(); } else { track1 = anim->getNodeTrack(k * 2 + 1); track2 = anim->getNodeTrack(k * 2 + 2); } Ogre::TransformKeyFrame* frame1 = track1->createNodeKeyFrame((float)j / 30.0f); Ogre::TransformKeyFrame* frame2 = track2->createNodeKeyFrame((float)j / 30.0f); float length = skeleton_length[ k ]; frame1->setTranslate(Ogre::Vector3(position.translation_x, position.translation_z - length, position.translation_y) / 1024); Ogre::Quaternion rot; Ogre::Matrix3 mat; mat.FromEulerAnglesZXY(Ogre::Radian(Ogre::Degree(-position.rotation_y)), Ogre::Radian(Ogre::Degree(-position.rotation_x)), Ogre::Radian(Ogre::Degree(-position.rotation_z))); rot.FromRotationMatrix(mat); frame2->setRotation(rot); } } } }
PhysicsRagDoll::RagBone::RagBone(PhysicsRagDoll* creator, OgreNewt::World* world, PhysicsRagDoll::RagBone* parent, Ogre::Bone* ogreBone, Ogre::MeshPtr mesh, Ogre::Vector3 dir, PhysicsRagDoll::RagBone::BoneShape shape, Ogre::Vector3 size, Ogre::Real mass, Actor* parentActor) { mDoll = creator; mParent = parent; mOgreBone = ogreBone; OgreNewt::ConvexCollisionPtr col; // in the case of the cylindrical primitives, they need to be rotated to align the main axis with the direction vector. Ogre::Quaternion orient = Ogre::Quaternion::IDENTITY; Ogre::Vector3 pos = Ogre::Vector3::ZERO; Ogre::Matrix3 rot; if (dir == Ogre::Vector3::UNIT_Y) { rot.FromEulerAnglesXYZ(Ogre::Degree(0), Ogre::Degree(0), Ogre::Degree(90)); orient.FromRotationMatrix(rot); } if (dir == Ogre::Vector3::UNIT_Z) { rot.FromEulerAnglesXYZ(Ogre::Degree(0), Ogre::Degree(90), Ogre::Degree(0)); orient.FromRotationMatrix(rot); } // make the rigid body. switch (shape) { case PhysicsRagDoll::RagBone::BS_BOX: col = OgreNewt::ConvexCollisionPtr(new OgreNewt::CollisionPrimitives::Box(world, size, 0)); break; case PhysicsRagDoll::RagBone::BS_CAPSULE: col = OgreNewt::ConvexCollisionPtr(new OgreNewt::CollisionPrimitives::Capsule(world, size.y, size.x, 0, orient, pos)); break; case PhysicsRagDoll::RagBone::BS_CONE: col = OgreNewt::ConvexCollisionPtr(new OgreNewt::CollisionPrimitives::Cone(world, size.y, size.x, 0, orient, pos)); break; case PhysicsRagDoll::RagBone::BS_CYLINDER: col = OgreNewt::ConvexCollisionPtr(new OgreNewt::CollisionPrimitives::Cylinder(world, size.y, size.x, 0, orient, pos)); break; case PhysicsRagDoll::RagBone::BS_ELLIPSOID: col = OgreNewt::ConvexCollisionPtr(new OgreNewt::CollisionPrimitives::Ellipsoid(world, size, 0)); break; case PhysicsRagDoll::RagBone::BS_CONVEXHULL: col = _makeConvexHull(world, mesh, size.x); break; default: col = OgreNewt::ConvexCollisionPtr(new OgreNewt::CollisionPrimitives::Box(world, size, 0)); break; } if (col) { if (col->getNewtonCollision() == NULL) { col.reset(); } } if (!col) { LOG_WARNING(Logger::CORE, " error creating collision for '" + ogreBone->getName() + "', still continuing."); mBody = NULL; } else { mBody = new OgreNewt::Body(world, col); mBody->setUserData(Ogre::Any(parentActor)); mBody->setStandardForceCallback(); const OgreNewt::MaterialID* ragdollMat = PhysicsManager::getSingleton().createMaterialID("default"); mBody->setMaterialGroupID(ragdollMat); Ogre::Vector3 inertia; Ogre::Vector3 com; col->calculateInertialMatrix(inertia, com); mBody->setMassMatrix(mass, inertia * mass); mBody->setCenterOfMass(com); mBody->setCustomTransformCallback(PhysicsRagDoll::_placementCallback); mOgreBone->setManuallyControlled(true); } }