animImportExport/animFileUtils.cpp

animImportExport/animFileUtils.cpp
//-
// ==========================================================================
// Copyright (C) 1995 - 2006 Autodesk, Inc. and/or its licensors. All
// rights reserved.
//
// The coded instructions, statements, computer programs, and/or related
// material (collectively the "Data") in these files contain unpublished
// information proprietary to Autodesk, Inc. ("Autodesk") and/or its
// licensors, which is protected by U.S. and Canadian federal copyright
// law and by international treaties.
//
// The Data is provided for use exclusively by You. You have the right
// to use, modify, and incorporate this Data into other products for
// purposes authorized by the Autodesk software license agreement,
// without fee.
//
// The copyright notices in the Software and this entire statement,
// including the above license grant, this restriction and the
// following disclaimer, must be included in all copies of the
// Software, in whole or in part, and all derivative works of
// the Software, unless such copies or derivative works are solely
// in the form of machine-executable object code generated by a
// source language processor.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
// AUTODESK DOES NOT MAKE AND HEREBY DISCLAIMS ANY EXPRESS OR IMPLIED
// WARRANTIES INCLUDING, BUT NOT LIMITED TO, THE WARRANTIES OF
// NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
// PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE, OR
// TRADE PRACTICE. IN NO EVENT WILL AUTODESK AND/OR ITS LICENSORS
// BE LIABLE FOR ANY LOST REVENUES, DATA, OR PROFITS, OR SPECIAL,
// DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES, EVEN IF AUTODESK
// AND/OR ITS LICENSORS HAS BEEN ADVISED OF THE POSSIBILITY
// OR PROBABILITY OF SUCH DAMAGES.
//
// ==========================================================================
//+
//
// File Name: animFileUtils.cc
//
// Description:
// Utility classes to read and write .anim files.
//
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <math.h>
#include <maya/MIOStream.h>
#include <maya/MFStream.h>
#include "animFileUtils.h"
#include "animImportExportStrings.h"
#include <maya/MGlobal.h>
#include <maya/MString.h>
#include <maya/MFnAnimCurve.h>
#include <maya/MAnimCurveClipboard.h>
#include <maya/MAnimCurveClipboardItem.h>
#include <maya/MAnimCurveClipboardItemArray.h>
#if defined (OSMac_)
using namespace std;
#endif
//-------------------------------------------------------------------------
// Class animUnitNames
//-------------------------------------------------------------------------
// String names for units.
//
const char *kMmString = "mm";
const char *kCmString = "cm";
const char *kMString = "m";
const char *kKmString = "km";
const char *kInString = "in";
const char *kFtString = "ft";
const char *kYdString = "yd";
const char *kMiString = "mi";
const char *kMmLString = "millimeter";
const char *kCmLString = "centimeter";
const char *kMLString = "meter";
const char *kKmLString = "kilometer";
const char *kInLString = "inch";
const char *kFtLString = "foot";
const char *kYdLString = "yard";
const char *kMiLString = "mile";
const char *kRadString = "rad";
const char *kDegString = "deg";
const char *kMinString = "min";
const char *kSecString = "sec";
const char *kRadLString = "radian";
const char *kDegLString = "degree";
const char *kMinLString = "minute";
const char *kSecLString = "second";
const char *kHourTString = "hour";
const char *kMinTString = "min";
const char *kSecTString = "sec";
const char *kMillisecTString = "millisec";
const char *kGameTString = "game";
const char *kFileTString = "film";
const char *kPalTString = "pal";
const char *kNtscTString = "ntsc";
const char *kShowTString = "show";
const char *kPalFTString = "palf";
const char *kNtscFTString = "ntscf";
const char *kUnitlessString = "unitless";
const char *kUnknownTimeString = "Unknown Time Unit";
const char *kUnknownAngularString = "Unknown Angular Unit";
const char *kUnknownLinearString = "Unknown Linear Unit";
animUnitNames::animUnitNames()
//
// Description:
// Class constructor.
//
{
}
animUnitNames::~animUnitNames()
//
// Description:
// Class destructor.
//
{
}
/* static */
void animUnitNames::setToLongName(const MAngle::Unit& unit, MString& name)
//
// Description:
// Sets the string with the long text name of the angle unit.
//
{
switch(unit) {
name.set(kDegLString);
break;
name.set(kRadLString);
break;
name.set(kMinLString);
break;
name.set(kSecLString);
break;
default:
name.set(kUnknownAngularString);
break;
}
}
/* static */
void animUnitNames::setToShortName(const MAngle::Unit& unit, MString& name)
//
// Description:
// Sets the string with the short text name of the angle unit.
//
{
switch(unit) {
name.set(kDegString);
break;
name.set(kRadString);
break;
name.set(kMinString);
break;
name.set(kSecString);
break;
default:
name.set(kUnknownAngularString);
break;
}
}
/* static */
void animUnitNames::setToLongName(const MDistance::Unit& unit, MString& name)
//
// Description:
// Sets the string with the long text name of the distance unit.
//
{
switch(unit) {
name.set(kInLString);
break;
name.set(kFtLString);
break;
name.set(kYdLString);
break;
name.set(kMiLString);
break;
name.set(kMmLString);
break;
name.set(kCmLString);
break;
name.set(kKmLString);
break;
name.set(kMLString);
break;
default:
name.set(kUnknownLinearString);
break;
}
}
/* static */
void animUnitNames::setToShortName(const MDistance::Unit& unit, MString& name)
//
// Description:
// Sets the string with the short text name of the distance unit.
//
{
switch(unit) {
name.set(kInString);
break;
name.set(kFtString);
break;
name.set(kYdString);
break;
name.set(kMiString);
break;
name.set(kMmString);
break;
name.set(kCmString);
break;
name.set(kKmString);
break;
name.set(kMString);
break;
default:
name.set(kUnknownLinearString);
break;
}
}
/* static */
void animUnitNames::setToLongName(const MTime::Unit &unit, MString &name)
//
// Description:
// Sets the string with the long text name of the time unit.
//
{
switch(unit) {
name.set(kHourTString);
break;
name.set(kMinTString);
break;
name.set(kSecTString);
break;
name.set(kMillisecTString);
break;
name.set(kGameTString);
break;
name.set(kFileTString);
break;
name.set(kPalTString);
break;
name.set(kNtscTString);
break;
name.set(kShowTString);
break;
name.set(kPalFTString);
break;
name.set(kNtscFTString);
break;
default:
name.set(kUnknownTimeString);
break;
}
}
/* static */
void animUnitNames::setToShortName(const MTime::Unit &unit, MString &name)
//
// Description:
// Sets the string with the short text name of the time unit.
//
{
setToLongName(unit, name);
}
/* static */
bool animUnitNames::setFromName(const MString &str, MAngle::Unit &unit)
//
// Description:
// The angle unit is set based on the passed string. If the string
// is not recognized, the angle unit is set to MAngle::kInvalid.
//
{
bool state = true;
const char *name = str.asChar();
if ((strcmp(name, kDegString) == 0) ||
(strcmp(name, kDegLString) == 0)) {
} else if ( (strcmp(name, kRadString) == 0) ||
(strcmp(name, kRadLString) == 0)) {
} else if ( (strcmp(name, kMinString) == 0) ||
(strcmp(name, kMinLString) == 0)) {
} else if ( (strcmp(name, kSecString) == 0) ||
(strcmp(name, kSecLString) == 0)) {
} else {
// This is not a recognized angular unit.
//
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kInvalidAngleUnits, stat);
msg.format(msgFmt, str);
state = false;
}
return state;
}
/* static */
bool animUnitNames::setFromName(const MString &str, MDistance::Unit &unit)
//
// Description:
// The distance unit is set based on the passed string. If the string
// is not recognized, the distance unit is set to MDistance::kInvalid.
//
{
bool state = true;
const char *name = str.asChar();
if ((strcmp(name, kInString) == 0) ||
(strcmp(name, kInLString) == 0)) {
} else if ( (strcmp(name, kFtString) == 0) ||
(strcmp(name, kFtLString) == 0)) {
} else if ( (strcmp(name, kYdString) == 0) ||
(strcmp(name, kYdLString) == 0)) {
} else if ( (strcmp(name, kMiString) == 0) ||
(strcmp(name, kMiLString) == 0)) {
} else if ( (strcmp(name, kMmString) == 0) ||
(strcmp(name, kMmLString) == 0)) {
} else if ( (strcmp(name, kCmString) == 0) ||
(strcmp(name, kCmLString) == 0)) {
} else if ( (strcmp(name, kKmString) == 0) ||
(strcmp(name, kKmLString) == 0)) {
} else if ( (strcmp(name, kMString) == 0) ||
(strcmp(name, kMLString) == 0)) {
} else {
// This is not a recognized distance unit.
//
state = false;
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kInvalidLinearUnits, stat);
msg.format(msgFmt, str);
unit = MDistance::kInvalid;
}
return state;
}
/* static */
bool animUnitNames::setFromName(const MString &str, MTime::Unit &unit)
//
// Description:
// The time unit is set based on the passed string. If the string
// is not recognized, the time unit is set to MTime::kInvalid.
//
{
bool state = true;
const char *name = str.asChar();
if (strcmp(name, kHourTString) == 0) {
unit = MTime::kHours;
} else if (strcmp(name, kMinTString) == 0) {
} else if (strcmp(name, kSecTString) == 0) {
} else if (strcmp(name, kMillisecTString) == 0) {
} else if (strcmp(name, kGameTString) == 0) {
unit = MTime::kGames;
} else if (strcmp(name, kFileTString) == 0) {
unit = MTime::kFilm;
} else if (strcmp(name, kPalTString) == 0) {
} else if (strcmp(name, kNtscTString) == 0) {
} else if (strcmp(name, kShowTString) == 0) {
} else if (strcmp(name, kPalFTString) == 0) {
} else if (strcmp(name, kNtscFTString) == 0) {
} else {
// This is not a recognized time unit.
//
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kInvalidTimeUnits, stat);
msg.format(msgFmt, str);
state = false;
}
return state;
}
//-------------------------------------------------------------------------
// Class animBase
//-------------------------------------------------------------------------
// Tangent type words
//
const char *kWordTangentGlobal = "global";
const char *kWordTangentFixed = "fixed";
const char *kWordTangentLinear = "linear";
const char *kWordTangentFlat = "flat";
const char *kWordTangentSmooth = "spline";
const char *kWordTangentStep = "step";
const char *kWordTangentSlow = "slow";
const char *kWordTangentFast = "fast";
const char *kWordTangentClamped = "clamped";
const char *kWordTangentPlateau = "plateau";
const char *kWordTangentStepNext = "stepnext";
const char *kWordTangentAuto = "auto";
// Infinity type words
//
const char *kWordConstant = "constant";
const char *kWordLinear = "linear";
const char *kWordCycle = "cycle";
const char *kWordCycleRelative = "cycleRelative";
const char *kWordOscillate = "oscillate";
// Param Curve types
//
const char *kWordTypeUnknown = "unknown";
const char *kWordTypeLinear = "linear";
const char *kWordTypeAngular = "angular";
const char *kWordTypeTime = "time";
const char *kWordTypeUnitless = "unitless";
// Keywords
//
const char *kAnim = "anim";
const char *kAnimData = "animData";
const char *kMovData = "movData";
const char *kMayaVersion = "mayaVersion";
const char *kAnimVersion = "animVersion";
const char *kTimeUnit = "timeUnit";
const char *kLinearUnit = "linearUnit";
const char *kAngularUnit = "angularUnit";
const char *kStartTime = "startTime";
const char *kEndTime = "endTime";
const char *kStartUnitless = "startUnitless";
const char *kEndUnitless = "endUnitless";
// animVersions:
//
const char *kAnimVersionString = "1.1";
// const double kVersion1 = 1.0; // initial release
const double kVersionNonWeightedAndBreakdowns = 1.1; // added support for non-weighted curves and breakdowns
const char *kTwoSpace = " ";
// animData keywords
//
const char *kInputString = "input";
const char *kOutputString = "output";
const char *kWeightedString = "weighted";
const char *kPreInfinityString = "preInfinity";
const char *kPostInfinityString = "postInfinity";
const char *kInputUnitString = "inputUnit";
const char *kOutputUnitString = "outputUnit";
const char *kTanAngleUnitString = "tangentAngleUnit";
const char *kKeysString = "keys";
// special characters
//
const char kSemiColonChar = ';';
const char kSpaceChar = ' ';
const char kTabChar = '\t';
const char kHashChar = '#';
const char kNewLineChar = '\n';
const char kSlashChar = '/';
const char kBraceLeftChar = '{';
const char kBraceRightChar = '}';
const char kDoubleQuoteChar = '"';
animBase::animBase ()
//
// Description:
// The constructor.
//
{
resetUnits();
}
animBase::~animBase()
//
// Description:
// The destructor.
//
{
}
void animBase::resetUnits()
//
// Description:
// Reset the units used by this class to the ui units.
//
{
timeUnit = MTime::uiUnit();
linearUnit = MDistance::uiUnit();
angularUnit = MAngle::uiUnit();
}
const char *
animBase::tangentTypeAsWord(MFnAnimCurve::TangentType type)
//
// Description:
// Returns a string with a test based desription of the passed
// MFnAnimCurve::TangentType.
//
{
switch (type) {
return (kWordTangentGlobal);
return (kWordTangentFixed);
return (kWordTangentLinear);
return (kWordTangentFlat);
return (kWordTangentSmooth);
return (kWordTangentStep);
return (kWordTangentStepNext);
return (kWordTangentSlow);
return (kWordTangentFast);
return (kWordTangentClamped);
return (kWordTangentPlateau);
return (kWordTangentAuto);
default:
break;
}
return (kWordTangentGlobal);
}
animBase::wordAsTangentType (char *type)
//
// Description:
// Returns a MFnAnimCurve::TangentType based on the passed string.
// If the string is not a recognized tangent type, tnen
// MFnAnimCurve::kTangentGlobal is returned.
//
{
if (strcmp(type, kWordTangentGlobal) == 0) {
}
if (strcmp(type, kWordTangentFixed) == 0) {
}
if (strcmp(type, kWordTangentLinear) == 0) {
}
if (strcmp(type, kWordTangentFlat) == 0) {
}
if (strcmp(type, kWordTangentSmooth) == 0) {
}
if (strcmp(type, kWordTangentStep) == 0) {
}
if (strcmp(type, kWordTangentStepNext) == 0) {
}
if (strcmp(type, kWordTangentSlow) == 0) {
}
if (strcmp(type, kWordTangentFast) == 0) {
}
if (strcmp(type, kWordTangentClamped) == 0) {
}
if (strcmp(type, kWordTangentPlateau) == 0) {
}
if (strcmp(type, kWordTangentAuto) == 0) {
}
}
const char *
animBase::infinityTypeAsWord(MFnAnimCurve::InfinityType type)
//
// Description:
// Returns a string containing the name of the passed
// MFnAnimCurve::InfinityType type.
//
{
switch (type) {
return (kWordConstant);
return (kWordLinear);
return (kWordCycle);
return (kWordCycleRelative);
return (kWordOscillate);
default:
break;
}
return (kWordConstant);
}
animBase::wordAsInfinityType(const char *type)
//
// Description:
// Returns a MFnAnimCurve::InfinityType from the passed string.
// If the string does not match a recognized infinity type,
// MFnAnimCurve::kConstant is returned.
//
{
if (strcmp(type, kWordConstant) == 0) {
} else if (strcmp(type, kWordLinear) == 0) {
} else if (strcmp(type, kWordCycle) == 0) {
} else if (strcmp(type, kWordCycleRelative) == 0) {
} else if (strcmp(type, kWordOscillate) == 0) {
}
}
const char *
animBase::outputTypeAsWord (MFnAnimCurve::AnimCurveType type)
//
// Description:
// Returns a string identifying the output type of the
// passed MFnAnimCurve::AnimCurveType.
//
{
switch (type) {
return (kWordTypeLinear);
return (kWordTypeAngular);
return (kWordTypeTime);
return (kWordTypeUnitless);
return (kWordTypeUnitless);
}
return (kWordTypeUnknown);
}
animBase::AnimBaseType
animBase::wordAsInputType(const char *input)
//
// Description:
// Returns an input type based on the passed string.
//
{
if (strcmp(input, kWordTypeTime) == 0) {
return animBase::kAnimBaseTime;
} else {
return animBase::kAnimBaseUnitless;
}
}
animBase::AnimBaseType
animBase::wordAsOutputType(const char *output)
//
// Description:
// Returns a output type based on the passed string.
//
{
if (strcmp(output, kWordTypeLinear) == 0) {
return animBase::kAnimBaseLinear;
} else if (strcmp(output, kWordTypeAngular) == 0) {
return animBase::kAnimBaseAngular;
} else if (strcmp(output, kWordTypeTime) == 0) {
return animBase::kAnimBaseTime;
} else {
return animBase::kAnimBaseUnitless;
}
}
const char *
animBase::boolInputTypeAsWord(bool isUnitless)
//
// Description:
// Returns a string based on a bool.
//
{
if (isUnitless) {
return (kWordTypeUnitless);
} else {
return (kWordTypeTime);
}
}
animBase::typeAsAnimCurveType( animBase::AnimBaseType input,
animBase::AnimBaseType output)
//
// Description:
// Returns a MFnAnimCurve::AnimCurveType based on the passed
// input and output types. If the input and output types do
// not create a valid MFnAnimCurve::AnimCurveType, then a
// MFnAnimCurve::kAnimCurveUnknown is returned.
//
{
switch (output) {
case kAnimBaseLinear:
if (kAnimBaseUnitless == input) {
} else {
}
break;
case kAnimBaseAngular:
if (kAnimBaseUnitless == input) {
} else {
}
break;
case kAnimBaseTime:
if (kAnimBaseUnitless == input) {
} else {
}
break;
case kAnimBaseUnitless:
if (kAnimBaseUnitless == input) {
} else {
}
break;
default:
// An unknown anim curve type.
//
break;
}
return type;
}
double animBase::asDouble (ifstream &clipFile)
//
// Description:
// Reads the next bit of valid data as a double.
//
{
advance(clipFile);
double value;
clipFile >> value;
return (value);
}
bool animBase::isNextNumeric(ifstream &clipFile)
//
// Description:
// The method skips past whitespace and comments and checks if
// the next character is numeric.
//
// true is returned if the character is numeric.
//
{
bool numeric = false;
advance(clipFile);
char next = clipFile.peek();
if (next >= '0' && next <= '9') {
numeric = true;
}
return numeric;
}
void animBase::advance (ifstream &clipFile)
//
// Description:
// The method skips past all of the whitespace and commented lines
// in the ifstream. It will also ignore semi-colons.
//
{
while (clipFile) {
clipFile >> ws;
char next = clipFile.peek();
if (next == kSemiColonChar) {
clipFile.ignore(1, kSemiColonChar);
continue;
}
if (next == kSlashChar || next == kHashChar) {
clipFile.ignore(INT_MAX, kNewLineChar);
continue;
}
break;
}
}
char* animBase::asWord (ifstream &clipFile, bool includeWS /* false */)
//
// Description:
// Returns the next string of characters in an ifstream. The string
// ends when whitespace or a semi-colon is encountered. If the
// includeWS argument is true, the string will not end if a white
// space character is encountered.
//
// If a double quote is detected '"', then verything up to the next
// double quote will be returned.
//
// This method returns a pointer to a static variable, so its contents
// should be used immediately.
//
{
static const int kBufLength = 1024;
static char string[kBufLength];
advance(clipFile);
char *c = string;
clipFile.read (c, 1);
if (*c == kDoubleQuoteChar) {
clipFile.read(c, 1);
while(!clipFile.eof() && (*c != kDoubleQuoteChar)) {
c++;
if (c-string >= kBufLength) {
break;
}
clipFile.read(c, 1);
}
} else {
// Get the case of the '{' or '}' character
//
if (*c == kBraceLeftChar || *c == kBraceRightChar) {
c++;
} else {
while(!clipFile.eof() && (*c != kSemiColonChar)) {
if (!includeWS && ((*c == kSpaceChar) || (*c == kTabChar))) {
break;
}
c++;
if (c-string >= kBufLength) {
break;
}
clipFile.read(c, 1);
}
}
}
*c = 0x00;
return (string);
}
char animBase::asChar (ifstream &clipFile)
//
// Description:
// Returns the next character of interest in the ifstream. All
// whitespace and commented lines are ignored.
//
{
advance(clipFile);
return clipFile.get();
}
bool animBase::isEquivalent(double a, double b)
//
// Description:
// Returns true if the doubles are within the tolerance.
//
{
const double tolerance = 1.0e-10;
return ((a > b) ? (a - b <= tolerance) : (b - a <= tolerance));
}
//-----------------------------------------------------------------------------
// Class animReader
//-----------------------------------------------------------------------------
animReader::animReader ()
//
// Description:
// Class constructor.
//
: animVersion (1.0)
, convertAnglesFromV2To3(false)
, convertAnglesFromV3To2(false)
{
}
animReader::~animReader()
//
// Description:
// Class destructor.
//
{
}
animReader::readClipboard(ifstream &readAnim, MAnimCurveClipboard& cb)
//
// Description:
// Given a clipboard and an ifstream, read the ifstream and add
// all of the anim curves described in ther stream into the
// API clipboard.
//
{
// Set the default values for the start and end of the clipboard.
// The MAnimCurveClipboard::set() method will examine all of the
// anim curves are determine the proper start and end values, if the
// start time is greater than the end value.
//
// By default, the start values are greater than the end values to
// ensure correct behavior if the file does not specify the start and
// end values.
//
//
double startTime = 1.0;
double endTime = 0.0;
double startUnitless = 1.0;
double endUnitless = 0.0;
resetUnits();
convertAnglesFromV2To3 = false;
convertAnglesFromV3To2 = false;
// Read the header. The header officially ends when the first non-header
// keyword is found. The header contains clipboard specific information
// where the body is anim curve specific.
//
char *dataType = NULL;
bool hasVersionString = false;
while (!readAnim.eof()) {
advance(readAnim);
dataType = asWord(readAnim);
if (strcmp(dataType, kAnimVersion) == 0) {
MString version(asWord(readAnim));
animVersion = version.asDouble();
MString thisVersion(kAnimVersionString);
hasVersionString = true;
// Add versioning control here.
//
if (version != thisVersion) {
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kInvalidVersion,
stat);
msg.format(msgFmt, version, thisVersion);
}
} else if (strcmp(dataType, kMayaVersion) == 0) {
MString version(asWord(readAnim, true));
MString currentVersion = MGlobal::mayaVersion();
if (currentVersion.substring(0,1) == "2.") {
MString vCheck = version.substring(0, 1);
if (vCheck != "2.") {
convertAnglesFromV3To2 = true;
}
} else {
// If this is a pre-Maya 3.0 file, then the tangent angles
// will need to be converted to work in Maya 3.0+
//
MString vCheck = version.substring(0, 1);
if (vCheck == "2.") {
convertAnglesFromV2To3 = true;
}
}
} else if (strcmp(dataType, kTimeUnit) == 0) {
MString timeUnitString(asWord(readAnim));
if (!animUnitNames::setFromName(timeUnitString, timeUnit)) {
MString unitName;
timeUnit = MTime::uiUnit();
animUnitNames::setToShortName(timeUnit, unitName);
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kSettingToUnit,
stat);
msg.format(msgFmt, kTimeUnit, unitName);
}
} else if (strcmp(dataType, kLinearUnit) == 0) {
MString linearUnitString(asWord(readAnim));
if (!animUnitNames::setFromName(linearUnitString, linearUnit)) {
MString unitName;
linearUnit = MDistance::uiUnit();
animUnitNames::setToShortName(linearUnit, unitName);
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kSettingToUnit,
stat);
msg.format(msgFmt, kLinearUnit, unitName);
}
} else if (strcmp(dataType, kAngularUnit) == 0) {
MString angularUnitString(asWord(readAnim));
if (!animUnitNames::setFromName(angularUnitString, angularUnit)) {
MString unitName;
angularUnit = MAngle::uiUnit();
animUnitNames::setToShortName(angularUnit, unitName);
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kSettingToUnit,
stat);
msg.format(msgFmt, kAngularUnit, unitName);
}
} else if (strcmp(dataType, kStartTime) == 0) {
startTime = asDouble(readAnim);
} else if (strcmp(dataType, kEndTime) == 0) {
endTime = asDouble(readAnim);
} else if (strcmp(dataType, kStartUnitless) == 0) {
startUnitless = asDouble(readAnim);
} else if (strcmp(dataType, kEndUnitless) == 0) {
endUnitless = asDouble(readAnim);
} else {
// The header should be finished. Begin to parse the body.
//
break;
}
}
// The animVersion string is required.
//
if (!hasVersionString) {
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kMissingKeyword, stat);
msg.format(msgFmt, kAnimVersion);
return (MS::kFailure);
}
// Set the linear and angular units to be the same as the file
// being read. This will allow fixed tangent data to be read
// in properly if the scene has different units than the .anim file.
//
MDistance::Unit oldDistanceUnit = MDistance::uiUnit();
MTime::Unit oldTimeUnit = MTime::uiUnit();
MDistance::setUIUnit(linearUnit);
MTime::setUIUnit(timeUnit);
while (!readAnim.eof()) {
if (NULL == dataType) {
dataType = asWord(readAnim);
}
if (strcmp(dataType, kAnim) == 0) {
MString fullAttributeName, leafAttributeName, nodeName;
// If this is from an unconnected anim curve, then there
// will not be an attribute name.
//
if (!isNextNumeric(readAnim)) {
fullAttributeName.set(asWord(readAnim));
// If the node names were specified, then the next two
// words should be the leaf attribute and the node name.
//
if (!isNextNumeric(readAnim)) {
leafAttributeName.set(asWord(readAnim));
nodeName.set(asWord(readAnim));
}
}
unsigned rowCount, childCount, attrCount;
rowCount = (unsigned)asDouble(readAnim);
childCount = (unsigned)asDouble(readAnim);
attrCount = (unsigned)asDouble(readAnim);
// If the next keyword is not an animData, then this is
// a place holder for the API clipboard.
//
dataType = asWord(readAnim);
if (strcmp(dataType, kAnimData) == 0) {
MAnimCurveClipboardItem clipboardItem;
if (readAnimCurve(readAnim, clipboardItem)) {
clipboardItem.setAddressingInfo(rowCount,
childCount, attrCount);
clipboardItem.setNameInfo( nodeName,
fullAttributeName,
leafAttributeName);
clipboardArray.append(clipboardItem);
} else {
// Could not read the anim curve.
//
MStatus stringStat;
MString msg = MStringResource::getString(kCouldNotReadAnim,
stringStat);
}
} else {
// This must be a place holder object for the clipboard.
//
MAnimCurveClipboardItem clipboardItem;
clipboardItem.setAddressingInfo(rowCount,
childCount, attrCount);
// Since there is no anim curve specified, what is
// in the fullAttributeName string is really the node
// name.
//
clipboardItem.setNameInfo( fullAttributeName,
nodeName,
leafAttributeName);
clipboardArray.append(clipboardItem);
// dataType already contains the next keyword.
//
continue;
}
} else {
if (!readAnim.eof()) {
MString warnStr(dataType);
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kUnknownKeyword,
stat);
msg.format(msgFmt, warnStr);
// Skip to the next line, this one is invalid.
//
readAnim.ignore(INT_MAX, kNewLineChar);
} else {
// The end of the file was reached.
//
break;
}
}
// Skip any whitespace.
//
dataType = NULL;
}
if (MS::kSuccess != cb.set( clipboardArray,
MTime(startTime, timeUnit), MTime(endTime, timeUnit),
(float) startUnitless, (float) endUnitless)) {
MStatus stringStat;
MString msg = MStringResource::getString(kClipboardFailure,
stringStat);
}
// Restore the old units.
//
MDistance::setUIUnit(oldDistanceUnit);
MTime::setUIUnit(oldTimeUnit);
return (MS::kSuccess);
}
void animReader::convertAnglesAndWeights3To2(MFnAnimCurve::AnimCurveType type,
bool isWeighted, MAngle &angle, double &weight)
//
// Description:
// Converts the tangent angles from Maya 3.0 to Maya2.* formats.
//
{
double oldAngle = angle.as(MAngle::kRadians);
double newAngle = oldAngle;
// Calculate the scale values for the conversion.
//
double xScale = 1.0;
double yScale = 1.0;
MTime tOne(1.0, MTime::kSeconds);
xScale = tOne.as(MTime::uiUnit());
}
switch (type) {
yScale = tOne.as(MTime::uiUnit());
break;
{
yScale = dOne.as(linearUnit);
}
break;
{
yScale = aOne.as(angularUnit);
}
break;
default:
break;
}
double tanAngle = tan(oldAngle);
newAngle = atan((xScale*tanAngle)/yScale);
if (isWeighted) {
double sinAngle = sin(oldAngle);
double cosAngle = cos(oldAngle);
double denominator = (yScale*yScale*sinAngle*sinAngle) +
(xScale*xScale*cosAngle*cosAngle);
weight = sqrtl(weight/denominator);
}
MAngle finalAngle(newAngle, MAngle::kRadians);
angle = finalAngle;
}
void animReader::convertAnglesAndWeights2To3(MFnAnimCurve::AnimCurveType type,
bool isWeighted, MAngle &angle, double &weight)
//
// Description:
// Converts the tangent angles from Maya 2.* to Maya3.0+ formats.
//
{
double oldAngle = angle.as(MAngle::kRadians);
double newAngle = oldAngle;
double newWeight = weight;
// Calculate the scale values for the conversion.
//
double xScale = 1.0;
double yScale = 1.0;
MTime tOne(1.0, MTime::kSeconds);
xScale = tOne.as(MTime::uiUnit());
}
switch (type) {
yScale = tOne.as(MTime::uiUnit());
break;
{
yScale = dOne.as(linearUnit);
}
break;
{
yScale = aOne.as(angularUnit);
}
break;
default:
break;
}
const double quarter = M_PI/2;
if (isEquivalent(oldAngle, 0.0) ||
isEquivalent(oldAngle, quarter) ||
isEquivalent(oldAngle, -quarter)) {
newAngle = oldAngle;
if (isWeighted) {
newWeight = yScale*oldAngle;
}
} else {
double tanAngle = tan(oldAngle);
newAngle = atan((yScale*tanAngle)/xScale);
if (isWeighted) {
double cosAngle = cos(oldAngle);
double cosSq = cosAngle*cosAngle;
double wSq = (weight*weight) *
(((xScale*xScale - yScale*yScale)*cosSq) + (yScale*yScale));
newWeight = sqrtl(wSq);
}
}
weight = newWeight;
MAngle finalAngle(newAngle, MAngle::kRadians);
angle = finalAngle;
}
bool animReader::readAnimCurve(
ifstream &clipFile, MAnimCurveClipboardItem &item)
//
// Description:
// Read a block of the ifstream that should contain anim curve
// data in the format determined by the animData keyword.
//
{
MFnAnimCurve animCurve;
MObject animCurveObj;
// Anim curve defaults.
//
animBase::AnimBaseType input = wordAsInputType(kWordTypeTime);
animBase::AnimBaseType output = wordAsOutputType(kWordTypeLinear);
MFnAnimCurve::InfinityType preInf = wordAsInfinityType(kWordConstant);
MFnAnimCurve::InfinityType postInf = wordAsInfinityType(kWordConstant);
MString inputUnitName;
animUnitNames::setToShortName(timeUnit, inputUnitName);
MString outputUnitName;
MAngle::Unit tanAngleUnit = angularUnit;
bool isWeighted (false);
char *dataType;
while (!clipFile.eof()) {
advance(clipFile);
dataType = asWord(clipFile);
if (strcmp(dataType, kInputString) == 0) {
input = wordAsInputType(asWord(clipFile));
} else if (strcmp(dataType, kOutputString) == 0) {
output = wordAsOutputType(asWord(clipFile));
} else if (strcmp(dataType, kWeightedString) == 0) {
isWeighted = (asDouble(clipFile) == 1.0);
} else if (strcmp(dataType, kPreInfinityString) == 0) {
preInf = wordAsInfinityType(asWord(clipFile));
} else if (strcmp(dataType, kPostInfinityString) == 0) {
postInf = wordAsInfinityType(asWord(clipFile));
} else if (strcmp(dataType, kInputUnitString) == 0) {
inputUnitName.set(asWord(clipFile));
} else if (strcmp(dataType, kOutputUnitString) == 0) {
outputUnitName.set(asWord(clipFile));
} else if (strcmp(dataType, kTanAngleUnitString) == 0) {
MString tUnit(asWord(clipFile));
if (!animUnitNames::setFromName(tUnit, tanAngleUnit)) {
MString unitName;
tanAngleUnit = angularUnit;
animUnitNames::setToShortName(tanAngleUnit, unitName);
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kSettingTanAngleUnit, stat);
msg.format(msgFmt, unitName);
}
} else if (strcmp(dataType, kKeysString) == 0) {
// Ignore the rest of this line.
//
clipFile.ignore(INT_MAX, kNewLineChar);
break;
} else if (strcmp(dataType, "{") == 0) {
// Skippping the '{' character. Just ignore it.
//
continue;
} else {
// An unrecogized keyword was found.
//
MString warnStr(dataType);
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kUnknownKeyword,
stat);
msg.format(msgFmt, warnStr);
continue;
}
}
// Read the animCurve
//
MStatus status;
MFnAnimCurve::AnimCurveType type = typeAsAnimCurveType(input, output);
animCurveObj = animCurve.create(type, NULL, &status);
if (status != MS::kSuccess) {
MString msg = MStringResource::getString(kCouldNotCreateAnim, status);
return false;
}
animCurve.setIsWeighted(isWeighted);
animCurve.setPreInfinityType(preInf);
animCurve.setPostInfinityType(postInf);
// Set the appropriate units.
//
MTime::Unit inputTimeUnit;
if (input == kAnimBaseTime) {
if (!animUnitNames::setFromName(inputUnitName, inputTimeUnit)) {
MString unitName;
inputTimeUnit = timeUnit;
animUnitNames::setToShortName(inputTimeUnit, unitName);
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kSettingToUnit,
stat);
msg.format(msgFmt, kInputUnitString, unitName);
}
}
MTime::Unit outputTimeUnit;
if (output == kAnimBaseTime) {
if (!animUnitNames::setFromName(outputUnitName, outputTimeUnit)) {
MString unitName;
outputTimeUnit = timeUnit;
animUnitNames::setToShortName(outputTimeUnit, unitName);
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kSettingToUnit,
stat);
msg.format(msgFmt, kOutputUnitString, unitName);
}
}
int index = 0;
double conversion = 1.0;
if (output == kAnimBaseLinear) {
if (outputUnitName.length() != 0) {
if (!animUnitNames::setFromName(outputUnitName, unit)) {
MString unitName;
unit = linearUnit;
animUnitNames::setToShortName(unit, unitName);
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kSettingToUnit,
stat);
msg.format(msgFmt, kOutputUnitString, unitName);
}
} else {
unit = linearUnit;
}
if (unit != MDistance::kCentimeters) {
MDistance one(1.0, unit);
conversion = one.as(MDistance::kCentimeters);
}
} else if (output == kAnimBaseAngular) {
if (outputUnitName.length() != 0) {
if (!animUnitNames::setFromName(outputUnitName, unit)) {
MString unitName;
unit = angularUnit;
animUnitNames::setToShortName(unit, unitName);
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kSettingToUnit,
stat);
msg.format(msgFmt, kOutputUnitString, unitName);
}
} else {
unit = angularUnit;
}
if (unit != MAngle::kRadians) {
MAngle one(1.0, unit);
conversion = one.as(MAngle::kRadians);
}
}
// Now read each keyframe
//
advance(clipFile);
char c = clipFile.peek();
while (clipFile && c != kBraceRightChar) {
double t = asDouble (clipFile);
double val = asDouble (clipFile);
MFnAnimCurve::TangentType tanIn = wordAsTangentType(asWord(clipFile));
MFnAnimCurve::TangentType tanOut = wordAsTangentType(asWord(clipFile));
switch (type) {
index = animCurve.addKey( MTime(val, inputTimeUnit),
MTime(val, outputTimeUnit),
tanIn, tanOut, NULL, &status);
break;
index = animCurve.addKey( MTime(t, inputTimeUnit),
val*conversion, tanIn, tanOut,
NULL, &status);
break;
index = animCurve.addKey( t, val*conversion,
tanIn, tanOut,
NULL, &status);
break;
index = animCurve.addKey( t, MTime(val, outputTimeUnit),
tanIn, tanOut,
NULL, &status);
break;
default:
MString msg = MStringResource::getString(kUnknownNode, status);
return false;
}
if (status != MS::kSuccess) {
MStatus stringStat;
MString msg = MStringResource::getString(kCouldNotKey, stringStat);
}
// Tangent locking needs to be called after the weights and
// angles are set for the fixed tangents.
//
bool tLocked = bool(asDouble(clipFile) == 1.0);
bool swLocked = bool(asDouble(clipFile) == 1.0);
bool isBreakdown (false);
if (animVersion >= kVersionNonWeightedAndBreakdowns) {
isBreakdown = (asDouble(clipFile) == 1.0);
}
// Only fixed tangents need additional information.
//
MAngle inAngle(asDouble(clipFile), tanAngleUnit);
double inWeight = asDouble(clipFile);
// If this is from a pre-Maya3.0 file, the tangent angles will
// need to be converted.
//
if (convertAnglesFromV2To3) {
convertAnglesAndWeights2To3(type,isWeighted,inAngle,inWeight);
} else if (convertAnglesFromV3To2) {
convertAnglesAndWeights3To2(type,isWeighted,inAngle,inWeight);
}
// By default, the tangents are locked. When the tangents
// are locked, setting the angle and weight of a fixed in
// tangent may change the tangent type of the out tangent.
//
animCurve.setTangentsLocked(index, false);
animCurve.setTangent(index, inAngle, inWeight, true);
}
// Only fixed tangents need additional information.
//
if (tanOut == MFnAnimCurve::kTangentFixed) {
MAngle outAngle(asDouble(clipFile), tanAngleUnit);
double outWeight = asDouble(clipFile);
// If this is from a pre-Maya3.0 file, the tangent angles will
// need to be converted.
//
if (convertAnglesFromV2To3) {
convertAnglesAndWeights2To3(type,isWeighted,outAngle,outWeight);
} else if (convertAnglesFromV3To2) {
convertAnglesAndWeights3To2(type,isWeighted,outAngle,outWeight);
}
// By default, the tangents are locked. When the tangents
// are locked, setting the angle and weight of a fixed out
// tangent may change the tangent type of the in tangent.
//
animCurve.setTangentsLocked(index, false);
animCurve.setTangent(index, outAngle, outWeight, false);
}
// To prevent tangent types from unexpectedly changing, tangent
// locking should be the last operation. See the above comments
// about fixed tangent types for more information.
//
animCurve.setWeightsLocked(index, swLocked);
animCurve.setTangentsLocked(index, tLocked);
animCurve.setIsBreakdown (index, isBreakdown);
// There should be no additional data on this line. Go to the
// next line of data.
//
clipFile.ignore(INT_MAX, kNewLineChar);
// Skip any comments.
//
advance(clipFile);
c = clipFile.peek();
}
// Ignore the brace that marks the end of the keys block.
//
if (c == kBraceRightChar) {
clipFile.ignore(INT_MAX, kNewLineChar);
}
// Ignore the brace that marks the end of the animData block.
//
advance(clipFile);
if (clipFile.peek() == kBraceRightChar) {
clipFile.ignore(INT_MAX, kNewLineChar);
} else {
// Something is wrong.
//
MStatus stringStat;
MString msg = MStringResource::getString(kMissingBrace, stringStat);
}
// Do not set the clipboard with an empty clipboard item.
//
if (!animCurveObj.isNull()) {
item.setAnimCurve(animCurveObj);
}
// Delete the copy of the anim curve.
//
MGlobal::deleteNode(animCurveObj);
return true;
}
//-------------------------------------------------------------------------
// Class animWriter
//-------------------------------------------------------------------------
animWriter::animWriter()
//
// Description:
// Class constructor.
//
{
}
animWriter::~animWriter()
//
// Description:
// Class destructor.
//
{
}
animWriter::writeClipboard( ofstream& animFile,
const MAnimCurveClipboard &cb,
bool nodeNames /* false */,
bool verboseUnits /* false */)
//
// Description:
// Write the contents of the clipboard to the ofstream.
//
{
// Check to see if there is anything on the clipboard at all
//
if (cb.isEmpty()) {
return status;
}
resetUnits();
// Write out the clipboard information
//
if (!writeHeader(animFile)) {
return (MS::kFailure);
}
// Now write out each animCurve
//
const MAnimCurveClipboardItemArray &clipboardArray =
cb.clipboardItems(&status);
if (MS::kSuccess != status) {
return status;
}
for (unsigned int i = 0; i < clipboardArray.length(); i++) {
const MAnimCurveClipboardItem &clipboardItem = clipboardArray[i];
MStatus statusInLoop = MS::kSuccess;
const MObject animCurveObj = clipboardItem.animCurve(&statusInLoop);
// The clipboard may contain Null anim curves. If a Null anim
// curve is returned, it is safe to ignore the error message
// and continue to the next anim curve in the list.
//
bool placeHolder = false;
if (MS::kSuccess != statusInLoop || animCurveObj.isNull()) {
placeHolder = true;
}
// Write out animCurve information
//
if (!writeAnim(animFile, clipboardItem, placeHolder, nodeNames)) {
return (MS::kFailure);
}
if (placeHolder) {
continue;
}
// Write out each curve in its specified format.
// For now, only the anim curve format.
//
if (!writeAnimCurve(animFile, &animCurveObj,
clipboardItem.animCurveType(),
verboseUnits)) {
return (MS::kFailure);
}
}
return (MS::kSuccess);
}
bool animWriter::writeHeader(ofstream& clip)
//
// Description:
// Writes the header for the file. The header contains the clipboard
// specific data.
//
{
if (!clip) {
return false;
}
clip << kAnimVersion << kSpaceChar << kAnimVersionString << kSemiColonChar << endl;
clip << kMayaVersion << kSpaceChar << MGlobal::mayaVersion() << kSemiColonChar << endl;
static MAnimCurveClipboard &clipboard =
double startTime = clipboard.startTime().as(timeUnit);
double endTime = clipboard.endTime().as(timeUnit);
if (startTime != endTime) {
MString unit;
animUnitNames::setToShortName(timeUnit, unit);
clip << kTimeUnit << kSpaceChar << unit << kSemiColonChar << endl;
animUnitNames::setToShortName(linearUnit, unit);
clip << kLinearUnit << kSpaceChar << unit << kSemiColonChar << endl;
animUnitNames::setToShortName(angularUnit, unit);
clip << kAngularUnit << kSpaceChar << unit << kSemiColonChar << endl;
clip << kStartTime << kSpaceChar << startTime << kSemiColonChar << endl;
clip << kEndTime << kSpaceChar << endTime << kSemiColonChar << endl;
}
float startUnitless = clipboard.startUnitlessInput();
float endUnitless = clipboard.endUnitlessInput();
if (startUnitless != endUnitless) {
clip << kStartUnitless << kSpaceChar << startUnitless <<
kSemiColonChar << endl;
clip << kEndUnitless << kSpaceChar << endUnitless <<
kSemiColonChar << endl;
}
return true;
}
bool animWriter::writeAnim( ofstream &clip,
const MAnimCurveClipboardItem &clipboardItem,
bool placeHolder /* false */,
bool nodeNames /* false */)
//
// Description:
// Write out the anim curve from the clipboard item into the
// ofstream. The position of the anim curve in the clipboard
// and the attribute to which it is attached is written out in this
// method.
//
// This method returns true if the write was successful.
//
{
if (!clip) {
return false;
}
clip << kAnim;
// If this is a clipboard place holder then there will be no full
// or leaf attribute names.
//
if (placeHolder) {
clip << kSpaceChar << clipboardItem.nodeName().asChar();
} else {
clip << kSpaceChar << clipboardItem.fullAttributeName().asChar();
if (nodeNames) {
clip << kSpaceChar << clipboardItem.leafAttributeName().asChar();
clip << kSpaceChar << clipboardItem.nodeName().asChar();
}
}
unsigned int rowCount, childCount, attrCount;
clipboardItem.getAddressingInfo(rowCount, childCount, attrCount);
clip << kSpaceChar << rowCount;
clip << kSpaceChar << childCount;
clip << kSpaceChar << attrCount;
clip << kSemiColonChar << endl;
return true;
}
bool animWriter::writeAnimCurve(ofstream &clip,
const MObject *animCurveObj,
bool verboseUnits /* false */)
//
// Description:
// Write out the anim curve from the clipboard item into the
// ofstream. The actual anim curve data is written out.
//
// This method returns true if the write was successful.
//
{
if (NULL == animCurveObj || animCurveObj->isNull() || !clip) {
return true;
}
MFnAnimCurve animCurve(*animCurveObj, &status);
if (MS::kSuccess != status) {
MString msg = MStringResource::getString(kCouldNotExport, status);
return false;
}
clip << kAnimData << kSpaceChar << kBraceLeftChar << endl;
clip << kTwoSpace << kInputString << kSpaceChar <<
boolInputTypeAsWord(animCurve.isUnitlessInput()) <<
kSemiColonChar << endl;
clip << kTwoSpace << kOutputString << kSpaceChar <<
outputTypeAsWord(type) << kSemiColonChar << endl;
clip << kTwoSpace << kWeightedString << kSpaceChar <<
(animCurve.isWeighted() ? 1 : 0) << kSemiColonChar << endl;
// These units default to the units in the header of the file.
//
if (verboseUnits) {
clip << kTwoSpace << kInputUnitString << kSpaceChar;
if (animCurve.isTimeInput()) {
MString unitName;
animUnitNames::setToShortName(timeUnit, unitName);
clip << unitName;
} else {
// The anim curve has unitless input.
//
clip << kUnitlessString;
}
clip << kSemiColonChar << endl;
clip << kTwoSpace << kOutputUnitString << kSpaceChar;
}
double conversion = 1.0;
MString unitName;
switch (type) {
animUnitNames::setToShortName(angularUnit, unitName);
if (verboseUnits) clip << unitName;
{
MAngle angle(1.0);
conversion = angle.as(angularUnit);
}
break;
animUnitNames::setToShortName(linearUnit, unitName);
if (verboseUnits) clip << unitName;
{
MDistance distance(1.0);
conversion = distance.as(linearUnit);
}
break;
animUnitNames::setToShortName(timeUnit, unitName);
if (verboseUnits) clip << unitName;
break;
default:
if (verboseUnits) clip << kUnitlessString;
break;
}
if (verboseUnits) clip << kSemiColonChar << endl;
if (verboseUnits) {
MString angleUnitName;
animUnitNames::setToShortName(angularUnit, angleUnitName);
clip << kTwoSpace << kTanAngleUnitString <<
kSpaceChar << angleUnitName << kSemiColonChar << endl;
}
clip << kTwoSpace << kPreInfinityString << kSpaceChar <<
infinityTypeAsWord(animCurve.preInfinityType()) <<
kSemiColonChar << endl;
clip << kTwoSpace << kPostInfinityString << kSpaceChar <<
infinityTypeAsWord(animCurve.postInfinityType()) <<
kSemiColonChar << endl;
clip << kTwoSpace << kKeysString << kSpaceChar << kBraceLeftChar << endl;
// And then write out each keyframe
//
unsigned numKeys = animCurve.numKeyframes();
for (unsigned i = 0; i < numKeys; i++) {
clip << kTwoSpace << kTwoSpace;
if (animCurve.isUnitlessInput()) {
clip << animCurve.unitlessInput(i);
}
else {
clip << animCurve.time(i).value();
}
// clamp tiny values so that it isn't so small it can't be read in
//
double animValue = (conversion*animCurve.value(i));
if (animBase::isEquivalent(animValue,0.0)) animValue = 0.0;
clip << kSpaceChar << animValue;
clip << kSpaceChar << tangentTypeAsWord(animCurve.inTangentType(i));
clip << kSpaceChar << tangentTypeAsWord(animCurve.outTangentType(i));
clip << kSpaceChar << (animCurve.tangentsLocked(i) ? 1 : 0);
clip << kSpaceChar << (animCurve.weightsLocked(i) ? 1 : 0);
clip << kSpaceChar << (animCurve.isBreakdown(i) ? 1 : 0);
MAngle angle;
double weight;
animCurve.getTangent(i, angle, weight, true);
clip << kSpaceChar << angle.as(angularUnit);
clip << kSpaceChar << weight;
}
MAngle angle;
double weight;
animCurve.getTangent(i, angle, weight, false);
clip << kSpaceChar << angle.as(angularUnit);
clip << kSpaceChar << weight;
}
clip << kSemiColonChar << endl;
}
clip << kTwoSpace << kBraceRightChar << endl;
clip << kBraceRightChar << endl;
return true;
}