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