XmlGeometryCache/XmlGeometryCache.cpp

XmlGeometryCache/XmlGeometryCache.cpp
//-
// ==========================================================================
// Copyright 2009 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+
//
// Description:
// This plug-in provides an example of the use of MPxCacheFormat.
//
// In this example, the cache files are written in xml format.
//
#include <string>
#include <stack>
#include <fstream>
#include <sstream>
#include <assert.h>
#include <stdlib.h>
#include <maya/MFnPlugin.h>
#include <maya/MGlobal.h>
#include <maya/MString.h>
#include <maya/MPxCacheFormat.h>
#include <maya/MTime.h>
#include <maya/MFloatVectorArray.h>
#include <maya/MDoubleArray.h>
#include <maya/MFloatArray.h>
#include <maya/MIntArray.h>
#include <maya/MVectorArray.h>
using namespace std;
class XmlCacheFormat : public MPxCacheFormat
{
public:
XmlCacheFormat();
~XmlCacheFormat();
static void* creator();
static void setPluginName( const MString& name );
static MString translatorName();
MStatus isValid();
MStatus open( const MString& fileName, FileAccessMode mode );
void close();
MStatus readHeader();
MStatus writeHeader( const MString& version, MTime& startTime, MTime& endTime );
void beginWriteChunk();
void endWriteChunk();
MStatus beginReadChunk();
void endReadChunk();
MStatus writeTime( MTime& time );
MStatus readTime( MTime& time );
MStatus findTime( MTime& time, MTime& foundTime );
MStatus readNextTime( MTime& foundTime );
unsigned readArraySize();
MStatus writeDoubleArray( const MDoubleArray& );
MStatus readDoubleArray( MDoubleArray&, unsigned size );
MStatus writeFloatArray( const MFloatArray& );
MStatus readFloatArray( MFloatArray&, unsigned size );
MStatus writeDoubleVectorArray( const MVectorArray& array );
MStatus readDoubleVectorArray( MVectorArray&, unsigned arraySize );
MStatus writeFloatVectorArray( const MFloatVectorArray& array );
MStatus readFloatVectorArray( MFloatVectorArray& array, unsigned arraySize );
MStatus writeChannelName( const MString& name );
MStatus findChannelName( const MString& name );
MStatus readChannelName( MString& name );
MStatus writeInt32( int );
int readInt32();
MStatus rewind();
MString extension();
protected:
static MString comment( const MString& text );
static MString quote( const MString& text );
static MString fExtension;
static MString fCacheFormatName;
private:
void startXmlBlock( string& t );
void endXmlBlock();
void writeXmlTagValue( string& tag, string value );
void writeXmlTagValue( string& tag, int value );
bool readXmlTagValue( string tag, MStringArray& value );
bool readXmlTagValueInChunk( string tag, MStringArray& values );
void readXmlTag( string& value );
bool findXmlStartTag( string& tag );
bool findXmlStartTagInChunk( string& tag );
bool findXmlEndTag( string& tag );
void writeXmlValue( string& value );
void writeXmlValue( double value );
void writeXmlValue( float value );
void writeXmlValue( int value );
MString fFileName;
fstream fFile;
stack<string> fXmlStack;
FileAccessMode fMode;
};
MString XmlCacheFormat::fExtension = "mc"; // For files on disk
MString XmlCacheFormat::fCacheFormatName = "xml"; // For presentation in GUI
inline MString XmlCacheFormat::translatorName()
{
return fCacheFormatName;
}
void* XmlCacheFormat::creator()
{
return new XmlCacheFormat();
}
// ****************************************
//
// Helper functions
string XMLSTARTTAG( string x )
{
return ( "<" + x + ">" );
}
string XMLENDTAG( string x )
{
return ( "</" + x + ">" );
}
string cacheTag("awGeoCache");
string startTimeTag("startTime");
string endTimeTag("endTime");
string versionTag("version");
string timeTag("time");
string sizeTag("size");
string intTag("integer32");
string doubleArrayTag("doubleArray");
string floatArrayTag("floatArray");
string doubleVectorArrayTag("doubleVectorArray");
string floatVectorArrayTag("floatVectorArray");
string channelTag("channel");
string chunkTag("chunk");
XmlCacheFormat::XmlCacheFormat()
{
}
XmlCacheFormat::~XmlCacheFormat()
{
close();
}
XmlCacheFormat::open( const MString& fileName, FileAccessMode mode )
{
bool rtn = true;
assert((fileName.length() > 0));
fFileName = fileName;
if( mode == kWrite ) {
fFile.open(fFileName.asChar(), ios::out);
}
else if (mode == kReadWrite) {
fFile.open(fFileName.asChar(), ios::app);
} else {
fFile.open(fFileName.asChar(), ios::in);
}
if (!fFile.is_open()) {
rtn = false;
} else {
if (mode == kRead) {
rtn = readHeader();
}
}
return rtn ? MS::kSuccess : MS::kFailure ;
}
XmlCacheFormat::isValid()
{
bool rtn = fFile.is_open();
return rtn ? MS::kSuccess : MS::kFailure ;
}
XmlCacheFormat::readHeader()
{
bool rtn = false;
if (kWrite != fMode) {
if( fFile.is_open() ) {
string tag;
readXmlTag( tag );
if( tag == XMLSTARTTAG(cacheTag) )
{
MStringArray value;
readXmlTagValue( versionTag, value );
readXmlTagValue( startTimeTag, value );
readXmlTagValue( endTimeTag, value );
readXmlTag( tag ); // Should be header close tag, check
if( tag != XMLENDTAG(cacheTag) )
{
// TODO - handle this error case
}
rtn = true;
}
}
}
return rtn ? MS::kSuccess : MS::kFailure ;
}
XmlCacheFormat::rewind()
{
if( fFile.is_open() )
{
close();
if(!open(fFileName, kRead ))
{
return MS::kFailure;
}
return MS::kSuccess;
}
else
{
return MS::kFailure;
}
}
void XmlCacheFormat::close()
{
if( fFile.is_open() ) {
fFile.close();
}
}
MStatus XmlCacheFormat::writeInt32( int i )
{
writeXmlTagValue(intTag, i);
return MS::kSuccess;
}
int
XmlCacheFormat::readInt32()
{
MStringArray value;
readXmlTagValue(intTag, value);
return atoi( value[0].asChar() );
}
XmlCacheFormat::writeHeader( const MString& version, MTime& startTime, MTime& endTime )
{
stringstream oss;
startXmlBlock(cacheTag);
string v(version.asChar());
writeXmlTagValue(versionTag, v);
oss << startTime;
writeXmlTagValue(startTimeTag, oss.str() );
oss.str("");
oss.clear();
oss << endTime;
writeXmlTagValue(endTimeTag, oss.str() );
endXmlBlock();
return MS::kSuccess;
}
XmlCacheFormat::readTime( MTime& time )
{
MStringArray timeValue;
readXmlTagValue(timeTag, timeValue);
time.setValue( strtod( timeValue[0].asChar(), NULL ) );
return MS::kSuccess;
}
XmlCacheFormat::writeTime( MTime& time )
{
stringstream oss;
oss << time;
writeXmlTagValue(timeTag, oss.str() );
return MS::kSuccess;
}
XmlCacheFormat::findChannelName( const MString& name )
//
// Given that the right time has already been found, find the name
// of the channel we're trying to read.
//
{
MStringArray value;
while (readXmlTagValueInChunk(channelTag, value))
{
if( value.length() == 1 && value[0] == name )
{
return MS::kSuccess;
}
}
return MS::kFailure;
}
XmlCacheFormat::readChannelName( MString& name )
//
// Given that the right time has already been found, find the name
// of the channel we're trying to read.
//
// If no more channels exist, return false. Some callers rely on this false return
// value to terminate scanning for channels, thus it's not an error condition.
//
// TODO: the current implementation assumes there are numChannels of data stored
// for every time. This assumption needs to be removed.
//
{
MStringArray value;
readXmlTagValueInChunk(channelTag, value);
name = value[0];
return name.length() == 0 ? MS::kFailure : MS::kSuccess;
}
XmlCacheFormat::readNextTime( MTime& foundTime )
//
// Read the next time based on the current read position.
//
{
MTime readAwTime(0.0, MTime::k6000FPS);
bool ret = readTime(readAwTime);
foundTime = readAwTime;
return ret ? MS::kSuccess : MS::kFailure ;
}
XmlCacheFormat::findTime( MTime& time, MTime& foundTime )
//
// Find the biggest cached time, which is smaller or equal to
// seekTime and return foundTime
//
{
MTime timeTolerance(0.0, MTime::k6000FPS);
MTime seekTime(time);
MTime preTime( seekTime - timeTolerance );
MTime postTime( seekTime + timeTolerance );
bool fileRewound = false;
while (1)
{
bool timeTagFound = beginReadChunk();
if ( ! timeTagFound && !fileRewound )
{
if(!rewind())
{
return MS::kFailure;
}
fileRewound = true;
timeTagFound = beginReadChunk();
}
if ( timeTagFound )
{
MTime rTime(0.0, MTime::k6000FPS);
readTime(rTime);
if(rTime >= preTime && rTime <= postTime)
{
foundTime = rTime;
return MS::kSuccess;
}
if(rTime > postTime )
{
if (!fileRewound)
{
if(!rewind())
{
return MS::kFailure;
}
fileRewound = true;
}
else
{
// Time could not be found
//
return MS::kFailure;
}
}
else
{
fileRewound = true;
}
endReadChunk();
}
else
{
// Not a valid disk cache file.
break;
}
}
return MS::kFailure;
}
XmlCacheFormat::writeChannelName( const MString& name )
{
string chan = name.asChar();
writeXmlTagValue( channelTag, chan );
return MS::kSuccess;
}
void XmlCacheFormat::beginWriteChunk()
{
startXmlBlock(chunkTag);
}
void XmlCacheFormat::endWriteChunk()
{
endXmlBlock();
}
MStatus XmlCacheFormat::beginReadChunk()
{
return findXmlStartTag(chunkTag) ? MS::kSuccess : MS::kFailure;
}
void XmlCacheFormat::endReadChunk()
{
findXmlEndTag(chunkTag);
}
XmlCacheFormat::writeDoubleArray( const MDoubleArray& array )
{
int size = array.length();
assert(size != 0);
writeXmlTagValue(sizeTag,size);
startXmlBlock( doubleArrayTag );
for(int i = 0; i < size; i++)
{
writeXmlValue(array[i]);
}
endXmlBlock();
return MS::kSuccess;
}
XmlCacheFormat::writeFloatArray( const MFloatArray& array )
{
int size = array.length();
assert(size != 0);
writeXmlTagValue(sizeTag,size);
startXmlBlock( floatArrayTag );
for(int i = 0; i < size; i++)
{
writeXmlValue(array[i]);
}
endXmlBlock();
return MS::kSuccess;
}
XmlCacheFormat::writeDoubleVectorArray( const MVectorArray& array )
{
int size = array.length();
assert(size != 0);
writeXmlTagValue(sizeTag,size);
startXmlBlock( doubleVectorArrayTag );
for(int i = 0; i < size; i++)
{
writeXmlValue(array[i][0]);
writeXmlValue(array[i][1]);
writeXmlValue(array[i][2]);
string endl("\n");
writeXmlValue(endl);
}
endXmlBlock();
return MS::kSuccess;
}
XmlCacheFormat::writeFloatVectorArray( const MFloatVectorArray& array )
{
int size = array.length();
assert(size != 0);
writeXmlTagValue(sizeTag,size);
startXmlBlock( floatVectorArrayTag );
for(int i = 0; i < size; i++)
{
writeXmlValue(array[i][0]);
writeXmlValue(array[i][1]);
writeXmlValue(array[i][2]);
string endl("\n");
writeXmlValue(endl);
}
endXmlBlock();
return MS::kSuccess;
}
unsigned
XmlCacheFormat::readArraySize()
{
MStringArray value;
if (readXmlTagValue(sizeTag, value))
{
unsigned readSize = (unsigned) atoi( value[0].asChar() );
return readSize;
}
return 0;
}
XmlCacheFormat::readDoubleArray( MDoubleArray& array, unsigned arraySize )
{
MStringArray value;
readXmlTagValue(doubleArrayTag, value);
assert( value.length() == arraySize );
array.setLength( arraySize );
for ( unsigned int i = 0; i < value.length(); i++ )
{
array[i] = strtod( value[i].asChar(), NULL );
}
return MS::kSuccess;
}
XmlCacheFormat::readFloatArray( MFloatArray& array, unsigned arraySize )
{
MStringArray value;
readXmlTagValue(floatArrayTag, value);
assert( value.length() == arraySize );
array.setLength( arraySize );
for ( unsigned int i = 0; i < value.length(); i++ )
{
array[i] = (float)strtod( value[i].asChar(), NULL );
}
return MS::kSuccess;
}
XmlCacheFormat::readDoubleVectorArray( MVectorArray& array, unsigned arraySize )
{
MStringArray value;
if( !readXmlTagValue(doubleVectorArrayTag, value) )
{
return MS::kFailure;
}
assert( value.length() == arraySize * 3 );
array.setLength( arraySize );
for (unsigned i = 0; i < arraySize; i++ )
{
double v[3];
v[0] = strtod( value[i*3].asChar(), NULL );
v[1] = strtod( value[i*3+1].asChar(), NULL );
v[2] = strtod( value[i*3+2].asChar(), NULL );
array.set( v, i );
}
return MS::kSuccess;
}
XmlCacheFormat::readFloatVectorArray( MFloatVectorArray& array, unsigned arraySize )
{
MStringArray value;
readXmlTagValue(floatVectorArrayTag, value);
assert( value.length() == arraySize * 3 );
array.clear();
array.setLength( arraySize );
for (unsigned i = 0; i < arraySize; i++ )
{
float v[3];
v[0] = (float)strtod( value[i*3].asChar(), NULL );
v[1] = (float)strtod( value[i*3+1].asChar(), NULL );
v[2] = (float)strtod( value[i*3+2].asChar(), NULL );
array.set(v,i);
}
return MS::kSuccess;
}
XmlCacheFormat::extension()
{
return fExtension;
}
// ****************************************
//
// Helper functions
//
void XmlCacheFormat::startXmlBlock( string& t )
{
fXmlStack.push(t);
fFile << "<" << t << ">\n";
}
void XmlCacheFormat::endXmlBlock()
{
string block = fXmlStack.top();
fFile << "</" << block << ">\n";
fXmlStack.pop();
}
void XmlCacheFormat::writeXmlTagValue( string& tag, string value )
{
for (unsigned int i = 0; i < fXmlStack.size(); i++ )
fFile << "\t";
fFile << "<" << tag << "> "; // Extra space is important for reading
fFile << value;
fFile << " </" << tag << ">\n"; // Extra space is important for reading
}
void XmlCacheFormat::writeXmlTagValue( string& tag, int value )
{
for (unsigned int i = 0; i < fXmlStack.size(); i++ )
fFile << "\t";
fFile << "<" << tag << "> "; // Extra space is important for reading
ostringstream oss;
oss << value;
fFile << oss.str();
fFile << " </" << tag << ">\n"; // Extra space is important for reading
}
bool XmlCacheFormat::readXmlTagValue( string tag, MStringArray& values )
{
string endTag = XMLENDTAG(tag);
bool status = true;
values.clear();
// Yes this could be much much smarter
if( findXmlStartTag(tag) )
{
string token;
fFile >> token;
while ( !fFile.eof() && token != endTag )
{
values.append( token.data() );
fFile >> token;
}
}
else
{
status = false;
}
return status;
}
bool XmlCacheFormat::readXmlTagValueInChunk( string tag, MStringArray& values )
{
string endTag = XMLENDTAG(tag);
bool status = true;
values.clear();
// Find the tag in the currently read chunk.
if( findXmlStartTagInChunk(tag) )
{
string token;
fFile >> token;
// Look for the values within the bounds of the tag.
while ( !fFile.eof() && token != endTag )
{
values.append( token.data() );
fFile >> token;
}
}
else
{
status = false;
}
return status;
}
void XmlCacheFormat::readXmlTag( string& value )
{
value.clear();
fFile >> value;
}
bool XmlCacheFormat::findXmlStartTag( string& tag )
{
string tagRead;
string tagExpected = XMLSTARTTAG(tag);
fFile >> tagRead;
// Keep looking all the way to EOF
while(!fFile.eof() && tagRead != tagExpected)
{
fFile >> tagRead;
}
if( tagRead != tagExpected )
{
}
return ( tagRead == tagExpected );
}
bool XmlCacheFormat::findXmlStartTagInChunk( string& tag )
//
// Look for the given tag within the currently read chunk.
//
{
string tagRead;
string tagExpected = XMLSTARTTAG(tag);
string tagEndChunk("</"+chunkTag+">");
fFile >> tagRead;
// Keep looking all the way to EOF
while((!fFile.eof()) && (tagRead != tagExpected) && (tagRead != tagEndChunk))
{
fFile >> tagRead;
}
if( (tagRead != tagExpected) && (tagRead != tagEndChunk) )
{
}
return ( tagRead == tagExpected );
}
bool XmlCacheFormat::findXmlEndTag(string& tag)
{
string tagRead;
string tagExpected("</"+tag+">");
fFile >> tagRead;
if( tagRead != tagExpected )
{
}
return ( tagRead == tagExpected );
}
void XmlCacheFormat::writeXmlValue( string& value )
{
fFile << value << " ";
}
void XmlCacheFormat::writeXmlValue( double value )
{
fFile << value << " ";
}
void XmlCacheFormat::writeXmlValue( float value )
{
fFile << value << " ";
}
void XmlCacheFormat::writeXmlValue( int value )
{
fFile << value << " ";
}
// ****************************************
MStatus initializePlugin( MObject obj )
{
MFnPlugin plugin( obj, PLUGIN_COMPANY, "1.0", "Any" );
plugin.registerCacheFormat(
XmlCacheFormat::translatorName(),
XmlCacheFormat::creator
);
return MS::kSuccess;
}
MStatus uninitializePlugin( MObject obj )
{
MFnPlugin plugin( obj );
plugin.deregisterCacheFormat( XmlCacheFormat::translatorName() );
return MS::kSuccess;
}