#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
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()
{
}
animUnitNames::~animUnitNames()
{
}
{
switch(unit) {
break;
break;
break;
break;
default:
name.
set(kUnknownAngularString);
break;
}
}
{
switch(unit) {
break;
break;
break;
break;
default:
name.
set(kUnknownAngularString);
break;
}
}
{
switch(unit) {
break;
break;
break;
break;
break;
break;
break;
break;
default:
name.
set(kUnknownLinearString);
break;
}
}
{
switch(unit) {
break;
break;
break;
break;
break;
break;
break;
break;
default:
name.
set(kUnknownLinearString);
break;
}
}
{
switch(unit) {
break;
break;
break;
name.
set(kMillisecTString);
break;
break;
break;
break;
break;
break;
break;
break;
default:
name.
set(kUnknownTimeString);
break;
}
}
{
setToLongName(unit, name);
}
{
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 {
state = false;
}
return state;
}
{
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 {
state = false;
unit = MDistance::kInvalid;
}
return state;
}
{
bool state = true;
const char *name = str.
asChar();
if (strcmp(name, kHourTString) == 0) {
} else if (strcmp(name, kMinTString) == 0) {
} else if (strcmp(name, kSecTString) == 0) {
} else if (strcmp(name, kMillisecTString) == 0) {
} else if (strcmp(name, kGameTString) == 0) {
} else if (strcmp(name, kFileTString) == 0) {
} 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 {
state = false;
}
return state;
}
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";
const char *kWordConstant = "constant";
const char *kWordLinear = "linear";
const char *kWordCycle = "cycle";
const char *kWordCycleRelative = "cycleRelative";
const char *kWordOscillate = "oscillate";
const char *kWordTypeUnknown = "unknown";
const char *kWordTypeLinear = "linear";
const char *kWordTypeAngular = "angular";
const char *kWordTypeTime = "time";
const char *kWordTypeUnitless = "unitless";
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";
const char *kAnimVersionString = "1.1";
const double kVersionNonWeightedAndBreakdowns = 1.1;
const char *kTwoSpace = " ";
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";
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 ()
{
resetUnits();
}
animBase::~animBase()
{
}
void animBase::resetUnits()
{
}
const char *
{
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)
{
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 *
{
switch (type) {
return (kWordConstant);
return (kWordLinear);
return (kWordCycle);
return (kWordCycleRelative);
return (kWordOscillate);
default:
break;
}
return (kWordConstant);
}
animBase::wordAsInfinityType(const char *type)
{
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 *
{
switch (type) {
return (kWordTypeLinear);
return (kWordTypeAngular);
return (kWordTypeTime);
return (kWordTypeUnitless);
return (kWordTypeUnitless);
}
return (kWordTypeUnknown);
}
animBase::AnimBaseType
animBase::wordAsInputType(const char *input)
{
if (strcmp(input, kWordTypeTime) == 0) {
return animBase::kAnimBaseTime;
} else {
return animBase::kAnimBaseUnitless;
}
}
animBase::AnimBaseType
animBase::wordAsOutputType(const char *output)
{
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)
{
if (isUnitless) {
return (kWordTypeUnitless);
} else {
return (kWordTypeTime);
}
}
animBase::typeAsAnimCurveType( animBase::AnimBaseType input,
animBase::AnimBaseType output)
{
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:
break;
}
return type;
}
double animBase::asDouble (ifstream &clipFile)
{
advance(clipFile);
double value;
clipFile >> value;
return (value);
}
bool animBase::isNextNumeric(ifstream &clipFile)
{
bool numeric = false;
advance(clipFile);
char next = clipFile.peek();
if (next >= '0' && next <= '9') {
numeric = true;
}
return numeric;
}
void animBase::advance (ifstream &clipFile)
{
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 )
{
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 {
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)
{
advance(clipFile);
return clipFile.get();
}
bool animBase::isEquivalent(double a, double b)
{
const double tolerance = 1.0e-10;
return ((a > b) ? (a - b <= tolerance) : (b - a <= tolerance));
}
animReader::animReader ()
: animVersion (1.0)
, convertAnglesFromV2To3(false)
, convertAnglesFromV3To2(false)
{
}
animReader::~animReader()
{
}
{
double startTime = 1.0;
double endTime = 0.0;
double startUnitless = 1.0;
double endUnitless = 0.0;
resetUnits();
convertAnglesFromV2To3 = false;
convertAnglesFromV3To2 = false;
char *dataType = NULL;
bool hasVersionString = false;
while (!readAnim.eof()) {
advance(readAnim);
dataType = asWord(readAnim);
if (strcmp(dataType, kAnimVersion) == 0) {
animVersion = version.asDouble();
MString thisVersion(kAnimVersionString);
hasVersionString = true;
if (version != thisVersion) {
stat);
msg.
format(msgFmt, version, thisVersion);
}
} else if (strcmp(dataType, kMayaVersion) == 0) {
MString version(asWord(readAnim,
true));
if (vCheck != "2.") {
convertAnglesFromV3To2 = true;
}
} else {
if (vCheck == "2.") {
convertAnglesFromV2To3 = true;
}
}
} else if (strcmp(dataType, kTimeUnit) == 0) {
MString timeUnitString(asWord(readAnim));
if (!animUnitNames::setFromName(timeUnitString, timeUnit)) {
animUnitNames::setToShortName(timeUnit, unitName);
stat);
msg.
format(msgFmt, kTimeUnit, unitName);
}
} else if (strcmp(dataType, kLinearUnit) == 0) {
MString linearUnitString(asWord(readAnim));
if (!animUnitNames::setFromName(linearUnitString, linearUnit)) {
animUnitNames::setToShortName(linearUnit, unitName);
stat);
msg.
format(msgFmt, kLinearUnit, unitName);
}
} else if (strcmp(dataType, kAngularUnit) == 0) {
MString angularUnitString(asWord(readAnim));
if (!animUnitNames::setFromName(angularUnitString, angularUnit)) {
animUnitNames::setToShortName(angularUnit, unitName);
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 {
break;
}
}
if (!hasVersionString) {
msg.
format(msgFmt, kAnimVersion);
}
while (!readAnim.eof()) {
if (NULL == dataType) {
dataType = asWord(readAnim);
}
if (strcmp(dataType, kAnim) == 0) {
MString fullAttributeName, leafAttributeName, nodeName;
if (!isNextNumeric(readAnim)) {
fullAttributeName.
set(asWord(readAnim));
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);
dataType = asWord(readAnim);
if (strcmp(dataType, kAnimData) == 0) {
if (readAnimCurve(readAnim, clipboardItem)) {
childCount, attrCount);
fullAttributeName,
leafAttributeName);
clipboardArray.
append(clipboardItem);
} else {
stringStat);
}
} else {
childCount, attrCount);
nodeName,
leafAttributeName);
clipboardArray.
append(clipboardItem);
continue;
}
} else {
if (!readAnim.eof()) {
stat);
readAnim.ignore(INT_MAX, kNewLineChar);
} else {
break;
}
}
dataType = NULL;
}
MTime(startTime, timeUnit),
MTime(endTime, timeUnit),
(float) startUnitless, (float) endUnitless)) {
stringStat);
}
}
bool isWeighted,
MAngle &angle,
double &weight)
{
double newAngle = oldAngle;
double xScale = 1.0;
double yScale = 1.0;
}
switch (type) {
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);
}
angle = finalAngle;
}
bool isWeighted,
MAngle &angle,
double &weight)
{
double newAngle = oldAngle;
double newWeight = weight;
double xScale = 1.0;
double yScale = 1.0;
}
switch (type) {
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;
angle = finalAngle;
}
bool animReader::readAnimCurve(
{
animBase::AnimBaseType input = wordAsInputType(kWordTypeTime);
animBase::AnimBaseType output = wordAsOutputType(kWordTypeLinear);
animUnitNames::setToShortName(timeUnit, inputUnitName);
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) {
if (!animUnitNames::setFromName(tUnit, tanAngleUnit)) {
tanAngleUnit = angularUnit;
animUnitNames::setToShortName(tanAngleUnit, unitName);
}
} else if (strcmp(dataType, kKeysString) == 0) {
clipFile.ignore(INT_MAX, kNewLineChar);
break;
} else if (strcmp(dataType, "{") == 0) {
continue;
} else {
stat);
continue;
}
}
animCurveObj = animCurve.
create(type, NULL, &status);
return false;
}
if (input == kAnimBaseTime) {
if (!animUnitNames::setFromName(inputUnitName, inputTimeUnit)) {
inputTimeUnit = timeUnit;
animUnitNames::setToShortName(inputTimeUnit, unitName);
stat);
msg.
format(msgFmt, kInputUnitString, unitName);
}
}
if (output == kAnimBaseTime) {
if (!animUnitNames::setFromName(outputUnitName, outputTimeUnit)) {
outputTimeUnit = timeUnit;
animUnitNames::setToShortName(outputTimeUnit, unitName);
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)) {
unit = linearUnit;
animUnitNames::setToShortName(unit, unitName);
stat);
msg.
format(msgFmt, kOutputUnitString, unitName);
}
} else {
unit = linearUnit;
}
}
} else if (output == kAnimBaseAngular) {
if (outputUnitName.
length() != 0) {
if (!animUnitNames::setFromName(outputUnitName, unit)) {
unit = angularUnit;
animUnitNames::setToShortName(unit, unitName);
stat);
msg.
format(msgFmt, kOutputUnitString, unitName);
}
} else {
unit = angularUnit;
}
}
}
advance(clipFile);
char c = clipFile.peek();
while (clipFile && c != kBraceRightChar) {
double t = asDouble (clipFile);
double val = asDouble (clipFile);
switch (type) {
MTime(val, outputTimeUnit),
tanIn, tanOut, NULL, &status);
break;
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:
return false;
}
}
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);
}
MAngle inAngle(asDouble(clipFile), tanAngleUnit);
double inWeight = asDouble(clipFile);
if (convertAnglesFromV2To3) {
convertAnglesAndWeights2To3(type,isWeighted,inAngle,inWeight);
} else if (convertAnglesFromV3To2) {
convertAnglesAndWeights3To2(type,isWeighted,inAngle,inWeight);
}
animCurve.
setTangent(index, inAngle, inWeight,
true);
}
MAngle outAngle(asDouble(clipFile), tanAngleUnit);
double outWeight = asDouble(clipFile);
if (convertAnglesFromV2To3) {
convertAnglesAndWeights2To3(type,isWeighted,outAngle,outWeight);
} else if (convertAnglesFromV3To2) {
convertAnglesAndWeights3To2(type,isWeighted,outAngle,outWeight);
}
animCurve.
setTangent(index, outAngle, outWeight,
false);
}
clipFile.ignore(INT_MAX, kNewLineChar);
advance(clipFile);
c = clipFile.peek();
}
if (c == kBraceRightChar) {
clipFile.ignore(INT_MAX, kNewLineChar);
}
advance(clipFile);
if (clipFile.peek() == kBraceRightChar) {
clipFile.ignore(INT_MAX, kNewLineChar);
} else {
}
}
return true;
}
animWriter::animWriter()
{
}
animWriter::~animWriter()
{
}
animWriter::writeClipboard( ofstream& animFile,
bool nodeNames ,
bool verboseUnits )
{
return status;
}
resetUnits();
if (!writeHeader(animFile)) {
}
return status;
}
for (
unsigned int i = 0; i < clipboardArray.
length(); i++) {
bool placeHolder = false;
placeHolder = true;
}
if (!writeAnim(animFile, clipboardItem, placeHolder, nodeNames)) {
}
if (placeHolder) {
continue;
}
if (!writeAnimCurve(animFile, &animCurveObj,
verboseUnits)) {
}
}
}
bool animWriter::writeHeader(ofstream& clip)
{
if (!clip) {
return false;
}
clip << kAnimVersion << kSpaceChar << kAnimVersionString << kSemiColonChar << endl;
double endTime = clipboard.
endTime().
as(timeUnit);
if (startTime != endTime) {
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;
}
if (startUnitless != endUnitless) {
clip << kStartUnitless << kSpaceChar << startUnitless <<
kSemiColonChar << endl;
clip << kEndUnitless << kSpaceChar << endUnitless <<
kSemiColonChar << endl;
}
return true;
}
bool animWriter::writeAnim( ofstream &clip,
bool placeHolder ,
bool nodeNames )
{
if (!clip) {
return false;
}
clip << kAnim;
if (placeHolder) {
} else {
if (nodeNames) {
}
}
unsigned int rowCount, childCount, attrCount;
clip << kSpaceChar << rowCount;
clip << kSpaceChar << childCount;
clip << kSpaceChar << attrCount;
clip << kSemiColonChar << endl;
return true;
}
bool animWriter::writeAnimCurve(ofstream &clip,
bool verboseUnits )
{
if (NULL == animCurveObj || animCurveObj->
isNull() || !clip) {
return true;
}
return false;
}
clip << kAnimData << kSpaceChar << kBraceLeftChar << endl;
clip << kTwoSpace << kInputString << kSpaceChar <<
kSemiColonChar << endl;
clip << kTwoSpace << kOutputString << kSpaceChar <<
outputTypeAsWord(type) << kSemiColonChar << endl;
clip << kTwoSpace << kWeightedString << kSpaceChar <<
(animCurve.
isWeighted() ? 1 : 0) << kSemiColonChar << endl;
if (verboseUnits) {
clip << kTwoSpace << kInputUnitString << kSpaceChar;
animUnitNames::setToShortName(timeUnit, unitName);
clip << unitName;
} else {
clip << kUnitlessString;
}
clip << kSemiColonChar << endl;
clip << kTwoSpace << kOutputUnitString << kSpaceChar;
}
double conversion = 1.0;
switch (type) {
animUnitNames::setToShortName(angularUnit, unitName);
if (verboseUnits) clip << unitName;
{
conversion = angle.
as(angularUnit);
}
break;
animUnitNames::setToShortName(linearUnit, unitName);
if (verboseUnits) clip << unitName;
{
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) {
animUnitNames::setToShortName(angularUnit, angleUnitName);
clip << kTwoSpace << kTanAngleUnitString <<
kSpaceChar << angleUnitName << kSemiColonChar << endl;
}
clip << kTwoSpace << kPreInfinityString << kSpaceChar <<
kSemiColonChar << endl;
clip << kTwoSpace << kPostInfinityString << kSpaceChar <<
kSemiColonChar << endl;
clip << kTwoSpace << kKeysString << kSpaceChar << kBraceLeftChar << endl;
for (unsigned i = 0; i < numKeys; i++) {
clip << kTwoSpace << kTwoSpace;
}
else {
}
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 << (animCurve.
isBreakdown(i) ? 1 : 0);
double weight;
clip << kSpaceChar << angle.
as(angularUnit);
clip << kSpaceChar << weight;
}
double weight;
clip << kSpaceChar << angle.
as(angularUnit);
clip << kSpaceChar << weight;
}
clip << kSemiColonChar << endl;
}
clip << kTwoSpace << kBraceRightChar << endl;
clip << kBraceRightChar << endl;
return true;
}