MStatus lrutils::setLocation(MObject obj, MVectorArray location, MFnTransform& transformFn, bool translate, bool rotation, bool scale) {
MStatus status = MS::kFailure;
status = transformFn.setObject(obj);
MyCheckStatusReturn(status, "invalid MObject provided for MFnTransform.setObject()");
if( status == MS::kSuccess ) {
if(translate) {
MVector vTranslation = location[0] ;
//stringstream text; text << "(" << vTranslation.x << ", " << vTranslation.y << ", " << vTranslation.z << ")";
//MGlobal::displayInfo( text.str().c_str() );
status = transformFn.setTranslation(vTranslation, MSpace::kTransform);
stringstream text; text << "MFnTransform.setTranslation() failed, status code [" << status.errorString().asChar() << "]";
MyCheckStatusReturn(status, text.str().c_str() );
vTranslation = transformFn.getTranslation(MSpace::kWorld);
//text.clear(); text << "(" << vTranslation.x << ", " << vTranslation.y << ", " << vTranslation.z << ")";
//MGlobal::displayInfo( text.str().c_str() );
}
if(rotation) {
MVector vRotation = location[1]*3.141592/180.0;
MEulerRotation eRotation = MEulerRotation(vRotation);
status = transformFn.setRotation(eRotation);
}
if(scale) {
MVector vScale = location[2];
double* scale = new double[3];
vScale.get(scale);
transformFn.setScale(scale);
//make the scale of the controller the identity
MGlobal::executeCommand("select -r "+transformFn.name()+";");
MGlobal::executeCommand("makeIdentity -s true -apply true;");
}
}
return status;
}
MEulerRotation convert( const Imath::Eulerd &from )
{
Imath::V3d xyz = from.toXYZVector();
return MEulerRotation( xyz.x, xyz.y, xyz.z, iMathToMayaRotationOrder<double>( from.order() ) );
}
//-----------------------------------------------------------------------------
// Purpose: Export the specified bits of the maya scene into the specified file
// Input : mArgDatabase The command line arguments as passed
// Output : MS::kSuccess if ok, MS::kFailure otherwise
//-----------------------------------------------------------------------------
MStatus CVstSmdIOCmd::DoImport(
const MArgDatabase &mArgDatabase )
{
MString optFilename;
if ( mArgDatabase.getFlagArgument( kOptFilename, 0, optFilename ) != MS::kSuccess || optFilename.length() == 0 )
{
MGlobal::displayError( "No filename specified for import" );
return MS::kFailure;
}
MString optGame;
if ( mArgDatabase.isFlagSet( kOptGame ) )
{
mArgDatabase.getFlagArgument( kOptGame, 0, optGame );
}
MString optTextureArchive;
if ( mArgDatabase.isFlagSet( kOptTextureArchive ) )
{
mArgDatabase.getFlagArgument( kOptTextureArchive, 0, optTextureArchive );
}
CQcData qcData;
char fullPath[ MAX_PATH ];
if ( !_fullpath( fullPath, optFilename.asChar(), sizeof( fullPath ) ) )
{
strncpy( fullPath, optFilename.asChar(), sizeof( fullPath ) );
}
qcData.GetQcData( fullPath );
if ( mArgDatabase.isFlagSet( kOptUpAxis ) )
{
MString upAxis;
mArgDatabase.getFlagArgument( kOptUpAxis, 0, upAxis );
switch ( *upAxis.asChar() )
{
case 'x':
case 'X':
qcData.m_upAxis = 0;
break;
case 'y':
case 'Y':
qcData.m_upAxis = 1;
break;
case 'z':
case 'Z':
default:
qcData.m_upAxis = 2;
break;
}
}
CSmdImport smdImport( optGame.asChar(), optTextureArchive.asChar() );
if ( mArgDatabase.isFlagSet( kOptImportSkeleton ) && !mArgDatabase.isFlagSet( kOptVmf ) )
{
mArgDatabase.getFlagArgument( kOptImportSkeleton, 0, smdImport.m_optImportSkeleton );
}
smdImport.SetNodeAddPrefix( GetNodeAddPrefix( mArgDatabase ) );
smdImport.SetNodeDelPrefix( GetNodeDelPrefix( mArgDatabase ) );
if ( mArgDatabase.isFlagSet( kOptImportType ) )
{
MString optImportType;
if ( mArgDatabase.getFlagArgument( kOptImportType, 0, optImportType ) && (
*optImportType.asChar() == 'a' || *optImportType.asChar() == 'A' ||
*optImportType.asChar() == 's' || *optImportType.asChar() == 'S' ) )
{
MSelectionList mSelectionList;
mArgDatabase.getObjects( mSelectionList );
MDagPath rootDagPath;
if ( mSelectionList.length() && mSelectionList.getDagPath( 0, rootDagPath ) )
{
return smdImport.ImportAnimation( optFilename.asChar(), rootDagPath, qcData, m_undo );
}
else
{
merr << "Cannot import animation without the root of the skeleton is selected or specified" << std::endl;
return MS::kFailure;
}
}
}
MTransformationMatrix topLevel;
if ( mArgDatabase.isFlagSet( kOptOrigin ) )
{
MVector o;
mArgDatabase.getFlagArgument( kOptOrigin, 0, o.x );
mArgDatabase.getFlagArgument( kOptOrigin, 1, o.y );
mArgDatabase.getFlagArgument( kOptOrigin, 2, o.z );
topLevel.setTranslation( o, MSpace::kObject );
}
if ( mArgDatabase.isFlagSet( kOptAngles ) )
{
MVector a;
if ( mArgDatabase.isFlagSet( kOptVmf ) )
{
// The angles are specified in Yaw Pitch Roll order ( YZX )
// but they're still an XYZ rotation
mArgDatabase.getFlagArgument( kOptAngles, 0, a.y );
mArgDatabase.getFlagArgument( kOptAngles, 1, a.z );
mArgDatabase.getFlagArgument( kOptAngles, 2, a.x );
}
else
{
mArgDatabase.getFlagArgument( kOptAngles, 0, a.x );
mArgDatabase.getFlagArgument( kOptAngles, 1, a.y );
mArgDatabase.getFlagArgument( kOptAngles, 2, a.z );
}
const MEulerRotation e( a.x / 180.0 * M_PI, a.y / 180.0 * M_PI, a.z / 180.0 * M_PI, MEulerRotation::kXYZ );
topLevel.rotateBy( e.asQuaternion(), MSpace::kObject );
}
if ( mArgDatabase.isFlagSet( kOptVmf ) )
{
if ( qcData.m_upAxis == 1U )
{
topLevel.rotateBy( MEulerRotation( 90.0 / 180.0 * M_PI, 0.0, 90.0 / 180.0 * M_PI ).asQuaternion(), MSpace::kObject );
}
else
{
topLevel.rotateBy( MEulerRotation( 0.0, 0.0, 90.0 / 180.0 * M_PI ).asQuaternion(), MSpace::kObject );
}
}
else
{
switch ( qcData.m_upAxis )
{
case 0U: // X Up
if ( MGlobal::isYAxisUp() )
{
topLevel.rotateBy( MEulerRotation( -M_PI / 2.0, M_PI / 2.0, 0.0 ).asQuaternion(), MSpace::kObject );
}
else
{
topLevel.rotateBy( MEulerRotation( 0.0, M_PI / 2.0, 0.0 ).asQuaternion(), MSpace::kObject );
}
break;
case 1U: // Y Up
if ( MGlobal::isZAxisUp() )
{
topLevel.rotateBy( MEulerRotation( M_PI / 2.0, 0.0, 0.0 ).asQuaternion(), MSpace::kObject );
}
break;
default:
case 2U: // Z Up
if ( MGlobal::isYAxisUp() )
{
topLevel.rotateBy( MEulerRotation( -M_PI / 2.0, 0.0, 0.0 ).asQuaternion(), MSpace::kObject );
}
break;
}
}
MDagPath mDagPath( smdImport.DoIt( optFilename.asChar(), qcData, topLevel, m_undo ) );
if ( mDagPath.isValid() && mDagPath.length() )
{
if ( mArgDatabase.isFlagSet( kOptVmf ) )
{
MFnNumericAttribute nFn;
MObject aObj( nFn.create( "yUp", "yUp", MFnNumericData::kBoolean, false ) );
MDagPath sDagPath( mDagPath );
sDagPath.extendToShapeDirectlyBelow( 0 );
m_undo.DagModifier().addAttribute( sDagPath.node(), aObj );
m_undo.DagModifierDoIt();
MPlug aP( sDagPath.node(), aObj );
if ( qcData.m_upAxis == 1U )
{
aP.setValue( true );
}
else
{
aP.setValue( false );
}
}
m_undo.SaveCurrentSelection();
MGlobal::select( mDagPath, MObject::kNullObj, MGlobal::kReplaceList );
setResult( mDagPath.partialPathName() );
m_undo.SaveCurrentSelection();
return MS::kSuccess;
}
m_undo.Undo();
return MS::kFailure;
}
MStatus boingRbCmd::createRigidBody(collision_shape_t::pointer collision_shape,
MObject node,
MString name,
MVector vel,
MVector pos,
MVector rot)
{
//MGlobal::getActiveSelectionList(m_undoSelectionList);
if (!name.length()) {
name = "dRigidBody";
}
double mscale[3] = {1,1,1};
MQuaternion mrotation = MEulerRotation(rot).asQuaternion();
//collision_shape_t::pointer collision_shape;
if(!collision_shape) {
//not connected to a collision shape, put a default one
collision_shape = solver_t::create_sphere_shape();
} else {
if ( rot == MVector::zero || pos == MVector::zero ) {
MFnDagNode fnDagNode(node);
//cout<<"node : "<<fnDagNode.partialPathName()<<endl;
MFnTransform fnTransform(fnDagNode.parent(0));
//cout<<"MFnTransform node : "<<fnTransform.partialPathName()<<endl;
pos = fnTransform.getTranslation(MSpace::kTransform);
fnTransform.getRotation(mrotation, MSpace::kTransform);
fnTransform.getScale(mscale);
}
}
//cout<<"removing m_rigid_body"<<endl;
//solver_t::remove_rigid_body(m_rigid_body);
cout<<"register name : "<<name<<endl;
shared_ptr<solver_impl_t> solv = solver_t::get_solver();
rigid_body_t::pointer m_rigid_body = solver_t::create_rigid_body(collision_shape);
solver_t::add_rigid_body(m_rigid_body, name.asChar());
//cout<<"transform : "<<pos<<endl;
//cout<<"rotation : "<<rot<<endl;
//cout<<"velocity : "<<vel<<endl;
//m_rigid_body->collision_shape()->set_user_pointer(name);
//const rigid_body_impl_t* rb = static_cast<const rigid_body_impl_t*>(m_rigid_body.get());
const rigid_body_impl_t* rb = m_rigid_body->impl();
//rigidBodyNode *rbNode = static_cast<rigidBodyNode*>(rb->get());
//rb->register_name(solv.get(),rbNode->name().asChar());
solv->register_name(rb, name.asChar());
m_rigid_body->set_transform(vec3f((float)pos.x, (float)pos.y, (float)pos.z),
quatf((float)mrotation.w, (float)mrotation.x, (float)mrotation.y, (float)mrotation.z));
m_rigid_body->collision_shape()->set_scale(vec3f((float)mscale[0], (float)mscale[1], (float)mscale[2]));
float mass = 1.f;
//MPlug(thisObject, rigidBodyNode::ia_mass).getValue(mass);
/*
float curMass = m_rigid_body->get_mass();
bool changedMassStatus= false;
if ((curMass > 0.f) != (mass > 0.f))
{
changedMassStatus = true;
}
if (changedMassStatus) solver_t::remove_rigid_body(m_rigid_body);
*/
m_rigid_body->set_mass(mass);
m_rigid_body->set_inertia((float)mass * m_rigid_body->collision_shape()->local_inertia());
//if (changedMassStatus)
// solver_t::add_rigid_body(m_rigid_body, name.asChar());
//initialize those default values too
float restitution = 0.3f;
//MPlug(thisObject, rigidBodyNode::ia_restitution).getValue(restitution);
m_rigid_body->set_restitution(restitution);
float friction = 0.5f;
//MPlug(thisObject, rigidBodyNode::ia_friction).getValue(friction);
m_rigid_body->set_friction(friction);
float linDamp = 0.f;
//MPlug(thisObject, rigidBodyNode::ia_linearDamping).getValue(linDamp);
m_rigid_body->set_linear_damping(linDamp);
float angDamp = 0.2f;
//MPlug(thisObject, rigidBodyNode::ia_angularDamping).getValue(angDamp);
m_rigid_body->set_angular_damping(angDamp);
//shared_ptr<solver_impl_t> solv = solver_t::get_solver();
//const char *namePtr = solv->m_nameMap.find(m_rigid_body);
//const char* rbname = MySerializer::findNameForPointer(m_rigid_body);
//cout<<"rbname = "<<namePtr<<endl;
//solv.get()->dynamicsWorld();
return MS::kSuccess;
}
void boing::createRigidBody()
{
//MGlobal::getActiveSelectionList(m_undoSelectionList);
if (!name.length()) {
name = "procBoingRb1";
}
std::cout<<"name in boing::createRigidBody() "<<name<<endl;
double mscale[3] = {1,1,1};
MQuaternion mrotation = MEulerRotation(m_initial_rotation).asQuaternion();
//collision_shape_t::pointer collision_shape;
if(!m_collision_shape) {
//not connected to a collision shape, put a default one
m_collision_shape = solver_t::create_box_shape();
} else {
if ( !node.isNull() ) {
MFnDagNode fnDagNode(node);
//cout<<"node : "<<fnDagNode.partialPathName()<<endl;
MFnTransform fnTransform(fnDagNode.parent(0));
//cout<<"MFnTransform node : "<<fnTransform.partialPathName()<<endl;
if ( m_initial_position == MVector::zero ) {
m_initial_position = fnTransform.getTranslation(MSpace::kTransform);
}
if ( m_initial_rotation == MVector::zero ) {
fnTransform.getRotation(mrotation, MSpace::kTransform);
}
fnTransform.getScale(mscale);
}
}
shared_ptr<solver_impl_t> solv = solver_t::get_solver();
m_rigid_body = solver_t::create_rigid_body(m_collision_shape);
m_rigid_body->set_transform(vec3f((float)m_initial_position.x, (float)m_initial_position.y, (float)m_initial_position.z),
quatf((float)mrotation.w, (float)mrotation.x, (float)mrotation.y, (float)mrotation.z));
m_rigid_body->set_linear_velocity( vec3f((float)m_initial_velocity.x,(float)m_initial_velocity.y,(float)m_initial_velocity.z) );
m_rigid_body->set_angular_velocity( vec3f((float)m_initial_angularvelocity.x,(float)m_initial_angularvelocity.y,(float)m_initial_angularvelocity.z) );
m_rigid_body->collision_shape()->set_scale(vec3f((float)mscale[0], (float)mscale[1], (float)mscale[2]));
/*
float mass = 1.f;
m_rigid_body->set_mass(mass);
m_rigid_body->set_inertia((float)mass * m_rigid_body->collision_shape()->local_inertia());
*/
//float mass = 0.f;
if (typeName == boingRBNode::typeName) {
MPlug(node, boingRBNode::ia_mass).getValue(m_mass);
}
float curMass = m_rigid_body->get_mass();
bool changedMassStatus= false;
if ((curMass > 0.f) != (m_mass > 0.f))
{
changedMassStatus = true;
}
if (changedMassStatus)
solver_t::remove_rigid_body(m_rigid_body);
m_rigid_body->set_mass(m_mass);
m_rigid_body->set_inertia((float)m_mass * m_rigid_body->collision_shape()->local_inertia());
if (changedMassStatus)
solver_t::add_rigid_body(m_rigid_body, name.asChar());
//initialize those default values too
float restitution = 0.3f;
//MPlug(thisObject, rigidBodyNode::ia_restitution).getValue(restitution);
m_rigid_body->set_restitution(restitution);
float friction = 0.5f;
//MPlug(thisObject, rigidBodyNode::ia_friction).getValue(friction);
m_rigid_body->set_friction(friction);
float linDamp = 0.f;
//MPlug(thisObject, rigidBodyNode::ia_linearDamping).getValue(linDamp);
m_rigid_body->set_linear_damping(linDamp);
float angDamp = 0.2f;
//MPlug(thisObject, rigidBodyNode::ia_angularDamping).getValue(angDamp);
m_rigid_body->set_angular_damping(angDamp);
m_rigid_body->impl()->body()->setUserPointer((void*) this);
}
