static
bool
_TranslateUsdAttributeToPlug(
const UsdAttribute& usdAttr,
const MFnCamera& cameraFn,
TfToken plugName,
const PxrUsdMayaPrimReaderArgs& args,
PxrUsdMayaPrimReaderContext* context,
bool millimetersToInches=false)
{
MStatus status;
MPlug plug = cameraFn.findPlug(plugName.GetText(), true, &status);
CHECK_MSTATUS_AND_RETURN(status, false);
// First check for and translate animation if there is any.
if (!_TranslateAnimatedUsdAttributeToPlug(usdAttr,
plug,
args,
context,
millimetersToInches)) {
// If that fails, then try just setting a static value.
UsdTimeCode timeCode = UsdTimeCode::EarliestTime();
float attrValue;
usdAttr.Get(&attrValue, timeCode);
if (millimetersToInches) {
attrValue = PxrUsdMayaUtil::ConvertMMToInches(attrValue);
}
status = plug.setFloat(attrValue);
CHECK_MSTATUS_AND_RETURN(status, false);
}
return true;
}
bool
DX11ResourceManager::translateCamera( const MDagPath &cameraPath )
//
// Description:
// Translate Maya's camera
//
{
bool translatedCamera = false;
if (cameraPath.isValid())
{
MStatus status;
MFnCamera camera (cameraPath, &status);
if ( !status ) {
status.perror("MFnCamera constructor");
}
else
{
translatedCamera = true;
MPoint eyePoint = camera.eyePoint( MSpace::kWorld );
MPoint lookAtPt = camera.centerOfInterestPoint( MSpace::kWorld );
MVector upDirection = camera.upDirection ( MSpace::kWorld );
MFloatMatrix projMatrix = camera.projectionMatrix();
double horizontalFieldOfView = MAngle( /* camera.verticalFieldOfView() / */ camera.horizontalFieldOfView()
).asDegrees();
double nearClippingPlane = camera.nearClippingPlane();
double farClippingPlane = camera.farClippingPlane();
// Convert API values to internal native storage.
//
m_camera.m_vEyePt = XMFLOAT3((float)eyePoint.x, (float)eyePoint.y, (float)eyePoint.z);
m_camera.m_vLookatPt = XMFLOAT3((float)lookAtPt.x, (float)lookAtPt.y, (float)lookAtPt.z);
m_camera.m_vUpVec = XMFLOAT3((float)upDirection.x, (float)upDirection.y, (float)upDirection.z);
m_camera.m_FieldOfView = (float)horizontalFieldOfView;
m_camera.m_nearClip = (float)nearClippingPlane;
m_camera.m_farClip = (float)farClippingPlane;
m_camera.m_isOrtho = camera.isOrtho();
}
}
else
{
initializeDefaultCamera();
}
return translatedCamera;
}
static
bool
_TranslateUsdAttributeToPlug(
const UsdAttribute& usdAttr,
const MFnCamera& cameraFn,
const TfToken& plugName,
const UsdMayaPrimReaderArgs& args,
UsdMayaPrimReaderContext* context,
const MDistance::Unit convertToUnit = MDistance::kMillimeters)
{
MStatus status;
MPlug plug = cameraFn.findPlug(plugName.GetText(), true, &status);
CHECK_MSTATUS_AND_RETURN(status, false);
// First check for and translate animation if there is any.
if (!_TranslateAnimatedUsdAttributeToPlug(usdAttr,
plug,
args,
context,
convertToUnit)) {
// If that fails, then try just setting a static value.
UsdTimeCode timeCode = UsdTimeCode::EarliestTime();
float attrValue;
usdAttr.Get(&attrValue, timeCode);
switch (convertToUnit) {
case MDistance::kInches:
attrValue = UsdMayaUtil::ConvertMMToInches(attrValue);
break;
case MDistance::kCentimeters:
attrValue = UsdMayaUtil::ConvertMMToCM(attrValue);
break;
default:
// The input is expected to be in millimeters.
break;
}
status = plug.setFloat(attrValue);
CHECK_MSTATUS_AND_RETURN(status, false);
}
return true;
}
bool
_ReadToCamera(
const UsdGeomCamera& usdCamera,
MFnCamera& cameraFn,
const UsdMayaPrimReaderArgs& args,
UsdMayaPrimReaderContext* context)
{
MStatus status;
// Now translate all of the USD camera attributes over to plugs on the
// Maya cameraFn.
UsdTimeCode timeCode = UsdTimeCode::EarliestTime();
UsdAttribute usdAttr;
TfToken plugName;
// Set the type of projection. This is NOT keyable in Maya.
TfToken projection;
usdCamera.GetProjectionAttr().Get(&projection, timeCode);
const bool isOrthographic = (projection == UsdGeomTokens->orthographic);
status = cameraFn.setIsOrtho(isOrthographic);
CHECK_MSTATUS_AND_RETURN(status, false);
// Setup the aperture.
usdAttr = usdCamera.GetHorizontalApertureAttr();
plugName = _tokens->MayaCameraAttrNameHorizontalAperture;
if (!_TranslateUsdAttributeToPlug(usdAttr, cameraFn, plugName,
args, context,
/* convertToUnit = */ MDistance::kInches)) {
return false;
}
if (isOrthographic) {
// For orthographic cameras, we'll re-use the horizontal aperture value
// to fill in Maya's orthographicWidth. The film aperture and film
// aperture offset plugs in Maya have no effect on orthographic cameras,
// but we author them anyway so that the data is preserved. Note also
// that Maya stores the orthographicWidth as centimeters.
plugName = _tokens->MayaCameraAttrNameOrthographicWidth;
if (!_TranslateUsdAttributeToPlug(usdAttr, cameraFn, plugName,
args, context,
/* convertToUnit = */ MDistance::kCentimeters)) {
return false;
}
}
usdAttr = usdCamera.GetVerticalApertureAttr();
plugName = _tokens->MayaCameraAttrNameVerticalAperture;
if (!_TranslateUsdAttributeToPlug(usdAttr, cameraFn, plugName,
args, context,
/* convertToUnit = */ MDistance::kInches)) {
return false;
}
// XXX:
// Lens Squeeze Ratio is DEPRECATED on USD schema.
// Writing it out here for backwards compatibility (see bug 123124).
cameraFn.setLensSqueezeRatio(1.0);
usdAttr = usdCamera.GetHorizontalApertureOffsetAttr();
plugName = _tokens->MayaCameraAttrNameHorizontalApertureOffset;
if (!_TranslateUsdAttributeToPlug(usdAttr, cameraFn, plugName,
args, context,
/* convertToUnit = */ MDistance::kInches)) {
return false;
}
usdAttr = usdCamera.GetVerticalApertureOffsetAttr();
plugName = _tokens->MayaCameraAttrNameVerticalApertureOffset;
if (!_TranslateUsdAttributeToPlug(usdAttr, cameraFn, plugName,
args, context,
/* convertToUnit = */ MDistance::kInches)) {
return false;
}
// Set the lens parameters.
usdAttr = usdCamera.GetFocalLengthAttr();
plugName = _tokens->MayaCameraAttrNameFocalLength;
if (!_TranslateUsdAttributeToPlug(usdAttr, cameraFn, plugName,
args, context)) {
return false;
}
usdAttr = usdCamera.GetFocusDistanceAttr();
plugName = _tokens->MayaCameraAttrNameFocusDistance;
if (!_TranslateUsdAttributeToPlug(usdAttr, cameraFn, plugName,
args, context)) {
return false;
}
usdAttr = usdCamera.GetFStopAttr();
plugName = _tokens->MayaCameraAttrNameFStop;
if (!_TranslateUsdAttributeToPlug(usdAttr, cameraFn, plugName,
args, context)) {
return false;
}
// Set the clipping planes. This one is a little different from the others
// because it is stored in USD as a single GfVec2f value but in Maya as
// separate nearClipPlane and farClipPlane attributes.
usdAttr = usdCamera.GetClippingRangeAttr();
MPlug nearClipPlug = cameraFn.findPlug(
_tokens->MayaCameraAttrNameNearClippingPlane.GetText(), true, &status);
CHECK_MSTATUS_AND_RETURN(status, false);
MPlug farClipPlug = cameraFn.findPlug(
_tokens->MayaCameraAttrNameFarClippingPlane.GetText(), true, &status);
CHECK_MSTATUS_AND_RETURN(status, false);
if (!_TranslateAnimatedUsdAttributeToPlugs(usdAttr,
nearClipPlug,
farClipPlug,
args,
context)) {
GfVec2f clippingRange;
usdCamera.GetClippingRangeAttr().Get(&clippingRange, timeCode);
status = cameraFn.setNearClippingPlane(clippingRange[0]);
CHECK_MSTATUS_AND_RETURN(status, false);
status = cameraFn.setFarClippingPlane(clippingRange[1]);
CHECK_MSTATUS_AND_RETURN(status, false);
}
return true;
}
MStatus CXRayCameraExport::ExportCamera(const MFileObject& file)
{
MDagPath node;
MObject component;
MSelectionList list;
MFnDagNode nodeFn;
MFnCamera C;
MStatus st ;
MGlobal::getActiveSelectionList( list );
for ( u32 index = 0; index < list.length(); ++index )
{
list.getDagPath ( index, node, component );
nodeFn.setObject ( node );
st = C.setObject (node);
if(st!=MStatus::kSuccess)
{
Msg ("Selected object is not a camera");
return MStatus::kInvalidParameter;
}
}
Msg("exporting camera named [%s]", C.name().asChar());
MTime tmTemp,tmTemp2;
MTime tmQuant;
// Remember the frame the scene was at so we can restore it later.
MTime storedFrame = MAnimControl::currentTime();
MTime startFrame = MAnimControl::minTime();
MTime endFrame = MAnimControl::maxTime();
tmTemp.setUnit (MTime::uiUnit());
tmTemp2.setUnit (MTime::uiUnit());
tmQuant.setUnit (MTime::uiUnit());
tmQuant = 10.0; //3 time in sec. temporary
COMotion M;
M.SetParam (0, (int)(endFrame-startFrame).as(MTime::uiUnit()), 30);
Fvector P,R;
tmTemp = startFrame;
MObject cam_parent = C.parent(0);
MFnTransform parentTransform(cam_parent);
MDistance dist;
while(tmTemp <= endFrame)
{
MAnimControl::setCurrentTime( tmTemp );
MMatrix parentMatrix = parentTransform.transformation().asMatrix();
MMatrix cv;
cv.setToIdentity ();
cv[2][2] = -1.0;
MMatrix TM;
TM = (cv*parentMatrix)*cv;
TM = cv*TM;
parentMatrix = TM;
Msg ("frame[%d]",(int)tmTemp.as(MTime::uiUnit()));
dist.setValue (parentMatrix[3][0]);
P.x = (float)dist.asMeters();
dist.setValue (parentMatrix[3][1]);
P.y = (float)dist.asMeters();
dist.setValue (parentMatrix[3][2]);
P.z = (float)dist.asMeters();
Msg ("P %3.3f,%3.3f,%3.3f",P.x,P.y,P.z);
double rot[3];
MTransformationMatrix::RotationOrder rot_order = MTransformationMatrix::kXYZ;
st = parentTransform.getRotation( rot, rot_order );
R.x = -(float)rot[0];
R.y = -(float)rot[1];
R.z = -(float)rot[2];
//. Msg ("rt %3.3f,%3.3f,%3.3f kWorld",R.x,R.y,R.z);
tmTemp2 = tmTemp-startFrame;
M.CreateKey (float(tmTemp2.as(MTime::uiUnit()))/30.0f,P,R);
if(tmTemp==endFrame)
break;
tmTemp += tmQuant;
if(tmTemp>endFrame)
tmTemp=endFrame;
};
MString fn_save_to = file.fullName();
fn_save_to += ".anm";
Msg("file full name [%s]", fn_save_to);
M.SaveMotion (fn_save_to.asChar());
MAnimControl::setCurrentTime( storedFrame );
return MS::kSuccess;
}
/********************************************************************************************************
* Method to translate a single camera *
********************************************************************************************************/
MStatus OgreExporter::writeCamera(MFnCamera& camera)
{
MPlug plug;
MPlugArray srcplugarray;
double dist;
MAngle angle;
MFnTransform* cameraTransform = NULL;
MFnAnimCurve* animCurve = NULL;
// get camera transform
for (int i=0; i<camera.parentCount(); i++)
{
if (camera.parent(i).hasFn(MFn::kTransform))
{
cameraTransform = new MFnTransform(camera.parent(i));
continue;
}
}
// start camera description
m_params.outCameras << "camera " << cameraTransform->partialPathName().asChar() << "\n";
m_params.outCameras << "{\n";
//write camera type
m_params.outCameras << "\ttype ";
if (camera.isOrtho())
m_params.outCameras << "ortho\n";
else
m_params.outCameras << "persp\n";
// write translation data
m_params.outCameras << "\ttranslation\n";
m_params.outCameras << "\t{\n";
//translateX
m_params.outCameras << "\t\tx ";
plug = cameraTransform->findPlug("translateX");
if (plug.isConnected() && m_params.exportCamerasAnim)
{
plug.connectedTo(srcplugarray,true,false,&stat);
for (int i=0; i < srcplugarray.length(); i++)
{
if (srcplugarray[i].node().hasFn(MFn::kAnimCurve))
{
if (animCurve)
delete animCurve;
animCurve = new MFnAnimCurve(srcplugarray[i].node());
continue;
}
else if (i == srcplugarray.length()-1)
{
std::cout << "Invalid link to translateX attribute\n";
return MS::kFailure;
}
}
m_params.outCameras << "anim " << animCurve->name().asChar() << "\n";
}
else
{
plug.getValue(dist);
m_params.outCameras << "= " << dist << "\n";
}
//translateY
m_params.outCameras << "\t\ty ";
plug = cameraTransform->findPlug("translateY");
if (plug.isConnected() && m_params.exportCamerasAnim)
{
plug.connectedTo(srcplugarray,true,false,&stat);
for (int i=0; i< srcplugarray.length(); i++)
{
if (srcplugarray[i].node().hasFn(MFn::kAnimCurve))
{
if (animCurve)
delete animCurve;
animCurve = new MFnAnimCurve(srcplugarray[i].node());
continue;
}
else if (i == srcplugarray.length()-1)
{
std::cout << "Invalid link to translateY attribute\n";
return MS::kFailure;
}
}
m_params.outCameras << "anim " << animCurve->name().asChar() << "\n";
}
else
{
plug.getValue(dist);
m_params.outCameras << "= " << dist << "\n";
}
//translateZ
m_params.outCameras << "\t\tz ";
plug = cameraTransform->findPlug("translateZ");
if (plug.isConnected() && m_params.exportCamerasAnim)
{
plug.connectedTo(srcplugarray,true,false,&stat);
for (int i=0; i< srcplugarray.length(); i++)
{
if (srcplugarray[i].node().hasFn(MFn::kAnimCurve))
{
if (animCurve)
delete animCurve;
animCurve = new MFnAnimCurve(srcplugarray[i].node());
continue;
}
else if (i == srcplugarray.length()-1)
{
std::cout << "Invalid link to translateZ attribute\n";
return MS::kFailure;
}
}
m_params.outCameras << "anim " << animCurve->name().asChar() << "\n";
}
else
{
plug.getValue(dist);
m_params.outCameras << "= " << dist << "\n";
}
m_params.outCameras << "\t}\n";
// write rotation data
m_params.outCameras << "\trotation\n";
m_params.outCameras << "\t{\n";
m_params.outCameras << "\t\tx ";
//rotateX
plug = cameraTransform->findPlug("rotateX");
if (plug.isConnected() && m_params.exportCamerasAnim)
{
plug.connectedTo(srcplugarray,true,false,&stat);
for (int i=0; i< srcplugarray.length(); i++)
{
if (srcplugarray[i].node().hasFn(MFn::kAnimCurve))
{
if (animCurve)
delete animCurve;
animCurve = new MFnAnimCurve(srcplugarray[i].node());
continue;
}
else if (i == srcplugarray.length()-1)
{
std::cout << "Invalid link to rotateX attribute\n";
return MS::kFailure;
}
}
m_params.outCameras << "anim " << animCurve->name().asChar() << "\n";
}
else
{
plug.getValue(angle);
m_params.outCameras << "= " << angle.asDegrees() << "\n";
}
//rotateY
m_params.outCameras << "\t\ty ";
plug = cameraTransform->findPlug("rotateY");
if (plug.isConnected() && m_params.exportCamerasAnim)
{
plug.connectedTo(srcplugarray,true,false,&stat);
for (int i=0; i< srcplugarray.length(); i++)
{
if (srcplugarray[i].node().hasFn(MFn::kAnimCurve))
{
if (animCurve)
delete animCurve;
animCurve = new MFnAnimCurve(srcplugarray[i].node());
continue;
}
else if (i == srcplugarray.length()-1)
{
std::cout << "Invalid link to rotateY attribute\n";
return MS::kFailure;
}
}
m_params.outCameras << "anim " << animCurve->name().asChar() << "\n";
}
else
{
plug.getValue(angle);
m_params.outCameras << "= " << angle.asDegrees() << "\n";
}
//rotateZ
m_params.outCameras << "\t\tz ";
plug = cameraTransform->findPlug("rotateZ");
if (plug.isConnected() && m_params.exportCamerasAnim)
{
plug.connectedTo(srcplugarray,true,false,&stat);
for (int i=0; i< srcplugarray.length(); i++)
{
if (srcplugarray[i].node().hasFn(MFn::kAnimCurve))
{
if (animCurve)
delete animCurve;
animCurve = new MFnAnimCurve(srcplugarray[i].node());
continue;
}
else if (i == srcplugarray.length()-1)
{
std::cout << "Invalid link to rotateZ attribute\n";
return MS::kFailure;
}
}
m_params.outCameras << "anim " << animCurve->name().asChar() << "\n";
}
else
{
plug.getValue(angle);
m_params.outCameras << "= " << angle.asDegrees() << "\n";
}
m_params.outCameras << "\t}\n";
// end camera description
m_params.outCameras << "}\n\n";
if (cameraTransform != NULL)
delete cameraTransform;
if (animCurve != NULL)
delete animCurve;
return MS::kSuccess;
}
MObject create(Alembic::AbcGeom::ICamera & iNode, MObject & iParent)
{
Alembic::AbcGeom::ICameraSchema schema = iNode.getSchema();
MString name(iNode.getName().c_str());
MFnCamera fnCamera;
MObject obj = fnCamera.create(iParent);
fnCamera.setName(name);
// we need to read this to determine the film fit
Alembic::AbcGeom::CameraSample samp;
iNode.getSchema().get(samp);
std::size_t numOps = samp.getNumOps();
if (numOps > 0)
{
std::string hint = samp[0].getHint();
if (hint == "filmFitFill")
{
fnCamera.setFilmFit(MFnCamera::kFillFilmFit);
}
else if (hint == "filmFitHorz")
{
fnCamera.setFilmFit(MFnCamera::kHorizontalFilmFit);
}
else if (hint == "filmFitVert")
{
fnCamera.setFilmFit(MFnCamera::kVerticalFilmFit);
}
else if (hint == "filmFitOver")
{
fnCamera.setFilmFit(MFnCamera::kOverscanFilmFit);
}
}
if (schema.isConstant())
{
// no center of interest
fnCamera.setFocalLength(samp.getFocalLength());
fnCamera.setLensSqueezeRatio(samp.getLensSqueezeRatio());
// camera scale might be in the 3x3
// weirdo attrs that are in inches
fnCamera.setHorizontalFilmAperture(samp.getHorizontalAperture()/2.54);
fnCamera.setVerticalFilmAperture(samp.getVerticalAperture()/2.54);
fnCamera.setHorizontalFilmOffset(samp.getHorizontalFilmOffset()/2.54);
fnCamera.setVerticalFilmOffset(samp.getVerticalFilmOffset()/2.54);
// film fit offset might be in the 3x3
if (samp.getOverScanLeft() == samp.getOverScanRight() &&
samp.getOverScanTop() == samp.getOverScanBottom() &&
samp.getOverScanLeft() == samp.getOverScanTop())
{
fnCamera.setOverscan(samp.getOverScanLeft() + 1.0);
}
else
{
MString warn = iNode.getName().c_str();
warn += " has unsupported overscan values.";
MGlobal::displayWarning(warn);
}
fnCamera.setNearClippingPlane(samp.getNearClippingPlane());
fnCamera.setFarClippingPlane(samp.getFarClippingPlane());
// prescale, film translate H, V, roll pivot H,V, film roll value
// post scale might be in the 3x3
fnCamera.setFStop(samp.getFStop());
fnCamera.setFocusDistance(samp.getFocusDistance());
MTime sec(1.0, MTime::kSeconds);
fnCamera.setShutterAngle(Alembic::AbcGeom::DegreesToRadians(
360.0 * (samp.getShutterClose()-samp.getShutterOpen()) *
sec.as(MTime::uiUnit()) ));
for (std::size_t i = 0; i < numOps; ++i)
{
Alembic::AbcGeom::FilmBackXformOp & op = samp[i];
if (op.getHint() == "filmFitOffs")
{
double val = op.getChannelValue(0) *
samp.getHorizontalAperture() / 5.08;
if (val != 0.0)
{
fnCamera.setFilmFitOffset(val);
}
else
{
fnCamera.setFilmFitOffset(op.getChannelValue(1) *
samp.getHorizontalAperture() / 5.08);
}
}
else if (op.getHint() == "preScale")
{
fnCamera.setPreScale(1.0/op.getChannelValue(0));
}
else if (op.getHint() == "filmTranslate")
{
fnCamera.setFilmTranslateH(op.getChannelValue(0));
fnCamera.setFilmTranslateV(op.getChannelValue(1));
}
else if (op.getHint() == "postScale")
{
fnCamera.setPostScale(1.0/op.getChannelValue(0));
}
else if (op.getHint() == "cameraScale")
{
fnCamera.setCameraScale(op.getChannelValue(0));
}
}
}
// extra transform node is unfortuneatly automatically created above the
// camera, let's do some reparenting and delete that extra transform
MDagPath path;
fnCamera.getPath(path);
MObject camObj = path.node();
MDagModifier dagMod;
dagMod.reparentNode(camObj, iParent);
dagMod.doIt();
dagMod.deleteNode(obj);
dagMod.doIt();
return camObj;
}
