//-*****************************************************************************
void WriteConcatTransform( const M44d &m )
{
RtMatrix rtm;
for ( int row = 0; row < 4; ++row )
{
for ( int col = 0; col < 4; ++col )
{
rtm[row][col] = (RtFloat)( m[row][col] );
}
}
RiConcatTransform( rtm );
}
MStatus ribGenCmd::doIt( const MArgList& args)
{
/*=========================================*
* the parameters of command
* =========================================*/
MString ribPath, shaderPath;
unsigned index;
index = args.flagIndex("p", "ribPath");
if(MArgList::kInvalidArgIndex != index)
args.get(index+1, ribPath);
index = args.flagIndex("sp", "shaderPath");
if(MArgList::kInvalidArgIndex != index)
args.get(index+1, shaderPath);
/*=========================================*
* shaderPath & ribPath
*=========================================*/
RtToken shader= new char[50] , path=new char[50];
strcpy(shader, shaderPath.asChar());
strcpy(path, ribPath.asChar());
char *curve[] = {"curves"};
RtMatrix identityMatrix =
{ { 1, 0, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 }};
RtInt ustep, vstep;
ustep = vstep =1;
/*=====================================*
* Begenning of writting out the .rib file.
*=====================================*/
RiBegin(path);
RiAttributeBegin();
RiTransformBegin();
//RiSurface(shader);
RiTransformEnd();
//RiAttribute("identifier", "name", curve);
RiConcatTransform(identityMatrix);
RiShadingInterpolation(RI_SMOOTH);
RiBasis(RiBezierBasis, ustep, RiBezierBasis, vstep);
int nodeId = 0, knotNum = 0;
float baseWidth = 0.0f, tipWidth = 0.0f;
MObject surface, node;
/*=========================================*
* get the informations of selected Objects in scene.
*=========================================*/
MSelectionList selection;
MGlobal::getActiveSelectionList(selection);
MItSelectionList iter(selection, MFn::kNurbsSurface );
for(; !iter.isDone(); iter.next())
{
RtInt numCurves = 0;
RtInt numVertexs = 0;
/*======================================*
* get the drawHairNode from selected NurbsSurface.
*======================================*/
iter.getDependNode(surface);
MFnDependencyNode surfaceFn(surface);
MStatus state;
MPlug plug = surfaceFn.findPlug("worldSpace",false, &state);
plug = plug.elementByLogicalIndex(0);
MPlugArray desPlugs;
plug.connectedTo(desPlugs,false,true);
plug = desPlugs[0];
node = plug.node(); //drawHairNode has found here!!
/*=====================================*
* get the attributes of drawHairNode.
*=====================================*/
MFnDependencyNode hairNodeFn(node);
plug = hairNodeFn.findPlug("nodeId");
plug.getValue(nodeId);
MGlobal::displayInfo(MString(" nodeId: ")+nodeId);
plug = hairNodeFn.findPlug("number");
plug.getValue(numCurves);
plug= hairNodeFn.findPlug("smooth");
plug.getValue(knotNum);
plug = hairNodeFn.findPlug("baseWidth");
plug.getValue(baseWidth);
plug = hairNodeFn.findPlug("tipWidth");
plug.getValue(tipWidth);
/*=====================================*
* caculate the linear interpolate of the width of the curve.
*=====================================*/
numVertexs = numCurves * knotNum;
int widthNum = numCurves * (knotNum -2 );
float *curveWidth = new float[widthNum];
float widthStep = 0.0f;
for(int c=0; c<widthNum; ++c){
widthStep = ((c%(knotNum-2)) / (float)(knotNum-3)) *(tipWidth - baseWidth);
if(widthStep < epslion)
widthStep = 0.0f;
curveWidth[c] = baseWidth + widthStep;
}
RtInt *nvertices = new RtInt[numCurves]; //the numbers of vertices on each curve.
RtPoint *vertexs = new RtPoint[numVertexs]; //the total vertexs.
/*=====================================*
* nvertices[] assignment.
*=====================================*/
for(int j=0; j<numCurves ; ++j){
nvertices[j] = knotNum;
}
/*=====================================*
* get the hair's datas from the static member
* named "nodeManager" of the drawHairNode class.
*=====================================*/
nodeMap::iterator iter = drawHairNode::nodeManager.find(nodeId);
vector<MPointArray> helixVec = iter->second;
/*=====================================*
* vertexs[] assignment.
*=====================================*/
float x=0, y=0, z=0;
int countVT=0;
for(vector<MPointArray>::iterator it=helixVec.begin(); it != helixVec.end(); ++it){
MPointArray helixCurve = (MPointArray)(*it);
for(int k=0; k < helixCurve.length() ; ++k){
x = helixCurve[k].x;
if(fabs(x) < epslion)
vertexs[countVT][0] = 0;
else
vertexs[countVT][0] = helixCurve[k].x;
y = helixCurve[k].y;
if(fabs(y) < epslion)
vertexs[countVT][1] = 0;
else
vertexs[countVT][1] = helixCurve[k].y;
z = helixCurve[k].z;
if(fabs(z) < epslion)
vertexs[countVT++][2] = 0;
else
vertexs[countVT++][2] = helixCurve[k].z;
}
}
RiCurves( RI_CUBIC, numCurves, nvertices, RI_NONPERIODIC, RI_P, vertexs, RI_WIDTH, curveWidth, RI_NULL);
}
RiAttributeEnd();
RiEnd();
return redoIt();
}
void liqWriteArchive::writeObjectToRib(const MDagPath &objDagPath, bool writeTransform)
{
if (!isObjectVisible(objDagPath)) {
return;
}
if (debug) { cout << "liquidWriteArchive: writing object: " << objDagPath.fullPathName().asChar() << endl; }
if (objDagPath.node().hasFn(MFn::kShape) || MFnDagNode( objDagPath ).typeName() == "liquidCoorSys") {
// we're looking at a shape node, so write out the geometry to the RIB
outputObjectName(objDagPath);
liqRibNode ribNode;
ribNode.set(objDagPath, 0, MRT_Unknown);
// don't write out clipping planes
if ( ribNode.object(0)->type == MRT_ClipPlane ) return;
if ( ribNode.rib.box != "" && ribNode.rib.box != "-" ) {
RiArchiveRecord( RI_COMMENT, "Additional RIB:\n%s", ribNode.rib.box.asChar() );
}
if ( ribNode.rib.readArchive != "" && ribNode.rib.readArchive != "-" ) {
// the following test prevents a really nasty infinite loop !!
if ( ribNode.rib.readArchive != outputFilename )
RiArchiveRecord( RI_COMMENT, "Read Archive Data: \nReadArchive \"%s\"", ribNode.rib.readArchive.asChar() );
}
if ( ribNode.rib.delayedReadArchive != "" && ribNode.rib.delayedReadArchive != "-" ) {
// the following test prevents a really nasty infinite loop !!
if ( ribNode.rib.delayedReadArchive != outputFilename )
RiArchiveRecord( RI_COMMENT, "Delayed Read Archive Data: \nProcedural \"DelayedReadArchive\" [ \"%s\" ] [ %f %f %f %f %f %f ]", ribNode.rib.delayedReadArchive.asChar(), ribNode.bound[0], ribNode.bound[3], ribNode.bound[1], ribNode.bound[4], ribNode.bound[2], ribNode.bound[5]);
}
// If it's a curve we should write the basis function
if ( ribNode.object(0)->type == MRT_NuCurve ) {
RiBasis( RiBSplineBasis, 1, RiBSplineBasis, 1 );
}
if ( !ribNode.object(0)->ignore ) {
ribNode.object(0)->writeObject();
}
} else {
// we're looking at a transform node
bool wroteTransform = false;
if (writeTransform && (objDagPath.apiType() == MFn::kTransform)) {
if (debug) { cout << "liquidWriteArchive: writing transform: " << objDagPath.fullPathName().asChar() << endl; }
// push the transform onto the RIB stack
outputObjectName(objDagPath);
MFnDagNode mfnDag(objDagPath);
MMatrix tm = mfnDag.transformationMatrix();
if (true) { // (!tm.isEquivalent(MMatrix::identity)) {
RtMatrix riTM;
tm.get(riTM);
wroteTransform = true;
outputIndentation();
RiAttributeBegin();
indentLevel++;
outputIndentation();
RiConcatTransform(riTM);
}
}
// go through all the children of this node and deal with each of them
int nChildren = objDagPath.childCount();
if (debug) { cout << "liquidWriteArchive: object " << objDagPath.fullPathName().asChar() << "has " << nChildren << " children" << endl; }
for(int i=0; i<nChildren; ++i) {
if (debug) { cout << "liquidWriteArchive: writing child number " << i << endl; }
MDagPath childDagNode;
MStatus stat = MDagPath::getAPathTo(objDagPath.child(i), childDagNode);
if (stat) {
writeObjectToRib(childDagNode, outputChildTransforms);
} else {
MGlobal::displayWarning("error getting a dag path to child node of object " + objDagPath.fullPathName());
}
}
if (wroteTransform) {
indentLevel--;
outputIndentation();
RiAttributeEnd();
}
}
if (debug) { cout << "liquidWriteArchive: finished writing object: " << objDagPath.fullPathName().asChar() << endl; }
}
