//-----------------------------------------------------------------------------------------
LPCSTR CXRayObjectExport::getMaterialName(MDagPath & mdagPath, int cid, int objectIdx)
{
MStatus stat;
int i, length;
MIntArray * currentMaterials = new MIntArray();
MStringArray mArray;
for ( i=0; i<numSets; i++ ) {
if ( lookup(mdagPath,i,cid) ) {
MFnSet fnSet( (*sets)[i] );
if ( MFnSet::kRenderableOnly == fnSet.restriction(&stat) ) {
currentMaterials->append( i );
mArray.append( fnSet.name() );
}
}
}
// Test for equivalent materials
//
bool materialsEqual = false;
if ((lastMaterials != NULL) && (lastMaterials->length() == currentMaterials->length())){
materialsEqual = true;
length = lastMaterials->length();
for (i=0; i<length; i++){
if ((*lastMaterials)[i]!=(*currentMaterials)[i]){
materialsEqual = false;
break;
}
}
}
if (!materialsEqual){
if (lastMaterials!=NULL) xr_delete(lastMaterials);
lastMaterials = currentMaterials;
int mLength = mArray.length();
if (mLength==0) xrDebug::Fatal(DEBUG_INFO,"Object '%s' has polygon '%d' without material.",0,cid);
if (mLength>1){
xrDebug::Fatal(DEBUG_INFO,"Object '%s' has polygon '%d' with more than one material.",0,cid);
}
}else{
xr_delete(currentMaterials);
}
return mArray[0].asChar();
}
bool DX11ViewportRenderer::drawSurface( const MDagPath &dagPath, bool active, bool templated)
{
bool drewSurface = false;
if ( !dagPath.hasFn( MFn::kMesh ))
{
MMatrix matrix = dagPath.inclusiveMatrix();
MFnDagNode dagNode(dagPath);
MBoundingBox box = dagNode.boundingBox();
float color[3] = {0.6f, 0.3f, 0.0f};
if (active)
{
color[0] = 1.0f;
color[1] = 1.0f;
color[2] = 1.0f;
}
else if (templated)
{
color[0] = 1.0f;
color[1] = 0.686f;
color[2] = 0.686f;
}
drawBounds( matrix, box, color);
return true;
}
if ( dagPath.hasFn( MFn::kMesh ))
{
MMatrix matrix = dagPath.inclusiveMatrix();
MFnDagNode dagNode(dagPath);
// Look for any hardware shaders which can draw D3D first.
//
bool drewWithHwShader = false;
{
MFnMesh fnMesh(dagPath);
MObjectArray sets;
MObjectArray comps;
unsigned int instanceNum = dagPath.instanceNumber();
if (!fnMesh.getConnectedSetsAndMembers(instanceNum, sets, comps, true))
MGlobal::displayError("ERROR : MFnMesh::getConnectedSetsAndMembers");
for ( unsigned i=0; i<sets.length(); i++ )
{
MObject set = sets[i];
MObject comp = comps[i];
MStatus status;
MFnSet fnSet( set, &status );
if (status == MS::kFailure) {
MGlobal::displayError("ERROR: MFnSet::MFnSet");
continue;
}
MObject shaderNode = findShader(set);
if (shaderNode != MObject::kNullObj)
{
MPxHardwareShader * hwShader =
MPxHardwareShader::getHardwareShaderPtr( shaderNode );
if (hwShader)
{
const MRenderProfile & profile = hwShader->profile();
if (profile.hasRenderer( MRenderProfile::kMayaD3D))
{
// Render a Maya D3D hw shader here....
//printf("Found a D3D hw shader\n");
//drewWithHwShader = true;
}
}
}
}
}
// Get the geometry buffers for this bad boy and render them
D3DGeometry* Geometry = m_resourceManager.getGeometry( dagPath, m_pD3DDevice);
if( Geometry)
{
// Transform from object to world space
//
XMMATRIX objectToWorld = XMMATRIX
(
(float)matrix.matrix[0][0], (float)matrix.matrix[0][1], (float)matrix.matrix[0][2], (float)matrix.matrix[0][3],
(float)matrix.matrix[1][0], (float)matrix.matrix[1][1], (float)matrix.matrix[1][2], (float)matrix.matrix[1][3],
(float)matrix.matrix[2][0], (float)matrix.matrix[2][1], (float)matrix.matrix[2][2], (float)matrix.matrix[2][3],
(float)matrix.matrix[3][0], (float)matrix.matrix[3][1], (float)matrix.matrix[3][2], (float)matrix.matrix[3][3]
);
FixedFunctionConstants cb;
if (!drewWithHwShader)
{
// Get material properties for shader associated with mesh
//
// 1. Try to draw with the sample internal programmable shader
bool drewGeometryWithShader = false;
// 2. Draw with fixed function shader
if (!drewGeometryWithShader)
{
// Set up a default material, just in case there is none.
//
float diffuse[3];
if (active)
{
if (templated)
{
m_pD3DDeviceCtx->RSSetState( m_pWireframeRS );
diffuse[0] = 1.0f; diffuse[1] = 0.686f; diffuse[2] = 0.686f;
}
else
{
m_pD3DDeviceCtx->RSSetState( m_pNormalRS );
diffuse[0] = 0.6f; diffuse[1] = 0.6f; diffuse[2] = 0.6f;
}
}
else
{
if (templated)
{
m_pD3DDeviceCtx->RSSetState( m_pWireframeRS );
diffuse[0] = 1.0f; diffuse[1] = 0.686f; diffuse[2] = 0.686f;
}
else
{
m_pD3DDeviceCtx->RSSetState( m_pNormalRS );
diffuse[0] = 0.5f; diffuse[1] = 0.5f; diffuse[2] = 0.5f;
}
}
// Set constant buffer
XMVECTOR det;
cb.wvIT = XMMatrixInverse( &det, objectToWorld * m_currentViewMatrix );
cb.wvp = XMMatrixTranspose( objectToWorld * m_currentViewMatrix * m_currentProjectionMatrix );
cb.wv = XMMatrixTranspose( objectToWorld * m_currentViewMatrix );
cb.lightDir = XMFLOAT4( 0.0f, 0.0f, 1.0f, 0.0f );
cb.lightColor = XMFLOAT4( 1.0f, 1.0f, 1.0f, 0.0f );
cb.ambientLight = XMFLOAT4( 0.2f, 0.2f, 0.2f, 0.0f );
cb.diffuseMaterial = XMFLOAT4( diffuse[0], diffuse[1], diffuse[2], 0.0f );
cb.specularColor = XMFLOAT4( 0.2f, 0.2f, 0.2f, 0.0f );
cb.diffuseCoeff = 1.0f;
cb.shininess = 16.0f;
cb.transparency = 1.0f;
m_pD3DDeviceCtx->UpdateSubresource( m_pFixedFunctionConstantBuffer, 0, NULL, &cb, 0, 0 );
// get shader
SurfaceEffectItemList::const_iterator it = m_resourceManager.getSurfaceEffectItemList().find( "Maya_fixedFunction" );
if ( it == m_resourceManager.getSurfaceEffectItemList().end() )
return false;
const SurfaceEffectItem* sei = it->second;
// bind shaders
m_pD3DDeviceCtx->VSSetShader( sei->fVertexShader, NULL, 0 );
m_pD3DDeviceCtx->VSSetConstantBuffers( 0, 1, &m_pFixedFunctionConstantBuffer );
m_pD3DDeviceCtx->IASetInputLayout( sei->fInputLayout );
m_pD3DDeviceCtx->PSSetShader( sei->fPixelShader, NULL, 0 );
m_pD3DDeviceCtx->PSSetConstantBuffers( 0, 1, &m_pFixedFunctionConstantBuffer );
Geometry->Render( m_pD3DDeviceCtx );
drewSurface = true;
}
}
// Draw wireframe on top
//
if ( drewSurface && active )
{
bool drawActiveWithBounds = false;
if (drawActiveWithBounds)
{
MBoundingBox box = dagNode.boundingBox();
float color[3] = {1.0f, 1.0f, 1.0f};
drawBounds( matrix, box, color );
}
else
{
cb.lightColor = XMFLOAT4( 0.0f, 0.0f, 0.0f, 0.0f );
cb.ambientLight = XMFLOAT4( 1.0f, 1.0f, 1.0f, 0.0f );
cb.diffuseMaterial = XMFLOAT4( 1.0f, 1.0f, 1.0f, 0.0f );
cb.specularColor = XMFLOAT4( 0.0f, 0.0f, 0.0f, 0.0f );
m_pD3DDeviceCtx->UpdateSubresource( m_pFixedFunctionConstantBuffer, 0, NULL, &cb, 0, 0 );
m_pD3DDeviceCtx->RSSetState( m_pWireframeRS );
Geometry->Render( m_pD3DDeviceCtx );
}
}
} // If Geometry
}
return drewSurface;
}
// Set keyframes to move selected object in a spiral
MStatus spiralAnimCurve::doIt( const MArgList& )
{
// Get the Active Selection List
//
MStatus status;
MSelectionList sList;
MGlobal::getActiveSelectionList( sList );
// Create an iterator for the selection list
//
MItSelectionList iter( sList, MFn::kDagNode, &status );
if ( MS::kSuccess != status ) {
cerr << "Failure in plugin setup";
return MS::kFailure;
}
MDagPath mObject;
MObject mComponent;
for ( ; !iter.isDone(); iter.next() ) {
status = iter.getDagPath( mObject, mComponent );
// Check if there was an error
//
if ( MS::kSuccess != status ) continue;
// We don't handle components
//
if ( !mComponent.isNull() ) continue;
// Create the function set
//
MFnDagNode fnSet( mObject, &status );
if ( MS::kSuccess != status ) {
cerr << "Failure to create function set\n";
continue;
}
// Get the plug for the X-translation channel
//
MString attrName( "translateX" );
const MObject attrX = fnSet.attribute( attrName, &status );
if ( MS::kSuccess != status ) {
cerr << "Failure to find attribute\n";
}
MFnAnimCurve acFnSetX;
acFnSetX.create( mObject.transform(), attrX, NULL, &status );
if ( MS::kSuccess != status ) {
cerr << "Failure creating MFnAnimCurve function set (translateX)\n";
continue;
}
// Repeat for Y-translation
//
attrName.set( "translateZ" );
const MObject attrZ = fnSet.attribute( attrName, &status );
if ( MS::kSuccess != status ) {
cerr << "Failure to find attribute\n";
}
MFnAnimCurve acFnSetZ;
acFnSetZ.create( mObject.transform(), attrZ, NULL, &status );
if ( MS::kSuccess != status ) {
cerr << "Failure creating MFnAnimCurve function set (translateZ)\n";
continue;
}
// Build spiral animation
//
for( int i = 1; i <= NUM_FRAMES; i++ ) {
// Build the keyframe at frame i
//
double x = sin( (double)i * RADIAL_VELOCITY ) *
( (double)i * OUTWARD_VELOCITY );
double z = cos( (double)i * RADIAL_VELOCITY ) *
( (double)i * OUTWARD_VELOCITY );
// cerr << "Setting keys - frame: " << i << " x: " << x << " z: " << z << endl;
MTime tm( (double)i, MTime::kFilm );
if ( ( MS::kSuccess != acFnSetX.addKeyframe( tm, x ) ) ||
( MS::kSuccess != acFnSetZ.addKeyframe( tm, z ) ) ) {
cerr << "Error setting the keyframe\n";
}
}
}
return status;
}
MStatus findTexturesPerPolygon::doIt( const MArgList& )
//
// Description:
// Find the texture files that apply to the color of each polygon of
// a selected shape if the shape has its polygons organized into sets.
//
{
// Get the selection and choose the first path on the selection list.
//
MStatus status;
MDagPath path;
MObject cmp;
MSelectionList slist;
MGlobal::getActiveSelectionList(slist);
slist.getDagPath(0, path, cmp);
// Have to make the path include the shape below it so that
// we can determine if the underlying shape node is instanced.
// By default, dag paths only include transform nodes.
//
path.extendToShape();
// If the shape is instanced then we need to determine which
// instance this path refers to.
//
int instanceNum = 0;
if (path.isInstanced())
instanceNum = path.instanceNumber();
// Get a list of all sets pertaining to the selected shape and the
// members of those sets.
//
MFnMesh fnMesh(path);
MObjectArray sets;
MObjectArray comps;
if (!fnMesh.getConnectedSetsAndMembers(instanceNum, sets, comps, true))
cerr << "ERROR: MFnMesh::getConnectedSetsAndMembers\n";
// Loop through all the sets. If the set is a polygonal set, find the
// shader attached to the and print out the texture file name for the
// set along with the polygons in the set.
//
for ( unsigned i=0; i<sets.length(); i++ ) {
MObject set = sets[i];
MObject comp = comps[i];
MFnSet fnSet( set, &status );
if (status == MS::kFailure) {
cerr << "ERROR: MFnSet::MFnSet\n";
continue;
}
// Make sure the set is a polygonal set. If not, continue.
MItMeshPolygon piter(path, comp, &status);
if ((status == MS::kFailure) || comp.isNull())
continue;
// Find the texture that is applied to this set. First, get the
// shading node connected to the set. Then, if there is an input
// attribute called "color", search upstream from it for a texture
// file node.
//
MObject shaderNode = findShader(set);
if (shaderNode == MObject::kNullObj)
continue;
MPlug colorPlug = MFnDependencyNode(shaderNode).findPlug("color", &status);
if (status == MS::kFailure)
continue;
MItDependencyGraph dgIt(colorPlug, MFn::kFileTexture,
MItDependencyGraph::kUpstream,
MItDependencyGraph::kBreadthFirst,
MItDependencyGraph::kNodeLevel,
&status);
if (status == MS::kFailure)
continue;
dgIt.disablePruningOnFilter();
// If no texture file node was found, just continue.
//
if (dgIt.isDone())
continue;
// Print out the texture node name and texture file that it references.
//
MObject textureNode = dgIt.thisNode();
MPlug filenamePlug = MFnDependencyNode(textureNode).findPlug("fileTextureName");
MString textureName;
filenamePlug.getValue(textureName);
cerr << "Set: " << fnSet.name() << endl;
cerr << "Texture Node Name: " << MFnDependencyNode(textureNode).name() << endl;
cerr << "Texture File Name: " << textureName.asChar() << endl;
// Print out the set of polygons that are contained in the current set.
//
for ( ; !piter.isDone(); piter.next() )
cerr << " poly component: " << piter.index() << endl;
}
return MS::kSuccess;
}
bool CXRayObjectExport::initializeSetsAndLookupTables( bool exportAll )
//
// Description :
// Creates a list of all sets in Maya, a list of mesh objects,
// and polygon/vertex lookup tables that will be used to
// determine which sets are referenced by the poly components.
//
{
int i=0,j=0, length;
MStatus stat;
// Initialize class data.
// Note: we cannot do this in the constructor as it
// only gets called upon registry of the plug-in.
//
numSets = 0;
sets = NULL;
lastSets = NULL;
lastMaterials = NULL;
objectId = 0;
objectCount = 0;
polygonTable = NULL;
vertexTable = NULL;
polygonTablePtr = NULL;
vertexTablePtr = NULL;
objectGroupsTablePtr = NULL;
objectNodeNamesArray.clear();
transformNodeNameArray.clear();
//////////////////////////////////////////////////////////////////
//
// Find all sets in Maya and store the ones we care about in
// the 'sets' array. Also make note of the number of sets.
//
//////////////////////////////////////////////////////////////////
// Get all of the sets in maya and put them into
// a selection list
//
MStringArray result;
MGlobal::executeCommand( "ls -sets", result );
MSelectionList * setList = new MSelectionList();
length = result.length();
for ( i=0; i<length; i++ )
{
setList->add( result[i] );
}
// Extract each set as an MObject and add them to the
// sets array.
// We may be excluding groups, matierials, or ptGroups
// in which case we can ignore those sets.
//
MObject mset;
sets = new MObjectArray();
length = setList->length();
for ( i=0; i<length; i++ )
{
setList->getDependNode( i, mset );
MFnSet fnSet( mset, &stat );
if ( stat ) {
if ( MFnSet::kRenderableOnly == fnSet.restriction(&stat) ) {
sets->append( mset );
}
}
}
xr_delete(setList);
numSets = sets->length();
//////////////////////////////////////////////////////////////////
//
// Do a dag-iteration and for every mesh found, create facet and
// vertex look-up tables. These tables will keep track of which
// sets each component belongs to.
//
// If exportAll is false then iterate over the activeSelection
// list instead of the entire DAG.
//
// These arrays have a corrisponding entry in the name
// stringArray.
//
//////////////////////////////////////////////////////////////////
MIntArray vertexCounts;
MIntArray polygonCounts;
if ( exportAll ) {
MItDag dagIterator( MItDag::kBreadthFirst, MFn::kInvalid, &stat);
if ( MS::kSuccess != stat) {
fprintf(stderr,"Failure in DAG iterator setup.\n");
return false;
}
objectNames = new MStringArray();
for ( ; !dagIterator.isDone(); dagIterator.next() )
{
MDagPath dagPath;
stat = dagIterator.getPath( dagPath );
if ( stat )
{
// skip over intermediate objects
//
MFnDagNode dagNode( dagPath, &stat );
if (dagNode.isIntermediateObject())
{
continue;
}
if (( dagPath.hasFn(MFn::kMesh)) &&
( dagPath.hasFn(MFn::kTransform)))
{
// We want only the shape,
// not the transform-extended-to-shape.
continue;
}
else if ( dagPath.hasFn(MFn::kMesh))
{
// We have a mesh so create a vertex and polygon table
// for this object.
//
MFnMesh fnMesh( dagPath );
int vtxCount = fnMesh.numVertices();
int polygonCount = fnMesh.numPolygons();
// we do not need this call anymore, we have the shape.
// dagPath.extendToShape();
MString name = dagPath.fullPathName();
objectNames->append( name );
objectNodeNamesArray.append( fnMesh.name() );
vertexCounts.append( vtxCount );
polygonCounts.append( polygonCount );
objectCount++;
}
}
}
}else{
MSelectionList slist;
MGlobal::getActiveSelectionList( slist );
MItSelectionList iter( slist );
MStatus status;
objectNames = new MStringArray();
// We will need to interate over a selected node's heirarchy
// in the case where shapes are grouped, and the group is selected.
MItDag dagIterator( MItDag::kDepthFirst, MFn::kInvalid, &status);
for ( ; !iter.isDone(); iter.next() ){
MDagPath objectPath;
stat = iter.getDagPath( objectPath );
// reset iterator's root node to be the selected node.
status = dagIterator.reset (objectPath.node(),
MItDag::kDepthFirst, MFn::kInvalid );
// DAG iteration beginning at at selected node
for ( ; !dagIterator.isDone(); dagIterator.next() ){
MDagPath dagPath;
MObject component = MObject::kNullObj;
status = dagIterator.getPath(dagPath);
if (!status){
fprintf(stderr,"Failure getting DAG path.\n");
freeLookupTables();
return false;
}
// skip over intermediate objects
//
MFnDagNode dagNode( dagPath, &stat );
if (dagNode.isIntermediateObject()) continue;
if (( dagPath.hasFn(MFn::kMesh)) && ( dagPath.hasFn(MFn::kTransform))){
// We want only the shape,
// not the transform-extended-to-shape.
continue;
}else if ( dagPath.hasFn(MFn::kMesh)){
// We have a mesh so create a vertex and polygon table
// for this object.
//
MFnMesh fnMesh( dagPath );
int vtxCount = fnMesh.numVertices();
int polygonCount = fnMesh.numPolygons();
// we do not need this call anymore, we have the shape.
// dagPath.extendToShape();
MString name = dagPath.fullPathName();
objectNames->append( name );
objectNodeNamesArray.append( fnMesh.name() );
vertexCounts.append( vtxCount );
polygonCounts.append( polygonCount );
objectCount++;
}
}
}
}
// Now we know how many objects we are dealing with
// and we have counts of the vertices/polygons for each
// object so create the maya group look-up table.
//
if( objectCount > 0 ) {
// To export Maya groups we traverse the hierarchy starting at
// each objectNodeNamesArray[i] going towards the root collecting transform
// nodes as we go.
length = objectNodeNamesArray.length();
for( i=0; i<length; i++ ) {
MIntArray transformNodeNameIndicesArray;
recFindTransformDAGNodes( objectNodeNamesArray[i], transformNodeNameIndicesArray );
}
if( transformNodeNameArray.length() > 0 ) {
objectGroupsTablePtr = xr_alloc<bool*>(objectCount);// (bool**) malloc( sizeof(bool*)*objectCount );
length = transformNodeNameArray.length();
for ( i=0; i<objectCount; i++ )
{
// objectGroupsTablePtr[i] = (bool*)calloc( length, sizeof(bool) );
objectGroupsTablePtr[i] = xr_alloc<bool>(length);
ZeroMemory(objectGroupsTablePtr[i],length*sizeof(bool));
// XXX nitrocaster: remove this 'cause malloc failure shouldn't be handled there
if ( objectGroupsTablePtr[i] == NULL ) {
Log("! calloc returned NULL (objectGroupsTablePtr)");
return false;
}
}
}
// else{
// Log("! Can't find transform for node.");
// return false;
// }
}
// Create the vertex/polygon look-up tables.
//
if ( objectCount > 0 ) {
vertexTablePtr = xr_alloc<bool*>(objectCount); //(bool**) malloc( sizeof(bool*)*objectCount );
polygonTablePtr = xr_alloc<bool*>(objectCount); //(bool**) malloc( sizeof(bool*)*objectCount );
for ( i=0; i<objectCount; i++ )
{
// vertexTablePtr[i] = (bool*)calloc( vertexCounts[i]*numSets, sizeof(bool) );
vertexTablePtr[i] = xr_alloc<bool>(vertexCounts[i]*numSets);
ZeroMemory(vertexTablePtr[i],vertexCounts[i]*numSets*sizeof(bool));
// XXX nitrocaster: remove this 'cause malloc failure shouldn't be handled there
if ( vertexTablePtr[i] == NULL ) {
Log("! calloc returned NULL (vertexTable)");
return false;
}
// polygonTablePtr[i] = (bool*)calloc( polygonCounts[i]*numSets, sizeof(bool) );
polygonTablePtr[i] = xr_alloc<bool>(polygonCounts[i]*numSets);
ZeroMemory(polygonTablePtr[i],polygonCounts[i]*numSets*sizeof(bool));
// XXX nitrocaster: remove this 'cause malloc failure shouldn't be handled there
if ( polygonTablePtr[i] == NULL ) {
Log("! calloc returned NULL (polygonTable)");
return false;
}
}
}
// If we found no meshes then return
//
if ( objectCount == 0 ) {
return false;
}
//////////////////////////////////////////////////////////////////
//
// Go through all of the set members (flattened lists) and mark
// in the lookup-tables, the sets that each mesh component belongs
// to.
//
//
//////////////////////////////////////////////////////////////////
bool flattenedList = true;
MDagPath object;
MObject component;
MSelectionList memberList;
for ( i=0; i<numSets; i++ )
{
MFnSet fnSet( (*sets)[i] );
memberList.clear();
stat = fnSet.getMembers( memberList, flattenedList );
if (MS::kSuccess != stat) {
fprintf(stderr,"Error in fnSet.getMembers()!\n");
}
int m, numMembers;
numMembers = memberList.length();
for ( m=0; m<numMembers; m++ )
{
if ( memberList.getDagPath(m,object,component) ) {
if ( (!component.isNull()) && (object.apiType() == MFn::kMesh) )
{
if (component.apiType() == MFn::kMeshVertComponent) {
MItMeshVertex viter( object, component );
for ( ; !viter.isDone(); viter.next() )
{
int compIdx = viter.index();
MString name = object.fullPathName();
// Figure out which object vertexTable
// to get.
//
int o, numObjectNames;
numObjectNames = objectNames->length();
for ( o=0; o<numObjectNames; o++ ) {
if ( (*objectNames)[o] == name ) {
// Mark set i as true in the table
//
vertexTable = vertexTablePtr[o];
*(vertexTable + numSets*compIdx + i) = true;
break;
}
}
}
}
else if (component.apiType() == MFn::kMeshPolygonComponent)
{
MItMeshPolygon piter( object, component );
for ( ; !piter.isDone(); piter.next() )
{
int compIdx = piter.index();
MString name = object.fullPathName();
// Figure out which object polygonTable
// to get.
//
int o, numObjectNames;
numObjectNames = objectNames->length();
for ( o=0; o<numObjectNames; o++ ) {
if ( (*objectNames)[o] == name ) {
// Mark set i as true in the table
//
// Check for bad components in the set
//
if ( compIdx >= polygonCounts[o] ) {
Msg("! Bad polygon index '%d' found. Polygon skipped",compIdx);
break;
}
polygonTable = polygonTablePtr[o];
*(polygonTable + numSets*compIdx + i) = true;
break;
}
}
}
}
}
else {
// There are no components, therefore we can mark
// all polygons as members of the given set.
//
if (object.hasFn(MFn::kMesh)) {
MFnMesh fnMesh( object, &stat );
if ( MS::kSuccess != stat) {
fprintf(stderr,"Failure in MFnMesh initialization.\n");
return false;
}
// We are going to iterate over all the polygons.
//
MItMeshPolygon piter( object, MObject::kNullObj, &stat );
if ( MS::kSuccess != stat) {
fprintf(stderr,
"Failure in MItMeshPolygon initialization.\n");
return false;
}
for ( ; !piter.isDone(); piter.next() )
{
int compIdx = piter.index();
MString name = object.fullPathName();
// Figure out which object polygonTable to get.
//
int o, numObjectNames;
numObjectNames = objectNames->length();
for ( o=0; o<numObjectNames; o++ ) {
if ( (*objectNames)[o] == name ) {
// Check for bad components in the set
//
if ( compIdx >= polygonCounts[o] ) {
Msg("! Bad polygon index '%d' found. Polygon skipped",compIdx);
break;
}
// Mark set i as true in the table
//
polygonTable = polygonTablePtr[o];
*(polygonTable + numSets*compIdx + i) = true;
break;
}
}
} // end of piter.next() loop
} // end of condition if (object.hasFn(MFn::kMesh))
} // end of else condifion if (!component.isNull())
} // end of memberList.getDagPath(m,object,component)
} // end of memberList loop
} // end of for-loop for sets
// Go through all of the group members and mark in the
// lookup-table, the group that each shape belongs to.
length = objectNodeNamesArray.length();
if (objectGroupsTablePtr){
for( i=0; i<length; i++ ) {
MIntArray groupTableIndicesArray;
bool *objectGroupTable = objectGroupsTablePtr[i];
int length2;
recFindTransformDAGNodes( objectNodeNamesArray[i], groupTableIndicesArray );
length2 = groupTableIndicesArray.length();
for( j=0; j<length2; j++ ) {
int groupIdx = groupTableIndicesArray[j];
objectGroupTable[groupIdx] = true;
}
}
}
return true;
}
MStatus parseShader(MObject &src, SXRShaderData& d)
{
MStatus status;
MFnSet fnSet( src, &status );
if (status == MStatus::kFailure) {
status.perror("Unable to lookup shader from set of shaders for object");
return status;
}
MObject shaderNode = findShader(src,d);
if (shaderNode == MObject::kNullObj)
return (MStatus::kFailure);
MPlug colorPlug = MFnDependencyNode(shaderNode).findPlug("color", &status);
if (status == MStatus::kFailure)
return (status);
MItDependencyGraph dgIt(colorPlug, MFn::kFileTexture,
MItDependencyGraph::kUpstream,
MItDependencyGraph::kBreadthFirst,
MItDependencyGraph::kNodeLevel,
&status);
if (status == MStatus::kFailure)
return (status);
dgIt.disablePruningOnFilter();
// If no texture file node was found, just continue.
//
if (dgIt.isDone()) {
// cout << "no textures found for " << colorPlug.name() << "\n";
return (MStatus::kSuccess);
}
// Print out the texture node name and texture file that it references.
//
MObject textureNode = dgIt.thisNode();
MPlug filenamePlug = MFnDependencyNode(textureNode).findPlug("fileTextureName");
MString textureName;
filenamePlug.getValue(textureName);
MStringArray rgFolders;
if (strchr (textureName.asChar(), '\\'))
{
textureName.split ('\\', rgFolders);
} else {
textureName.split ('/', rgFolders);
}
d.tex_name = rgFolders[rgFolders.length() -1];
// cout << "Found texture file: '" << filename.asChar() << "'\n";
short index;
//double side flag
MPlug xrDoubleSidePlug= MFnDependencyNode(shaderNode).findPlug("xrayDoubleSide", &status);
if (status == MS::kSuccess)
{
MFnEnumAttribute enm = xrDoubleSidePlug.attribute();
if ((status == MS::kSuccess)&&(MS::kSuccess==xrDoubleSidePlug.getValue(index)))
d.double_side = index;
}
//engine
MPlug xrEnginePlug= MFnDependencyNode(shaderNode).findPlug("xrayEngineShader", &status);
if (status == MS::kSuccess)
{
MFnEnumAttribute enm = xrEnginePlug.attribute();
if ((status == MS::kSuccess)&&(MS::kSuccess==xrEnginePlug.getValue(index)))
d.eng_name = enm.fieldName(index);
}
//compiler
MPlug xrCompilerPlug = MFnDependencyNode(shaderNode).findPlug("xrayCompilerShader", &status);
if (status == MS::kSuccess)
{
MFnEnumAttribute enm = xrCompilerPlug.attribute();
if ((status == MS::kSuccess)&&(MS::kSuccess==xrCompilerPlug.getValue(index)))
d.comp_name = enm.fieldName(index);
}
//game material
MPlug xrGameMaterialPlug = MFnDependencyNode(shaderNode).findPlug("xrayGameMaterial", &status);
if (status == MS::kSuccess)
{
MFnEnumAttribute enm = xrGameMaterialPlug.attribute();
if ((status == MS::kSuccess)&&(MS::kSuccess==xrGameMaterialPlug.getValue(index)))
d.gmat_name = enm.fieldName(index);
}
return (MStatus::kSuccess);
}
