// Decide if the dag is in the model. Dag paths and names
// may not be setup if the dag has not been added to
// the model.
static bool dagNotInModel( MDagPath& dagPath )
{
MStatus status;
MFnDagNode dagFn( dagPath, &status );
if ( status.error() )
return false;
bool inModel = dagFn.inModel( &status );
if ( status.error() )
return false;
return ( inModel == false );
}
// Node added to model callback.
static void userNodeRemovedCB(MObject& node,void *clientData)
{
if (! node.isNull()) {
bool doDisplay = true;
MStatus status;
MFnDagNode dagNode(node,&status);
if ( status.error() ) {
doDisplay = false;
MGlobal::displayInfo("Error: failed to get dag node.");
}
if ( doDisplay ) {
MString s = dagNode.name();
MString info("DAG Model - Node removed: ");
info+= s;
MGlobal::displayInfo(info);
}
}
// remove the callback
MCallbackId id = MMessage::currentCallbackId();
MMessage::removeCallback(id);
}
// Node added to model callback.
static void userNodeAddedCB(MObject& node,void *clientData)
{
MStatus status;
if (! node.isNull()) {
bool doDisplay = true;
MDagPath path;
status = MDagPath::getAPathTo(node,path);
if ( status.error() ) {
doDisplay = false;
MGlobal::displayInfo("Error: failed to get dag path to node.");
}
if ( doDisplay ) {
MString s = path.fullPathName();
MString info("DAG Model - Node added: ");
info+= s;
path.transform(&status);
if (MS::kInvalidParameter == status) {
info += "(WORLD)";
}
MGlobal::displayInfo(info);
}
}
// remove the callback
MCallbackId id = MMessage::currentCallbackId();
MMessage::removeCallback(id);
// listen for removal message
/* MCallbackId id = */ MModelMessage::addNodeRemovedFromModelCallback( node, userNodeRemovedCB, 0, &status );
if ( status.error() ) {
MGlobal::displayError("Failed to install node removed from model callback.\n");
return;
}
}
// Install a node added callback for the node specified
// by dagPath.
static void installNodeAddedCallback( MDagPath& dagPath )
{
MStatus status;
MObject dagNode = dagPath.node();
if ( dagNode.isNull() )
return;
/* MCallbackId id = */ MModelMessage::addNodeAddedToModelCallback( dagNode, userNodeAddedCB, 0, &status );
if ( status.error() ) {
MGlobal::displayError("Failed to install node added to model callback.\n");
return;
}
}
MStatus nodeCreatedCB::doIt( const MArgList& args )
//
// Description:
// implements the MEL nodeCreatedCB command.
//
{
MStatus stat = MS::kSuccess;
MArgDatabase argData( syntax(), args );
// Parse command flags.
//
if ( argData.isFlagSet( kRegisterFlag ) ) {
// Register a new procedure.
//
MString proc;
argData.getFlagArgument( kRegisterFlag, 0, proc );
stat = registerMelProc( proc, argData.isFlagSet( kFullDagPathFlag ) );
} else if ( argData.isFlagSet( kUnregisterFlag ) ) {
// Unregister a procedure.
//
MString proc;
argData.getFlagArgument( kUnregisterFlag, 0, proc );
stat = unregisterMelProc( proc );
} else if ( argData.isFlagSet( kFilterFlag ) ) {
// Change the filter being applied.
//
MString filter;
argData.getFlagArgument( kFilterFlag, 0, filter );
stat = changeFilter( filter );
}
if ( stat.error() ) {
MGlobal::displayError( stat.errorString() );
}
return stat;
}
MStatus geometrySurfaceConstraintCommand::parseArgs(const MArgList &argList)
{
MStatus ReturnStatus;
MArgDatabase argData(syntax(), argList, &ReturnStatus);
if ( ReturnStatus.error() )
return MS::kFailure;
// Settings only work at creation time. Would need an
// attribute on the node in order to push this state
// into the node at any time.
ConstraintType typ;
if (argData.isFlagSet(kConstrainToLargestWeightFlag))
typ = geometrySurfaceConstraintCommand::kLargestWeight;
else if (argData.isFlagSet(kConstrainToSmallestWeightFlag))
typ = geometrySurfaceConstraintCommand::kSmallestWeight;
else
typ = geometrySurfaceConstraintCommand::kLargestWeight;
weightType = typ;
// Need parent to process
return MS::kUnknownParameter;
}
void
OsdPtexMeshData::rebuildHbrMeshIfNeeded(OpenSubdivPtexShader *shader)
{
MStatus status;
if (!_meshTopoDirty && !shader->getHbrMeshDirty())
return;
MFnMesh meshFn(_meshDagPath, &status);
if (status != MS::kSuccess) return;
int level = shader->getLevel();
if (level < 1) level =1;
SchemeType scheme = shader->getScheme();
if (scheme == kLoop) scheme = kCatmark; // XXX: avoid loop for now
// Get Maya vertex topology and crease data
MIntArray vertexCount;
MIntArray vertexList;
meshFn.getVertices(vertexCount, vertexList);
MUintArray edgeIds;
MDoubleArray edgeCreaseData;
meshFn.getCreaseEdges(edgeIds, edgeCreaseData);
MUintArray vtxIds;
MDoubleArray vtxCreaseData;
meshFn.getCreaseVertices(vtxIds, vtxCreaseData);
if (vertexCount.length() == 0) return;
// Cache attribute values
_level = shader->getLevel();
_scheme = shader->getScheme();
_kernel = shader->getKernel();
_adaptive = shader->isAdaptive();
_interpBoundary = shader->getInterpolateBoundary();
// Copy Maya vectors into std::vectors
std::vector<int> numIndices(&vertexCount[0], &vertexCount[vertexCount.length()]);
std::vector<int> faceIndices(&vertexList[0], &vertexList[vertexList.length()]);
std::vector<int> vtxCreaseIndices(&vtxIds[0], &vtxIds[vtxIds.length()]);
std::vector<double> vtxCreases(&vtxCreaseData[0], &vtxCreaseData[vtxCreaseData.length()]);
std::vector<double> edgeCreases(&edgeCreaseData[0], &edgeCreaseData[edgeCreaseData.length()]);
// Edge crease index is stored as pairs of vertex ids
int nEdgeIds = edgeIds.length();
std::vector<int> edgeCreaseIndices;
edgeCreaseIndices.resize(nEdgeIds*2);
for (int i = 0; i < nEdgeIds; ++i) {
int2 vertices;
status = meshFn.getEdgeVertices(edgeIds[i], vertices);
if (status.error()) {
status.perror("ERROR can't get creased edge vertices");
continue;
}
edgeCreaseIndices[i*2] = vertices[0];
edgeCreaseIndices[i*2+1] = vertices[1];
}
// Convert attribute enums to HBR enums (this is why the enums need to match)
// XXX use some sort of built-in transmorgification avoid assumption?
HbrMeshUtil::SchemeType hbrScheme = (HbrMeshUtil::SchemeType) _scheme;
OsdHbrMesh::InterpolateBoundaryMethod hbrInterpBoundary =
(OsdHbrMesh::InterpolateBoundaryMethod) _interpBoundary;
// Convert Maya mesh to internal HBR representation
_hbrmesh = ConvertToHBR(meshFn.numVertices(), numIndices, faceIndices,
vtxCreaseIndices, vtxCreases,
std::vector<int>(), std::vector<float>(),
edgeCreaseIndices, edgeCreases,
hbrInterpBoundary,
hbrScheme,
true ); // add ptex indices to HBR
// note: GL function can't be used in prepareForDraw API.
_needsInitializeMesh = true;
// Mesh topology data is up to date
_meshTopoDirty = false;
shader->setHbrMeshDirty(false);
}
// #### rebuildHbrMeshIfNeeded
//
// If the topology of the mesh changes, or any attributes that affect
// how the mesh is computed the original HBR needs to be rebuilt
// which will trigger a rebuild of the FAR mesh and subsequent buffers.
//
void
OsdMeshData::rebuildHbrMeshIfNeeded(OpenSubdivShader *shader)
{
MStatus status = MS::kSuccess;
if (!_meshTopoDirty && !shader->getHbrMeshDirty())
return;
MFnMesh meshFn(_meshDagPath);
// Cache attribute values
_level = shader->getLevel();
_kernel = shader->getKernel();
_adaptive = shader->isAdaptive();
_uvSet = shader->getUVSet();
// Get Maya vertex topology and crease data
MIntArray vertexCount;
MIntArray vertexList;
meshFn.getVertices(vertexCount, vertexList);
MUintArray edgeIds;
MDoubleArray edgeCreaseData;
meshFn.getCreaseEdges(edgeIds, edgeCreaseData);
MUintArray vtxIds;
MDoubleArray vtxCreaseData;
meshFn.getCreaseVertices(vtxIds, vtxCreaseData);
if (vertexCount.length() == 0) return;
// Copy Maya vectors into std::vectors
std::vector<int> numIndices(&vertexCount[0], &vertexCount[vertexCount.length()]);
std::vector<int> faceIndices(&vertexList[0], &vertexList[vertexList.length()]);
std::vector<int> vtxCreaseIndices(&vtxIds[0], &vtxIds[vtxIds.length()]);
std::vector<double> vtxCreases(&vtxCreaseData[0], &vtxCreaseData[vtxCreaseData.length()]);
std::vector<double> edgeCreases(&edgeCreaseData[0], &edgeCreaseData[edgeCreaseData.length()]);
// Edge crease index is stored as pairs of vertex ids
int nEdgeIds = edgeIds.length();
std::vector<int> edgeCreaseIndices;
edgeCreaseIndices.resize(nEdgeIds*2);
for (int i = 0; i < nEdgeIds; ++i) {
int2 vertices;
status = meshFn.getEdgeVertices(edgeIds[i], vertices);
if (status.error()) {
MERROR(status, "OpenSubdivShader: Can't get edge vertices");
continue;
}
edgeCreaseIndices[i*2] = vertices[0];
edgeCreaseIndices[i*2+1] = vertices[1];
}
// Convert attribute enums to HBR enums (this is why the enums need to match)
HbrMeshUtil::SchemeType hbrScheme = (HbrMeshUtil::SchemeType) shader->getScheme();
OsdHbrMesh::InterpolateBoundaryMethod hbrInterpBoundary =
(OsdHbrMesh::InterpolateBoundaryMethod) shader->getInterpolateBoundary();
OsdHbrMesh::InterpolateBoundaryMethod hbrInterpUVBoundary =
(OsdHbrMesh::InterpolateBoundaryMethod) shader->getInterpolateUVBoundary();
// clear any existing face-varying descriptor
if (_fvarDesc) {
delete _fvarDesc;
_fvarDesc = NULL;
}
// read UV data from maya and build per-face per-vert list of UVs for HBR face-varying data
std::vector< float > uvList;
status = buildUVList( meshFn, uvList );
if (! status.error()) {
// Create face-varying data descriptor. The memory required for indices
// and widths needs to stay alive as the HBR library only takes in the
// pointers and assumes the client will maintain the memory so keep _fvarDesc
// around as long as _hbrmesh is around.
int fvarIndices[] = { 0, 1 };
int fvarWidths[] = { 1, 1 };
_fvarDesc = new FVarDataDesc( 2, fvarIndices, fvarWidths, 2, hbrInterpUVBoundary );
}
if (_fvarDesc && hbrScheme != HbrMeshUtil::kCatmark) {
MGlobal::displayWarning("Face-varying not yet supported for Loop/Bilinear, using Catmull-Clark");
hbrScheme = HbrMeshUtil::kCatmark;
}
// Convert Maya mesh to internal HBR representation
_hbrmesh = ConvertToHBR(meshFn.numVertices(), numIndices, faceIndices,
vtxCreaseIndices, vtxCreases,
std::vector<int>(), std::vector<float>(),
edgeCreaseIndices, edgeCreases,
hbrInterpBoundary,
hbrScheme,
false, // no ptex
_fvarDesc,
_fvarDesc?&uvList:NULL); // yes fvar (if have UVs)
// note: GL function can't be used in prepareForDraw API.
_needsInitializeMesh = true;
// Mesh topology data is up to date
_meshTopoDirty = false;
shader->setHbrMeshDirty(false);
}
MStatus puttyNode::deform( MDataBlock& block, MItGeometry& iter, const MMatrix& worldMatrix, unsigned int multiIndex)
{
// MGlobal::displayInfo("deform");
MStatus status = MS::kSuccess;
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// get inputs
//
// get the node ready flag
MDataHandle dh = block.inputValue(aScriptSourced,&status);
SYS_ERROR_CHECK(status, "Error getting aScriptSourced data handle\n");
bool scriptSourced = dh.asBool();
if (!scriptSourced)
return MS::kSuccess;
dh = block.inputValue(aNodeReady,&status);
SYS_ERROR_CHECK(status, "Error getting node ready data handle\n");
bool nodeReady = dh.asBool();
// if it's not ready, don't do anything
if (!nodeReady)
return MS::kSuccess;
dh = block.inputValue(aDefSpace,&status);
SYS_ERROR_CHECK(status, "Error getting defSpace data handle\n");
short defSpace = dh.asShort();
dh = block.inputValue(aDefWeights,&status);
SYS_ERROR_CHECK(status, "Error getting defWeights data handle\n");
short defWeights = dh.asShort();
dh = block.inputValue(aDefEnvelope,&status);
SYS_ERROR_CHECK(status, "Error getting defEnvelope data handle\n");
short defEnvelope = dh.asShort();
// get the command
dh = block.inputValue(aCmdBaseName,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName handle\n");
MString script = dh.asString();
/* if (script == "")
{
status = MS::kFailure;
USER_ERROR_CHECK(status, "no script provided!\n");
}
*/
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// build mel cmd string
//
// check if it's a valid cmd
// get the envelope
//
double env = 1;
if (defEnvelope == MSD_ENVELOPE_AUTO)
{
dh = block.inputValue(envelope,&status);
SYS_ERROR_CHECK(status, "Error getting envelope data handle\n");
env = double(dh.asFloat());
// early stop 'cause there is nothing more to do
if (env == 0.0)
return MS::kSuccess;
}
// get the points, transform them into the right space if needed
//
int count = iter.count();
MVectorArray points(count);
for ( ; !iter.isDone(); iter.next())
points[iter.index()] = iter.position();
if ( defSpace == MSD_SPACE_WORLD )
{
for (int i = 0;i<count;i++)
points[i] = MPoint(points[i]) * worldMatrix;
}
// get the weights
//
MDoubleArray weights;
if ( defWeights == MSD_WEIGHTS_AUTO)
{
weights.setLength(count);
for (int i = 0;i<count;i++)
weights[i] = weightValue(block,multiIndex,i);
}
// get the object name and type
// get the input geometry, traverse through the data handles
MArrayDataHandle adh = block.outputArrayValue( input, &status );
SYS_ERROR_CHECK(status,"error getting input array data handle.\n");
status = adh.jumpToElement( multiIndex );
SYS_ERROR_CHECK(status, "input jumpToElement failed.\n");
// compound data
MDataHandle cdh = adh.inputValue( &status );
SYS_ERROR_CHECK(status, "error getting input inputValue\n");
// input geometry child
dh = cdh.child( inputGeom );
MObject dInputGeometry = dh.data();
// get the type
MString geometryType = dInputGeometry.apiTypeStr();
// get the name
// MFnDagNode dagFn( dInputGeometry, &status);
// SYS_ERROR_CHECK(status, "error converting geometry obj to dag node\n");
// MString geometryName = dagFn.fullPathName(&status);
// SYS_ERROR_CHECK(status, "error getting full path name \n");
// MString geometryType = "";
// MString geometryName = "";
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// set the current values on the temp plugs for the script to be picked up
//
// the position
MObject thisNode = thisMObject();
MPlug currPlug(thisNode,aCurrPosition);
MFnVectorArrayData vecD;
MObject currObj = vecD.create(points,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currPosPlug value\n");
// the weights
currPlug =MPlug(thisNode,aCurrWeight);
MFnDoubleArrayData dblD;
currObj = dblD.create(weights,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currWeightsPlug value\n");
// world matrix
currPlug =MPlug(thisNode,aCurrWorldMatrix);
MFnMatrixData matD;
currObj = matD.create(worldMatrix,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currWorldMatrixPlug value\n");
// the multi index
currPlug =MPlug(thisNode,aCurrMultiIndex);
currPlug.setValue(int(multiIndex));
SYS_ERROR_CHECK(status, "error setting currMultiIndexPlug value\n");
// geometry name/type
// currPlug =MPlug(thisNode,aCurrGeometryName);
// currPlug.setValue(geometryName);
// SYS_ERROR_CHECK(status, "error setting aCurrGeometryName value\n");
currPlug =MPlug(thisNode,aCurrGeometryType);
currPlug.setValue(geometryType);
SYS_ERROR_CHECK(status, "error setting aCurrGeometryType value\n");
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// execute the mel script
//
MString melCmd = script+"(\"" +name()+"\","+count+")";
MCommandResult melResult;
status = MGlobal::executeCommand(melCmd,melResult);
// if the command did not work, then try to resource the script
// (might have been that we were in a fresh scene and nothing was ready yet
if (status != MS::kSuccess)
{
dh = block.inputValue(aScript,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName handle\n");
MString scriptFile = dh.asString();
// try to source the script
MString cmd = "source \"" + scriptFile+"\"";
MCommandResult melResult;
status = MGlobal::executeCommand(cmd,melResult);
// if successfull, retry the command
if (!status.error())
{
status = MGlobal::executeCommand(melCmd,melResult);
}
}
USER_ERROR_CHECK(status, "Error executing mel command, please check the function you provided is valid, error free and has the appropriate parameters!");
// check the result type
if ((melResult.resultType()) != (MCommandResult::kDoubleArray))
{
USER_ERROR_CHECK(MS::kFailure, "result of mel command has wrong type, should be doubleArray (which will be interpreted as vectorArray)!");
}
// get the result as a double array
MDoubleArray newP;
status = melResult.getResult(newP);
USER_ERROR_CHECK(status, "Error getting result of mel command!");
int newCount = newP.length()/3;
// size check
if (newCount != count)
{
USER_ERROR_CHECK(MS::kFailure, "the size of the result does not match the size of the input!");
}
// convert the double array into a vector array
MPointArray newPoints(newCount);
for(int i=0;i<newCount;i++)
newPoints[i]=MPoint(newP[i*3],newP[i*3+1],newP[i*3+2]);
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// interprete and apply the result
//
// do the envelope and weights
if ((defEnvelope == MSD_ENVELOPE_AUTO)||((defWeights == MSD_WEIGHTS_AUTO)))
{
MDoubleArray envPP(count, env);
if (defWeights == MSD_WEIGHTS_AUTO)
{
for (int i = 0;i<count;i++)
envPP[i] *= weights[i];
}
// linear interpolation between old and new points
for (int i = 0;i<count;i++)
newPoints[i] = (points[i] * (1-envPP[i])) + (newPoints[i] * envPP[i]);
}
// retransform the result if it was in world space
if ( defSpace == MSD_SPACE_WORLD )
{
MMatrix worldMatrixInv = worldMatrix.inverse();
for (int i = 0;i<count;i++)
newPoints[i] *= worldMatrixInv;
}
// set the points
iter.reset();
for ( ; !iter.isDone(); iter.next())
iter.setPosition(newPoints[iter.index()]);
return status;
}
MStatus puttyNode::compute( const MPlug& plug, MDataBlock& block )
{
MStatus status;
if ( plug == aNodeReady )
{
// MGlobal::displayInfo("compute");
bool result =false;
MString cmdBaseName;
// get the source flag
MDataHandle dh = block.inputValue(aSource,&status);
SYS_ERROR_CHECK(status, "Error getting source data handle\n");
bool source = dh.asBool();
// get the command
dh = block.inputValue(aScript,&status);
SYS_ERROR_CHECK(status, "Error getting reload script handle\n");
MString script = dh.asString();
if (script == "")
{
MGlobal::displayError("no script provided!\n");
}
else
{
// chech if script is sourced
dh = block.inputValue(aScriptSourced,&status);
SYS_ERROR_CHECK(status, "Error getting aScriptSourced data handle\n");
bool scriptSourced = dh.asBool();
// if it's not ready, don't do anything
if (!scriptSourced)
return MS::kSuccess;
else
{
MCommandResult melResult;
// now get the real name of the function and store it in a separate attribute
MString cmd="basenameEx \"" + script+"\"";
status = MGlobal::executeCommand(cmd,melResult);
melResult.getResult(cmdBaseName);
result = true;
MDataHandle dhCBN = block.outputValue(aCmdBaseName,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName data handle\n");
dhCBN.set(cmdBaseName);
dhCBN.setClean();
// see if an interface function is present, if yes, execute it
cmd= "if(exists(\"" + cmdBaseName +".interface\")) {";
cmd+= "string $attr[] = `deleteAttr -q " +name()+"`; string $a;";
cmd+="for($a in $attr) deleteAttr (\""+name()+".\"+$a);";
cmd+= cmdBaseName +".interface(\"" +name()+"\");}";
status = MGlobal::executeCommand(cmd);
}
}
// check the current status
// set the result
MDataHandle dhNodeReady = block.outputValue(aNodeReady,&status);
SYS_ERROR_CHECK(status, "Error getting reload data handle\n");
dhNodeReady.set(result);
dhNodeReady.setClean();
return MS::kSuccess;
}
else if (plug==aScriptSourced)
{
// this part of the function sources the script
// try to source the script
// cerr << "\nsource";
MStatus status;
bool result = true;
// get the source flag
MDataHandle dh = block.inputValue(aSource,&status);
SYS_ERROR_CHECK(status, "Error getting source data handle\n");
bool source = dh.asBool();
// get the script
dh = block.inputValue(aScript,&status);
SYS_ERROR_CHECK(status, "Error getting reload script handle\n");
MString script = dh.asString();
MString cmd = "source \"" + script+"\"";
MCommandResult melResult;
status = MGlobal::executeCommand(cmd,melResult);
if (status.error())
{
MGlobal::displayError( "Error sourcing mel script, please check the function you provided is valid!");
result = false;
}
// set the result
MDataHandle dhScriptSourced = block.outputValue(aScriptSourced,&status);
SYS_ERROR_CHECK(status, "Error getting ScriptSourced data handle\n");
dhScriptSourced.set(result);
dhScriptSourced.setClean();
return MS::kSuccess;
}
return MS::kUnknownParameter;
}
void exportF3d::setF3dField(MFnFluid &fluidFn, const char *outputPath,
const MDagPath &dagPath)
{
try {
MStatus stat;
unsigned int i, xres = 0, yres = 0, zres = 0;
double xdim,ydim,zdim;
// Get the resolution of the fluid container
stat = fluidFn.getResolution(xres, yres, zres);
stat = fluidFn.getDimensions(xdim, ydim, zdim);
V3d size(xdim,ydim,zdim);
const V3i res(xres, yres, zres);
int psizeTot = fluidFn.gridSize();
/// get the transform and rotation
MObject parentObj = fluidFn.parent(0, &stat);
if (stat != MS::kSuccess) {
MGlobal::displayError("Can't find fluid's parent node");
return;
}
MDagPath parentPath = dagPath;
parentPath.pop();
MTransformationMatrix tmatFn(dagPath.inclusiveMatrix());
if (stat != MS::kSuccess) {
MGlobal::displayError("Failed to get transformation matrix of fluid's parent node");
return;
}
MFnTransform fnXform(parentPath, &stat);
if (stat != MS::kSuccess) {
MGlobal::displayError("Can't create a MFnTransform from fluid's parent node");
return;
}
if (m_verbose)
{
fprintf(stderr, "cellnum: %dx%dx%d = %d\n",
xres, yres, zres,psizeTot);
}
float *density(NULL), *temp(NULL), *fuel(NULL);
float *pressure(NULL), *falloff(NULL);
density = fluidFn.density( &stat );
if ( stat.error() ) m_density = false;
temp = fluidFn.temperature( &stat );
if ( stat.error() ) m_temperature = false;
fuel = fluidFn.fuel( &stat );
if ( stat.error() ) m_fuel = false;
pressure= fluidFn.pressure( &stat );
if ( stat.error() ) m_pressure = false;
falloff = fluidFn.falloff( &stat );
if ( stat.error() ) m_falloff = false;
float *r,*g,*b;
if (m_color) {
stat = fluidFn.getColors(r,b,g);
if ( stat.error() ) m_color = false;
}else
m_color = false;
float *u,*v,*w;
if (m_texture) {
stat = fluidFn.getCoordinates(u,v,w);
if ( stat.error() ) m_texture = false;
}else
m_texture = false;
/// velocity info
float *Xvel(NULL),*Yvel(NULL), *Zvel(NULL);
if (m_vel) {
stat = fluidFn.getVelocity( Xvel,Yvel,Zvel );
if ( stat.error() ) m_vel = false;
}
if (m_density == false && m_temperature==false && m_fuel==false &&
m_pressure==false && m_falloff==false && m_vel == false &&
m_color == false && m_texture==false)
{
MGlobal::displayError("No fluid attributes found for writing, please check fluids settings");
return;
}
/// Fields
DenseFieldf::Ptr densityFld, tempFld, fuelFld, pressureFld, falloffFld;
DenseField3f::Ptr CdFld, uvwFld;
MACField3f::Ptr vMac;
MPlug autoResizePlug = fluidFn.findPlug("autoResize", &stat);
bool autoResize;
autoResizePlug.getValue(autoResize);
// maya's fluid transformation
V3d dynamicOffset(0);
M44d localToWorld;
MatrixFieldMapping::Ptr mapping(new MatrixFieldMapping());
M44d fluid_mat(tmatFn.asMatrix().matrix);
if(autoResize) {
fluidFn.findPlug("dofx").getValue(dynamicOffset[0]);
fluidFn.findPlug("dofy").getValue(dynamicOffset[1]);
fluidFn.findPlug("dofz").getValue(dynamicOffset[2]);
}
Box3i extents;
extents.max = res - V3i(1);
extents.min = V3i(0);
mapping->setExtents(extents);
localToWorld.setScale(size);
localToWorld *= M44d().setTranslation( -(size*0.5) );
localToWorld *= M44d().setTranslation( dynamicOffset );
localToWorld *= fluid_mat;
mapping->setLocalToWorld(localToWorld);
if (m_density){
densityFld = new DenseFieldf;
densityFld->setSize(res);
densityFld->setMapping(mapping);
}
if (m_fuel){
fuelFld = new DenseFieldf;
fuelFld->setSize(res);
fuelFld->setMapping(mapping);
}
if (m_temperature){
tempFld = new DenseFieldf;
tempFld->setSize(res);
tempFld->setMapping(mapping);
}
if (m_pressure){
pressureFld = new DenseFieldf;
pressureFld->setSize(res);
pressureFld->setMapping(mapping);
}
if (m_falloff){
falloffFld = new DenseFieldf;
falloffFld->setSize(res);
falloffFld->setMapping(mapping);
}
if (m_vel){
vMac = new MACField3f;
vMac->setSize(res);
vMac->setMapping(mapping);
}
if (m_color){
CdFld = new DenseField3f;
CdFld->setSize(res);
CdFld->setMapping(mapping);
}
if (m_texture){
uvwFld = new DenseField3f;
uvwFld->setSize(res);
uvwFld->setMapping(mapping);
}
size_t iX, iY, iZ;
for( iZ = 0; iZ < zres; iZ++ )
{
for( iX = 0; iX < xres; iX++ )
{
for( iY = 0; iY < yres ; iY++ )
{
/// data is in x major but we are writting in z major order
i = fluidFn.index( iX, iY, iZ);
if ( m_density )
densityFld->lvalue(iX, iY, iZ) = density[i];
if ( m_temperature )
tempFld->lvalue(iX, iY, iZ) = temp[i];
if ( m_fuel )
fuelFld->lvalue(iX, iY, iZ) = fuel[i];
if ( m_pressure )
pressureFld->lvalue(iX, iY, iZ) = pressure[i];
if ( m_falloff )
falloffFld->lvalue(iX, iY, iZ) = falloff[i];
if (m_color)
CdFld->lvalue(iX, iY, iZ) = V3f(r[i], g[i], b[i]);
if (m_texture)
uvwFld->lvalue(iX, iY, iZ) = V3f(u[i], v[i], w[i]);
}
}
}
if (m_vel) {
unsigned x,y,z;
for(z=0;z<zres;++z) for(y=0;y<yres;++y) for(x=0;x<xres+1;++x) {
vMac->u(x,y,z) = *Xvel++;
}
for(z=0;z<zres;++z) for(y=0;y<yres+1;++y) for(x=0;x<xres;++x) {
vMac->v(x,y,z) = *Yvel++;
}
for(z=0;z<zres+1;++z) for(y=0;y<yres;++y) for(x=0;x<xres;++x) {
vMac->w(x,y,z) = *Zvel++;
}
}
Field3DOutputFile out;
if (!out.create(outputPath)) {
MGlobal::displayError("Couldn't create file: "+ MString(outputPath));
return;
}
string fieldname("maya");
if (m_density){
out.writeScalarLayer<float>(fieldname, "density", densityFld);
}
if (m_fuel) {
out.writeScalarLayer<float>(fieldname,"fuel", fuelFld);
}
if (m_temperature){
out.writeScalarLayer<float>(fieldname,"temperature", tempFld);
}
if (m_color) {
out.writeVectorLayer<float>(fieldname,"Cd", CdFld);
}
if (m_vel)
out.writeVectorLayer<float>(fieldname,"v_mac", vMac);
out.close();
}
catch(const std::exception &e)
{
MGlobal::displayError( MString(e.what()) );
return;
}
}