MStatus AlembicNode::compute(const MPlug & plug, MDataBlock & dataBlock)
{
MStatus status;
// update the frame number to be imported
MDataHandle speedHandle = dataBlock.inputValue(mSpeedAttr, &status);
double speed = speedHandle.asDouble();
MDataHandle offsetHandle = dataBlock.inputValue(mOffsetAttr, &status);
double offset = offsetHandle.asDouble();
MDataHandle timeHandle = dataBlock.inputValue(mTimeAttr, &status);
MTime t = timeHandle.asTime();
double inputTime = t.as(MTime::kSeconds);
double fps = getFPS();
// scale and offset inputTime.
inputTime = computeAdjustedTime(inputTime, speed, offset/fps);
// this should be done only once per file
if (mFileInitialized == false)
{
mFileInitialized = true;
//Get list of input filenames
MFnDependencyNode depNode(thisMObject());
MPlug layerFilesPlug = depNode.findPlug("abc_layerFiles");
MFnStringArrayData fnSAD( layerFilesPlug.asMObject() );
MStringArray storedFilenames = fnSAD.array();
//Legacy support for single-filename input
if( storedFilenames.length() == 0 )
{
MFileObject fileObject;
MDataHandle dataHandle = dataBlock.inputValue(mAbcFileNameAttr);
fileObject.setRawFullName(dataHandle.asString());
MString fileName = fileObject.resolvedFullName();
storedFilenames.append( fileName );
}
std::vector<std::string> abcFilenames;
for(unsigned int i = 0; i < storedFilenames.length(); i++)
abcFilenames.push_back( storedFilenames[i].asChar() );
Alembic::Abc::IArchive archive;
Alembic::AbcCoreFactory::IFactory factory;
factory.setPolicy(Alembic::Abc::ErrorHandler::kQuietNoopPolicy);
archive = factory.getArchive( abcFilenames );
if (!archive.valid())
{
MString theError = "Error opening these alembic files: ";
const unsigned int numFilenames = storedFilenames.length();
for( unsigned int i = 0; i < numFilenames; i++ )
{
theError += storedFilenames[ i ];
if( i != (numFilenames - 1) )
theError += ", ";
}
printError(theError);
}
// initialize some flags for plug update
mSubDInitialized = false;
mPolyInitialized = false;
// When an alembic cache will be imported at the first time using
// AbcImport, we need to set mIncludeFilterAttr (filterHandle) to be
// mIncludeFilterString for later use. When we save a maya scene(.ma)
// mIncludeFilterAttr will be saved. Then when we load the saved
// .ma file, mIncludeFilterString will be set to be mIncludeFilterAttr.
MDataHandle includeFilterHandle =
dataBlock.inputValue(mIncludeFilterAttr, &status);
MString& includeFilterString = includeFilterHandle.asString();
if (mIncludeFilterString.length() > 0)
{
includeFilterHandle.set(mIncludeFilterString);
dataBlock.setClean(mIncludeFilterAttr);
}
else if (includeFilterString.length() > 0)
{
mIncludeFilterString = includeFilterString;
}
MDataHandle excludeFilterHandle =
dataBlock.inputValue(mExcludeFilterAttr, &status);
MString& excludeFilterString = excludeFilterHandle.asString();
if (mExcludeFilterString.length() > 0)
{
excludeFilterHandle.set(mExcludeFilterString);
dataBlock.setClean(mExcludeFilterAttr);
}
else if (excludeFilterString.length() > 0)
{
mExcludeFilterString = excludeFilterString;
}
MFnDependencyNode dep(thisMObject());
MPlug allSetsPlug = dep.findPlug("allColorSets");
CreateSceneVisitor visitor(inputTime, !allSetsPlug.isNull(),
MObject::kNullObj, CreateSceneVisitor::NONE, "",
mIncludeFilterString, mExcludeFilterString);
visitor.walk(archive);
if (visitor.hasSampledData())
{
// information retrieved from the hierarchy traversal
// and given to AlembicNode to provide update
visitor.getData(mData);
mData.getFrameRange(mSequenceStartTime, mSequenceEndTime);
MDataHandle startFrameHandle = dataBlock.inputValue(mStartFrameAttr,
&status);
startFrameHandle.set(mSequenceStartTime*fps);
MDataHandle endFrameHandle = dataBlock.inputValue(mEndFrameAttr,
&status);
endFrameHandle.set(mSequenceEndTime*fps);
}
}
// Retime
MDataHandle cycleHandle = dataBlock.inputValue(mCycleTypeAttr, &status);
short playType = cycleHandle.asShort();
inputTime = computeRetime(inputTime, mSequenceStartTime, mSequenceEndTime,
playType);
clamp<double>(mSequenceStartTime, mSequenceEndTime, inputTime);
// update only when the time lapse is big enough
if (fabs(inputTime - mCurTime) > 0.00001)
{
mOutRead = std::vector<bool>(mOutRead.size(), false);
mCurTime = inputTime;
}
if (plug == mOutPropArrayAttr)
{
if (mOutRead[0])
{
dataBlock.setClean(plug);
return MS::kSuccess;
}
mOutRead[0] = true;
unsigned int propSize =
static_cast<unsigned int>(mData.mPropList.size());
if (propSize > 0)
{
MArrayDataHandle outArrayHandle = dataBlock.outputValue(
mOutPropArrayAttr, &status);
unsigned int outHandleIndex = 0;
MDataHandle outHandle;
// for all of the nodes with sampled attributes
for (unsigned int i = 0; i < propSize; i++)
{
// only use the handle if it matches the index.
// The index wont line up in the sparse case so we
// can just skip that element.
if (outArrayHandle.elementIndex() == outHandleIndex++)
{
outHandle = outArrayHandle.outputValue();
}
else
{
continue;
}
if (mData.mPropList[i].mArray.valid())
{
readProp(mCurTime, mData.mPropList[i].mArray, outHandle);
}
else if (mData.mPropList[i].mScalar.valid())
{
// for visibility only
if (mData.mPropList[i].mScalar.getName() ==
Alembic::AbcGeom::kVisibilityPropertyName)
{
Alembic::Util::int8_t visVal = 1;
mData.mPropList[i].mScalar.get(&visVal,
Alembic::Abc::ISampleSelector(mCurTime,
Alembic::Abc::ISampleSelector::kNearIndex ));
outHandle.setGenericBool(visVal != 0, false);
}
else
{
// for all scalar props
readProp(mCurTime, mData.mPropList[i].mScalar, outHandle);
}
}
outArrayHandle.next();
}
outArrayHandle.setAllClean();
}
}
else if (plug == mOutTransOpArrayAttr )
{
if (mOutRead[1])
{
dataBlock.setClean(plug);
return MS::kSuccess;
}
mOutRead[1] = true;
unsigned int xformSize =
static_cast<unsigned int>(mData.mXformList.size());
if (xformSize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutTransOpArrayAttr, &status);
MPlug arrayPlug(thisMObject(), mOutTransOpArrayAttr);
MDataHandle outHandle;
unsigned int outHandleIndex = 0;
for (unsigned int i = 0; i < xformSize; i++)
{
std::vector<double> sampleList;
if (mData.mIsComplexXform[i])
{
readComplex(mCurTime, mData.mXformList[i], sampleList);
}
else
{
Alembic::AbcGeom::XformSample samp;
read(mCurTime, mData.mXformList[i], sampleList, samp);
}
unsigned int sampleSize = (unsigned int)sampleList.size();
for (unsigned int j = 0; j < sampleSize; j++)
{
// only use the handle if it matches the index.
// The index wont line up in the sparse case so we
// can just skip that element.
if (outArrayHandle.elementIndex() == outHandleIndex++)
{
outHandle = outArrayHandle.outputValue(&status);
}
else
continue;
outArrayHandle.next();
outHandle.set(sampleList[j]);
}
}
outArrayHandle.setAllClean();
}
}
else if (plug == mOutLocatorPosScaleArrayAttr )
{
if (mOutRead[8])
{
dataBlock.setClean(plug);
return MS::kSuccess;
}
mOutRead[8] = true;
unsigned int locSize =
static_cast<unsigned int>(mData.mLocList.size());
if (locSize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutLocatorPosScaleArrayAttr, &status);
MPlug arrayPlug(thisMObject(), mOutLocatorPosScaleArrayAttr);
MDataHandle outHandle;
unsigned int outHandleIndex = 0;
for (unsigned int i = 0; i < locSize; i++)
{
std::vector< double > sampleList;
read(mCurTime, mData.mLocList[i], sampleList);
unsigned int sampleSize = (unsigned int)sampleList.size();
for (unsigned int j = 0; j < sampleSize; j++)
{
// only use the handle if it matches the index.
// The index wont line up in the sparse case so we
// can just skip that element.
if (outArrayHandle.elementIndex() == outHandleIndex++)
{
outHandle = outArrayHandle.outputValue(&status);
}
else
continue;
outArrayHandle.next();
outHandle.set(sampleList[j]);
}
}
outArrayHandle.setAllClean();
}
}
else if (plug == mOutSubDArrayAttr)
{
if (mOutRead[2])
{
// Reference the output to let EM know we are the writer
// of the data. EM sets the output to holder and causes
// race condition when evaluating fan-out destinations.
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutSubDArrayAttr, &status);
const unsigned int elementCount = outArrayHandle.elementCount();
for (unsigned int j = 0; j < elementCount; j++)
{
outArrayHandle.outputValue().data();
outArrayHandle.next();
}
outArrayHandle.setAllClean();
return MS::kSuccess;
}
mOutRead[2] = true;
unsigned int subDSize =
static_cast<unsigned int>(mData.mSubDList.size());
if (subDSize > 0)
{
MArrayDataHandle outArrayHandle = dataBlock.outputValue(
mOutSubDArrayAttr, &status);
MDataHandle outHandle;
for (unsigned int j = 0; j < subDSize; j++)
{
// these elements can be sparse if they have been deleted
if (outArrayHandle.elementIndex() != j)
{
continue;
}
outHandle = outArrayHandle.outputValue(&status);
outArrayHandle.next();
MObject obj = outHandle.data();
if (obj.hasFn(MFn::kMesh))
{
MFnMesh fnMesh(obj);
readSubD(mCurTime, fnMesh, obj, mData.mSubDList[j],
mSubDInitialized);
outHandle.set(obj);
}
}
mSubDInitialized = true;
outArrayHandle.setAllClean();
}
// for the case where we don't have any nodes, we want to make sure
// to push out empty meshes on our connections, this can happen if
// the input file was offlined, currently we only need to do this for
// meshes as Nurbs, curves, and the other channels don't crash Maya
else
{
MArrayDataHandle outArrayHandle = dataBlock.outputValue(
mOutSubDArrayAttr, &status);
if (outArrayHandle.elementCount() > 0)
{
do
{
MDataHandle outHandle = outArrayHandle.outputValue();
MObject obj = outHandle.data();
if (obj.hasFn(MFn::kMesh))
{
MFloatPointArray emptyVerts;
MIntArray emptyCounts;
MIntArray emptyConnects;
MFnMesh emptyMesh;
emptyMesh.create(0, 0, emptyVerts, emptyCounts,
emptyConnects, obj);
outHandle.set(obj);
}
}
while (outArrayHandle.next() == MS::kSuccess);
}
mSubDInitialized = true;
outArrayHandle.setAllClean();
}
}
else if (plug == mOutPolyArrayAttr)
{
if (mOutRead[3])
{
// Reference the output to let EM know we are the writer
// of the data. EM sets the output to holder and causes
// race condition when evaluating fan-out destinations.
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutPolyArrayAttr, &status);
const unsigned int elementCount = outArrayHandle.elementCount();
for (unsigned int j = 0; j < elementCount; j++)
{
outArrayHandle.outputValue().data();
outArrayHandle.next();
}
outArrayHandle.setAllClean();
return MS::kSuccess;
}
mOutRead[3] = true;
unsigned int polySize =
static_cast<unsigned int>(mData.mPolyMeshList.size());
if (polySize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutPolyArrayAttr, &status);
MDataHandle outHandle;
for (unsigned int j = 0; j < polySize; j++)
{
// these elements can be sparse if they have been deleted
if (outArrayHandle.elementIndex() != j)
{
continue;
}
outHandle = outArrayHandle.outputValue(&status);
outArrayHandle.next();
MObject obj = outHandle.data();
if (obj.hasFn(MFn::kMesh))
{
MFnMesh fnMesh(obj);
readPoly(mCurTime, fnMesh, obj, mData.mPolyMeshList[j],
mPolyInitialized);
outHandle.set(obj);
}
}
mPolyInitialized = true;
outArrayHandle.setAllClean();
}
// for the case where we don't have any nodes, we want to make sure
// to push out empty meshes on our connections, this can happen if
// the input file was offlined, currently we only need to do this for
// meshes as Nurbs, curves, and the other channels don't crash Maya
else
{
MArrayDataHandle outArrayHandle = dataBlock.outputValue(
mOutPolyArrayAttr, &status);
if (outArrayHandle.elementCount() > 0)
{
do
{
MDataHandle outHandle = outArrayHandle.outputValue(&status);
MObject obj = outHandle.data();
if (obj.hasFn(MFn::kMesh))
{
MFloatPointArray emptyVerts;
MIntArray emptyCounts;
MIntArray emptyConnects;
MFnMesh emptyMesh;
emptyMesh.create(0, 0, emptyVerts, emptyCounts,
emptyConnects, obj);
outHandle.set(obj);
}
}
while (outArrayHandle.next() == MS::kSuccess);
}
mPolyInitialized = true;
outArrayHandle.setAllClean();
}
}
else if (plug == mOutCameraArrayAttr)
{
if (mOutRead[4])
{
dataBlock.setClean(plug);
return MS::kSuccess;
}
mOutRead[4] = true;
unsigned int cameraSize =
static_cast<unsigned int>(mData.mCameraList.size());
if (cameraSize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutCameraArrayAttr, &status);
MPlug arrayPlug(thisMObject(), mOutCameraArrayAttr);
double angleConversion = 1.0;
switch (MAngle::uiUnit())
{
case MAngle::kRadians:
angleConversion = 0.017453292519943295;
break;
case MAngle::kAngMinutes:
angleConversion = 60.0;
break;
case MAngle::kAngSeconds:
angleConversion = 3600.0;
break;
default:
break;
}
MDataHandle outHandle;
unsigned int index = 0;
for (unsigned int cameraIndex = 0; cameraIndex < cameraSize;
cameraIndex++)
{
Alembic::AbcGeom::ICamera & cam =
mData.mCameraList[cameraIndex];
std::vector<double> array;
read(mCurTime, cam, array);
for (unsigned int dataIndex = 0; dataIndex < array.size();
dataIndex++, index++)
{
// skip over sparse elements
if (index != outArrayHandle.elementIndex())
{
continue;
}
outHandle = outArrayHandle.outputValue(&status);
outArrayHandle.next();
// not shutter angle index, so not an angle
if (dataIndex != 11)
{
outHandle.set(array[dataIndex]);
}
else
{
outHandle.set(array[dataIndex] * angleConversion);
}
} // for the per camera data handles
} // for each camera
outArrayHandle.setAllClean();
}
}
else if (plug == mOutNurbsSurfaceArrayAttr)
{
if (mOutRead[5])
{
// Reference the output to let EM know we are the writer
// of the data. EM sets the output to holder and causes
// race condition when evaluating fan-out destinations.
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutNurbsSurfaceArrayAttr, &status);
const unsigned int elementCount = outArrayHandle.elementCount();
for (unsigned int j = 0; j < elementCount; j++)
{
outArrayHandle.outputValue().data();
outArrayHandle.next();
}
outArrayHandle.setAllClean();
return MS::kSuccess;
}
mOutRead[5] = true;
unsigned int nSurfaceSize =
static_cast<unsigned int>(mData.mNurbsList.size());
if (nSurfaceSize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutNurbsSurfaceArrayAttr, &status);
MDataHandle outHandle;
for (unsigned int j = 0; j < nSurfaceSize; j++)
{
// these elements can be sparse if they have been deleted
if (outArrayHandle.elementIndex() != j)
continue;
outHandle = outArrayHandle.outputValue(&status);
outArrayHandle.next();
MObject obj = outHandle.data();
if (obj.hasFn(MFn::kNurbsSurface))
{
readNurbs(mCurTime, mData.mNurbsList[j], obj);
outHandle.set(obj);
}
}
outArrayHandle.setAllClean();
}
}
else if (plug == mOutNurbsCurveGrpArrayAttr)
{
if (mOutRead[6])
{
// Reference the output to let EM know we are the writer
// of the data. EM sets the output to holder and causes
// race condition when evaluating fan-out destinations.
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutNurbsCurveGrpArrayAttr, &status);
const unsigned int elementCount = outArrayHandle.elementCount();
for (unsigned int j = 0; j < elementCount; j++)
{
outArrayHandle.outputValue().data();
outArrayHandle.next();
}
outArrayHandle.setAllClean();
return MS::kSuccess;
}
mOutRead[6] = true;
unsigned int nCurveGrpSize =
static_cast<unsigned int>(mData.mCurvesList.size());
if (nCurveGrpSize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutNurbsCurveGrpArrayAttr, &status);
MDataHandle outHandle;
std::vector<MObject> curvesObj;
for (unsigned int i = 0; i < nCurveGrpSize; ++i)
{
readCurves(mCurTime, mData.mCurvesList[i],
mData.mNumCurves[i], curvesObj);
}
std::size_t numChild = curvesObj.size();
// not the best way to do this
// only reading bunches of curves based on the connections would be
// more efficient when there is a bunch of broken connections
for (unsigned int i = 0; i < numChild; i++)
{
if (outArrayHandle.elementIndex() != i)
{
continue;
}
outHandle = outArrayHandle.outputValue(&status);
outArrayHandle.next();
status = outHandle.set(curvesObj[i]);
}
outArrayHandle.setAllClean();
}
}
else
{
return MS::kUnknownParameter;
}
dataBlock.setClean(plug);
return status;
}
void liqBoundingBoxLocator::draw( M3dView & view,
const MDagPath & path,
M3dView::DisplayStyle style,
M3dView::DisplayStatus status )
{
MFnDagNode dagFn( thisMObject() );
MFnDagNode transFn( dagFn.parent( 0 ) );
MStatus stat;
bool drawBox( 0 );
MPlug plug = dagFn.findPlug( "drawBox", stat );
if ( stat == MS::kSuccess ) plug.getValue( drawBox );
if ( !drawBox ) return;
MDoubleArray bb( 6 );
MGlobal::executeCommand( MString( "exactWorldBoundingBox " ) + transFn.fullPathName(), bb );
pts = shared_array< MPoint >( new MPoint[ 8 ] );
pts[0].x = bb[0];
pts[0].y = bb[4];
pts[0].z = bb[2];
pts[1].x = bb[0];
pts[1].y = bb[4];
pts[1].z = bb[5];
pts[2].x = bb[3];
pts[2].y = bb[4];
pts[2].z = bb[5];
pts[3].x = bb[3];
pts[3].y = bb[4];
pts[3].z = bb[2];
pts[4].x = bb[0];
pts[4].y = bb[1];
pts[4].z = bb[2];
pts[5].x = bb[0];
pts[5].y = bb[1];
pts[5].z = bb[5];
pts[6].x = bb[3];
pts[6].y = bb[1];
pts[6].z = bb[5];
pts[7].x = bb[3];
pts[7].y = bb[1];
pts[7].z = bb[2];
MMatrix m( path.inclusiveMatrix() );
for( unsigned i( 0 ); i < 8; i++ )
pts[i] *= m.inverse();
// draw box
view.beginGL();
view.setDrawColor( MColor( .57f, 0, .57f ) );
glPushAttrib( GL_CURRENT_BIT );
glBegin(GL_LINE_STRIP);
glVertex3f( (float)pts[0].x, (float)pts[0].y, (float)pts[0].z );
glVertex3f( (float)pts[1].x, (float)pts[1].y, (float)pts[1].z );
glVertex3f( (float)pts[2].x, (float)pts[2].y, (float)pts[2].z );
glVertex3f( (float)pts[3].x, (float)pts[3].y, (float)pts[3].z );
glVertex3f( (float)pts[0].x, (float)pts[0].y, (float)pts[0].z );
glEnd();
glBegin(GL_LINE_STRIP);
glVertex3f( (float)pts[4].x, (float)pts[4].y, (float)pts[4].z );
glVertex3f( (float)pts[5].x, (float)pts[5].y, (float)pts[5].z );
glVertex3f( (float)pts[6].x, (float)pts[6].y, (float)pts[6].z );
glVertex3f( (float)pts[7].x, (float)pts[7].y, (float)pts[7].z );
glVertex3f( (float)pts[4].x, (float)pts[4].y, (float)pts[4].z );
glEnd();
glBegin(GL_LINE_STRIP);
glVertex3f( (float)pts[0].x, (float)pts[0].y, (float)pts[0].z );
glVertex3f( (float)pts[4].x, (float)pts[4].y, (float)pts[4].z );
glEnd();
glBegin(GL_LINE_STRIP);
glVertex3f( (float)pts[1].x, (float)pts[1].y, (float)pts[1].z );
glVertex3f( (float)pts[5].x, (float)pts[5].y, (float)pts[5].z );
glEnd();
glBegin(GL_LINE_STRIP);
glVertex3f( (float)pts[2].x, (float)pts[2].y, (float)pts[2].z );
glVertex3f( (float)pts[6].x, (float)pts[6].y, (float)pts[6].z );
glEnd();
glBegin(GL_LINE_STRIP);
glVertex3f( (float)pts[3].x, (float)pts[3].y, (float)pts[3].z );
glVertex3f( (float)pts[7].x, (float)pts[7].y, (float)pts[7].z );
glEnd();
view.endGL();
}
// Compute takes two parameters: plug and data.
// - Plug is the the data value that needs to be recomputed
// - Data provides handles to all of the nodes attributes, only these
// handles should be used when performing computations.
//
MStatus mix::compute( const MPlug& plug, MDataBlock& block )
{
// The plug parameter will allow us to determine which output attribute
// needs to be calculated.
//
if( plug == aOutColor || plug == aOutTransparency || plug.parent() == aOutColor || plug.parent() == aOutTransparency )
{
MStatus status;
MFloatVector resultColor( 0.0, 0.0, 0.0 );
// Get surface shading parameters from input block
//
MFloatVector& surfaceNormal = block.inputValue( aNormalCamera, &status ).asFloatVector();
CHECK_MSTATUS( status );
MFloatVector& surfaceColor = block.inputValue( aColor, &status ).asFloatVector();
CHECK_MSTATUS( status );
MFloatVector& incandescence = block.inputValue( aIncandescence, &status ).asFloatVector();
CHECK_MSTATUS( status );
float diffuseReflectivity = block.inputValue( aDiffuseReflectivity, &status ).asFloat();
CHECK_MSTATUS( status );
// float translucenceCoeff = block.inputValue( aTranslucenceCoeff,
// &status ).asFloat();
// CHECK_MSTATUS( status );
// Get light list
//
MArrayDataHandle lightData = block.inputArrayValue( aLightData, &status );
CHECK_MSTATUS( status );
int numLights = lightData.elementCount( &status );
CHECK_MSTATUS( status );
// Calculate the effect of the lights in the scene on the color
//
// Iterate through light list and get ambient/diffuse values
//
for( int count=1; count <= numLights; count++ )
{
// Get the current light out of the array
//
MDataHandle currentLight = lightData.inputValue( &status );
CHECK_MSTATUS( status );
// Get the intensity of that light
//
MFloatVector& lightIntensity = currentLight.child( aLightIntensity ).asFloatVector();
// Find ambient component
//
if ( currentLight.child( aLightAmbient ).asBool() )
{
resultColor += lightIntensity;
}
// Find diffuse component
//
if ( currentLight.child( aLightDiffuse ).asBool() )
{
MFloatVector& lightDirection = currentLight.child( aLightDirection ).asFloatVector();
float cosln = lightDirection * surfaceNormal;
if ( cosln > 0.0f )
{
resultColor += lightIntensity * ( cosln * diffuseReflectivity );
}
}
// Advance to the next light.
//
if ( count < numLights ) {
status = lightData.next();
CHECK_MSTATUS( status );
}
}
// Factor incident light with surface color and add incandescence
//
resultColor[0] = resultColor[0] * surfaceColor[0] + incandescence[0];
resultColor[1] = resultColor[1] * surfaceColor[1] + incandescence[1];
resultColor[2] = resultColor[2] * surfaceColor[2] + incandescence[2];
// Set ouput color attribute
//
if ( plug == aOutColor || plug.parent() == aOutColor )
{
// Get the handle to the attribute
//
MDataHandle outColorHandle = block.outputValue( aOutColor, &status );
CHECK_MSTATUS( status );
MFloatVector& outColor = outColorHandle.asFloatVector();
outColor = resultColor; // Set the output value
outColorHandle.setClean(); // Mark the output value as clean
}
// Set ouput transparency
//
if ( plug == aOutTransparency || plug.parent() == aOutTransparency )
{
MFloatVector& transparency = block.inputValue( aInTransparency, &status ).asFloatVector();
CHECK_MSTATUS( status );
// Get the handle to the attribute
//
MDataHandle outTransHandle = block.outputValue( aOutTransparency, &status );
CHECK_MSTATUS( status );
MFloatVector& outTrans = outTransHandle.asFloatVector();
outTrans = transparency; // Set the output value
outTransHandle.setClean(); // Mark the output value as clean
}
}
else
{
return( MS::kUnknownParameter ); // We got an unexpected plug
}
return( MS::kSuccess );
}
// Load a joint
void skeleton::loadJoint(MDagPath& jointDag,joint* parent)
{
int i;
joint newJoint;
joint* parentJoint = parent;
if (jointDag.hasFn(MFn::kJoint))
{
MFnIkJoint jointFn(jointDag);
// Get parent index
int idx=-1;
if (parent)
{
idx = parent->id;
}
// Get joint matrix
MMatrix worldMatrix = jointDag.inclusiveMatrix();
/*float translation1[3];
float rotation1[4];
float scale1[3];
extractTranMatrix(worldMatrix,translation1,rotation1,scale1);
Quaternion q(rotation1[0],rotation1[1],rotation1[2],rotation1[3]);
float angle;
Vector3 axis;
q.ToAngleAxis(angle,axis);
Vector3 x,y,z;
q.ToAxes(x,y,z);*/
//printMatrix(worldMatrix);
// Calculate scaling factor inherited by parent
// Calculate Local Matrix
MMatrix localMatrix = worldMatrix;
if (parent)
localMatrix = worldMatrix * parent->worldMatrix.inverse();
float translation2[3];
float rotation2[4];
float scale2[3];
extractTranMatrix(worldMatrix,translation2,rotation2,scale2);
//printMatrix(localMatrix);
// Set joint info
newJoint.name = jointFn.partialPathName();
newJoint.id = m_joints.size();
newJoint.parentIndex = idx;
newJoint.jointDag = jointDag;
newJoint.worldMatrix = worldMatrix;
newJoint.localMatrix = localMatrix;
for (int iRow = 0; iRow < 4; iRow++)
for (int iCol = 0; iCol < 3; iCol++)
newJoint.tran.m_mat[iRow][iCol] = (FLOAT)worldMatrix[iRow][iCol];
//printMatrix(worldMatrix);
/*MQuaternion q;
q = worldMatrix;
newJoint.tran.q[0] = (float)q.x;
newJoint.tran.q[1] = (float)q.y;
newJoint.tran.q[2] = (float)q.z;
newJoint.tran.q[3] = (float)q.w;
newJoint.tran.t[0] = (float)worldMatrix[3][0];
newJoint.tran.t[1] = (float)worldMatrix[3][1];
newJoint.tran.t[2] = (float)worldMatrix[3][2];*/
MPlug plug = jointFn.findPlug("unRibbonEnabled");
if(!plug.isNull())
{
bool enabled;
plug.getValue(enabled);
if(enabled)
{
plug = jointFn.findPlug("unRibbonVisible");
bool visible;
plug.getValue(visible);
plug = jointFn.findPlug("unRibbonAbove");
float above;
plug.getValue(above);
plug = jointFn.findPlug("unRibbonBelow");
float below;
plug.getValue(below);
plug = jointFn.findPlug("unRibbonEdgesPerSecond");
short edgePerSecond;
plug.getValue(edgePerSecond);
plug = jointFn.findPlug("unRibbonEdgeLife");
float edgeLife;
plug.getValue(edgeLife);
plug = jointFn.findPlug("unRibbonGravity");
float gravity;
plug.getValue(gravity);
plug = jointFn.findPlug("unRibbonTextureRows");
short rows;
plug.getValue(rows);
plug = jointFn.findPlug("unRibbonTextureCols");
short cols;
plug.getValue(cols);
plug = jointFn.findPlug("unRibbonTextureSlot");
short slot;
plug.getValue(slot);
plug = jointFn.findPlug("unRibbonVertexColor");
MObject object;
plug.getValue(object);
MFnNumericData data(object);
float r,g,b;
data.getData(r,g,b);
plug = jointFn.findPlug("unRibbonVertexAlpha");
float alpha;
plug.getValue(alpha);
plug = jointFn.findPlug("unRibbonBlendMode");
short blendMode;
plug.getValue(blendMode);
plug = jointFn.findPlug("unRibbonTextureFilename");
MItDependencyGraph dgIt(plug, MFn::kFileTexture,
MItDependencyGraph::kUpstream,
MItDependencyGraph::kBreadthFirst,
MItDependencyGraph::kNodeLevel);
dgIt.disablePruningOnFilter();
MString textureName;
if (!dgIt.isDone())
{
MObject textureNode = dgIt.thisNode();
MPlug filenamePlug = MFnDependencyNode(textureNode).findPlug("fileTextureName");
filenamePlug.getValue(textureName);
}
else
{
char str[256];
sprintf(str,"%s ribbon system must has file-texture",newJoint.name.asChar());
MessageBox(0,str,0,0);
}
newJoint.hasRibbonSystem = true;
newJoint.ribbon.visible = visible;
newJoint.ribbon.above = above;
newJoint.ribbon.below = below;
newJoint.ribbon.gravity = gravity;
newJoint.ribbon.edgePerSecond = edgePerSecond;
newJoint.ribbon.edgeLife = edgeLife;
newJoint.ribbon.rows = rows;
newJoint.ribbon.cols = cols;
newJoint.ribbon.slot = slot;
newJoint.ribbon.color[0] = r;
newJoint.ribbon.color[1] = g;
newJoint.ribbon.color[2] = b;
newJoint.ribbon.alpha = alpha;
newJoint.ribbon.blendMode = blendMode;
newJoint.ribbon.textureFilename = textureName.asChar();
}
}
plug = jointFn.findPlug("unParticleEnabled");
if(!plug.isNull())
{
bool enabled;
plug.getValue(enabled);
if(enabled)
{
newJoint.hasParticleSystem = true;
plug = jointFn.findPlug("unParticleVisible");
bool visible;
plug.getValue(visible);
plug = jointFn.findPlug("unParticleSpeed");
float speed;
plug.getValue(speed);
plug = jointFn.findPlug("unParticleVariationPercent");
float variation;
plug.getValue(variation);
plug = jointFn.findPlug("unParticleConeAngle");
float coneAngle;
plug.getValue(coneAngle);
plug = jointFn.findPlug("unParticleGravity");
float gravity;
plug.getValue(gravity);
plug = jointFn.findPlug("unParticleExplosiveForce");
float explosiveForce = 0.0f;
if(!plug.isNull())
{
plug.getValue(explosiveForce);
}
plug = jointFn.findPlug("unParticleLife");
float life;
plug.getValue(life);
plug = jointFn.findPlug("unParticleLifeVariation");
float lifeVar;
if(plug.isNull())
{
lifeVar = 0.0f;
}
else
{
plug.getValue(lifeVar);
}
plug = jointFn.findPlug("unParticleEmissionRate");
float emissionRate;
plug.getValue(emissionRate);
plug = jointFn.findPlug("unParticleLimitNum");
short limitNum;
plug.getValue(limitNum);
plug = jointFn.findPlug("unParticleInitialNum");
short initialNum = 0;
if(!plug.isNull())plug.getValue(initialNum);
plug = jointFn.findPlug("unParticleAttachToEmitter");
bool attachToEmitter;
plug.getValue(attachToEmitter);
plug = jointFn.findPlug("unParticleMoveWithEmitter");
bool moveWithEmitter = false;
if(!plug.isNull())plug.getValue(moveWithEmitter);
//23
plug = jointFn.findPlug("unParticleForTheSword");
bool forTheSword = false;
if(!plug.isNull())plug.getValue(forTheSword);
//24
plug = jointFn.findPlug("unParticleForTheSwordInitialAngle");
float forTheSwordInitialAngle = 0;
if(!plug.isNull())plug.getValue(forTheSwordInitialAngle);
//25
plug = jointFn.findPlug("unParticleWander");
bool wander = false;
if(!plug.isNull())plug.getValue(wander);
//25
plug = jointFn.findPlug("unParticleWanderRadius");
float wanderRadius = 0.0f;
if(!plug.isNull())plug.getValue(wanderRadius);
//25
plug = jointFn.findPlug("unParticleWanderSpeed");
float wanderSpeed = 0.0f;
if(!plug.isNull())plug.getValue(wanderSpeed);
plug = jointFn.findPlug("unParticleAspectRatio");
float aspectRatio;
if(plug.isNull())
{
aspectRatio = 1.0f;
}
else
{
plug.getValue(aspectRatio);
}
plug = jointFn.findPlug("unParticleInitialAngleBegin");
float angleBegin;
if(plug.isNull())
{
angleBegin = 0.0f;
}
else
{
plug.getValue(angleBegin);
}
plug = jointFn.findPlug("unParticleInitialAngleEnd");
float angleEnd;
if(plug.isNull())
{
angleEnd = 0.0f;
}
else
{
plug.getValue(angleEnd);
}
plug = jointFn.findPlug("unParticleRotationSpeed");
float rotationSpeed;
if(plug.isNull())
{
rotationSpeed = 0;
}
else
{
plug.getValue(rotationSpeed);
}
plug = jointFn.findPlug("unParticleRotationSpeedVar");
float rotationSpeedVar;
if(plug.isNull())
{
rotationSpeedVar = 0;
}
else
{
plug.getValue(rotationSpeedVar);
}
plug = jointFn.findPlug("unParticleEmitterWidth");
float width;
plug.getValue(width);
plug = jointFn.findPlug("unParticleEmitterLength");
float length;
plug.getValue(length);
plug = jointFn.findPlug("unParticleEmitterHeight");
float height = 0.0f;
if(!plug.isNull())
{
plug.getValue(height);
}
plug = jointFn.findPlug("unParticleBlendMode");
short blendMode;
plug.getValue(blendMode);
plug = jointFn.findPlug("unParticleTextureFilename");
MItDependencyGraph dgIt(plug, MFn::kFileTexture,
MItDependencyGraph::kUpstream,
MItDependencyGraph::kBreadthFirst,
MItDependencyGraph::kNodeLevel);
dgIt.disablePruningOnFilter();
MString textureName;
if (!dgIt.isDone())
{
MObject textureNode = dgIt.thisNode();
MPlug filenamePlug = MFnDependencyNode(textureNode).findPlug("fileTextureName");
filenamePlug.getValue(textureName);
}
else
{
char str[256];
sprintf(str,"%s particle system must has file-texture",newJoint.name.asChar());
MessageBox(0,str,0,0);
}
plug = jointFn.findPlug("unParticleTextureRows");
short rows;
plug.getValue(rows);
plug = jointFn.findPlug("unParticleTextureCols");
short cols;
plug.getValue(cols);
plug = jointFn.findPlug("unParticleTextureChangeStyle");
short changeStyle;
if(plug.isNull())
{
//0 - 顺序
//1 - 随机
changeStyle = 0;
}
else
{
plug.getValue(changeStyle);
}
plug = jointFn.findPlug("unParticleTextureChangeInterval");
short changeInterval;
if(plug.isNull())
{
//默认30ms换一个
changeInterval = 30;
}
else
{
plug.getValue(changeInterval);
}
plug = jointFn.findPlug("unParticleTailLength");
float tailLength;
plug.getValue(tailLength);
plug = jointFn.findPlug("unParticleTimeMiddle");
float timeMiddle;
plug.getValue(timeMiddle);
plug = jointFn.findPlug("unParticleColorStart");
MObject object;
plug.getValue(object);
MFnNumericData dataS(object);
float colorStart[3];
dataS.getData(colorStart[0],colorStart[1],colorStart[2]);
plug = jointFn.findPlug("unParticleColorMiddle");
plug.getValue(object);
MFnNumericData dataM(object);
float colorMiddle[3];
dataM.getData(colorMiddle[0],colorMiddle[1],colorMiddle[2]);
plug = jointFn.findPlug("unParticleColorEnd");
plug.getValue(object);
MFnNumericData dataE(object);
float colorEnd[3];
dataE.getData(colorEnd[0],colorEnd[1],colorEnd[2]);
plug = jointFn.findPlug("unParticleAlpha");
plug.getValue(object);
MFnNumericData dataAlpha(object);
float alpha[3];
dataAlpha.getData(alpha[0],alpha[1],alpha[2]);
//Scale
plug = jointFn.findPlug("unParticleScale");
plug.getValue(object);
MFnNumericData dataScale(object);
float scale[3];
dataScale.getData(scale[0],scale[1],scale[2]);
//ScaleVar
plug = jointFn.findPlug("unParticleScaleVar");
float scaleVar[3] = {0.0f,0.0f,0.0f};
if(!plug.isNull())
{
plug.getValue(object);
MFnNumericData dataScaleVar(object);
dataScaleVar.getData(scaleVar[0],scaleVar[1],scaleVar[2]);
}
//FixedSize
plug = jointFn.findPlug("unParticleFixedSize");
bool fixedSize = false;
if(!plug.isNull())
{
plug.getValue(fixedSize);
}
//HeadLifeSpan
plug = jointFn.findPlug("unParticleHeadLifeSpan");
plug.getValue(object);
MFnNumericData dataHeadLifeSpan(object);
short headLifeSpan[3];
dataHeadLifeSpan.getData(headLifeSpan[0],headLifeSpan[1],headLifeSpan[2]);
plug = jointFn.findPlug("unParticleHeadDecay");
plug.getValue(object);
MFnNumericData dataHeadDecay(object);
short headDecay[3];
dataHeadDecay.getData(headDecay[0],headDecay[1],headDecay[2]);
plug = jointFn.findPlug("unParticleTailLifeSpan");
plug.getValue(object);
MFnNumericData dataTailLifeSpan(object);
short tailLifeSpan[3];
dataTailLifeSpan.getData(tailLifeSpan[0],tailLifeSpan[1],tailLifeSpan[2]);
plug = jointFn.findPlug("unParticleTailDecay");
plug.getValue(object);
MFnNumericData dataTailDecay(object);
short tailDecay[3];
dataTailDecay.getData(tailDecay[0],tailDecay[1],tailDecay[2]);
plug = jointFn.findPlug("unParticleHead");
bool head;
plug.getValue(head);
plug = jointFn.findPlug("unParticleTail");
bool tail;
plug.getValue(tail);
plug = jointFn.findPlug("unParticleUnShaded");
bool unshaded;
plug.getValue(unshaded);
plug = jointFn.findPlug("unParticleUnFogged");
bool unfogged;
plug.getValue(unfogged);
plug = jointFn.findPlug("unParticleBlockByY0");
bool blockByY0 = false;
if(!plug.isNull())
plug.getValue(blockByY0);
newJoint.particle.visible = visible;
newJoint.particle.speed = speed;
newJoint.particle.variation = variation / 100.0f;
newJoint.particle.coneAngle = coneAngle;
newJoint.particle.gravity = gravity;
newJoint.particle.explosiveForce = explosiveForce;
newJoint.particle.life = life;
newJoint.particle.lifeVar = lifeVar;
newJoint.particle.emissionRate = emissionRate;
newJoint.particle.initialNum = initialNum;
newJoint.particle.limitNum = limitNum;
newJoint.particle.attachToEmitter = attachToEmitter;
newJoint.particle.moveWithEmitter = moveWithEmitter;
newJoint.particle.forTheSword = forTheSword;
newJoint.particle.forTheSwordInitialAngle = forTheSwordInitialAngle;
newJoint.particle.wander = wander;
newJoint.particle.wanderRadius = wanderRadius;
newJoint.particle.wanderSpeed = wanderSpeed;
newJoint.particle.aspectRatio = aspectRatio;
newJoint.particle.initialAngleBegin = angleBegin;
newJoint.particle.initialAngleEnd = angleEnd;
newJoint.particle.rotationSpeed = rotationSpeed;
newJoint.particle.rotationSpeedVar = rotationSpeedVar;
newJoint.particle.width = width;
newJoint.particle.length = length;
newJoint.particle.height = height;
newJoint.particle.blendMode = blendMode;
newJoint.particle.textureFilename = textureName.asChar();
newJoint.particle.textureRows = rows;
newJoint.particle.textureCols = cols;
newJoint.particle.changeStyle = changeStyle;
newJoint.particle.changeInterval = changeInterval;
newJoint.particle.tailLength = tailLength;
newJoint.particle.timeMiddle = timeMiddle;
newJoint.particle.colorStart[0] = colorStart[0];
newJoint.particle.colorStart[1] = colorStart[1];
newJoint.particle.colorStart[2] = colorStart[2];
newJoint.particle.colorMiddle[0] = colorMiddle[0];
newJoint.particle.colorMiddle[1] = colorMiddle[1];
newJoint.particle.colorMiddle[2] = colorMiddle[2];
newJoint.particle.colorEnd[0] = colorEnd[0];
newJoint.particle.colorEnd[1] = colorEnd[1];
newJoint.particle.colorEnd[2] = colorEnd[2];
newJoint.particle.alpha[0] = alpha[0];
newJoint.particle.alpha[1] = alpha[1];
newJoint.particle.alpha[2] = alpha[2];
newJoint.particle.scale[0] = scale[0];
newJoint.particle.scale[1] = scale[1];
newJoint.particle.scale[2] = scale[2];
newJoint.particle.scaleVar[0] = scaleVar[0];
newJoint.particle.scaleVar[1] = scaleVar[1];
newJoint.particle.scaleVar[2] = scaleVar[2];
newJoint.particle.fixedSize = fixedSize;
newJoint.particle.headLifeSpan[0] = headLifeSpan[0];
newJoint.particle.headLifeSpan[1] = headLifeSpan[1];
newJoint.particle.headLifeSpan[2] = headLifeSpan[2];
newJoint.particle.headDecay[0] = headDecay[0];
newJoint.particle.headDecay[1] = headDecay[1];
newJoint.particle.headDecay[2] = headDecay[2];
newJoint.particle.tailLifeSpan[0] = tailLifeSpan[0];
newJoint.particle.tailLifeSpan[1] = tailLifeSpan[1];
newJoint.particle.tailLifeSpan[2] = tailLifeSpan[2];
newJoint.particle.tailDecay[0] = tailDecay[0];
newJoint.particle.tailDecay[1] = tailDecay[1];
newJoint.particle.tailDecay[2] = tailDecay[2];
newJoint.particle.head = head;
newJoint.particle.tail = tail;
newJoint.particle.unshaded = unshaded;
newJoint.particle.unfogged = unfogged;
newJoint.particle.blockByY0 = blockByY0;
}
}
m_joints.push_back(newJoint);
// Get pointer to newly created joint
parentJoint = &newJoint;
}
// Load children joints
for (i=0; i<jointDag.childCount();i++)
{
MObject child;
child = jointDag.child(i);
MDagPath childDag = jointDag;
childDag.push(child);
loadJoint(childDag,parentJoint);
}
}
MStatus proWater::compute(const MPlug& plug, MDataBlock& dataBlock)
{
MStatus status = MStatus::kUnknownParameter;
if (plug.attribute() == outputGeom) {
// get the input corresponding to this output
//
unsigned int index = plug.logicalIndex();
MObject thisNode = this->thisMObject();
MPlug inPlug(thisNode,input);
inPlug.selectAncestorLogicalIndex(index,input);
MDataHandle hInput = dataBlock.inputValue(inPlug);
// get the input geometry and input groupId
//
MDataHandle hGeom = hInput.child(inputGeom);
MDataHandle hGroup = hInput.child(groupId);
unsigned int groupId = hGroup.asLong();
MDataHandle hOutput = dataBlock.outputValue(plug);
hOutput.copy(hGeom);
MStatus returnStatus;
MDataHandle envData = dataBlock.inputValue(envelope, &returnStatus);
if (MS::kSuccess != returnStatus) return returnStatus;
float env = envData.asFloat();
MDataHandle timeData = dataBlock.inputValue(time, &returnStatus);
if(MS::kSuccess != returnStatus) return returnStatus;
double t = timeData.asDouble();
MDataHandle dirData = dataBlock.inputValue(dir, &returnStatus);
if(MS::kSuccess != returnStatus) return returnStatus;
double dirDeg = dirData.asDouble();
MDataHandle bigData = dataBlock.inputValue(bigFreq, &returnStatus);
if(MS::kSuccess != returnStatus) return returnStatus;
double bigFreqAmp = bigData.asDouble();
MDataHandle ampData = dataBlock.inputValue(amplitude1, &returnStatus);
if(MS::kSuccess != returnStatus) return returnStatus;
double amp1 = ampData.asDouble();
MDataHandle freqData = dataBlock.inputValue(frequency1, &returnStatus);
if(MS::kSuccess != returnStatus) return returnStatus;
double freq1 = freqData.asDouble();
MDataHandle ampData2 = dataBlock.inputValue(amplitude2, &returnStatus);
if(MS::kSuccess != returnStatus) return returnStatus;
double amp2 = ampData2.asDouble();
MDataHandle freqData2 = dataBlock.inputValue(frequency2, &returnStatus);
if(MS::kSuccess != returnStatus) return returnStatus;
double freq2 = freqData2.asDouble();
// Get the MFnMesh
MStatus stat;
MObject inputObj = hOutput.data();
MFnMesh * meshFn = new MFnMesh(inputObj, &stat);
// do the deformation
//
MItGeometry iter(hOutput,groupId,false);
for ( ; !iter.isDone(); iter.next()) {
MPoint pt = iter.position();
//float2 uvPoint;
//float u,v;
//uvPoint[0] = u;
//uvPoint[1] = v;
//meshFn->getUVAtPoint(pt, uvPoint, MSpace::kObject);
float u = pt.x; //uvPoint[0]*100;
float v = pt.z; //uvPoint[1]*100;
float degDir = dirDeg;
float dir = degDir* M_PI/180;
float dirX = cos(dir);
float dirY = sin(dir);
float bigFreq = 0.01;
float bigWaves = scaled_raw_noise_3d(0, 1, (u + 3*t*dirX)*bigFreq*dirX, (v + 3*t*dirY)*bigFreq*dirY*2, t*0.01);
float frequency1 = freq1/10;//0.2;
float amplitude1 = amp1;//1.3;
float firstOctave = -(std::abs(scaled_raw_noise_3d(-amplitude1, amplitude1, (float)(u + 0.7*t*dirX)*frequency1*0.4, (float)(v + 0.7*t*dirY)*frequency1*0.6, 0.05*t))-amplitude1);
float frequency2 = freq2/10;
float amplitude2 = amp2;
float secondOctave = - (std::abs(scaled_raw_noise_3d(-amplitude2, amplitude2, (float)(u + 0.7*t*dirX)*frequency2*0.35, (float)(v + 0.7*t*dirY)*frequency2*0.65, 0.005*t))-amplitude2);
float frequency3 = freq1/10;
float amplitude3 = amp1/1.5;
float thirdOctave = - (std::abs(scaled_raw_noise_3d(-amplitude3, amplitude3, (float)(u + t*0.5*dirX)*frequency3*0.4, (float)(v + t*0.5*dirY)*frequency3*0.6, 30))-amplitude3);
float frequency4 = freq2/10;
float amplitude4 = amp2/1.5;
float fourthOctave = scaled_raw_noise_3d(-amplitude4, amplitude4, (float)(u + t*0.5*dirX)*frequency4*0.4, (float)(v + t*0.5*dirY)*frequency4*0.6, 50);
float frequency5 = freq2;
float amplitude5 = amp2/2;
float fifthOctave = scaled_raw_noise_3d(-amplitude5, amplitude5, (float)(u + t*0.5*dirX)*frequency5*0.15, (float)(v + t*0.5*dirY)*frequency5*0.85, 0.001*t);
float disp = bigFreqAmp*bigWaves + 7*(bigWaves)*firstOctave + secondOctave + thirdOctave*thirdOctave + fourthOctave + std::abs(bigWaves-1)*fifthOctave;
pt = pt + iter.normal()*disp;
iter.setPosition(pt);
}
delete meshFn;
status = MStatus::kSuccess;
}
return status;
}
MBoundingBox cubeLocator::boundingBox () const {
MPlug plug (thisMObject (), cubeLocator::size) ;
float multiplier =plug.asFloat () ;
return (cubeLocator::boundingbox (multiplier)) ;
}
//---------------------------------------
void MaterialExporter::setSetParamTexture (
const cgfxAttrDef* attribute,
MObject texture,
COLLADASW::Sampler::SamplerType samplerType,
COLLADASW::ValueType::ColladaType samplerValueType )
{
// Get a pointer to the current stream writer.
COLLADASW::StreamWriter* streamWriter = mDocumentExporter->getStreamWriter();
// Get the image id
MFnDependencyNode textureNode ( texture );
String plugName = textureNode.name().asChar(); // file1
// Get the file texture name
MPlug filenamePlug = textureNode.findPlug ( ATTR_FILE_TEXTURE_NAME );
MString mayaFileName;
filenamePlug.getValue ( mayaFileName );
if ( mayaFileName.length() == 0 ) return;
String fileName = mayaFileName.asChar ();
// Get the image path
COLLADASW::URI shaderFxFileUri = getShaderFxFileUri ();
// Take the filename for the unique image name
COLLADASW::URI sourceFileUri ( shaderFxFileUri, fileName );
if ( sourceFileUri.getScheme ().empty () )
sourceFileUri.setScheme ( COLLADASW::URI::SCHEME_FILE );
String mayaImageId = DocumentExporter::mayaNameToColladaName ( sourceFileUri.getPathFileBase().c_str () );
// Get the image id of the maya image
EffectExporter* effectExporter = mDocumentExporter->getEffectExporter ();
String colladaImageId = effectExporter->findColladaImageId ( mayaImageId );
if ( colladaImageId.empty () )
{
// Check if there is an extra attribute "colladaId" and use this as export id.
MString attributeValue;
DagHelper::getPlugValue ( texture, COLLADA_ID_ATTRIBUTE_NAME, attributeValue );
if ( attributeValue != EMPTY_CSTRING )
{
// Generate a valid collada name, if necessary.
colladaImageId = mDocumentExporter->mayaNameToColladaName ( attributeValue, false );
}
else
{
// Generate a COLLADA id for the new light object
colladaImageId = DocumentExporter::mayaNameToColladaName ( textureNode.name() );
}
// Make the id unique and store it in a map for refernences.
EffectTextureExporter* textureExporter = effectExporter->getTextureExporter ();
colladaImageId = textureExporter->getImageIdList ().addId ( colladaImageId );
textureExporter->getMayaIdColladaImageId () [mayaImageId] = colladaImageId;
}
// Export the image
EffectTextureExporter* textureExporter = mDocumentExporter->getEffectExporter()->getTextureExporter();
COLLADASW::Image* colladaImage = textureExporter->exportImage ( mayaImageId, colladaImageId, sourceFileUri );
mayaImageId = colladaImage->getImageId();
// Create the sampler and surface sid
String samplerSid = mayaImageId + COLLADASW::Sampler::SAMPLER_SID_SUFFIX;
String surfaceSid = mayaImageId + COLLADASW::Sampler::SURFACE_SID_SUFFIX;
// Avoid export of dublicate sampler params
if ( mSamplers.find ( samplerSid ) != mSamplers.end () ) return;
mSamplers.insert ( samplerSid );
// Create the sampler and add the sampler <setparam>
COLLADASW::Sampler sampler ( samplerType, samplerSid, surfaceSid );
sampler.setFormat ( EffectTextureExporter::FORMAT );
sampler.setImageId ( colladaImage->getImageId() );
sampler.addInSetParam ( streamWriter );
}
// Creases, corners, holes are organized by MEL script into maya sets
// that are connected to shape and have corresponded attributes:
// liqSubdivCrease, liqSubdivCorner, liqSubdivHole, liqSubdivStitch
// 'stitch' -- new tag introduced in PRman 11 suited for seamless
// stitching two subdiv surfaces aligned by common edge line.
// If global flag liqglo_useMtorSubdiv is set, then procedure looks also
// for analog mtor attributes
//
void liqRibSubdivisionData::checkExtraTags( MObject &mesh )
{
CM_TRACE_FUNC("liqRibSubdivisionData::checkExtraTags("<<MFnDependencyNode(mesh).name()<<")");
MStatus status = MS::kSuccess;
MPlugArray array;
MFnMesh fnMesh( mesh );
MFnDependencyNode depNode( mesh );
depNode.getConnections( array ); // collect all plugs connected to mesh
// this is a temporary solution - the maya2008 polycreases are a bit crap in
// that they cannot be removed and there is no way at the moment to tag
// faces as holes in Maya to we keep the "set" way of doing it - Alf
if( liqglo.liqglo_outputMayaPolyCreases )
{
// this looks redundant but there is no other way to determine
// if the object has creases at all
MUintArray ids;
MDoubleArray creaseData;
status = fnMesh.getCreaseEdges( ids, creaseData );
if( status == MS::kSuccess )
addExtraTags( mesh, TAG_CREASE );
status = fnMesh.getCreaseVertices( ids, creaseData );
if( status == MS::kSuccess )
addExtraTags( mesh, TAG_CORNER );
}
// for each plug check if it is connected as dst to maya set
// and this set has attribute for subdiv extra tag with non zero value
for ( unsigned i = 0 ; i < array.length() ; i++ )
{
MPlugArray connections;
MPlug curPlug = array[i];
if( !curPlug.connectedTo( connections, false, true ) )
continue; /* look only for plugs connected as dst (src = false) */
for ( unsigned i = 0 ; i < connections.length() ; i++ )
{
MPlug dstPlug = connections[i];
MObject dstNode = dstPlug.node();
if( dstNode.hasFn( MFn::kSet ) )
{
/* if connected to set */
float extraTagValue;
MFnDependencyNode setNode( dstNode, &status );
if( status != MS::kSuccess )
continue;
if ( liquidGetPlugValue( setNode, "liqSubdivCrease", extraTagValue, status ) == MS::kSuccess )
{
if( extraTagValue && !liqglo.liqglo_outputMayaPolyCreases ) // skip zero values
addExtraTags( dstNode, extraTagValue, TAG_CREASE );
}
else
if ( liquidGetPlugValue( setNode, "liqSubdivCorner", extraTagValue, status ) == MS::kSuccess )
{
if( extraTagValue && !liqglo.liqglo_outputMayaPolyCreases ) // skip zero values
addExtraTags( dstNode, extraTagValue, TAG_CORNER );
}
else
if ( liquidGetPlugValue( setNode, "liqSubdivHole", extraTagValue, status ) == MS::kSuccess )
{
if( extraTagValue ) // skip zero values
addExtraTags( dstNode, extraTagValue, TAG_HOLE );
}
else
if ( liquidGetPlugValue( setNode, "liqSubdivStitch", extraTagValue, status ) == MS::kSuccess )
{
if( extraTagValue ) // skip zero values
addExtraTags( dstNode, extraTagValue, TAG_STITCH );
}
if( liqglo.liqglo_useMtorSubdiv ) // check mtor subdivisions extra tag
{
if ( liquidGetPlugValue( setNode, "mtorSubdivCrease", extraTagValue, status ) == MS::kSuccess )
{
if( extraTagValue && !liqglo.liqglo_outputMayaPolyCreases ) // skip zero values
addExtraTags( dstNode, extraTagValue, TAG_CREASE );
}
else
if ( liquidGetPlugValue( setNode, "mtorSubdivCorner", extraTagValue, status ) == MS::kSuccess )
{
if( extraTagValue && !liqglo.liqglo_outputMayaPolyCreases ) // skip zero values
addExtraTags( dstNode, extraTagValue, TAG_CORNER );
}
else
if ( liquidGetPlugValue( setNode, "mtorSubdivHole", extraTagValue, status ) == MS::kSuccess )
{
if( extraTagValue ) // skip zero values
addExtraTags( dstNode, extraTagValue, TAG_HOLE );
}
}
}
}
}
bool interpolateBoundaryOld = false;
bool mtor_interpolateBoundary = false;
int liqSubdivUVInterpolation;
liquidGetPlugValue( fnMesh, "liqSubdivInterpolateBoundary", interpolateBoundary, status );
liquidGetPlugValue( fnMesh, "interpBoundary", interpolateBoundaryOld, status );
if( liqglo.liqglo_useMtorSubdiv )
liquidGetPlugValue( fnMesh, "mtorSubdivInterp", mtor_interpolateBoundary, status );
if ( liquidGetPlugValue( fnMesh, "liqSubdivUVInterpolation", liqSubdivUVInterpolation, status ) == MS::kSuccess )
{
switch( liqSubdivUVInterpolation )
{
case 0: // true facevarying
trueFacevarying = true;
case 1: //
uvDetail = rFaceVarying;
break;
case 2:
uvDetail = rFaceVertex;
break;
}
}
if( mtor_interpolateBoundary || interpolateBoundaryOld )
interpolateBoundary = 2; // Old School
if( interpolateBoundary )
addExtraTags( mesh, interpolateBoundary, TAG_BOUNDARY );
if( trueFacevarying )
addExtraTags( mesh, 0, TAG_FACEVARYINGBOUNDARY );
}
bool getObjectShadingGroups(const MDagPath& shapeObjectDP, MIntArray& perFaceAssignments, MObjectArray& shadingGroups, bool needsPerFaceInfo=true)
{
// if obj is a light, simply return the mobject
if (shapeObjectDP.node().hasFn(MFn::kLight))
{
perFaceAssignments.clear();
shadingGroups.clear();
shadingGroups.append(shapeObjectDP.node());
return true;
}
if (shapeObjectDP.node().hasFn(MFn::kMesh))
{
// Find the Shading Engines Connected to the SourceNode
MFnMesh meshFn(shapeObjectDP.node());
perFaceAssignments.clear();
shadingGroups.clear();
MObjectArray comps;
// this one seems to be extremly much faster if we need no per face informations.
// e.g. for a sphere with 90000 faces, the non per face method needs 0.05 sec. whereas the
// method with per face info needs about 20 sec.
if (!needsPerFaceInfo)
{
meshFn.getConnectedSetsAndMembers(shapeObjectDP.instanceNumber(), shadingGroups, comps, true);
return true;
}
meshFn.getConnectedShaders(shapeObjectDP.instanceNumber(), shadingGroups, perFaceAssignments);
if (!meshFn.findPlug("displaySmoothMesh").asBool())
return true;
MIntArray indices;
indices = perFaceAssignments;
int subdivs = 0;
int multiplier = 0;
if (meshFn.findPlug("displaySmoothMesh").asBool())
{
MMeshSmoothOptions options;
MStatus status = meshFn.getSmoothMeshDisplayOptions(options);
if (status)
{
if (!meshFn.findPlug("useSmoothPreviewForRender", false, &status).asBool())
{
int smoothLevel = meshFn.findPlug("renderSmoothLevel", false, &status).asInt();
options.setDivisions(smoothLevel);
}
subdivs = options.divisions();
if (subdivs > 0)
multiplier = static_cast<int> (pow(4.0f, (subdivs - 1)));
}
}
if (multiplier > 0)
perFaceAssignments.clear();
for (unsigned int i = 0; i < indices.length(); i++)
{
int subdivisions = multiplier * meshFn.polygonVertexCount(i);
int index = 0 > indices[i] ? 0 : indices[i]; // non assigned has -1, but we want 0
perFaceAssignments.append(index);
// simply replicate the index for all subdiv faces
for (int k = 0; k < subdivisions - 1; k++)
perFaceAssignments.append(index);
}
return true;
}
if (shapeObjectDP.node().hasFn(MFn::kNurbsSurface)||shapeObjectDP.hasFn(MFn::kParticle)||shapeObjectDP.hasFn(MFn::kNParticle))
{
MObject instObjGroupsAttr;
if (shapeObjectDP.hasFn(MFn::kNurbsSurface))
{
MFnNurbsSurface fnNurbs(shapeObjectDP.node());
instObjGroupsAttr = fnNurbs.attribute("instObjGroups");
}
if (shapeObjectDP.hasFn(MFn::kParticle)||shapeObjectDP.hasFn(MFn::kNParticle))
{
MFnParticleSystem fnPart(shapeObjectDP.node());
instObjGroupsAttr = fnPart.attribute("instObjGroups");
}
MPlug instPlug(shapeObjectDP.node(), instObjGroupsAttr);
// Get the instance that our node is referring to;
// In other words get the Plug for instObjGroups[intanceNumber];
MPlug instPlugElem = instPlug.elementByLogicalIndex(shapeObjectDP.instanceNumber());
// Find the ShadingGroup plugs that we are connected to as Source
MPlugArray SGPlugArray;
instPlugElem.connectedTo(SGPlugArray, false, true);
perFaceAssignments.clear();
shadingGroups.clear();
// Loop through each ShadingGroup Plug
for (unsigned int i=0; i < SGPlugArray.length(); ++i)
{
shadingGroups.append(SGPlugArray[i].node());
return true;
}
}
return false;
}
MStatus OnbShader::compute(const MPlug& plug, MDataBlock& block)
{
// Sanity check
if (plug != aOutColor && plug.parent() != aOutColor &&
plug != aOutTransparency && plug.parent() != aOutTransparency)
{
return MS::kUnknownParameter;
}
// Note that this currently only implements the diffuse portion of the
// shader and ignores specular. The diffuse portion is the Oren-Nayar
// computation from:
// Engel, Wolfgang et al. Programming Vertex, Geometry, and Pixel Shaders
// http://content.gpwiki.org/index.php/D3DBook:(Lighting)_Oren-Nayar
// Further extensions could be added to this compute method to include
// the intended Blinn specular component as well as ambient and
// incandescence components.
// See the VP2 fragment-based implementation in onbShaderOverride for the
// full shader.
MStatus status;
MFloatVector resultColor(0.0f, 0.0f, 0.0f);
MFloatVector resultTransparency(0.0f, 0.0f, 0.0f);
// Get surface shading parameters from input block
const MFloatVector& surfaceColor =
block.inputValue(aColor, &status).asFloatVector();
CHECK_MSTATUS(status);
const float roughness = block.inputValue(aRoughness, &status).asFloat();
CHECK_MSTATUS(status);
const MFloatVector& transparency =
block.inputValue(aTransparency, &status).asFloatVector();
CHECK_MSTATUS(status);
const MFloatVector& surfaceNormal =
block.inputValue(aNormalCamera, &status).asFloatVector();
CHECK_MSTATUS(status);
const MFloatVector& rayDirection =
block.inputValue(aRayDirection).asFloatVector();
const MFloatVector viewDirection = -rayDirection;
// Pre-compute some values that do not vary with lights
const float NV = viewDirection*surfaceNormal;
const float acosNV = acosf(NV);
const float roughnessSq = roughness*roughness;
const float A = 1.0f - 0.5f*(roughnessSq/(roughnessSq + 0.57f));
const float B = 0.45f*(roughnessSq/(roughnessSq + 0.09f));
// Get light list
MArrayDataHandle lightData = block.inputArrayValue(aLightData, &status);
CHECK_MSTATUS(status);
const int numLights = lightData.elementCount(&status);
CHECK_MSTATUS(status);
// Iterate through light list and get ambient/diffuse values
for (int count=1; count<=numLights; count++)
{
// Get the current light
MDataHandle currentLight = lightData.inputValue(&status);
CHECK_MSTATUS(status);
// Find diffuse component
if (currentLight.child(aLightDiffuse).asBool())
{
// Get the intensity and direction of that light
const MFloatVector& lightIntensity =
currentLight.child(aLightIntensity).asFloatVector();
const MFloatVector& lightDirection =
currentLight.child(aLightDirection).asFloatVector();
// Compute the diffuse factor
const float NL = lightDirection*surfaceNormal;
const float acosNL = acosf(NL);
const float alpha = std::max(acosNV, acosNL);
const float beta = std::min(acosNV, acosNL);
const float gamma =
(viewDirection - (surfaceNormal*NV)) *
(lightDirection - (surfaceNormal*NL));
const float C = sinf(alpha)*tanf(beta);
const float factor =
std::max(0.0f, NL)*(A + B*std::max(0.0f, gamma)*C);
// Add to result color
resultColor += lightIntensity*factor;
}
// Advance to the next light.
if (count < numLights)
{
status = lightData.next();
CHECK_MSTATUS(status);
}
}
// Factor incident light with surface color
resultColor[0] = resultColor[0]*surfaceColor[0];
resultColor[1] = resultColor[1]*surfaceColor[1];
resultColor[2] = resultColor[2]*surfaceColor[2];
// Set ouput color attribute
if (plug == aOutColor || plug.parent() == aOutColor)
{
// Get the handle to the attribute
MDataHandle outColorHandle = block.outputValue(aOutColor, &status);
CHECK_MSTATUS(status);
MFloatVector& outColor = outColorHandle.asFloatVector();
// Set the result and mark it clean
outColor = resultColor;
outColorHandle.setClean();
}
// Set ouput transparency
if (plug == aOutTransparency || plug.parent() == aOutTransparency)
{
// Get the handle to the attribute
MDataHandle outTransHandle =
block.outputValue(aOutTransparency, &status);
CHECK_MSTATUS(status);
MFloatVector& outTrans = outTransHandle.asFloatVector();
// Set the result and mark it clean
outTrans = transparency;
outTransHandle.setClean();
}
return MS::kSuccess;
}
MStatus splatDeformer::compute(const MPlug& plug, MDataBlock& data)
{
// do this if we are using an OpenMP implementation that is not the same as Maya's.
// Even if it is the same, it does no harm to make this call.
MThreadUtils::syncNumOpenMPThreads();
MStatus status = MStatus::kUnknownParameter;
if (plug.attribute() != outputGeom) {
return status;
}
unsigned int index = plug.logicalIndex();
MObject thisNode = this->thisMObject();
// get input value
MPlug inPlug(thisNode,input);
inPlug.selectAncestorLogicalIndex(index,input);
MDataHandle hInput = data.inputValue(inPlug, &status);
MCheckStatus(status, "ERROR getting input mesh\n");
// get the input geometry
MDataHandle inputData = hInput.child(inputGeom);
if (inputData.type() != MFnData::kMesh) {
printf("Incorrect input geometry type\n");
return MStatus::kFailure;
}
// get the input groupId - ignored for now...
MDataHandle hGroup = inputData.child(groupId);
unsigned int groupId = hGroup.asLong();
// get deforming mesh
MDataHandle deformData = data.inputValue(deformingMesh, &status);
MCheckStatus(status, "ERROR getting deforming mesh\n");
if (deformData.type() != MFnData::kMesh) {
printf("Incorrect deformer geometry type %d\n", deformData.type());
return MStatus::kFailure;
}
MObject dSurf = deformData.asMeshTransformed();
MFnMesh fnDeformingMesh;
fnDeformingMesh.setObject( dSurf ) ;
MDataHandle outputData = data.outputValue(plug);
outputData.copy(inputData);
if (outputData.type() != MFnData::kMesh) {
printf("Incorrect output mesh type\n");
return MStatus::kFailure;
}
MItGeometry iter(outputData, groupId, false);
// create fast intersector structure
MMeshIntersector intersector;
intersector.create(dSurf);
// get all points at once. Faster to query, and also better for
// threading than using iterator
MPointArray verts;
iter.allPositions(verts);
int nPoints = verts.length();
// use bool variable as lightweight object for failure check in loop below
bool failed = false;
MTimer timer; timer.beginTimer();
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(int i=0; i<nPoints; i++) {
// Cannot break out of an OpenMP loop, so if one of the
// intersections failed, skip the rest
if(failed) continue;
// mesh point object must be in loop-local scope to avoid race conditions
MPointOnMesh meshPoint;
// Do intersection. Need to use per-thread status value as
// MStatus has internal state and may trigger race conditions
// if set from multiple threads. Probably benign in this case,
// but worth being careful.
MStatus localStatus = intersector.getClosestPoint(verts[i], meshPoint);
if(localStatus != MStatus::kSuccess) {
// NOTE - we cannot break out of an OpenMP region, so set
// bad status and skip remaining iterations
failed = true;
continue;
}
// default OpenMP scheduling breaks traversal into large
// chunks, so low risk of false sharing here in array write.
verts[i] = meshPoint.getPoint();
}
timer.endTimer(); printf("Runtime for threaded loop %f\n", timer.elapsedTime());
// write values back onto output using fast set method on iterator
iter.setAllPositions(verts);
if(failed) {
printf("Closest point failed\n");
return MStatus::kFailure;
}
return status;
}
void extractPolygons(Model* model) {
MStatus stat;
MItDag dagIter(MItDag::kBreadthFirst, MFn::kInvalid);
for (; !dagIter.isDone(); dagIter.next()) {
MDagPath dagPath;
stat = dagIter.getPath(dagPath);
if (!stat) { continue; };
MFnDagNode dagNode(dagPath, &stat);
if (dagNode.isIntermediateObject()) continue;
if (!dagPath.hasFn( MFn::kMesh )) continue;
if (dagPath.hasFn( MFn::kTransform)) continue;
if (!dagPath.isVisible()) continue;
MFnMesh fnMesh(dagPath);
MStringArray UVSets;
stat = fnMesh.getUVSetNames( UVSets );
// Get all UVs for the first UV set.
MFloatArray u, v;
fnMesh.getUVs(u, v, &UVSets[0]);
MPointArray vertexList;
fnMesh.getPoints(vertexList, MSpace::kObject);
MFloatVectorArray meshNormals;
fnMesh.getNormals(meshNormals);
unsigned instanceNumber = dagPath.instanceNumber();
MObjectArray sets;
MObjectArray comps;
fnMesh.getConnectedSetsAndMembers( instanceNumber, sets, comps, true );
//printMaterials(dagPath);
unsigned int comlength = comps.length();
for (unsigned int compi = 0; compi < comlength; compi++) {
SubMesh submesh;
MItMeshPolygon itPolygon(dagPath, comps[compi]);
unsigned int polyCount = 0;
for (; !itPolygon.isDone(); itPolygon.next()) {
polyCount++;
MIntArray polygonVertices;
itPolygon.getVertices(polygonVertices);
int count;
itPolygon.numTriangles(count);
for (; count > -1; count--) {
MPointArray nonTweaked;
MIntArray triangleVertices;
MIntArray localIndex;
MStatus status;
status = itPolygon.getTriangle(count, nonTweaked, triangleVertices, MSpace::kObject);
if (status == MS::kSuccess) {
VertexDefinition vertex1;
VertexDefinition vertex2;
VertexDefinition vertex3;
{ // vertices
int vertexCount = vertexList.length();
{
int vertexIndex0 = triangleVertices[0];
MPoint point0 = vertexList[vertexIndex0];
vertex1.vertex.x = (float)point0.x;
vertex1.vertex.y = (float)point0.y;
vertex1.vertex.z = (float)point0.z;
}
{
int vertexIndex0 = triangleVertices[1];
MPoint point0 = vertexList[vertexIndex0];
vertex2.vertex.x = (float)point0.x;
vertex2.vertex.y = (float)point0.y;
vertex2.vertex.z = (float)point0.z;
}
{
int vertexIndex0 = triangleVertices[2];
MPoint point0 = vertexList[vertexIndex0];
vertex3.vertex.x = (float)point0.x;
vertex3.vertex.y = (float)point0.y;
vertex3.vertex.z = (float)point0.z;
}
}
{ // normals
// Get face-relative vertex indices for this triangle
localIndex = GetLocalIndex(polygonVertices, triangleVertices);
{
int index0 = itPolygon.normalIndex(localIndex[0]);
MPoint point0 = meshNormals[index0];
vertex1.normal.x = (float)point0.x;
vertex1.normal.y = (float)point0.y;
vertex1.normal.z = (float)point0.z;
}
{
int index0 = itPolygon.normalIndex(localIndex[1]);
MPoint point0 = meshNormals[index0];
vertex2.normal.x = (float)point0.x;
vertex2.normal.y = (float)point0.y;
vertex2.normal.z = (float)point0.z;
}
{
int index0 = itPolygon.normalIndex(localIndex[2]);
MPoint point0 = meshNormals[index0];
vertex3.normal.x = (float)point0.x;
vertex3.normal.y = (float)point0.y;
vertex3.normal.z = (float)point0.z;
}
}
{ // uvs
int uvID[3];
MStatus uvFetchStatus;
for (unsigned int vtxInPolygon = 0; vtxInPolygon < 3; vtxInPolygon++) {
uvFetchStatus = itPolygon.getUVIndex(localIndex[vtxInPolygon], uvID[vtxInPolygon]);
}
if (uvFetchStatus == MStatus::kSuccess) {
{
int index0 = uvID[0];
float uvu = u[index0];
float uvv = v[index0];
vertex1.uv.x = uvu;
vertex1.uv.y = 1.0f - uvv;
}
{
int index0 = uvID[1];
float uvu = u[index0];
float uvv = v[index0];
vertex2.uv.x = uvu;
vertex2.uv.y = 1.0f - uvv;
}
{
int index0 = uvID[2];
float uvu = u[index0];
float uvv = v[index0];
vertex3.uv.x = uvu;
vertex3.uv.y = 1.0f - uvv; // directx
}
}
}
submesh.addVertex(vertex1);
submesh.addVertex(vertex2);
submesh.addVertex(vertex3);
}
}
}
{
Material material;
{
MObjectArray shaders;
MIntArray indices;
fnMesh.getConnectedShaders(0, shaders, indices);
unsigned int shaderCount = shaders.length();
MPlugArray connections;
MFnDependencyNode shaderGroup(shaders[compi]);
MPlug shaderPlug = shaderGroup.findPlug("surfaceShader");
shaderPlug.connectedTo(connections, true, false);
for(unsigned int u = 0; u < connections.length(); u++) {
if(connections[u].node().hasFn(MFn::kLambert)) {
MFnLambertShader lambertShader(connections[u].node());
MPlugArray plugs;
lambertShader.findPlug("color").connectedTo(plugs, true, false);
for (unsigned int p = 0; p < plugs.length(); p++) {
MPlug object = plugs[p];
if (!object.isNull()) {
MObject node = object.node();
if (node.hasFn(MFn::kFileTexture)) {
MFnDependencyNode* diffuseMapNode = new MFnDependencyNode(node);
MPlug filenamePlug = diffuseMapNode->findPlug ("fileTextureName");
MString mayaFileName;
filenamePlug.getValue (mayaFileName);
std::string diffuseMapFileName = mayaFileName.asChar();
std::string diffuseMapAssetPath = extractAssetPath(diffuseMapFileName);
material.addTexture("ColorMap", diffuseMapAssetPath);
}
}
}
MColor color = lambertShader.color();
MString materialNameRaw = lambertShader.name();
std::string materialName = materialNameRaw.asChar();
material.setName(materialName);
Vector4MaterialParameter* diffuseColorParameter = new Vector4MaterialParameter("DiffuseColor");
diffuseColorParameter->value.x = color.r;
diffuseColorParameter->value.y = color.g;
diffuseColorParameter->value.z = color.b;
diffuseColorParameter->value.w = color.a;
material.addParameter(diffuseColorParameter);
}
}
}
{
if (material.hasTextures()) {
material.setEffect("shaders/deferred_render_colormap_normal_depth.cg");
}
else {
material.setEffect("shaders/deferred_render_color_normal_depth.cg");
}
}
{
FloatMaterialParameter* specularPowerParameter = new FloatMaterialParameter("SpecularPower");
specularPowerParameter->value = 1.0;
material.addParameter(specularPowerParameter);
}
{
FloatMaterialParameter* specularIntensityParameter = new FloatMaterialParameter("SpecularIntensity");
specularIntensityParameter->value = 1.0f;
material.addParameter(specularIntensityParameter);
}
{
FloatMaterialParameter* diffusePowerParameter = new FloatMaterialParameter("DiffusePower");
diffusePowerParameter->value = 1.0f;
material.addParameter(diffusePowerParameter);
}
submesh.setMaterial(material);
}
model->addSubMesh(submesh);
}
}
}
void MG_vectorGL::draw( M3dView & view, const MDagPath & path,
M3dView::DisplayStyle dispStyle,
M3dView::DisplayStatus status )
{
MPlug drawItP (thisMObject(),drawIt);
bool drawItV;
drawItP.getValue(drawItV);
MPlug arrowSizeP (thisMObject(),arrowSize);
double arrowSizeV;
arrowSizeP.getValue(arrowSizeV);
MPlug upVecP (thisMObject(),upVec);
MVector upVecV;
upVecP.child(0).getValue(upVecV.x);
upVecP.child(1).getValue(upVecV.y);
upVecP.child(2).getValue(upVecV.z);
MPlug vecsP (thisMObject(),vecs);
MPlug startPointP (thisMObject(),startPoint);
int elemVecs = vecsP.numElements();
int elemPoints = startPointP.numElements();
if ( drawItV == 0 )
{
return ;
}
if (elemVecs != elemPoints )
{
return;
}
// Draw it
view.beginGL();
glPushAttrib( GL_ALL_ATTRIB_BITS );
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glLineWidth(2);
if(status == M3dView::kLead)
glColor4f(0.0,1.0,0.0,1.0f);
else
glColor4f(1.0,1.0,0.0,1.0f);
for ( unsigned int i = 0 ; i < elemVecs ; i++ )
{
vecsP.selectAncestorLogicalIndex( i , vecs);
startPointP.selectAncestorLogicalIndex( i , startPoint);
MVector currentVec ;
MPoint currentPoint;
vecsP.child(0).getValue(currentVec.x);
vecsP.child(1).getValue(currentVec.y);
vecsP.child(2).getValue(currentVec.z);
startPointP.child(0).getValue(currentPoint.x);
startPointP.child(1).getValue(currentPoint.y);
startPointP.child(2).getValue(currentPoint.z);
drawArrow(currentVec , upVecV , arrowSizeV , currentPoint);
}
glDisable(GL_BLEND);
glPopAttrib();
}
void NifMeshExporterSkyrim::ExportMesh( MObject dagNode ) {
//out << "NifTranslator::ExportMesh {";
ComplexShape cs;
MStatus stat;
MObject mesh;
//Find Mesh child of given transform object
MFnDagNode nodeFn(dagNode);
cs.SetName(this->translatorUtils->MakeNifName(nodeFn.name()));
for (int i = 0; i != nodeFn.childCount(); ++i) {
// get a handle to the child
if (nodeFn.child(i).hasFn(MFn::kMesh)) {
MFnMesh tempFn(nodeFn.child(i));
//No history items
if (!tempFn.isIntermediateObject()) {
//out << "Found a mesh child." << endl;
mesh = nodeFn.child(i);
break;
}
}
}
MFnMesh visibleMeshFn(mesh, &stat);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to create visibleMeshFn.");
}
//out << visibleMeshFn.name().asChar() << ") {" << endl;
MFnMesh meshFn;
MObject dataObj;
MPlugArray inMeshPlugArray;
MPlug childPlug;
MPlug geomPlug;
MPlug inputPlug;
// this will hold the returned vertex positions
MPointArray vts;
//For now always use the visible mesh
meshFn.setObject(mesh);
//out << "Use the function set to get the points" << endl;
// use the function set to get the points
stat = meshFn.getPoints(vts);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to get points.");
}
//Maya won't store any information about objects with no vertices. Just skip it.
if (vts.length() == 0) {
MGlobal::displayWarning("An object in this scene has no vertices. Nothing will be exported.");
return;
}
vector<WeightedVertex> nif_vts(vts.length());
for (int i = 0; i != vts.length(); ++i) {
nif_vts[i].position.x = float(vts[i].x);
nif_vts[i].position.y = float(vts[i].y);
nif_vts[i].position.z = float(vts[i].z);
}
//Set vertex info later since it includes skin weights
//cs.SetVertices( nif_vts );
//out << "Use the function set to get the colors" << endl;
MColorArray myColors;
meshFn.getFaceVertexColors(myColors);
//out << "Prepare NIF color vector" << endl;
vector<Color4> niColors(myColors.length());
for (unsigned int i = 0; i < myColors.length(); ++i) {
niColors[i] = Color4(myColors[i].r, myColors[i].g, myColors[i].b, myColors[i].a);
}
cs.SetColors(niColors);
// this will hold the returned vertex positions
MFloatVectorArray nmls;
//out << "Use the function set to get the normals" << endl;
// use the function set to get the normals
stat = meshFn.getNormals(nmls, MSpace::kTransform);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to get normals");
}
//out << "Prepare NIF normal vector" << endl;
vector<Vector3> nif_nmls(nmls.length());
for (int i = 0; i != nmls.length(); ++i) {
nif_nmls[i].x = float(nmls[i].x);
nif_nmls[i].y = float(nmls[i].y);
nif_nmls[i].z = float(nmls[i].z);
}
cs.SetNormals(nif_nmls);
//out << "Use the function set to get the UV set names" << endl;
MStringArray uvSetNames;
MString baseUVSet;
MFloatArray myUCoords;
MFloatArray myVCoords;
bool has_uvs = false;
// get the names of the uv sets on the mesh
meshFn.getUVSetNames(uvSetNames);
vector<TexCoordSet> nif_uvs;
//Record assotiation between name and uv set index for later
map<string, int> uvSetNums;
int set_num = 0;
for (unsigned int i = 0; i < uvSetNames.length(); ++i) {
if (meshFn.numUVs(uvSetNames[i]) > 0) {
TexType tt;
string set_name = uvSetNames[i].asChar();
if (set_name == "base" || set_name == "map1") {
tt = BASE_MAP;
}
else if (set_name == "dark") {
tt = DARK_MAP;
}
else if (set_name == "detail") {
tt = DETAIL_MAP;
}
else if (set_name == "gloss") {
tt = GLOSS_MAP;
}
else if (set_name == "glow") {
tt = GLOW_MAP;
}
else if (set_name == "bump") {
tt = BUMP_MAP;
}
else if (set_name == "decal0") {
tt = DECAL_0_MAP;
}
else if (set_name == "decal1") {
tt = DECAL_1_MAP;
}
else {
tt = BASE_MAP;
}
//Record the assotiation
uvSetNums[set_name] = set_num;
//Get the UVs
meshFn.getUVs(myUCoords, myVCoords, &uvSetNames[i]);
//Make sure this set actually has some UVs in it. Maya sometimes returns empty UV sets.
if (myUCoords.length() == 0) {
continue;
}
//Store the data
TexCoordSet tcs;
tcs.texType = tt;
tcs.texCoords.resize(myUCoords.length());
for (unsigned int j = 0; j < myUCoords.length(); ++j) {
tcs.texCoords[j].u = myUCoords[j];
//Flip the V coords
tcs.texCoords[j].v = 1.0f - myVCoords[j];
}
nif_uvs.push_back(tcs);
baseUVSet = uvSetNames[i];
has_uvs = true;
set_num++;
}
}
cs.SetTexCoordSets(nif_uvs);
// this will hold references to the shaders used on the meshes
MObjectArray Shaders;
// this is used to hold indices to the materials returned in the object array
MIntArray FaceIndices;
//out << "Get the connected shaders" << endl;
// get the shaders used by the i'th mesh instance
// Assume this is not instanced for now
// TODO support instancing properly
stat = visibleMeshFn.getConnectedShaders(0, Shaders, FaceIndices);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to get connected shader list.");
}
vector<ComplexFace> nif_faces;
//Add shaders to propGroup array
vector< vector<NiPropertyRef> > propGroups;
for (unsigned int shader_num = 0; shader_num < Shaders.length(); ++shader_num) {
//Maya sometimes lists shaders that are not actually attached to any face. Disregard them.
bool shader_is_used = false;
for (size_t f = 0; f < FaceIndices.length(); ++f) {
if (FaceIndices[f] == shader_num) {
shader_is_used = true;
break;
}
}
if (shader_is_used == false) {
//Shader isn't actually used, so continue to the next one.
continue;
}
//out << "Found attached shader: ";
//Attach all properties previously associated with this shader to
//this NiTriShape
MFnDependencyNode fnDep(Shaders[shader_num]);
//Find the shader that this shading group connects to
MPlug p = fnDep.findPlug("surfaceShader");
MPlugArray plugs;
p.connectedTo(plugs, true, false);
for (unsigned int i = 0; i < plugs.length(); ++i) {
if (plugs[i].node().hasFn(MFn::kLambert)) {
fnDep.setObject(plugs[i].node());
break;
}
}
//out << fnDep.name().asChar() << endl;
vector<NiPropertyRef> niProps = this->translatorData->shaders[fnDep.name().asChar()];
propGroups.push_back(niProps);
}
cs.SetPropGroups(propGroups);
//out << "Export vertex and normal data" << endl;
// attach an iterator to the mesh
MItMeshPolygon itPoly(mesh, &stat);
if (stat != MS::kSuccess) {
throw runtime_error("Failed to create polygon iterator.");
}
// Create a list of faces with vertex IDs, and duplicate normals so they have the same ID
for (; !itPoly.isDone(); itPoly.next()) {
int poly_vert_count = itPoly.polygonVertexCount(&stat);
if (stat != MS::kSuccess) {
throw runtime_error("Failed to get vertex count.");
}
//Ignore polygons with less than 3 vertices
if (poly_vert_count < 3) {
continue;
}
ComplexFace cf;
//Assume all faces use material 0 for now
cf.propGroupIndex = 0;
for (int i = 0; i < poly_vert_count; ++i) {
ComplexPoint cp;
cp.vertexIndex = itPoly.vertexIndex(i);
cp.normalIndex = itPoly.normalIndex(i);
if (niColors.size() > 0) {
int color_index;
stat = meshFn.getFaceVertexColorIndex(itPoly.index(), i, color_index);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to get vertex color.");
}
cp.colorIndex = color_index;
}
//Get the UV set names used by this particular vertex
MStringArray vertUvSetNames;
itPoly.getUVSetNames(vertUvSetNames);
for (unsigned int j = 0; j < vertUvSetNames.length(); ++j) {
TexCoordIndex tci;
tci.texCoordSetIndex = uvSetNums[vertUvSetNames[j].asChar()];
int uv_index;
itPoly.getUVIndex(i, uv_index, &vertUvSetNames[j]);
tci.texCoordIndex = uv_index;
cp.texCoordIndices.push_back(tci);
}
cf.points.push_back(cp);
}
nif_faces.push_back(cf);
}
//Set shader/face association
if (nif_faces.size() != FaceIndices.length()) {
throw runtime_error("Num faces found do not match num faces reported.");
}
for (unsigned int face_index = 0; face_index < nif_faces.size(); ++face_index) {
nif_faces[face_index].propGroupIndex = FaceIndices[face_index];
}
cs.SetFaces(nif_faces);
//--Skin Processing--//
//Look up any skin clusters
if (this->translatorData->meshClusters.find(visibleMeshFn.fullPathName().asChar()) != this->translatorData->meshClusters.end()) {
const vector<MObject> & clusters = this->translatorData->meshClusters[visibleMeshFn.fullPathName().asChar()];
if (clusters.size() > 1) {
throw runtime_error("Objects with multiple skin clusters affecting them are not currently supported. Try deleting the history and re-binding them.");
}
vector<MObject>::const_iterator cluster = clusters.begin();
if (cluster->isNull() != true) {
MFnSkinCluster clusterFn(*cluster);
//out << "Processing skin..." << endl;
//Get path to visible mesh
MDagPath meshPath;
visibleMeshFn.getPath(meshPath);
//out << "Getting a list of all verticies in this mesh" << endl;
//Get a list of all vertices in this mesh
MFnSingleIndexedComponent compFn;
MObject vertices = compFn.create(MFn::kMeshVertComponent);
MItGeometry gIt(meshPath);
MIntArray vertex_indices(gIt.count());
for (int vert_index = 0; vert_index < gIt.count(); ++vert_index) {
vertex_indices[vert_index] = vert_index;
}
compFn.addElements(vertex_indices);
//out << "Getting Influences" << endl;
//Get influences
MDagPathArray myBones;
clusterFn.influenceObjects(myBones, &stat);
//out << "Creating a list of NiNodeRefs of influences." << endl;
//Create list of NiNodeRefs of influences
vector<NiNodeRef> niBones(myBones.length());
for (unsigned int bone_index = 0; bone_index < niBones.size(); ++bone_index) {
const char* boneName = myBones[bone_index].fullPathName().asChar();
if (this->translatorData->nodes.find(myBones[bone_index].fullPathName().asChar()) == this->translatorData->nodes.end()) {
//There is a problem; one of the joints was not exported. Abort.
throw runtime_error("One of the joints necessary to export a bound skin was not exported.");
}
niBones[bone_index] = this->translatorData->nodes[myBones[bone_index].fullPathName().asChar()];
}
//out << "Getting weights from Maya" << endl;
//Get weights from Maya
MDoubleArray myWeights;
unsigned int bone_count = myBones.length();
stat = clusterFn.getWeights(meshPath, vertices, myWeights, bone_count);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to get vertex weights.");
}
//out << "Setting skin influence list in ComplexShape" << endl;
//Set skin information in ComplexShape
cs.SetSkinInfluences(niBones);
//out << "Adding weights to ComplexShape vertices" << endl;
//out << "Number of weights: " << myWeights.length() << endl;
//out << "Number of bones: " << myBones.length() << endl;
//out << "Number of Maya vertices: " << gIt.count() << endl;
//out << "Number of NIF vertices: " << int(nif_vts.size()) << endl;
unsigned int weight_index = 0;
SkinInfluence sk;
for (unsigned int vert_index = 0; vert_index < nif_vts.size(); ++vert_index) {
for (unsigned int bone_index = 0; bone_index < myBones.length(); ++bone_index) {
//out << "vert_index: " << vert_index << " bone_index: " << bone_index << " weight_index: " << weight_index << endl;
// Only bother with weights that are significant
if (myWeights[weight_index] > 0.0f) {
sk.influenceIndex = bone_index;
sk.weight = float(myWeights[weight_index]);
nif_vts[vert_index].weights.push_back(sk);
}
++weight_index;
}
}
}
MPlugArray connected_dismember_plugs;
MObjectArray dismember_nodes;
meshFn.findPlug("message").connectedTo(connected_dismember_plugs, false, true);
bool has_valid_dismemember_partitions = true;
int faces_count = cs.GetFaces().size();
int current_face_index;
vector<BodyPartList> body_parts_list;
vector<uint> dismember_faces(faces_count, 0);
for (int x = 0; x < connected_dismember_plugs.length(); x++) {
MFnDependencyNode dependency_node(connected_dismember_plugs[x].node());
if (dependency_node.typeName() == "nifDismemberPartition") {
dismember_nodes.append(dependency_node.object());
}
}
if (dismember_nodes.length() == 0) {
has_valid_dismemember_partitions = false;
}
else {
int blind_data_id;
int blind_data_value;
MStatus status;
MPlug target_faces_plug;
MItMeshPolygon it_polygons(meshFn.object());
MString mel_command;
MStringArray current_body_parts_flags;
MFnDependencyNode current_dismember_node;
MFnDependencyNode current_blind_data_node;
//Naive sort here, there is no reason and is extremely undesirable and not recommended to have more
//than 10-20 dismember partitions out of many reasons, so it's okay here
//as it makes the code easier to understand
vector<int> dismember_nodes_id(dismember_nodes.length(), -1);
for (int x = 0; x < dismember_nodes.length(); x++) {
current_dismember_node.setObject(dismember_nodes[x]);
connected_dismember_plugs.clear();
current_dismember_node.findPlug("targetFaces").connectedTo(connected_dismember_plugs, true, false);
if (connected_dismember_plugs.length() == 0) {
has_valid_dismemember_partitions = false;
break;
}
current_blind_data_node.setObject(connected_dismember_plugs[0].node());
dismember_nodes_id[x] = current_blind_data_node.findPlug("typeId").asInt();
}
for (int x = 0; x < dismember_nodes.length() - 1; x++) {
for (int y = x + 1; y < dismember_nodes.length(); y++) {
if (dismember_nodes_id[x] > dismember_nodes_id[y]) {
MObject aux = dismember_nodes[x];
blind_data_id = dismember_nodes_id[x];
dismember_nodes[x] = dismember_nodes[y];
dismember_nodes_id[x] = dismember_nodes_id[y];
dismember_nodes[y] = aux;
dismember_nodes_id[y] = blind_data_id;
}
}
}
for (int x = 0; x < dismember_nodes.length(); x++) {
current_dismember_node.setObject(dismember_nodes[x]);
target_faces_plug = current_dismember_node.findPlug("targetFaces");
connected_dismember_plugs.clear();
target_faces_plug.connectedTo(connected_dismember_plugs, true, false);
if (connected_dismember_plugs.length() > 0) {
current_blind_data_node.setObject(connected_dismember_plugs[0].node());
current_face_index = 0;
blind_data_id = current_blind_data_node.findPlug("typeId").asInt();
for (it_polygons.reset(); !it_polygons.isDone(); it_polygons.next()) {
if (it_polygons.polygonVertexCount() >= 3) {
status = meshFn.getIntBlindData(it_polygons.index(), MFn::Type::kMeshPolygonComponent, blind_data_id, "dismemberValue", blind_data_value);
if (status == MStatus::kSuccess && blind_data_value == 1 &&
meshFn.hasBlindDataComponentId(it_polygons.index(), MFn::Type::kMeshPolygonComponent, blind_data_id)) {
dismember_faces[current_face_index] = x;
}
current_face_index++;
}
}
}
else {
has_valid_dismemember_partitions = false;
break;
}
mel_command = "getAttr ";
mel_command += current_dismember_node.name();
mel_command += ".bodyPartsFlags";
status = MGlobal::executeCommand(mel_command, current_body_parts_flags);
BSDismemberBodyPartType body_part_type = NifDismemberPartition::stringArrayToBodyPartType(current_body_parts_flags);
current_body_parts_flags.clear();
mel_command = "getAttr ";
mel_command += current_dismember_node.name();
mel_command += ".partsFlags";
status = MGlobal::executeCommand(mel_command, current_body_parts_flags);
BSPartFlag part_type = NifDismemberPartition::stringArrayToPart(current_body_parts_flags);
current_body_parts_flags.clear();
BodyPartList body_part;
body_part.bodyPart = body_part_type;
body_part.partFlag = part_type;
body_parts_list.push_back(body_part);
}
}
if (has_valid_dismemember_partitions == false) {
MGlobal::displayWarning("No proper dismember partitions, generating default ones for " + meshFn.name());
for (int x = 0; x < dismember_faces.size(); x++) {
dismember_faces[x] = 0;
}
BodyPartList body_part;
body_part.bodyPart = (BSDismemberBodyPartType)0;
body_part.partFlag = (BSPartFlag)(PF_EDITOR_VISIBLE | PF_START_NET_BONESET);
body_parts_list.clear();
body_parts_list.push_back(body_part);
}
cs.SetDismemberPartitionsBodyParts(body_parts_list);
cs.SetDismemberPartitionsFaces(dismember_faces);
}
//out << "Setting vertex info" << endl;
//Set vertex info now that any skins have been processed
cs.SetVertices(nif_vts);
//ComplexShape is now complete, so split it
//Get parent
NiNodeRef parNode = this->translatorUtils->GetDAGParent(dagNode);
Matrix44 transform = Matrix44::IDENTITY;
vector<NiNodeRef> influences = cs.GetSkinInfluences();
if (influences.size() > 0) {
//This is a skin, so we use the common ancestor of all influences
//as the parent
vector<NiAVObjectRef> objects;
for (size_t i = 0; i < influences.size(); ++i) {
objects.push_back(StaticCast<NiAVObject>(influences[i]));
}
//Get world transform of existing parent
Matrix44 oldParWorld = parNode->GetWorldTransform();
//Set new parent node
parNode = FindCommonAncestor(objects);
transform = oldParWorld * parNode->GetWorldTransform().Inverse();
}
//Get transform using temporary NiAVObject
NiAVObjectRef tempAV = new NiAVObject;
this->nodeExporter->ExportAV(tempAV, dagNode);
NiAVObjectRef avObj;
if (this->translatorOptions->exportTangentSpace == "falloutskyrimtangentspace") {
//out << "Split ComplexShape from " << meshFn.name().asChar() << endl;
avObj = cs.Split(parNode, tempAV->GetLocalTransform() * transform, this->translatorOptions->exportBonesPerSkinPartition,
this->translatorOptions->exportAsTriStrips, true, this->translatorOptions->exportMinimumVertexWeight, 16);
}
else {
avObj = cs.Split(parNode, tempAV->GetLocalTransform() * transform, this->translatorOptions->exportBonesPerSkinPartition,
this->translatorOptions->exportAsTriStrips, false, this->translatorOptions->exportMinimumVertexWeight);
}
//out << "Get the NiAVObject portion of the root of the split" <<endl;
//Get the NiAVObject portion of the root of the split
avObj->SetName(tempAV->GetName());
avObj->SetVisibility(tempAV->GetVisibility());
avObj->SetFlags(tempAV->GetFlags());
//If polygon mesh is hidden, hide tri_shape
MPlug vis = visibleMeshFn.findPlug(MString("visibility"));
bool visibility;
vis.getValue(visibility);
NiNodeRef splitRoot = DynamicCast<NiNode>(avObj);
if (splitRoot != NULL) {
//Root is a NiNode with NiTriBasedGeom children.
vector<NiAVObjectRef> children = splitRoot->GetChildren();
for (unsigned c = 0; c < children.size(); ++c) {
//Set the default collision propogation flag to "use triangles"
children[c]->SetFlags(2);
// Make the mesh invisible if necessary
if (visibility == false) {
children[c]->SetVisibility(false);
}
}
}
else {
//Root must be a NiTriBasedGeom. Make it invisible if necessary
if (visibility == false) {
avObj->SetVisibility(false);
}
}
}
MStatus closestPointOnCurveCommand::redoIt()
{
// DOUBLE-CHECK TO MAKE SURE THERE'S A SPECIFIED OBJECT TO EVALUATE ON:
if (sList.length() == 0)
{
MStatus stat;
MString msg = MStringResource::getString(kNoValidObject, stat);
displayError(msg);
return MStatus::kFailure;
}
// RETRIEVE THE SPECIFIED OBJECT AS A DAGPATH:
MDagPath curveDagPath;
sList.getDagPath(0, curveDagPath);
// CHECK FOR INVALID NODE-TYPE INPUT WHEN SPECIFIED/SELECTED NODE IS *NOT* A "CURVE" NOR "CURVE TRANSFORM":
if (!curveDagPath.node().hasFn(MFn::kNurbsCurve) && !(curveDagPath.node().hasFn(MFn::kTransform) && curveDagPath.hasFn(MFn::kNurbsCurve)))
{
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kInvalidType, stat);
MStringArray selectionStrings;
sList.getSelectionStrings(0, selectionStrings);
msg.format(msgFmt, selectionStrings[0]);
displayError(msg);
return MStatus::kFailure;
}
// WHEN COMMAND *NOT* IN "QUERY MODE" (I.E. "CREATION MODE"), CREATE AND CONNECT A "closestPointOnCurve" NODE AND RETURN ITS NODE NAME:
if (!queryFlagSet)
{
// CREATE THE NODE:
MFnDependencyNode depNodeFn;
if (closestPointOnCurveNodeName == "")
depNodeFn.create("closestPointOnCurve");
else
depNodeFn.create("closestPointOnCurve", closestPointOnCurveNodeName);
closestPointOnCurveNodeName = depNodeFn.name();
// SET THE ".inPosition" ATTRIBUTE, IF SPECIFIED IN THE COMMAND:
if (inPositionFlagSet)
{
MPlug inPositionXPlug = depNodeFn.findPlug("inPositionX");
inPositionXPlug.setValue(inPosition.x);
MPlug inPositionYPlug = depNodeFn.findPlug("inPositionY");
inPositionYPlug.setValue(inPosition.y);
MPlug inPositionZPlug = depNodeFn.findPlug("inPositionZ");
inPositionZPlug.setValue(inPosition.z);
}
// MAKE SOME ADJUSTMENTS WHEN THE SPECIFIED NODE IS A "TRANSFORM" OF A CURVE SHAPE:
unsigned instanceNumber=0;
if (curveDagPath.node().hasFn(MFn::kTransform))
{
// EXTEND THE DAGPATH TO ITS CURVE "SHAPE" NODE:
curveDagPath.extendToShape();
// TRANSFORMS ARE *NOT* NECESSARILY THE "FIRST" INSTANCE TRANSFORM OF A CURVE SHAPE:
instanceNumber = curveDagPath.instanceNumber();
}
// CONNECT THE NODES:
MPlug worldCurvePlug, inCurvePlug;
inCurvePlug = depNodeFn.findPlug("inCurve");
depNodeFn.setObject(curveDagPath.node());
worldCurvePlug = depNodeFn.findPlug("worldSpace");
worldCurvePlug = worldCurvePlug.elementByLogicalIndex(instanceNumber);
MDGModifier dgModifier;
dgModifier.connect(worldCurvePlug, inCurvePlug);
dgModifier.doIt();
// SET COMMAND RESULT TO BE NEW NODE'S NAME, AND RETURN:
setResult(closestPointOnCurveNodeName);
return MStatus::kSuccess;
}
// OTHERWISE, WE'RE IN THE COMMAND'S "QUERY MODE":
else
{
// COMPUTE THE CLOSEST POSITION, NORMAL, TANGENT, PARAMETER-U AND DISTANCE, USING THE *FIRST* INSTANCE TRANSFORM WHEN CURVE IS SPECIFIED AS A "SHAPE":
MPoint position;
MVector normal, tangent;
double paramU, distance;
closestTangentUAndDistance(curveDagPath, inPosition, position, normal, tangent, paramU, distance);
// WHEN NO QUERYABLE FLAG IS SPECIFIED, INDICATE AN ERROR:
if (!positionFlagSet && !normalFlagSet && !tangentFlagSet && !paramUFlagSet && !distanceFlagSet)
{
MStatus stat;
MString msg = MStringResource::getString(kNoQueryFlag, stat);
displayError(msg);
return MStatus::kFailure;
}
// WHEN JUST THE "DISTANCE" IS QUERIED, RETURN A SINGLE "FLOAT" INSTEAD OF AN ENTIRE FLOAT ARRAY FROM THE COMMAND:
else if (distanceFlagSet && !(positionFlagSet || normalFlagSet || tangentFlagSet || paramUFlagSet))
setResult(distance);
// WHEN JUST THE "PARAMETER-U" IS QUERIED, RETURN A SINGLE "FLOAT" INSTEAD OF AN ENTIRE FLOAT ARRAY FROM THE COMMAND:
else if (paramUFlagSet && !(positionFlagSet || normalFlagSet || tangentFlagSet || distanceFlagSet))
setResult(paramU);
// OTHERWISE, SET THE RETURN VALUE OF THE COMMAND'S RESULT TO A "COMPOSITE ARRAY OF FLOATS":
else
{
// HOLDS FLOAT ARRAY RESULT:
MDoubleArray floatArrayResult;
// APPEND THE RESULTS OF THE CLOSEST POSITION, NORMAL, TANGENT, PARAMETER-U AND DISTANCE VALUES TO THE FLOAT ARRAY RESULT:
if (positionFlagSet)
{
floatArrayResult.append(position.x);
floatArrayResult.append(position.y);
floatArrayResult.append(position.z);
}
if (normalFlagSet)
{
floatArrayResult.append(normal.x);
floatArrayResult.append(normal.y);
floatArrayResult.append(normal.z);
}
if (tangentFlagSet)
{
floatArrayResult.append(tangent.x);
floatArrayResult.append(tangent.y);
floatArrayResult.append(tangent.z);
}
if (paramUFlagSet)
floatArrayResult.append(paramU);
if (distanceFlagSet)
floatArrayResult.append(distance);
// FINALLY, SET THE COMMAND'S RESULT:
setResult(floatArrayResult);
}
return MStatus::kSuccess;
}
}
// Load texture data from a texture node
MStatus Material::loadTexture(MFnDependencyNode* pTexNode,TexOpType& opType,MStringArray& uvsets,ParamList& params)
{
Texture tex;
// Get texture filename
MString filename, absFilename;
MRenderUtil::exactFileTextureName(pTexNode->object(),absFilename);
filename = absFilename.substring(absFilename.rindex('/')+1,absFilename.length()-1);
MString command = "toNativePath(\"";
command += absFilename;
command += "\")";
MGlobal::executeCommand(command,absFilename);
tex.absFilename = absFilename;
tex.filename = filename;
tex.uvsetIndex = 0;
tex.uvsetName = "";
// Set texture operation type
tex.opType = opType;
// Get connections to uvCoord attribute of texture node
MPlugArray texSrcPlugs;
pTexNode->findPlug("uvCoord").connectedTo(texSrcPlugs,true,false);
// Get place2dtexture node (if connected)
MFnDependencyNode* pPlace2dTexNode = NULL;
for (int j=0; j<texSrcPlugs.length(); j++)
{
if (texSrcPlugs[j].node().hasFn(MFn::kPlace2dTexture))
{
pPlace2dTexNode = new MFnDependencyNode(texSrcPlugs[j].node());
continue;
}
}
// Get uvChooser node (if connected)
MFnDependencyNode* pUvChooserNode = NULL;
if (pPlace2dTexNode)
{
MPlugArray placetexSrcPlugs;
pPlace2dTexNode->findPlug("uvCoord").connectedTo(placetexSrcPlugs,true,false);
for (int j=0; j<placetexSrcPlugs.length(); j++)
{
if (placetexSrcPlugs[j].node().hasFn(MFn::kUvChooser))
{
pUvChooserNode = new MFnDependencyNode(placetexSrcPlugs[j].node());
continue;
}
}
}
// Get uvset index
if (pUvChooserNode)
{
bool foundMesh = false;
bool foundUvset = false;
MPlug uvsetsPlug = pUvChooserNode->findPlug("uvSets");
MPlugArray uvsetsSrcPlugs;
for (int i=0; i<uvsetsPlug.evaluateNumElements() && !foundMesh; i++)
{
uvsetsPlug[i].connectedTo(uvsetsSrcPlugs,true,false);
for (int j=0; j<uvsetsSrcPlugs.length() && !foundMesh; j++)
{
if (uvsetsSrcPlugs[j].node().hasFn(MFn::kMesh))
{
uvsetsSrcPlugs[j].getValue(tex.uvsetName);
for (int k=0; k<uvsets.length() && !foundUvset; k++)
{
if (uvsets[k] == tex.uvsetName)
{
tex.uvsetIndex = k;
foundUvset = true;
}
}
}
}
}
}
// Get texture options from Place2dTexture node
if (pPlace2dTexNode)
{
// Get address mode
//U
bool wrapU, mirrorU;
pPlace2dTexNode->findPlug("wrapU").getValue(wrapU);
pPlace2dTexNode->findPlug("mirrorU").getValue(mirrorU);
if (mirrorU)
tex.am_u = TAM_MIRROR;
else if (wrapU)
tex.am_u = TAM_WRAP;
else
tex.am_u = TAM_CLAMP;
// V
bool wrapV,mirrorV;
pPlace2dTexNode->findPlug("wrapV").getValue(wrapV);
pPlace2dTexNode->findPlug("mirrorV").getValue(mirrorV);
if (mirrorV)
tex.am_v = TAM_MIRROR;
else if (wrapV)
tex.am_v = TAM_WRAP;
else
tex.am_v = TAM_CLAMP;
// Get texture scale
double covU,covV;
pPlace2dTexNode->findPlug("coverageU").getValue(covU);
pPlace2dTexNode->findPlug("coverageV").getValue(covV);
tex.scale_u = covU;
if (fabs(tex.scale_u) < PRECISION)
tex.scale_u = 0;
tex.scale_v = covV;
if (fabs(tex.scale_v) < PRECISION)
tex.scale_v = 0;
// Get texture scroll
double transU,transV;
pPlace2dTexNode->findPlug("translateFrameU").getValue(transU);
pPlace2dTexNode->findPlug("translateFrameV").getValue(transV);
tex.scroll_u = -0.5 * (covU-1.0)/covU - transU/covU;
if (fabs(tex.scroll_u) < PRECISION)
tex.scroll_u = 0;
tex.scroll_v = 0.5 * (covV-1.0)/covV + transV/covV;
if (fabs(tex.scroll_v) < PRECISION)
tex.scroll_v = 0;
// Get texture rotation
double rot;
pPlace2dTexNode->findPlug("rotateFrame").getValue(rot);
tex.rot = -rot;
if (fabs(rot) < PRECISION)
tex.rot = 0;
}
// add texture to material texture list
m_textures.push_back(tex);
// free up memory
if (pUvChooserNode)
delete pUvChooserNode;
if (pPlace2dTexNode)
delete pPlace2dTexNode;
return MS::kSuccess;
}
//
// Write the 'connectAttr' commands for all of a node's incoming
// connections.
//
void maTranslator::writeNodeConnections(fstream& f, const MObject& node)
{
MFnDependencyNode nodeFn(node);
MPlugArray plugs;
nodeFn.getConnections(plugs);
unsigned int numBrokenConns = fBrokenConnSrcs.length();
unsigned int numPlugs = plugs.length();
unsigned int i;
for (i = 0; i < numPlugs; i++)
{
//
// We only care about connections where we are the destination.
//
MPlug destPlug = plugs[i];
MPlugArray srcPlug;
destPlug.connectedTo(srcPlug, true, false);
if (srcPlug.length() > 0)
{
MObject srcNode = srcPlug[0].node();
MFnDependencyNode srcNodeFn(srcNode);
//
// Don't write the connection if the source is not writable...
//
if (!srcNodeFn.canBeWritten()) continue;
//
// or the connection was made in a referenced file...
//
if (destPlug.isFromReferencedFile()) continue;
//
// or the plug is procedural...
//
if (destPlug.isProcedural()) continue;
//
// or it is a connection between a default node and a shared
// node (because those will get set up automatically).
//
if (srcNodeFn.isDefaultNode() && nodeFn.isShared()) continue;
f << "connectAttr \"";
//
// Default nodes get a colon at the start of their names.
//
if (srcNodeFn.isDefaultNode()) f << ":";
f << srcPlug[0].partialName(true).asChar()
<< "\" \"";
if (nodeFn.isDefaultNode()) f << ":";
f << destPlug.partialName(true).asChar()
<< "\"";
//
// If the src plug is also one from which a broken
// connection originated, then add the "-rd/referenceDest" flag
// to the command. That will help Maya to better adjust if the
// referenced file has changed the next time it is loaded.
//
if (srcNodeFn.isFromReferencedFile())
{
unsigned int j;
for (j = 0; j < numBrokenConns; j++)
{
if (fBrokenConnSrcs[j] == srcPlug[0])
{
f << " -rd \""
<< fBrokenConnDests[j].partialName(true).asChar()
<< "\"";
break;
}
}
}
//
// If the plug is locked, then add a "-l/lock" flag to the
// command.
//
if (destPlug.isLocked()) f << " -l on";
//
// If the destination attribute is a multi for which index
// does not matter, then we must add the "-na/nextAvailable"
// flag to the command.
//
MObject attr = destPlug.attribute();
MFnAttribute attrFn(attr);
if (!attrFn.indexMatters()) f << " -na";
f << ";" << endl;
}
}
}
// Load material data
MStatus Material::load(MFnDependencyNode* pShader,MStringArray& uvsets,ParamList& params)
{
MStatus stat;
clear();
//read material name, adding the requested prefix
MString tmpStr = params.matPrefix;
if (tmpStr != "")
tmpStr += "/";
tmpStr += pShader->name();
MStringArray tmpStrArray;
tmpStr.split(':',tmpStrArray);
m_name = "";
for (int i=0; i<tmpStrArray.length(); i++)
{
m_name += tmpStrArray[i];
if (i < tmpStrArray.length()-1)
m_name += "_";
}
//check if we want to export with lighting off option
m_lightingOff = params.lightingOff;
// GET MATERIAL DATA
// Check material type
if (pShader->object().hasFn(MFn::kPhong))
{
stat = loadPhong(pShader);
}
else if (pShader->object().hasFn(MFn::kBlinn))
{
stat = loadBlinn(pShader);
}
else if (pShader->object().hasFn(MFn::kLambert))
{
stat = loadLambert(pShader);
}
else if (pShader->object().hasFn(MFn::kPluginHwShaderNode))
{
stat = loadCgFxShader(pShader);
}
else
{
stat = loadSurfaceShader(pShader);
}
// Get textures data
MPlugArray colorSrcPlugs;
MPlugArray texSrcPlugs;
MPlugArray placetexSrcPlugs;
if (m_isTextured)
{
// Translate multiple textures if material is multitextured
if (m_isMultiTextured)
{
// Get layered texture node
MFnDependencyNode* pLayeredTexNode = NULL;
if (m_type == MT_SURFACE_SHADER)
pShader->findPlug("outColor").connectedTo(colorSrcPlugs,true,false);
else
pShader->findPlug("color").connectedTo(colorSrcPlugs,true,false);
for (int i=0; i<colorSrcPlugs.length(); i++)
{
if (colorSrcPlugs[i].node().hasFn(MFn::kLayeredTexture))
{
pLayeredTexNode = new MFnDependencyNode(colorSrcPlugs[i].node());
continue;
}
}
// Get inputs to layered texture
MPlug inputsPlug = pLayeredTexNode->findPlug("inputs");
// Scan inputs and export textures
for (int i=inputsPlug.numElements()-1; i>=0; i--)
{
MFnDependencyNode* pTextureNode = NULL;
// Search for a connected texture
inputsPlug[i].child(0).connectedTo(colorSrcPlugs,true,false);
for (int j=0; j<colorSrcPlugs.length(); j++)
{
if (colorSrcPlugs[j].node().hasFn(MFn::kFileTexture))
{
pTextureNode = new MFnDependencyNode(colorSrcPlugs[j].node());
continue;
}
}
// Translate the texture if it was found
if (pTextureNode)
{
// Get blend mode
TexOpType opType;
short bm;
inputsPlug[i].child(2).getValue(bm);
switch(bm)
{
case 0:
opType = TOT_REPLACE;
break;
case 1:
opType = TOT_ALPHABLEND;
break;
case 4:
opType = TOT_ADD;
break;
case 6:
opType = TOT_MODULATE;
break;
default:
opType = TOT_MODULATE;
}
stat = loadTexture(pTextureNode,opType,uvsets,params);
delete pTextureNode;
if (MS::kSuccess != stat)
{
std::cout << "Error loading layered texture\n";
std::cout.flush();
delete pLayeredTexNode;
return MS::kFailure;
}
}
}
if (pLayeredTexNode)
delete pLayeredTexNode;
}
// Else translate the single texture
else
{
// Get texture node
MFnDependencyNode* pTextureNode = NULL;
if (m_type == MT_SURFACE_SHADER)
pShader->findPlug("outColor").connectedTo(colorSrcPlugs,true,false);
else
pShader->findPlug("color").connectedTo(colorSrcPlugs,true,false);
for (int i=0; i<colorSrcPlugs.length(); i++)
{
if (colorSrcPlugs[i].node().hasFn(MFn::kFileTexture))
{
pTextureNode = new MFnDependencyNode(colorSrcPlugs[i].node());
continue;
}
}
if (pTextureNode)
{
TexOpType opType = TOT_MODULATE;
stat = loadTexture(pTextureNode,opType,uvsets,params);
delete pTextureNode;
if (MS::kSuccess != stat)
{
std::cout << "Error loading texture\n";
std::cout.flush();
return MS::kFailure;
}
}
}
}
return MS::kSuccess;
}
void
simpleFluidEmitter::volumeFluidEmitter(
MFnFluid& fluid,
const MMatrix& fluidWorldMatrix,
int plugIndex,
MDataBlock& block,
double dt,
double conversion,
double dropoff
)
//==============================================================================
//
// Method:
//
// simpleFluidEmitter::volumeFluidEmitter
//
// Description:
//
// Emits fluid from points distributed over the surface of the
// emitter's owner object.
//
// Parameters:
//
// fluid: fluid into which we are emitting
// fluidWorldMatrix: object->world matrix for the fluid
// plugIndex: identifies which fluid connected to the emitter
// we are emitting into
// block: datablock for the emitter, to retrieve attribute
// values
// dt: time delta for this frame
// conversion: mapping from UI emission rates to internal units
// dropoff: specifies how much emission rate drops off as
// we move away from the local y-axis of the
// volume emitter shape.
//
//==============================================================================
{
// get emitter position and relevant matrices
//
MPoint emitterPos = getWorldPosition();
MMatrix emitterWorldMatrix = getWorldMatrix();
MMatrix fluidInverseWorldMatrix = fluidWorldMatrix.inverse();
// get emission rates for density, fuel, heat, and emission color
//
double densityEmit = fluidDensityEmission( block );
double fuelEmit = fluidFuelEmission( block );
double heatEmit = fluidHeatEmission( block );
bool doEmitColor = fluidEmitColor( block );
MColor emitColor = fluidColor( block );
// rate modulation based on frame time, user value conversion factor, and
// standard emitter "rate" value (not actually exposed in most fluid
// emitters, but there anyway).
//
double theRate = getRate(block) * dt * conversion;
// find the voxels that intersect the bounding box of the volume
// primitive associated with the emitter
//
MBoundingBox bbox;
if( !volumePrimitiveBoundingBox( bbox ) )
{
// shouldn't happen
//
return;
}
// transform volume primitive into fluid space
//
bbox.transformUsing( emitterWorldMatrix );
bbox.transformUsing( fluidInverseWorldMatrix );
MPoint lowCorner = bbox.min();
MPoint highCorner = bbox.max();
// see if autoresize to emitter is on, so we can resize before emitting
//
// unfortunately, we need the fluidShape itself in order to check
// we'll just look at the first connected fluid,
// walking the multi is left as an excercise for the reader
// similarly, determining whether there is start frame emission
// and resizing at the start frame, or not, is left as an excercise
// and finally, emission with autoResize will need to include the dynamicOffset
//
MObject thisObj = thisMObject();
MFnDependencyNode nodeFn(thisObj);
bool autoResize = false;
bool resizeToEmitter = false;
MPlug fnPlug = nodeFn.findPlug("emissionFunction");
if(fnPlug.isConnected()) {
MPlugArray connections;
fnPlug.connectedTo(connections, false, true);
if (connections.length() > 0) {
MObject sourceNode = connections[0].node();
if (sourceNode.hasFn(MFn::kFluid)) {
MFnFluid fluidFn(sourceNode);
autoResize = fluidFn.isAutoResize();
resizeToEmitter = fluidFn.isResizeToEmitter();
if(autoResize && resizeToEmitter) {
fluidFn.expandToInclude(lowCorner, highCorner);
}
}
}
}
if(autoResize && resizeToEmitter) {
fluid.updateGrid ();
}
// get voxel dimensions and sizes (object space)
//
double size[3];
unsigned int res[3];
fluid.getDimensions( size[0], size[1], size[2] );
fluid.getResolution( res[0], res[1], res[2] );
// voxel sizes
double dx = size[0] / res[0];
double dy = size[1] / res[1];
double dz = size[2] / res[2];
// voxel centers
double Ox = -size[0]/2;
double Oy = -size[1]/2;
double Oz = -size[2]/2;
// get fluid voxel coord range of bounding box
//
int3 lowCoords;
int3 highCoords;
fluid.toGridIndex( lowCorner, lowCoords );
fluid.toGridIndex( highCorner, highCoords );
int i;
for ( i = 0; i < 3; i++ )
{
if ( lowCoords[i] < 0 ) {
lowCoords[i] = 0;
} else if ( lowCoords[i] > ((int)res[i])-1 ) {
lowCoords[i] = ((int)res[i])-1;
}
if ( highCoords[i] < 0 ) {
highCoords[i] = 0;
} else if ( highCoords[i] > ((int)res[i])-1 ) {
highCoords[i] = ((int)res[i])-1;
}
}
// figure out the emitter size relative to the voxel size, and compute
// a per-voxel sampling rate that uses 1 sample/voxel for emitters that
// are >= 2 voxels big in all dimensions. For smaller emitters, use up
// to 8 samples per voxel.
//
double emitterVoxelSize[3];
emitterVoxelSize[0] = (highCorner[0]-lowCorner[0])/dx;
emitterVoxelSize[1] = (highCorner[1]-lowCorner[1])/dy;
emitterVoxelSize[2] = (highCorner[2]-lowCorner[2])/dz;
double minVoxelSize = MIN(emitterVoxelSize[0],MIN(emitterVoxelSize[1],emitterVoxelSize[2]));
if( minVoxelSize < 1.0 )
{
minVoxelSize = 1.0;
}
int maxSamples = 8;
int numSamples = (int)(8.0/(minVoxelSize*minVoxelSize*minVoxelSize) + 0.5);
if( numSamples < 1 ) numSamples = 1;
if( numSamples > maxSamples ) numSamples = maxSamples;
// non-jittered, just use one sample in the voxel center. Should replace
// with uniform sampling pattern.
//
bool jitter = fluidJitter(block);
if( !jitter )
{
numSamples = 1;
}
// for each voxel that could potentially intersect the volume emitter
// primitive, take some samples in the voxel. For those inside the
// volume, compute their dropoff relative to the primitive's local y-axis,
// and emit an appropriate amount into the voxel.
//
for( i = lowCoords[0]; i <= highCoords[0]; i++ )
{
double x = Ox + (i+0.5)*dx;
for( int j = lowCoords[1]; j < highCoords[1]; j++ )
{
double y = Oy + (j+0.5)*dy;
for( int k = lowCoords[2]; k < highCoords[2]; k++ )
{
double z = Oz + (k+0.5)*dz;
for ( int si = 0; si < numSamples; si++) {
// compute voxel sample point (object space)
//
double rx, ry, rz;
if(jitter) {
rx = x + dx*(randgen() - 0.5);
ry = y + dy*(randgen() - 0.5);
rz = z + dz*(randgen() - 0.5);
} else {
rx = x;
ry = y;
rz = z;
}
// to world space
MPoint pt( rx, ry, rz );
pt *= fluidWorldMatrix;
// test to see if point is inside volume primitive
//
if( volumePrimitivePointInside( pt, emitterWorldMatrix ) )
{
// compute dropoff
//
double dist = pt.distanceTo( emitterPos );
double distDrop = dropoff * (dist*dist);
double newVal = (theRate * exp( -distDrop )) / (double)numSamples;
// emit into arrays
//
if( newVal != 0.0 )
{
fluid.emitIntoArrays( (float) newVal, i, j, k, (float)densityEmit, (float)heatEmit, (float)fuelEmit, doEmitColor, emitColor );
}
}
}
}
}
}
}
bool FxAttributeFiller::FillScript( DXCCEffectPath& parameter, MPlug& plug )
{
MString plugName= Shader->EncodePlug(plug);
MString MELPlugName= MFnDependencyNode(plug.node()).name() + MString(".") + plugName;
switch(parameter.End->Description.Class)
{
case D3DXPC_SCALAR:
{
if( 0 == lstrcmpiA( SasUiControl.asChar(), "Slider"))
{
Script.AppendFormat("\tdxfxControlSliderCreate(\"float\", \"%s\", \"%f\", \"%f\", \"%d\", \"%s\");\n", SasUiLabel.asChar(), SasUiMin, SasUiMax, SasUiSteps, MELPlugName.asChar() );
}
else
{
Script.AppendFormat("\tdxfxControlScalarCreate(\"float\", \"%s\", \"%s\");\n", SasUiLabel.asChar(), MELPlugName.asChar());
}
}
break;
case D3DXPC_VECTOR:
{
if( 0 == lstrcmpiA( SasUiControl.asChar(), "ColorPicker")
&& parameter.End->Description.Columns >= 3)
{//COLOR
Script.AppendFormat("\tdxfxControlColorCreate(\"%s\", \"%s\", %d);\n", SasUiLabel.asChar(), MELPlugName.asChar(), parameter.End->Description.Columns);
}
else
{//VECTOR
Script.AppendFormat("\tdxfxControlVectorCreate(\"float\", \"%s\", \"%s\", %d);\n", SasUiLabel.asChar(), MELPlugName.asChar(), parameter.End->Description.Columns);
}
}
break;
case D3DXPC_MATRIX_ROWS:
case D3DXPC_MATRIX_COLUMNS:
{
Script.AppendFormat("\tdxfxControlMatrixCreate(\"float\", \"%s\", \"%s\", %d, %d);\n", SasUiLabel.asChar(), MELPlugName.asChar(), parameter.End->Description.Rows, parameter.End->Description.Columns);
}
break;
case D3DXPC_OBJECT:
switch(parameter.End->Description.Type)
{
case D3DXPT_STRING:
{
Script.AppendFormat("\tdxfxControlStringCreate(\"%s\", \"%s\");\n", SasUiLabel.asChar(), MELPlugName.asChar());
}
break;
case D3DXPT_TEXTURE:
case D3DXPT_TEXTURE1D:
case D3DXPT_TEXTURE2D:
case D3DXPT_TEXTURE3D:
case D3DXPT_TEXTURECUBE:
{
Script.AppendFormat("\tdxfxControlTextureCreate(\"%s\", \"%s\");\n", SasUiLabel.asChar(), MELPlugName.asChar());
}
break;
default:
break;
};
break;
default:
break;
};
return true;
}
// Load an animation clip
MStatus skeleton::loadClip(MString clipName,int start,int stop,int rate)
{
uint fps = getFps();
float frameTime = 1000.0f / fps;
MStatus stat;
int i,j;
std::vector<int> times;
if (m_joints.size() < 0)
return MS::kFailure;
times.clear();
for (int t=start; t<stop; t+=rate)
times.push_back(t);
times.push_back(stop);
// create the animation
animation a;
a.name = clipName.asChar();
if(m_animations.size() == 0)
{
a.startTime = 0;
a.endTime = times[times.size()-1] - times[0];
}
else
{
a.startTime = m_animations[m_animations.size()-1].endTime + 1;
a.endTime = a.startTime + times[times.size()-1] - times[0];
}
m_animations.push_back(a);
int animIdx = m_animations.size() - 1;
for (i=0; i<times.size(); i++)
{
MAnimControl::setCurrentTime(MTime(times[i],MTime::uiUnit()));
for (j=0; j<m_joints.size(); j++)
{
keyframeTranslation translation;
keyframeRotation rotation;
keyframeScale scale;
joint &jt = m_joints[j];
int time = times[i] - times[0] + a.startTime;
loadKeyframe(m_joints[j],time,translation,rotation,scale);
translation.time *= frameTime;
rotation.time *= frameTime;
scale.time *= frameTime;
size_t size = jt.keyframesTranslation.size();
if(size > 0)
{
keyframeTranslation& t = jt.keyframesTranslation[size - 1];
if(!equal(translation.v[0],t.v[0]) || !equal(translation.v[1],t.v[1]) || !equal(translation.v[2],t.v[2]))
{
//如果跟上一次不一样，并且跨越了桢，那么需要补一桢
int lastTime = Round(t.time / frameTime);
if(time - 1 > lastTime)
{
keyframeTranslation temp = t;
temp.time = (time - 1) * frameTime;
jt.keyframesTranslation.push_back(temp);
}
jt.keyframesTranslation.push_back(translation);
}
}
else
{
jt.keyframesTranslation.push_back(translation);
}
MFnIkJoint jn(jt.jointDag);
if(jn.name() == "Hips")
{
// breakable;
}
size = jt.keyframesRotation.size();
if(size > 0)
{
keyframeRotation& r = jt.keyframesRotation[size - 1];
if(!equal(rotation.q[0],r.q[0]) || !equal(rotation.q[1],r.q[1]) || !equal(rotation.q[2],r.q[2]) || !equal(rotation.q[3],r.q[3]))
{
//如果跟上一次不一样，并且跨越了桢，那么需要补一桢
int lastTime = Round(r.time / frameTime);
if(time - 1 > lastTime)
{
keyframeRotation temp = r;
temp.time = (time - 1) * frameTime;
jt.keyframesRotation.push_back(temp);
}
jt.keyframesRotation.push_back(rotation);
}
}
else
{
jt.keyframesRotation.push_back(rotation);
}
size = jt.keyframesScale.size();
if(size > 0)
{
keyframeScale& s = jt.keyframesScale[size - 1];
if(!equal(scale.v[0],s.v[0]) || !equal(scale.v[1],s.v[1]) || !equal(scale.v[2],s.v[2]))
{
//如果跟上一次不一样，并且跨越了桢，那么需要补一桢
int lastTime = Round(s.time / frameTime);
if(time - 1 > lastTime)
{
keyframeScale temp = s;
temp.time = (time - 1) * frameTime;
jt.keyframesScale.push_back(temp);
}
jt.keyframesScale.push_back(scale);
}
}
else
{
jt.keyframesScale.push_back(scale);
}
if(jt.hasRibbonSystem)
{
keyframeT<bool> keyframeVisible;
keyframeT<float> keyframeAbove;
keyframeT<float> keyframeBelow;
keyframeT<short> keyframeSlot;
keyframeT<float3> keyframeColor;
keyframeT<float> keyframeAlpha;
MFnIkJoint jointFn(jt.jointDag);
MPlug plug;
plug = jointFn.findPlug("unRibbonVisible");
bool visible;
plug.getValue(visible);
plug = jointFn.findPlug("unRibbonAbove");
float above;
plug.getValue(above);
plug = jointFn.findPlug("unRibbonBelow");
float below;
plug.getValue(below);
plug = jointFn.findPlug("unRibbonTextureSlot");
short slot;
plug.getValue(slot);
plug = jointFn.findPlug("unRibbonVertexColor");
MObject object;
plug.getValue(object);
MFnNumericData data(object);
float r,g,b;
data.getData(r,g,b);
plug = jointFn.findPlug("unRibbonVertexAlpha");
float alpha;
plug.getValue(alpha);
keyframeVisible.time = time * frameTime;
keyframeAbove.time = time * frameTime;
keyframeBelow.time = time * frameTime;
keyframeSlot.time = time * frameTime;
keyframeColor.time = time * frameTime;
keyframeAlpha.time = time * frameTime;
keyframeVisible.data = visible;
keyframeAbove.data = above;
keyframeBelow.data = below;
keyframeSlot.data = slot;
keyframeColor.data[0] = r;
keyframeColor.data[1] = g;
keyframeColor.data[2] = b;
keyframeAlpha.data = alpha;
addKeyFramesBool(&jt.ribbon.keyframesVisible,&keyframeVisible);
addKeyFramesFloat(&jt.ribbon.keyframeAbove,&keyframeAbove);
addKeyFramesFloat(&jt.ribbon.keyframeBelow,&keyframeBelow);
size = jt.ribbon.keyframeSlot.size();
if(size > 0)
{
keyframeT<short>& s = jt.ribbon.keyframeSlot[size - 1];
if(s.data == slot)
{
jt.ribbon.keyframeSlot.push_back(keyframeSlot);
}
}
else
{
jt.ribbon.keyframeSlot.push_back(keyframeSlot);
}
size = jt.ribbon.keyframeColor.size();
if(size > 0)
{
keyframeT<float3>& s = jt.ribbon.keyframeColor[size - 1];
if(!equal(s.data[0],r) || !equal(s.data[1],g) || !equal(s.data[2],b))
{
jt.ribbon.keyframeColor.push_back(keyframeColor);
}
}
else
{
jt.ribbon.keyframeColor.push_back(keyframeColor);
}
addKeyFramesFloat(&jt.ribbon.keyframeAlpha,&keyframeAlpha);
}
if(jt.hasParticleSystem)
{
keyframeT<bool> keyframeVisible;
keyframeT<float> keyframeSpeed;
keyframeT<float> keyframeVariation;
keyframeT<float> keyframeConeAngle;
keyframeT<float> keyframeGravity;
keyframeT<float> keyframeExplosiveForce;
keyframeT<float> keyframeEmissionRate;
keyframeT<float> keyframeWidth;
keyframeT<float> keyframeLength;
keyframeT<float> keyframeHeight;
MFnIkJoint jointFn(jt.jointDag);
MPlug plug;
plug = jointFn.findPlug("unParticleVisible");
bool visible;
plug.getValue(visible);
plug = jointFn.findPlug("unParticleSpeed");
float speed;
plug.getValue(speed);
plug = jointFn.findPlug("unParticleVariationPercent");
float variation;
plug.getValue(variation);
plug = jointFn.findPlug("unParticleConeAngle");
float coneAngle;
plug.getValue(coneAngle);
plug = jointFn.findPlug("unParticleGravity");
float gravity;
plug.getValue(gravity);
plug = jointFn.findPlug("unParticleExplosiveForce");
float explosiveForce = 0.0f;
if(!plug.isNull())
{
plug.getValue(explosiveForce);
}
plug = jointFn.findPlug("unParticleEmissionRate");
float emissionRate;
plug.getValue(emissionRate);
plug = jointFn.findPlug("unParticleEmitterWidth");
float width;
plug.getValue(width);
plug = jointFn.findPlug("unParticleEmitterLength");
float length;
plug.getValue(length);
plug = jointFn.findPlug("unParticleEmitterHeight");
float height = 0.0f;
if(!plug.isNull())
{
plug.getValue(height);
}
keyframeVisible.time = time * frameTime;
keyframeSpeed.time = time * frameTime;
keyframeVariation.time = time * frameTime;
keyframeConeAngle.time = time * frameTime;
keyframeGravity.time = time * frameTime;
keyframeExplosiveForce.time = time * frameTime;
keyframeEmissionRate.time = time * frameTime;
keyframeWidth.time = time * frameTime;
keyframeLength.time = time * frameTime;
keyframeHeight.time = time * frameTime;
keyframeVisible.data = visible;
keyframeSpeed.data = speed;
keyframeVariation.data = variation / 100.0f;
keyframeConeAngle.data = coneAngle;
keyframeGravity.data = gravity;
keyframeExplosiveForce.data = explosiveForce;
keyframeEmissionRate.data = emissionRate;
keyframeWidth.data = width;
keyframeLength.data = length;
keyframeHeight.data = height;
addKeyFramesBool(&jt.particle.keyframesVisible,&keyframeVisible);
addKeyFramesFloat(&jt.particle.keyframesSpeed,&keyframeSpeed);
addKeyFramesFloat(&jt.particle.keyframesVariation,&keyframeVariation);
addKeyFramesFloat(&jt.particle.keyframesConeAngle,&keyframeConeAngle);
addKeyFramesFloat(&jt.particle.keyframesGravity,&keyframeGravity);
addKeyFramesFloat(&jt.particle.keyframesExplosiveForce,&keyframeExplosiveForce);
addKeyFramesFloat(&jt.particle.keyframesEmissionRate,&keyframeEmissionRate);
addKeyFramesFloat(&jt.particle.keyframesWidth,&keyframeWidth);
addKeyFramesFloat(&jt.particle.keyframesLength,&keyframeLength);
addKeyFramesFloat(&jt.particle.keyframesHeight,&keyframeHeight);
}
}
}
return MS::kSuccess;
}
bool FxAttributeFiller::FillPlug( DXCCEffectPath& parameter, MPlug& plug )
{
HRESULT hr= S_OK;
LPDXCCRESOURCE pResource= NULL;
LPDIRECT3DBASETEXTURE9 pTexture= NULL;
D3DXPARAMETER_DESC desc= parameter.End->Description;
float NumericVals[16]= {0.0f};
MString StringVal;
LPCSTR StringValStr= "";
bool RestoreFound= false;
LPCVOID pRestoreData= NULL;
size_t RestoreSize= 0;
CComPtr<IDXCCPropertyCollection> pCollection;
DXCCPROPERTY_KEY key= 0;
if(Restore)
{
if( DXCC_SUCCEEDED( Restore->GetPath( parameter.End->LongPathName, &pCollection, &key) ) )
{
pCollection->GetPropertyValueAsData(key, &pRestoreData);
DXCCPROPERTY_DESC desc= pCollection->GetPropertyDesc(key);
if(desc == DXCCPD_STRING)
{
StringVal= (LPCSTR)pRestoreData;
StringValStr= (LPCSTR)pRestoreData;
RestoreFound= true;
}
else
{
size_t RestoreSize= DXCCPropertySize( desc, pRestoreData );
memcpy( NumericVals, pRestoreData, RestoreSize);
RestoreFound= true;
}
}
}
if((desc.Type == D3DXPT_BOOL)
||(desc.Type == D3DXPT_INT)
||(desc.Type == D3DXPT_FLOAT))
{
if(!RestoreFound)
{
if(plug.isArray())
{
hr= Shader->Effect->GetFloatArray(parameter.End->Handle, NumericVals, 16);
if(DXCC_FAILED(hr))
DXCC_GOTO_EXIT(e_Exit, TRUE);
}
else
{
hr= Shader->Effect->GetFloat(parameter.End->Handle, NumericVals);
if(DXCC_FAILED(hr))
DXCC_GOTO_EXIT(e_Exit, TRUE);
}
}
if(plug.isArray())
{
int count= desc.Rows * desc.Columns;
for(int i= 0; i < count; i++)
{
MPlug subPlug= plug.elementByLogicalIndex(i);
DXCHECK_MSTATUS(subPlug.setValue( NumericVals[i] ));
}
}
else
{
DXCHECK_MSTATUS(plug.setValue( NumericVals[0] ));
}
}
else if((desc.Type == D3DXPT_TEXTURE)
||(desc.Type == D3DXPT_TEXTURE1D)
||(desc.Type == D3DXPT_TEXTURE2D)
||(desc.Type == D3DXPT_TEXTURE3D)
||(desc.Type == D3DXPT_TEXTURECUBE))
{
if(!RestoreFound)
{
hr= Shader->Effect->GetTexture(parameter.End->Handle, &pTexture);
if(DXCC_SUCCEEDED(hr) && pTexture != NULL)
{
hr= g_PreviewPipeline.AccessManager()->FindResourceByPointer(
(LPUNKNOWN)pTexture,
NULL,
&pResource);
if(DXCC_SUCCEEDED(hr))
{
StringVal= pResource->GetResourcePath();
}
}
else
{
D3DXHANDLE hResourceAddy= Shader->Effect->GetAnnotationByName( parameter.End->Handle, "SasResourceAddress");
if(hResourceAddy)
{
LPCSTR resourceAddressStr= NULL;
Shader->Effect->GetString(hResourceAddy, &resourceAddressStr);
StringVal= resourceAddressStr;
}
}
}
DXCHECK_MSTATUS(plug.setValue( StringVal ));
}
else if(desc.Type == D3DXPT_STRING)
{
if(!RestoreFound)
{
hr= Shader->Effect->GetString(parameter.End->Handle, &StringValStr);
StringVal= StringValStr;
}
DXCHECK_MSTATUS(plug.setValue( StringVal ));
}
else
{
DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
}
e_Exit:
DXCC_RELEASE(pResource);
DXCC_RELEASE(pTexture);
return DXCC_SUCCEEDED(hr);
}
ConstObjectPtr LiveScene::readAttribute( const Name &name, double time ) const
{
if ( !m_isRoot && m_dagPath.length() == 0 )
{
throw Exception( "IECoreMaya::LiveScene::readAttribute: Dag path no longer exists!" );
}
tbb::mutex::scoped_lock l( s_mutex );
if ( !m_isRoot )
{
if( name == SceneInterface::visibilityName )
{
bool visible = true;
MStatus st;
MFnDagNode dagFn( m_dagPath );
MPlug visibilityPlug = dagFn.findPlug( MPxTransform::visibility, &st );
if( st )
{
visible = visibilityPlug.asBool();
}
if( visible )
{
MDagPath childDag;
// find an object that's either a SceneShape, or has a cortex converter and check its visibility:
unsigned int childCount = 0;
m_dagPath.numberOfShapesDirectlyBelow(childCount);
for ( unsigned int c = 0; c < childCount; c++ )
{
MDagPath d = m_dagPath;
if( d.extendToShapeDirectlyBelow( c ) )
{
MFnDagNode fnChildDag(d);
if( fnChildDag.typeId() == SceneShape::id )
{
childDag = d;
break;
}
if ( fnChildDag.isIntermediateObject() )
{
continue;
}
FromMayaShapeConverterPtr shapeConverter = FromMayaShapeConverter::create( d );
if( shapeConverter )
{
childDag = d;
break;
}
FromMayaDagNodeConverterPtr dagConverter = FromMayaDagNodeConverter::create( d );
if( dagConverter )
{
childDag = d;
break;
}
}
}
if( childDag.isValid() )
{
MFnDagNode dagFn( childDag );
MPlug visibilityPlug = dagFn.findPlug( MPxSurfaceShape::visibility, &st );
if( st )
{
visible = visibilityPlug.asBool();
}
}
}
return new BoolData( visible );
}
}
else if( name == SceneInterface::visibilityName )
{
return new BoolData( true );
}
std::vector< CustomAttributeReader > &attributeReaders = customAttributeReaders();
for ( std::vector< CustomAttributeReader >::const_reverse_iterator it = attributeReaders.rbegin(); it != attributeReaders.rend(); ++it )
{
ConstObjectPtr attr = it->m_read( m_dagPath, name );
if( !attr )
{
continue;
}
return attr;
}
if( strstr( name.c_str(), "user:"******"ieAttr_" + name.string().substr(5) ).c_str(), false, &st );
if( st )
{
FromMayaConverterPtr plugConverter = FromMayaPlugConverter::create( attrPlug );
if( !plugConverter )
{
return IECore::NullObject::defaultNullObject();
}
return plugConverter->convert();
}
}
return IECore::NullObject::defaultNullObject();
}
MStatus slopeShaderBehavior::connectNodeToNode( MObject &sourceNode, MObject &destinationNode, bool force )
//
// Description:
// Overloaded function from MPxDragAndDropBehavior
// this method will handle the connection between the slopeShader and the shader it is
// assigned to as well as any meshes that it is assigned to.
//
{
MStatus result = MS::kFailure;
MFnDependencyNode src(sourceNode);
//if we are dragging from a lambert
//we want to check what we are dragging
//onto.
if(sourceNode.hasFn(MFn::kLambert))
{
MObject shaderNode;
MPlugArray connections;
MObjectArray shaderNodes;
shaderNodes.clear();
//if the source node was a lambert
//than we will check the downstream connections to see
//if a slope shader is assigned to it.
//
src.getConnections(connections);
unsigned i;
for(i = 0; i < connections.length(); i++)
{
//check the incoming connections to this plug
//
MPlugArray connectedPlugs;
connections[i].connectedTo(connectedPlugs, true, false);
for(unsigned j = 0; j < connectedPlugs.length(); j++)
{
//if the incoming node is a slope shader than
//append the node to the shaderNodes array
//
MObject currentnode = connectedPlugs[j].node();
if(MFnDependencyNode(currentnode).typeName() == "slopeShader")
{
shaderNodes.append(currentnode);
}
}
}
//if we found a shading node
//than check the destination node
//type to see if it is a mesh
//
if(shaderNodes.length() > 0)
{
MFnDependencyNode dest(destinationNode);
if(destinationNode.hasFn(MFn::kMesh))
{
//if the node is a mesh than for each slopeShader
//connect the worldMesh attribute to the dirtyShaderPlug
//attribute to force an evaluation of the node when the mesh
//changes
//
for(i = 0; i < shaderNodes.length(); i++)
{
MPlug srcPlug = dest.findPlug("worldMesh");
MPlug destPlug = MFnDependencyNode(shaderNodes[i]).findPlug("dirtyShaderPlug");
if(!srcPlug.isNull() && !destPlug.isNull())
{
MString cmd = "connectAttr -na ";
cmd += srcPlug.name() + " ";
cmd += destPlug.name();
MGlobal::executeCommand(cmd);
}
}
//get the shading engine so we can assign the shader
//to the mesh after doing the connection
//
MObject shadingEngine = findShadingEngine(sourceNode);
//if there is a valid shading engine than make
//the connection
//
if(!shadingEngine.isNull())
{
MString cmd = "sets -edit -forceElement ";
cmd += MFnDependencyNode(shadingEngine).name() + " ";
cmd += MFnDagNode(destinationNode).partialPathName();
result = MGlobal::executeCommand(cmd);
}
}
}
}
else if(src.typeName() == "slopeShader")
//if we are dragging from a slope shader
//than we want to see what we are dragging onto
//
{
if(destinationNode.hasFn(MFn::kMesh))
{
//if the user is dragging onto a mesh
//than make the connection from the worldMesh
//to the dirtyShader plug on the slopeShader
//
MFnDependencyNode dest(destinationNode);
MPlug srcPlug = dest.findPlug("worldMesh");
MPlug destPlug = src.findPlug("dirtyShaderPlug");
if(!srcPlug.isNull() && !destPlug.isNull())
{
MString cmd = "connectAttr -na ";
cmd += srcPlug.name() + " ";
cmd += destPlug.name();
result = MGlobal::executeCommand(cmd);
}
}
}
return result;
}
MStatus liqSurfaceNode::compute( const MPlug& plug, MDataBlock& block )
{
// outColor or individual R, G, B channel
if( (plug == aOutColor) || (plug.parent() == aOutColor) ||
(plug == aOutTransparency) || (plug.parent() == aOutTransparency)
) {
//cout <<"compute... "<<endl;
// init shader
MStatus status;
MFloatVector theColor( 0.0f, 0.0f, 0.0f );
MFloatVector& cColor = block.inputValue(aColor).asFloatVector();
MFloatVector& cTrans = block.inputValue(aOpacity).asFloatVector();
MFloatVector& ctex = block.inputValue(aGLPreviewTexture).asFloatVector();
// exploit maya's free openGL preview
if ( ctex != MFloatVector( -1.0, -1.0, -1.0 ) ) theColor = ctex;
else theColor = cColor;
MFloatVector resultColor( 0.0, 0.0, 0.0 );
MFloatVector resultTrans( cTrans );
// lambert calc -------------------
bool& ignoreLights = block.inputValue( aMayaIgnoreLights, &status ).asBool();
float& Ka = block.inputValue( aMayaKa, &status ).asFloat();
float& Kd = block.inputValue( aMayaKd, &status ).asFloat();
// get surface normal
MFloatVector& surfaceNormal = block.inputValue( aNormalCamera, &status ).asFloatVector();
CHECK_MSTATUS( status );
if ( ignoreLights ) {
MFloatVector cam( 0.0, 0.0, 1.0 );
float cosln = cam * surfaceNormal;
if ( cosln > 0.0f ) {
float diff = cosln * cosln * Kd + Ka;
resultColor = diff * theColor;
}
} else {
// Get light list
MArrayDataHandle lightData = block.inputArrayValue( aLightData, &status );
CHECK_MSTATUS( status );
int numLights = lightData.elementCount( &status );
CHECK_MSTATUS( status );
// Iterate through light list and get ambient/diffuse values
for( int count=1; count <= numLights; count++ )
{
// Get the current light out of the array
MDataHandle currentLight = lightData.inputValue( &status );
CHECK_MSTATUS( status );
// Get the intensity of that light
MFloatVector& lightIntensity = currentLight.child( aLightIntensity ).asFloatVector();
// Find ambient component
if ( currentLight.child( aLightAmbient ).asBool() ) {
resultColor += lightIntensity;
}
// Find diffuse component
if ( currentLight.child( aLightDiffuse ).asBool() ) {
MFloatVector& lightDirection = currentLight.child( aLightDirection ).asFloatVector();
float cosln = lightDirection * surfaceNormal;
if ( cosln > 0.0f ) resultColor += lightIntensity * cosln * Kd ;
}
// Advance to the next light.
if ( count < numLights ) {
status = lightData.next();
CHECK_MSTATUS( status );
}
}
resultColor[0] *= theColor[0];
resultColor[1] *= theColor[1];
resultColor[2] *= theColor[2];
}
resultTrans[0] = ( 1 - resultTrans[0] );
resultTrans[1] = ( 1 - resultTrans[1] );
resultTrans[2] = ( 1 - resultTrans[2] );
// set ouput color attribute
MDataHandle outColorHandle = block.outputValue( aOutColor );
MFloatVector& outColor = outColorHandle.asFloatVector();
outColor = resultColor;
outColorHandle.setClean();
MDataHandle outTransHandle = block.outputValue( aOutTransparency );
MFloatVector& outTrans = outTransHandle.asFloatVector();
outTrans = resultTrans;
outTransHandle.setClean();
} else return MS::kUnknownParameter;
return MS::kSuccess;
}
MStatus nodeInfo::doIt( const MArgList& args )
//
// Description
// This method performs the action of the command.
//
// This method iterates over all selected items and
// prints out connected plug and dependency node type
// information.
//
{
MStatus stat; // Status code
MObject dependNode; // Selected dependency node
stat = parseArgs ( args );
if ( !stat )
return stat;
// Create a selection list iterator
//
MSelectionList slist;
MGlobal::getActiveSelectionList( slist );
MItSelectionList iter( slist, MFn::kInvalid,&stat );
// Iterate over all selected dependency nodes
//
for ( ; !iter.isDone(); iter.next() )
{
// Get the selected dependency node
//
stat = iter.getDependNode( dependNode );
if ( !stat ) {
stat.perror("getDependNode");
continue;
}
// Create a function set for the dependency node
//
MFnDependencyNode fnDependNode( dependNode );
// Check the type of the dependency node
//
MString nodeName = fnDependNode.name();
nodeName += ": ";
printType( dependNode, nodeName );
// Get all connected plugs to this node
//
MPlugArray connectedPlugs;
stat = fnDependNode.getConnections( connectedPlugs );
int numberOfPlugs = connectedPlugs.length();
if ( !quiet )
cerr << " Found: " << numberOfPlugs << " connections" << endl;
// Print out the dependency node name and attributes
// for each plug
//
for ( int i=0; i<numberOfPlugs; i++ )
{
MPlug plug = connectedPlugs[i];
MString pinfo = plug.info();
if ( !quiet )
cerr << " Plug info: " << pinfo << endl;
// Now get the plugs that this plug is the
// destination of and print the node type.
//
MPlugArray array;
plug.connectedTo( array, true, false );
for ( unsigned int j=0; j<array.length(); j++ )
{
MObject mnode = array[j].node();
MString msg( " This plug is a dest of a " );
printType( mnode, msg );
}
}
}
return MS::kSuccess;
}
MStatus AbcExport::doIt(const MArgList & args)
{
try
{
MStatus status;
util::clearIsAnimatedCache();
MTime oldCurTime = MAnimControl::currentTime();
MArgParser argData(syntax(), args, &status);
if (argData.isFlagSet("help"))
{
MGlobal::displayInfo(util::getHelpText());
return MS::kSuccess;
}
bool verbose = argData.isFlagSet("verbose");
// If skipFrame is true, when going through the playback range of the
// scene, as much frames are skipped when possible. This could cause
// a problem for, time dependent solutions like
// particle system / hair simulation
bool skipFrame = true;
if (argData.isFlagSet("dontSkipUnwrittenFrames"))
skipFrame = false;
double startEvaluationTime = DBL_MAX;
if (argData.isFlagSet("preRollStartFrame"))
{
double startAt = 0.0;
argData.getFlagArgument("preRollStartFrame", 0, startAt);
startEvaluationTime = startAt;
}
unsigned int jobSize = argData.numberOfFlagUses("jobArg");
if (jobSize == 0)
return status;
// the frame range we will be iterating over for all jobs,
// includes frames which are not skipped and the startAt offset
std::set<double> allFrameRange;
// this will eventually hold only the animated jobs.
// its a list because we will be removing jobs from it
std::list < AbcWriteJobPtr > jobList;
for (unsigned int jobIndex = 0; jobIndex < jobSize; jobIndex++)
{
JobArgs jobArgs;
MArgList jobArgList;
argData.getFlagArgumentList("jobArg", jobIndex, jobArgList);
MString jobArgsStr = jobArgList.asString(0);
MStringArray jobArgsArray;
{
// parse the job arguments
// e.g. -perFrameCallbackMel "print \"something\"" will be splitted to
// [0] -perFrameCallbackMel
// [1] print "something"
enum State {
kArgument, // parsing an argument (not quoted)
kDoubleQuotedString, // parsing a double quoted string
kSingleQuotedString, // parsing a single quoted string
};
State state = kArgument;
MString stringBuffer;
for (unsigned int charIdx = 0; charIdx < jobArgsStr.numChars();
charIdx++)
{
MString ch = jobArgsStr.substringW(charIdx, charIdx);
switch (state)
{
case kArgument:
if (ch == " ")
{
// space terminates the current argument
if (stringBuffer.length() > 0) {
jobArgsArray.append(stringBuffer);
stringBuffer.clear();
}
// goto another argument
state = kArgument;
}
else if (ch == "\"")
{
if (stringBuffer.length() > 0)
{
// double quote is part of the argument
stringBuffer += ch;
}
else
{
// goto double quoted string
state = kDoubleQuotedString;
}
}
else if (ch == "'")
{
if (stringBuffer.length() > 0)
{
// single quote is part of the argument
stringBuffer += ch;
}
else
{
// goto single quoted string
state = kSingleQuotedString;
}
}
else
{
stringBuffer += ch;
}
break;
case kDoubleQuotedString:
// double quote terminates the current string
if (ch == "\"")
{
jobArgsArray.append(stringBuffer);
stringBuffer.clear();
state = kArgument;
}
else if (ch == "\\")
{
// escaped character
MString nextCh = (++charIdx < jobArgsStr.numChars())
? jobArgsStr.substringW(charIdx, charIdx) : "\\";
if (nextCh == "n") stringBuffer += "\n";
else if (nextCh == "t") stringBuffer += "\t";
else if (nextCh == "r") stringBuffer += "\r";
else if (nextCh == "\\") stringBuffer += "\\";
else if (nextCh == "'") stringBuffer += "'";
else if (nextCh == "\"") stringBuffer += "\"";
else stringBuffer += nextCh;
}
else
{
stringBuffer += ch;
}
break;
case kSingleQuotedString:
// single quote terminates the current string
if (ch == "'")
{
jobArgsArray.append(stringBuffer);
stringBuffer.clear();
state = kArgument;
}
else if (ch == "\\")
{
// escaped character
MString nextCh = (++charIdx < jobArgsStr.numChars())
? jobArgsStr.substringW(charIdx, charIdx) : "\\";
if (nextCh == "n") stringBuffer += "\n";
else if (nextCh == "t") stringBuffer += "\t";
else if (nextCh == "r") stringBuffer += "\r";
else if (nextCh == "\\") stringBuffer += "\\";
else if (nextCh == "'") stringBuffer += "'";
else if (nextCh == "\"") stringBuffer += "\"";
else stringBuffer += nextCh;
}
else
{
stringBuffer += ch;
}
break;
}
}
// the rest of the argument
if (stringBuffer.length() > 0)
{
jobArgsArray.append(stringBuffer);
}
}
// the frame range within this job
std::vector< FrameRangeArgs > frameRanges(1);
frameRanges.back().startTime = oldCurTime.value();
frameRanges.back().endTime = oldCurTime.value();
frameRanges.back().strideTime = 1.0;
bool hasRange = false;
bool hasRoot = false;
bool sampleGeo = true; // whether or not to subsample geometry
std::string fileName;
bool asOgawa = true;
unsigned int numJobArgs = jobArgsArray.length();
for (unsigned int i = 0; i < numJobArgs; ++i)
{
MString arg = jobArgsArray[i];
arg.toLowerCase();
if (arg == "-f" || arg == "-file")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError("File incorrectly specified.");
return MS::kFailure;
}
fileName = jobArgsArray[++i].asChar();
}
else if (arg == "-fr" || arg == "-framerange")
{
if (i+2 >= numJobArgs || !jobArgsArray[i+1].isDouble() ||
!jobArgsArray[i+2].isDouble())
{
MGlobal::displayError("Frame Range incorrectly specified.");
return MS::kFailure;
}
// this is not the first -frameRange argument, we are going
// to add one more frame range to the frame range array.
if (hasRange)
{
frameRanges.push_back(FrameRangeArgs());
}
hasRange = true;
frameRanges.back().startTime = jobArgsArray[++i].asDouble();
frameRanges.back().endTime = jobArgsArray[++i].asDouble();
// make sure start frame is smaller or equal to endTime
if (frameRanges.back().startTime > frameRanges.back().endTime)
{
std::swap(frameRanges.back().startTime,
frameRanges.back().endTime);
}
}
else if (arg == "-frs" || arg == "-framerelativesample")
{
if (i+1 >= numJobArgs || !jobArgsArray[i+1].isDouble())
{
MGlobal::displayError(
"Frame Relative Sample incorrectly specified.");
return MS::kFailure;
}
frameRanges.back().shutterSamples.insert(
jobArgsArray[++i].asDouble());
}
else if (arg == "-nn" || arg == "-nonormals")
{
jobArgs.noNormals = true;
}
else if (arg == "-pr" || arg == "-preroll")
{
frameRanges.back().preRoll = true;
}
else if (arg == "-ro" || arg == "-renderableonly")
{
jobArgs.excludeInvisible = true;
}
else if (arg == "-s" || arg == "-step")
{
if (i+1 >= numJobArgs || !jobArgsArray[i+1].isDouble())
{
MGlobal::displayError("Step incorrectly specified.");
return MS::kFailure;
}
frameRanges.back().strideTime = jobArgsArray[++i].asDouble();
}
else if (arg == "-sl" || arg == "-selection")
{
jobArgs.useSelectionList = true;
}
else if (arg == "-sn" || arg == "-stripnamespaces")
{
if (i+1 >= numJobArgs || !jobArgsArray[i+1].isUnsigned())
{
// the strip all namespaces case
// so we pick a very LARGE number
jobArgs.stripNamespace = 0xffffffff;
}
else
{
jobArgs.stripNamespace = jobArgsArray[++i].asUnsigned();
}
}
else if (arg == "-uv" || arg == "-uvwrite")
{
jobArgs.writeUVs = true;
}
else if (arg == "-wcs" || arg == "-writecolorsets")
{
jobArgs.writeColorSets = true;
}
else if (arg == "-wfs" || arg == "-writefacesets")
{
jobArgs.writeFaceSets = true;
}
else if (arg == "-wfg" || arg == "-wholeframegeo")
{
sampleGeo = false;
}
else if (arg == "-ws" || arg == "-worldspace")
{
jobArgs.worldSpace = true;
}
else if (arg == "-wv" || arg == "-writevisibility")
{
jobArgs.writeVisibility = true;
}
else if (arg == "-wc" || arg == "-writecreases")
{
jobArgs.writeCreases = true;
}
else if (arg == "-mfc" || arg == "-melperframecallback")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError(
"melPerFrameCallback incorrectly specified.");
return MS::kFailure;
}
jobArgs.melPerFrameCallback = jobArgsArray[++i].asChar();
}
else if (arg == "-pfc" || arg == "-pythonperframecallback")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError(
"pythonPerFrameCallback incorrectly specified.");
return MS::kFailure;
}
jobArgs.pythonPerFrameCallback = jobArgsArray[++i].asChar();
}
else if (arg == "-mpc" || arg == "-melpostjobcallback")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError(
"melPostJobCallback incorrectly specified.");
return MS::kFailure;
}
jobArgs.melPostCallback = jobArgsArray[++i].asChar();
}
else if (arg == "-ppc" || arg == "-pythonpostjobcallback")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError(
"pythonPostJobCallback incorrectly specified.");
return MS::kFailure;
}
jobArgs.pythonPostCallback = jobArgsArray[++i].asChar();
}
// geomArbParams - attribute filtering stuff
else if (arg == "-atp" || arg == "-attrprefix")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError(
"attrPrefix incorrectly specified.");
return MS::kFailure;
}
jobArgs.prefixFilters.push_back(jobArgsArray[++i].asChar());
}
else if (arg == "-a" || arg == "-attr")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError(
"attr incorrectly specified.");
return MS::kFailure;
}
jobArgs.attribs.insert(jobArgsArray[++i].asChar());
}
// userProperties - attribute filtering stuff
else if (arg == "-uatp" || arg == "-userattrprefix")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError(
"userAttrPrefix incorrectly specified.");
return MS::kFailure;
}
jobArgs.userPrefixFilters.push_back(jobArgsArray[++i].asChar());
}
else if (arg == "-u" || arg == "-userattr")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError(
"userAttr incorrectly specified.");
return MS::kFailure;
}
jobArgs.userAttribs.insert(jobArgsArray[++i].asChar());
}
else if (arg == "-rt" || arg == "-root")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError(
"root incorrectly specified.");
return MS::kFailure;
}
hasRoot = true;
MString root = jobArgsArray[++i];
MSelectionList sel;
if (sel.add(root) != MS::kSuccess)
{
MString warn = root;
warn += " could not be select, skipping.";
MGlobal::displayWarning(warn);
continue;
}
unsigned int numRoots = sel.length();
for (unsigned int j = 0; j < numRoots; ++j)
{
MDagPath path;
if (sel.getDagPath(j, path) != MS::kSuccess)
{
MString warn = path.fullPathName();
warn += " (part of ";
warn += root;
warn += " ) not a DAG Node, skipping.";
MGlobal::displayWarning(warn);
continue;
}
jobArgs.dagPaths.insert(path);
}
}
else if (arg == "-ef" || arg == "-eulerfilter")
{
jobArgs.filterEulerRotations = true;
}
else if (arg == "-df" || arg == "-dataformat")
{
if (i+1 >= numJobArgs)
{
MGlobal::displayError(
"dataFormat incorrectly specified.");
return MS::kFailure;
}
MString dataFormat = jobArgsArray[++i];
dataFormat.toLowerCase();
if (dataFormat == "hdf")
{
asOgawa = false;
}
else if (dataFormat == "ogawa")
{
asOgawa = true;
}
}
else
{
MString warn = "Ignoring unsupported flag: ";
warn += jobArgsArray[i];
MGlobal::displayWarning(warn);
}
} // for i
if (fileName == "")
{
MString error = "-file not specified.";
MGlobal::displayError(error);
return MS::kFailure;
}
{
MString fileRule, expandName;
MString alembicFileRule = "alembicCache";
MString alembicFilePath = "cache/alembic";
MString queryFileRuleCmd;
queryFileRuleCmd.format("workspace -q -fre \"^1s\"",
alembicFileRule);
MString queryFolderCmd;
queryFolderCmd.format("workspace -en `workspace -q -fre \"^1s\"`",
alembicFileRule);
// query the file rule for alembic cache
MGlobal::executeCommand(queryFileRuleCmd, fileRule);
if (fileRule.length() > 0)
{
// we have alembic file rule, query the folder
MGlobal::executeCommand(queryFolderCmd, expandName);
}
else
{
// alembic file rule does not exist, create it
MString addFileRuleCmd;
addFileRuleCmd.format("workspace -fr \"^1s\" \"^2s\"",
alembicFileRule, alembicFilePath);
MGlobal::executeCommand(addFileRuleCmd);
// save the workspace. maya may discard file rules on exit
MGlobal::executeCommand("workspace -s");
// query the folder
MGlobal::executeCommand(queryFolderCmd, expandName);
}
// resolve the expanded file rule
if (expandName.length() == 0)
{
expandName = alembicFilePath;
}
// get the path to the alembic file rule
MFileObject directory;
directory.setRawFullName(expandName);
MString directoryName = directory.resolvedFullName();
// make sure the cache folder exists
if (!directory.exists())
{
// create the cache folder
MString createFolderCmd;
createFolderCmd.format("sysFile -md \"^1s\"", directoryName);
MGlobal::executeCommand(createFolderCmd);
}
// resolve the relative path
MFileObject absoluteFile;
absoluteFile.setRawFullName(fileName.c_str());
#if MAYA_API_VERSION < 201300
if (absoluteFile.resolvedFullName() !=
absoluteFile.expandedFullName())
{
#else
if (!MFileObject::isAbsolutePath(fileName.c_str())) {
#endif
// this is a relative path
MString absoluteFileName = directoryName + "/" +
fileName.c_str();
absoluteFile.setRawFullName(absoluteFileName);
fileName = absoluteFile.resolvedFullName().asChar();
}
else
{
fileName = absoluteFile.resolvedFullName().asChar();
}
// check the path must exist before writing
MFileObject absoluteFilePath;
absoluteFilePath.setRawFullName(absoluteFile.path());
if (!absoluteFilePath.exists()) {
MString error;
error.format("Path ^1s does not exist!", absoluteFilePath.resolvedFullName());
MGlobal::displayError(error);
return MS::kFailure;
}
// check the file is used by any AlembicNode in the scene
MItDependencyNodes dgIter(MFn::kPluginDependNode);
for (; !dgIter.isDone(); dgIter.next()) {
MFnDependencyNode alembicNode(dgIter.thisNode());
if (alembicNode.typeName() != "AlembicNode") {
continue;
}
MPlug abcFilePlug = alembicNode.findPlug("abc_File");
if (abcFilePlug.isNull()) {
continue;
}
MFileObject alembicFile;
alembicFile.setRawFullName(abcFilePlug.asString());
if (!alembicFile.exists()) {
continue;
}
if (alembicFile.resolvedFullName() == absoluteFile.resolvedFullName()) {
MString error = "Can't export to an Alembic file which is in use.";
MGlobal::displayError(error);
return MS::kFailure;
}
}
std::ofstream ofs(fileName.c_str());
if (!ofs.is_open()) {
MString error = MString("Can't write to file: ") + fileName.c_str();
MGlobal::displayError(error);
return MS::kFailure;
}
ofs.close();
}
// if -frameRelativeSample argument is not specified for a frame range,
// we are assuming a -frameRelativeSample 0.0
for (std::vector<FrameRangeArgs>::iterator range =
frameRanges.begin(); range != frameRanges.end(); ++range)
{
if (range->shutterSamples.empty())
range->shutterSamples.insert(0.0);
}
if (jobArgs.prefixFilters.empty())
{
jobArgs.prefixFilters.push_back("ABC_");
}
// the list of frame ranges for sampling
std::vector<FrameRangeArgs> sampleRanges;
std::vector<FrameRangeArgs> preRollRanges;
for (std::vector<FrameRangeArgs>::const_iterator range =
frameRanges.begin(); range != frameRanges.end(); ++range)
{
if (range->preRoll)
preRollRanges.push_back(*range);
else
sampleRanges.push_back(*range);
}
// the list of frames written into the abc file
std::set<double> geoSamples;
std::set<double> transSamples;
for (std::vector<FrameRangeArgs>::const_iterator range =
sampleRanges.begin(); range != sampleRanges.end(); ++range)
{
for (double frame = range->startTime;
frame <= range->endTime;
frame += range->strideTime)
{
for (std::set<double>::const_iterator shutter =
range->shutterSamples.begin();
shutter != range->shutterSamples.end(); ++shutter)
{
double curFrame = *shutter + frame;
if (!sampleGeo)
{
double intFrame = (double)(int)(
curFrame >= 0 ? curFrame + .5 : curFrame - .5);
// only insert samples that are close to being an integer
if (fabs(curFrame - intFrame) < 1e-4)
{
geoSamples.insert(curFrame);
}
}
else
{
geoSamples.insert(curFrame);
}
transSamples.insert(curFrame);
}
}
if (geoSamples.empty())
{
geoSamples.insert(range->startTime);
}
if (transSamples.empty())
{
transSamples.insert(range->startTime);
}
}
bool isAcyclic = false;
if (sampleRanges.empty())
{
// no frame ranges or all frame ranges are pre-roll ranges
hasRange = false;
geoSamples.insert(frameRanges.back().startTime);
transSamples.insert(frameRanges.back().startTime);
}
else
{
// check if the time range is even (cyclic)
// otherwise, we will use acyclic
// sub frames pattern
std::vector<double> pattern(
sampleRanges.begin()->shutterSamples.begin(),
sampleRanges.begin()->shutterSamples.end());
std::transform(pattern.begin(), pattern.end(), pattern.begin(),
std::bind2nd(std::plus<double>(),
sampleRanges.begin()->startTime));
// check the frames against the pattern
std::vector<double> timeSamples(
transSamples.begin(), transSamples.end());
for (size_t i = 0; i < timeSamples.size(); i++)
{
// next pattern
if (i % pattern.size() == 0 && i / pattern.size() > 0)
{
std::transform(pattern.begin(), pattern.end(),
pattern.begin(), std::bind2nd(std::plus<double>(),
sampleRanges.begin()->strideTime));
}
// pattern mismatch, we use acyclic time sampling type
if (timeSamples[i] != pattern[i % pattern.size()])
{
isAcyclic = true;
break;
}
}
}
// the list of frames to pre-roll
std::set<double> preRollSamples;
for (std::vector<FrameRangeArgs>::const_iterator range =
preRollRanges.begin(); range != preRollRanges.end(); ++range)
{
for (double frame = range->startTime;
frame <= range->endTime;
frame += range->strideTime)
{
for (std::set<double>::const_iterator shutter =
range->shutterSamples.begin();
shutter != range->shutterSamples.end(); ++shutter)
{
double curFrame = *shutter + frame;
preRollSamples.insert(curFrame);
}
}
if (preRollSamples.empty())
{
preRollSamples.insert(range->startTime);
}
}
if (jobArgs.dagPaths.size() > 1)
{
// check for validity of the DagPath relationships complexity : n^2
util::ShapeSet::const_iterator m, n;
util::ShapeSet::const_iterator end = jobArgs.dagPaths.end();
for (m = jobArgs.dagPaths.begin(); m != end; )
{
MDagPath path1 = *m;
m++;
for (n = m; n != end; n++)
{
MDagPath path2 = *n;
if (util::isAncestorDescendentRelationship(path1,path2))
{
MString errorMsg = path1.fullPathName();
errorMsg += " and ";
errorMsg += path2.fullPathName();
errorMsg += " have an ancestor relationship.";
MGlobal::displayError(errorMsg);
return MS::kFailure;
}
} // for n
} // for m
}
// no root is specified, and we aren't using a selection
// so we'll try to translate the whole Maya scene by using all
// children of the world as roots.
else if (!hasRoot && !jobArgs.useSelectionList)
{
MSelectionList sel;
#if MAYA_API_VERSION >= 201100
sel.add("|*", true);
#else
// older versions of Maya will not be able to find top level nodes
// within namespaces
sel.add("|*");
#endif
unsigned int numRoots = sel.length();
for (unsigned int i = 0; i < numRoots; ++i)
{
MDagPath path;
sel.getDagPath(i, path);
jobArgs.dagPaths.insert(path);
}
}
else if (hasRoot && jobArgs.dagPaths.empty())
{
MString errorMsg = "No valid root nodes were specified.";
MGlobal::displayError(errorMsg);
return MS::kFailure;
}
else if (jobArgs.useSelectionList)
{
MSelectionList activeList;
MGlobal::getActiveSelectionList(activeList);
if (activeList.length() == 0)
{
MString errorMsg =
"-selection specified but nothing is actively selected.";
MGlobal::displayError(errorMsg);
return MS::kFailure;
}
}
AbcA::TimeSamplingPtr transTime, geoTime;
if (hasRange)
{
if (isAcyclic)
{
// acyclic, uneven time sampling
// e.g. [0.8, 1, 1.2], [2.8, 3, 3.2], .. not continuous
// [0.8, 1, 1.2], [1.7, 2, 2.3], .. shutter different
std::vector<double> samples(
transSamples.begin(), transSamples.end());
std::transform(samples.begin(), samples.end(), samples.begin(),
std::bind2nd(std::multiplies<double>(), util::spf()));
transTime.reset(new AbcA::TimeSampling(AbcA::TimeSamplingType(
AbcA::TimeSamplingType::kAcyclic), samples));
}
else
{
// cyclic, even time sampling between time periods
// e.g. [0.8, 1, 1.2], [1.8, 2, 2.2], ...
std::vector<double> samples;
double startTime = sampleRanges[0].startTime;
double strideTime = sampleRanges[0].strideTime;
for (std::set<double>::const_iterator shutter =
sampleRanges[0].shutterSamples.begin();
shutter != sampleRanges[0].shutterSamples.end();
++shutter)
{
samples.push_back((startTime + *shutter) * util::spf());
}
if (samples.size() > 1)
{
Alembic::Util::uint32_t numSamples =
static_cast<Alembic::Util::uint32_t>(samples.size());
transTime.reset(
new AbcA::TimeSampling(AbcA::TimeSamplingType(
numSamples, strideTime * util::spf()), samples));
}
// uniform sampling
else
{
transTime.reset(new AbcA::TimeSampling(
strideTime * util::spf(), samples[0]));
}
}
}
else
{
// time ranges are not specified
transTime.reset(new AbcA::TimeSampling());
}
if (sampleGeo || !hasRange)
{
geoTime = transTime;
}
else
{
// sampling geo on whole frames
if (isAcyclic)
{
// acyclic, uneven time sampling
std::vector<double> samples(
geoSamples.begin(), geoSamples.end());
// one more sample for setup()
if (*transSamples.begin() != *geoSamples.begin())
samples.insert(samples.begin(), *transSamples.begin());
std::transform(samples.begin(), samples.end(), samples.begin(),
std::bind2nd(std::multiplies<double>(), util::spf()));
geoTime.reset(new AbcA::TimeSampling(AbcA::TimeSamplingType(
AbcA::TimeSamplingType::kAcyclic), samples));
}
else
{
double geoStride = sampleRanges[0].strideTime;
if (geoStride < 1.0)
geoStride = 1.0;
double geoStart = *geoSamples.begin() * util::spf();
geoTime.reset(new AbcA::TimeSampling(
geoStride * util::spf(), geoStart));
}
}
AbcWriteJobPtr job(new AbcWriteJob(fileName.c_str(), asOgawa,
transSamples, transTime, geoSamples, geoTime, jobArgs));
jobList.push_front(job);
// make sure we add additional whole frames, if we arent skipping
// the inbetween ones
if (!skipFrame && !allFrameRange.empty())
{
double localMin = *(transSamples.begin());
std::set<double>::iterator last = transSamples.end();
last--;
double localMax = *last;
double globalMin = *(allFrameRange.begin());
last = allFrameRange.end();
last--;
double globalMax = *last;
// if the min of our current frame range is beyond
// what we know about, pad a few more frames
if (localMin > globalMax)
{
for (double f = globalMax; f < localMin; f++)
{
allFrameRange.insert(f);
}
}
// if the max of our current frame range is beyond
// what we know about, pad a few more frames
if (localMax < globalMin)
{
for (double f = localMax; f < globalMin; f++)
{
allFrameRange.insert(f);
}
}
}
// right now we just copy over the translation samples since
// they are guaranteed to contain all the geometry samples
allFrameRange.insert(transSamples.begin(), transSamples.end());
// copy over the pre-roll samples
allFrameRange.insert(preRollSamples.begin(), preRollSamples.end());
}
// add extra evaluation run up, if necessary
if (startEvaluationTime != DBL_MAX && !allFrameRange.empty())
{
double firstFrame = *allFrameRange.begin();
for (double f = startEvaluationTime; f < firstFrame; ++f)
{
allFrameRange.insert(f);
}
}
std::set<double>::iterator it = allFrameRange.begin();
std::set<double>::iterator itEnd = allFrameRange.end();
MComputation computation;
computation.beginComputation();
// loop through every frame in the list, if a job has that frame in it's
// list of transform or shape frames, then it will write out data and
// call the perFrameCallback, if that frame is also the last one it has
// to work on then it will also call the postCallback.
// If it doesn't have this frame, then it does nothing
for (; it != itEnd; it++)
{
if (verbose)
{
double frame = *it;
MString info;
info = frame;
MGlobal::displayInfo(info);
}
MGlobal::viewFrame(*it);
std::list< AbcWriteJobPtr >::iterator j = jobList.begin();
std::list< AbcWriteJobPtr >::iterator jend = jobList.end();
while (j != jend)
{
if (computation.isInterruptRequested())
return MS::kFailure;
bool lastFrame = (*j)->eval(*it);
if (lastFrame)
{
j = jobList.erase(j);
}
else
j++;
}
}
computation.endComputation();
// set the time back
MGlobal::viewFrame(oldCurTime);
return MS::kSuccess;
}
catch (Alembic::Util::Exception & e)
{
MString theError("Alembic Exception encountered: ");
theError += e.what();
MGlobal::displayError(theError);
return MS::kFailure;
}
catch (std::exception & e)
{
MString theError("std::exception encountered: ");
theError += e.what();
MGlobal::displayError(theError);
return MS::kFailure;
}
}
MStatus ClassParameterHandler::doUpdate( IECore::ConstParameterPtr parameter, MPlug &plug ) const
{
if( !parameter || !parameter->isInstanceOf( IECore::ClassParameterTypeId ) )
{
return MS::kFailure;
}
MObject attribute = plug.attribute();
// compatibility for the deprecated compound plug behaviour: should return MS::kFailure
MFnTypedAttribute fnTAttr( attribute );
if ( !fnTAttr.hasObj( attribute ) || fnTAttr.attrType() != MFnData::kStringArray )
{
MFnCompoundAttribute fnCAttr( attribute );
if( !fnCAttr.hasObj( attribute ) )
{
return MS::kFailure;
}
if( fnCAttr.numChildren()!=3 )
{
return MS::kFailure;
}
MObject classNameAttr = fnCAttr.child( 0 );
MFnTypedAttribute fnTAttr( classNameAttr );
if( !fnTAttr.hasObj( classNameAttr ) )
{
return MS::kFailure;
}
if( fnTAttr.name() != fnCAttr.name() + "__className" )
{
return MS::kFailure;
}
if( fnTAttr.attrType()!=MFnData::kString )
{
return MS::kFailure;
}
MObject classVersionAttr = fnCAttr.child( 1 );
MFnNumericAttribute fnNAttr( classVersionAttr );
if( !fnNAttr.hasObj( classVersionAttr ) )
{
return MS::kFailure;
}
if( fnNAttr.name() != fnCAttr.name() + "__classVersion" )
{
return MS::kFailure;
}
if( fnNAttr.unitType() != MFnNumericData::kInt )
{
return MS::kFailure;
}
MObject searchPathEnvVarAttr = fnCAttr.child( 2 );
fnTAttr.setObject( searchPathEnvVarAttr );
if( !fnTAttr.hasObj( searchPathEnvVarAttr ) )
{
return MS::kFailure;
}
if( fnTAttr.name() != fnCAttr.name() + "__searchPathEnvVar" )
{
return MS::kFailure;
}
if( fnTAttr.attrType()!=MFnData::kString )
{
return MS::kFailure;
}
if( !storeClass( parameter, plug ) )
{
return MS::kFailure;
}
}
if( !storeClass( parameter, plug ) )
{
return MS::kFailure;
}
return finishUpdating( parameter, plug );
}
MStatus splineSolverNode::preSolve()
{
MStatus stat;
setRotatePlane(false);
setSingleChainOnly(true);
setPositionOnly(false);
//Get Handle
MIkHandleGroup * handle_group = handleGroup();
if (NULL == handle_group) {
return MS::kFailure;
}
MObject handle = handle_group->handle( 0 );
MDagPath handlePath = MDagPath::getAPathTo( handle );
fnHandle.setObject( handlePath );
//Get Curve
MPlug inCurvePlug = fnHandle.findPlug( "inCurve" );
MDataHandle curveHandle = inCurvePlug.asMDataHandle();
MObject inputCurveObject = curveHandle.asNurbsCurveTransformed();
curveFn.setObject( inputCurveObject );
float initCurveLength = curveFn.length();
MVector initNormal = curveFn.normal(0);
MVector initTangent = curveFn.tangent(0);
float stretchRatio = 1;
// Get the position of the end_effector
//
MDagPath effectorPath;
fnHandle.getEffector(effectorPath);
tran.setObject( effectorPath );
// Get the start joint position
//
MDagPath startJointPath;
fnHandle.getStartJoint( startJointPath );
joints.clear();
//Get Joints
while (true)
{
effectorPath.pop();
joints.push_back( effectorPath );
if (effectorPath == startJointPath)
break;
}
std::reverse(joints.begin(), joints.end());
if (!fnHandle.hasAttribute("str"))
{
//Add Custom Attributes to Handle
MFnNumericAttribute fnAttr;
MObject attr = fnAttr.create("stretchRatio", "str", MFnNumericData::kDouble, stretchRatio);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setMin(0);
fnAttr.setMax(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("anchorPosition", "ancp", MFnNumericData::kDouble, 0.0);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setMin(0);
fnAttr.setMax(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("curveLength", "cvLen", MFnNumericData::kDouble, initCurveLength);
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("initNormal", "norm", MFnNumericData::k3Double);
fnAttr.setDefault(initNormal.x, initNormal.y, initNormal.z);
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("initTangent", "tang", MFnNumericData::k3Double);
fnAttr.setDefault(initTangent.x, initTangent.y, initTangent.z);
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("jointsLength", "jsLen", MFnNumericData::kDouble, getJointsTotalLenght());
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("startTwist", "strtw", MFnNumericData::kDouble, 0.0);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("endTwist", "endtw", MFnNumericData::kDouble, 0.0);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
MObject twistRamp = MRampAttribute::createCurveRamp("twistRamp", "twr");
fnHandle.addAttribute(twistRamp, MFnDependencyNode::kLocalDynamicAttr);
MObject scaleRamp = MRampAttribute::createCurveRamp("scaleRamp", "scr");
fnHandle.addAttribute(scaleRamp, MFnDependencyNode::kLocalDynamicAttr);
} else
{
MPlug strPlug = fnHandle.findPlug("str");
stretchRatio = strPlug.asDouble();
}
return MS::kSuccess;
}
//------------------------------------------------------------------------------
//
bool LocatorRepresentation::activate()
{
MPxAssembly* const assembly = getAssembly();
// Create a locator node, and parent it to our container.
MDagModifier dagMod;
MStatus status;
dagMod.createNode(MString("locator"), assembly->thisMObject(), &status);
if (status != MStatus::kSuccess) {
return false;
}
status = dagMod.doIt();
if (status != MStatus::kSuccess) {
return false;
}
// If we have annotation text, create an annotation shape, and a
// transform for it. Parent the annotation transform to the assembly.
if (fAnnotation.numChars() > 0) {
MObject transformObj = dagMod.createNode(
MString("transform"), assembly->thisMObject(), &status);
if (status != MStatus::kSuccess) {
return false;
}
MString annotationName = "annotation";
// the + "#" forces Maya to rename using integers for unique names
MString transformName = annotationName + "#";
dagMod.renameNode(transformObj, transformName);
status = dagMod.doIt();
if (status != MStatus::kSuccess) {
return false;
}
MObject annotationObj = dagMod.createNode(
MString("annotationShape"), transformObj, &status);
if (status != MStatus::kSuccess) {
return false;
}
status = dagMod.doIt();
if (status != MStatus::kSuccess) {
return false;
}
// Set the annotation text.
MFnDependencyNode annotation(annotationObj);
MPlug text = annotation.findPlug(MString("text"), true, &status);
if (status != MStatus::kSuccess) {
return false;
}
text.setValue(fAnnotation);
// Get rid of the arrow: our annotation doesn't need to be
// offset from the locator for readability, since the locator
// has no volume. Therefore, we don't need an arrow to point
// from the annotation back to the object.
MPlug displayArrow =
annotation.findPlug(MString("displayArrow"), true, &status);
if (status != MStatus::kSuccess) {
return false;
}
displayArrow.setValue(false);
}
return status == MStatus::kSuccess;
}
