void SceneShape::sceneShapeAttributeNames( const MDagPath &p, SceneInterface::NameList &attributeNames )
{
MDagPath dagPath;
SceneShape *sceneShape = findScene( p, false, &dagPath );
if ( !sceneShape )
{
return;
}
SceneInterface::NameList sceneAttrNames;
ConstSceneInterfacePtr scene = sceneShape->getSceneInterface();
if ( !scene )
{
return;
}
scene->attributeNames( sceneAttrNames );
attributeNames.insert( attributeNames.end(), sceneAttrNames.begin(), sceneAttrNames.end() );
MFnDagNode fnChildDag( dagPath );
if( !fnChildDag.isIntermediateObject() && hasSceneShapeLink( p ) )
{
attributeNames.push_back( LinkedScene::linkAttribute );
}
}
bool SceneShape::hasSceneShapeObject( const MDagPath &p )
{
MDagPath dagPath;
SceneShape *sceneShape = findScene( p, true, &dagPath );
if ( !sceneShape )
{
return false;
}
MFnDagNode fnChildDag( dagPath );
MStatus st;
MPlug objectOnlyPlug = fnChildDag.findPlug( aObjectOnly, &st );
if( !st )
{
throw Exception( "Could not find 'objectOnly' plug in SceneShape!");
}
// if we're rendering object and children than it should only be represented as a link to the scene and no objects.
if( !objectOnlyPlug.asBool() )
{
return false;
}
IECore::ConstSceneInterfacePtr sceneInterface = sceneShape->getSceneInterface();
if( !sceneInterface )
{
return false;
}
return sceneInterface->hasObject();
}
bool SceneShape::hasSceneShapeLink( const MDagPath &p )
{
MDagPath dagPath;
SceneShape *sceneShape = findScene( p, true, &dagPath );
if ( !sceneShape )
{
return false;
}
MFnDagNode fnChildDag( dagPath );
MStatus st;
MPlug objectOnlyPlug = fnChildDag.findPlug( aObjectOnly, &st );
if( !st )
{
throw Exception( "Could not find 'objectOnly' plug in SceneShape!");
}
// if we're doing objects only, we just output the object directly, so we don't need link attributes...
if( objectOnlyPlug.asBool() )
{
return false;
}
if ( !sceneShape->getSceneInterface() )
{
return false;
}
// so if it's not object only, then we know the scene loads everything and we can create a link to it.
return true;
}
ConstObjectPtr SceneShape::readSceneShapeAttribute( const MDagPath &p, SceneInterface::Name attributeName )
{
MDagPath dagPath;
SceneShape *sceneShape = findScene( p, false, &dagPath );
if ( !sceneShape )
{
return 0;
}
MFnDagNode fnChildDag( dagPath );
if( attributeName == LinkedScene::linkAttribute )
{
if( !fnChildDag.isIntermediateObject() )
{
return readSceneShapeLink(p);
}
}
ConstSceneInterfacePtr scene = sceneShape->getSceneInterface();
if ( !scene )
{
return 0;
}
MPlug timePlug = fnChildDag.findPlug( aTime );
MTime time;
timePlug.getValue( time );
return scene->readAttribute( attributeName, time.as( MTime::kSeconds ) );
}
ConstObjectPtr SceneShape::readSceneShapeObject( const MDagPath &p )
{
SceneShape *sceneShape = findScene( p, true );
if ( !sceneShape )
{
return 0;
}
MPlug pTime( sceneShape->thisMObject(), aTime );
MTime time;
pTime.getValue( time );
double t = time.as( MTime::kSeconds );
return sceneShape->getSceneInterface()->readObject( t );
}
void SceneShape::readTags( const MDagPath &p, SceneInterface::NameList &tags, int filter )
{
SceneShape *sceneShape = findScene( p, false );
if ( !sceneShape )
{
return;
}
const SceneInterface *scene = sceneShape->getSceneInterface().get();
if ( !scene )
{
return;
}
scene->readTags( tags, filter );
}
void SceneShape::readTags( const MDagPath &p, SceneInterface::NameList &tags, bool includeChildren )
{
SceneShape *sceneShape = findScene( p, false );
if ( !sceneShape )
{
return;
}
const SceneInterface *scene = sceneShape->getSceneInterface();
if ( !scene )
{
return;
}
scene->readTags( tags, includeChildren );
}
bool SceneShape::hasTag( const MDagPath &p, const SceneInterface::Name &tag )
{
SceneShape *sceneShape = findScene( p, false );
if ( !sceneShape )
{
return false;
}
const SceneInterface *scene = sceneShape->getSceneInterface();
if ( !scene )
{
return false;
}
return scene->hasTag( tag );
}
ConstObjectPtr SceneShape::readSceneShapeLink( const MDagPath &p )
{
MDagPath dagPath;
SceneShape *sceneShape = findScene( p, true, &dagPath );
if ( !sceneShape )
{
throw Exception("readSceneShapeLink: Could not find SceneShape!");
}
ConstSceneInterfacePtr scene = sceneShape->getSceneInterface();
if ( !scene )
{
throw Exception( "Empty scene!");
}
MFnDagNode fnChildDag( dagPath );
MStatus st;
MPlug timePlug = fnChildDag.findPlug( aTime, &st );
if( !st )
{
throw Exception( "Could not find 'time' plug in SceneShape!");
}
// if time plug is connected to maya global time, then we assume there's no time remapping between the Maya scene and the loaded scene.
MPlugArray array;
timePlug.connectedTo( array, true, false, &st );
if( !st )
{
throw Exception( "Could not find 'time' plug connections in SceneShape!");
}
for ( unsigned int i = 0; i < array.length(); i++ )
{
if ( array[i].name() == "time1.outTime" )
{
/// connected to time, so no time remapping between maya scene and loaded scene.
return LinkedScene::linkAttributeData( scene.get() );
}
}
/// couldn't find connection to maya time, so this node is mapping the time some other way.
MTime time;
timePlug.getValue( time );
return LinkedScene::linkAttributeData( scene.get(), time.as( MTime::kSeconds ) );
}
bool SceneShape::hasTag( const MDagPath &p, const SceneInterface::Name &tag, int filter )
{
SceneShape *sceneShape = findScene( p, false );
if ( !sceneShape )
{
return false;
}
/// \todo Perhaps getSceneInterface() should return a raw pointer?
/// Also perhaps it shouldn't be prefixed with "get" since there is no
/// corresponding set.
const SceneInterface *scene = sceneShape->getSceneInterface().get();
if ( !scene )
{
return false;
}
return scene->hasTag( tag, filter );
}
void SceneShapeUI::getDrawRequests( const MDrawInfo &info, bool objectAndActiveOnly, MDrawRequestQueue &requests )
{
// it's easy if no one want to look at us
if( !info.objectDisplayStatus( M3dView::kDisplayMeshes ) )
{
return;
}
// the node we're meant to be drawing
SceneShape *sceneShape = (SceneShape *)surfaceShape();
if( !sceneShape->getSceneInterface() )
{
return;
}
// draw data encapsulating that node
MDrawData drawData;
getDrawData( sceneShape, drawData );
// a request for the bound if necessary
MPlug pDrawBound( sceneShape->thisMObject(), SceneShape::aDrawRootBound );
bool drawBound;
pDrawBound.getValue( drawBound );
if( drawBound )
{
bool doDrawBound = true;
// If objectOnly is true, check for an object. If none found, no need to add the bound request.
MPlug pObjectOnly( sceneShape->thisMObject(), SceneShape::aObjectOnly );
bool objectOnly;
pObjectOnly.getValue( objectOnly );
if( objectOnly && !sceneShape->getSceneInterface()->hasObject() )
{
doDrawBound = false;
}
if( doDrawBound )
{
MDrawRequest request = info.getPrototype( *this );
request.setDrawData( drawData );
request.setToken( BoundDrawMode );
request.setDisplayStyle( M3dView::kWireFrame );
setWireFrameColors( request, info.displayStatus() );
requests.add( request );
}
}
MPlug pDrawAllBounds( sceneShape->thisMObject(), SceneShape::aDrawChildBounds );
bool drawAllBounds = false;
pDrawAllBounds.getValue( drawAllBounds );
// requests for the scene if necessary
MPlug pGLPreview( sceneShape->thisMObject(), SceneShape::aDrawGeometry );
bool glPreview;
pGLPreview.getValue( glPreview );
if( glPreview || drawAllBounds )
{
if( info.displayStyle()==M3dView::kGouraudShaded || info.displayStyle()==M3dView::kFlatShaded )
{
// make a request for solid drawing with a material
MDrawRequest solidRequest = info.getPrototype( *this );
solidRequest.setDrawData( drawData );
MDagPath path = info.multiPath();
M3dView view = info.view();
MMaterial material = MPxSurfaceShapeUI::material( path );
if( !material.evaluateMaterial( view, path ) )
{
MString pathName = path.fullPathName();
IECore::msg( IECore::Msg::Warning, "SceneShapeUI::getDrawRequests", boost::format( "Failed to evaluate material for \"%s\"." ) % pathName.asChar() );
}
if( material.materialIsTextured() )
{
material.evaluateTexture( drawData );
}
solidRequest.setMaterial( material );
// set the transparency request. we don't have a decent way of finding out
// if shaders applied by the procedural are transparent, so we've got a transparency
// attribute on the procedural holder for users to use. maya materials may also say
// they're transparent. if either asks for transparency then we'll ask for it here
bool transparent = false;
material.getHasTransparency( transparent );
solidRequest.setIsTransparent( transparent );
solidRequest.setToken( SceneDrawMode );
requests.add( solidRequest );
if( info.displayStatus()==M3dView::kActive || info.displayStatus()==M3dView::kLead || info.displayStatus()==M3dView::kHilite )
{
MDrawRequest wireRequest = info.getPrototype( *this );
wireRequest.setDrawData( drawData );
wireRequest.setDisplayStyle( M3dView::kWireFrame );
wireRequest.setToken( SceneDrawMode );
setWireFrameColors( wireRequest, info.displayStatus() );
wireRequest.setComponent( MObject::kNullObj );
if ( !objectAndActiveOnly )
{
if ( sceneShape->hasActiveComponents() )
{
MObjectArray components = sceneShape->activeComponents();
MObject component = components[0];
wireRequest.setComponent( component );
}
}
requests.add( wireRequest );
}
}
else
{
MDrawRequest request = info.getPrototype( *this );
request.setDrawData( drawData );
setWireFrameColors( request, info.displayStatus() );
request.setToken( SceneDrawMode );
request.setComponent( MObject::kNullObj );
if ( !objectAndActiveOnly )
{
if ( sceneShape->hasActiveComponents() )
{
MObjectArray components = sceneShape->activeComponents();
MObject component = components[0];
request.setComponent( component );
}
}
requests.add( request );
}
}
}
bool SceneShapeUI::select( MSelectInfo &selectInfo, MSelectionList &selectionList, MPointArray &worldSpaceSelectPts ) const
{
MStatus s;
// early out if we're not selectable. we always allow components to be selected if we're highlighted,
// but we don't allow ourselves to be selected as a whole unless meshes are in the selection mask.
// it's not ideal that we act like a mesh, but it's at least consistent with the drawing mask we use.
if( selectInfo.displayStatus() != M3dView::kHilite )
{
MSelectionMask meshMask( MSelectionMask::kSelectMeshes );
// Apparently selectInfo.selectable() still returns true when meshes are not
// displayed by the M3dView, so we are also testing the objectDisplay status.
// This was last confirmed in Maya 2014, and is presumably a Maya bug.
if( !selectInfo.selectable( meshMask ) || !selectInfo.objectDisplayStatus( M3dView::kDisplayMeshes ) )
{
return false;
}
}
// early out if we have no scene to draw
SceneShape *sceneShape = static_cast<SceneShape *>( surfaceShape() );
if( !sceneShape->getSceneInterface() )
{
return false;
}
IECoreGL::ConstScenePtr scene = sceneShape->glScene();
if( !scene )
{
return false;
}
// we want to perform the selection using an IECoreGL::Selector, so we
// can avoid the performance penalty associated with using GL_SELECT mode.
// that means we don't really want to call view.beginSelect(), but we have to
// call it just to get the projection matrix for our own selection, because as far
// as I can tell, there is no other way of getting it reliably.
M3dView view = selectInfo.view();
view.beginSelect();
Imath::M44d projectionMatrix;
glGetDoublev( GL_PROJECTION_MATRIX, projectionMatrix.getValue() );
view.endSelect();
view.beginGL();
glMatrixMode( GL_PROJECTION );
glLoadMatrixd( projectionMatrix.getValue() );
IECoreGL::Selector::Mode selectionMode = IECoreGL::Selector::IDRender;
if( selectInfo.displayStatus() == M3dView::kHilite && !selectInfo.singleSelection() )
{
selectionMode = IECoreGL::Selector::OcclusionQuery;
}
std::vector<IECoreGL::HitRecord> hits;
{
IECoreGL::Selector selector( Imath::Box2f( Imath::V2f( 0 ), Imath::V2f( 1 ) ), selectionMode, hits );
IECoreGL::State::bindBaseState();
selector.baseState()->bind();
scene->render( selector.baseState() );
if( selectInfo.displayStatus() != M3dView::kHilite )
{
// We're not in component selection mode. We'd like to be able to select the scene shape
// using the bounding box so we draw it too but only if it is visible
MPlug pDrawBound( sceneShape->thisMObject(), SceneShape::aDrawRootBound );
bool drawBound;
pDrawBound.getValue( drawBound );
if( drawBound )
{
IECoreGL::BoxPrimitive::renderWireframe( IECore::convert<Imath::Box3f>( sceneShape->boundingBox() ) );
}
}
}
view.endGL();
if( hits.empty() )
{
return false;
}
// iterate over the hits, converting them into components and also finding
// the closest one.
MIntArray componentIndices;
float depthMin = std::numeric_limits<float>::max();
int depthMinIndex = -1;
for( unsigned int i=0, e = hits.size(); i < e; i++ )
{
if( hits[i].depthMin < depthMin )
{
depthMin = hits[i].depthMin;
depthMinIndex = componentIndices.length();
}
int index = sceneShape->selectionIndex( IECoreGL::NameStateComponent::nameFromGLName( hits[i].name ) );
componentIndices.append( index );
}
assert( depthMinIndex >= 0 );
// figure out the world space location of the closest hit
MDagPath camera;
view.getCamera( camera );
MPoint worldIntersectionPoint;
selectionRayToWorldSpacePoint( camera, selectInfo, depthMin, worldIntersectionPoint );
// turn the processed hits into appropriate changes to the current selection
if( selectInfo.displayStatus() == M3dView::kHilite )
{
// selecting components
MFnSingleIndexedComponent fnComponent;
MObject component = fnComponent.create( MFn::kMeshPolygonComponent, &s ); assert( s );
if( selectInfo.singleSelection() )
{
fnComponent.addElement( componentIndices[depthMinIndex] );
}
else
{
fnComponent.addElements( componentIndices );
}
MSelectionList items;
items.add( selectInfo.multiPath(), component );
MDagPath path = selectInfo.multiPath();
selectInfo.addSelection(
items, worldIntersectionPoint,
selectionList, worldSpaceSelectPts,
MSelectionMask::kSelectMeshFaces,
true
);
}
else
{
// Check if we should be able to select that object
MPlug pObjectOnly( sceneShape->thisMObject(), SceneShape::aObjectOnly );
bool objectOnly;
pObjectOnly.getValue( objectOnly );
if( objectOnly && !sceneShape->getSceneInterface()->hasObject() )
{
return true;
}
// selecting objects
MSelectionList item;
item.add( selectInfo.selectPath() );
selectInfo.addSelection(
item, worldIntersectionPoint,
selectionList, worldSpaceSelectPts,
MSelectionMask::kSelectMeshes,
false
);
}
return true;
}
bool SceneShapeUI::snap( MSelectInfo &snapInfo ) const
{
MStatus s;
if( snapInfo.displayStatus() != M3dView::kHilite )
{
MSelectionMask meshMask( MSelectionMask::kSelectMeshes );
if( !snapInfo.selectable( meshMask ) )
{
return false;
}
}
// early out if we have no scene to draw
SceneShape *sceneShape = static_cast<SceneShape *>( surfaceShape() );
const IECore::SceneInterface *sceneInterface = sceneShape->getSceneInterface().get();
if( !sceneInterface )
{
return false;
}
IECoreGL::ConstScenePtr scene = sceneShape->glScene();
if( !scene )
{
return false;
}
// Get the viewport that the snapping operation is taking place in.
M3dView view = snapInfo.view();
// Use an IECoreGL::Selector to find the point in world space that we wish to snap to.
// We do this by first getting the origin of the selection ray and transforming it into
// NDC space using the OpenGL projection and transformation matrices. Once we have the
// point in NDC we can use it to define the viewport that the IECoreGL::Selector will use.
MPoint localRayOrigin;
MVector localRayDirection;
snapInfo.getLocalRay( localRayOrigin, localRayDirection );
Imath::V3d org( localRayOrigin[0], localRayOrigin[1], localRayOrigin[2] );
MDagPath camera;
view.getCamera( camera );
MMatrix localToCamera = snapInfo.selectPath().inclusiveMatrix() * camera.inclusiveMatrix().inverse();
view.beginSelect();
Imath::M44d projectionMatrix;
glGetDoublev( GL_PROJECTION_MATRIX, projectionMatrix.getValue() );
view.endSelect();
double v[4][4];
localToCamera.get( v );
Imath::M44d cam( v );
Imath::V3d ndcPt3d = ( (org * cam ) * projectionMatrix + Imath::V3d( 1. ) ) * Imath::V3d( .5 );
Imath::V2d ndcPt( std::max( std::min( ndcPt3d[0], 1. ), 0. ), 1. - std::max( std::min( ndcPt3d[1], 1. ), 0. ) );
view.beginGL();
glMatrixMode( GL_PROJECTION );
glLoadMatrixd( projectionMatrix.getValue() );
float radius = .001; // The radius of the selection area in NDC.
double aspect = double( view.portWidth() ) / view.portHeight();
Imath::V2f selectionWH( radius, radius * aspect );
std::vector<IECoreGL::HitRecord> hits;
{
IECoreGL::Selector selector( Imath::Box2f( ndcPt - selectionWH, ndcPt + selectionWH ), IECoreGL::Selector::IDRender, hits );
IECoreGL::State::bindBaseState();
selector.baseState()->bind();
scene->render( selector.baseState() );
}
view.endGL();
if( hits.empty() )
{
return false;
}
// Get the closest mesh hit.
float depthMin = std::numeric_limits<float>::max();
int depthMinIndex = -1;
for( unsigned int i=0, e = hits.size(); i < e; i++ )
{
if( hits[i].depthMin < depthMin )
{
depthMin = hits[i].depthMin;
depthMinIndex = i;
}
}
// Get the absolute path of the hit object.
IECore::SceneInterface::Path objPath;
std::string objPathStr;
sceneInterface->path( objPath );
IECore::SceneInterface::pathToString( objPath, objPathStr );
objPathStr += IECoreGL::NameStateComponent::nameFromGLName( hits[depthMinIndex].name );
IECore::SceneInterface::stringToPath( objPathStr, objPath );
// Validate the hit selection.
IECore::ConstSceneInterfacePtr childInterface;
try
{
childInterface = sceneInterface->scene( objPath );
}
catch(...)
{
return false;
}
if( !childInterface )
{
return false;
}
if( !childInterface->hasObject() )
{
return false;
}
// Get the mesh primitive so that we can query it's vertices.
double time = sceneShape->time();
IECore::ConstObjectPtr object = childInterface->readObject( time );
IECore::ConstMeshPrimitivePtr meshPtr = IECore::runTimeCast<const IECore::MeshPrimitive>( object.get() );
if ( !meshPtr )
{
return false;
}
// Calculate the snap point in object space.
MPoint worldIntersectionPoint;
selectionRayToWorldSpacePoint( camera, snapInfo, depthMin, worldIntersectionPoint );
Imath::V3f pt( worldIntersectionPoint[0], worldIntersectionPoint[1], worldIntersectionPoint[2] );
Imath::M44f objToWorld( worldTransform( childInterface.get(), time ) );
pt = pt * objToWorld.inverse();
// Get the list of vertices in the mesh.
IECore::V3fVectorData::ConstPtr pointData( meshPtr->variableData<IECore::V3fVectorData>( "P", IECore::PrimitiveVariable::Vertex ) );
const std::vector<Imath::V3f> &vertices( pointData->readable() );
// Find the vertex that is closest to the snap point.
Imath::V3d closestVertex;
float closestDistance = std::numeric_limits<float>::max();
for( std::vector<Imath::V3f>::const_iterator it( vertices.begin() ); it != vertices.end(); ++it )
{
Imath::V3d vert( *it );
float d( ( pt - vert ).length() ); // Calculate the distance between the vertex and the snap point.
if( d < closestDistance )
{
closestDistance = d;
closestVertex = vert;
}
}
// Snap to the vertex.
closestVertex *= objToWorld;
snapInfo.setSnapPoint( MPoint( closestVertex[0], closestVertex[1], closestVertex[2] ) );
return true;
}
void SceneShapeUI::draw( const MDrawRequest &request, M3dView &view ) const
{
MStatus s;
MDrawData drawData = request.drawData();
SceneShape *sceneShape = (SceneShape *)drawData.geometry();
assert( sceneShape );
view.beginGL();
M3dView::LightingMode lightingMode;
view.getLightingMode( lightingMode );
LightingState lightingState;
bool restoreLightState = cleanupLights( request, view, &lightingState );
// maya can sometimes leave an error from it's own code,
// and we don't want that to confuse us in our drawing code.
while( glGetError()!=GL_NO_ERROR )
{
}
try
{
// draw the bound if asked
if( request.token()==BoundDrawMode )
{
IECoreGL::BoxPrimitive::renderWireframe( IECore::convert<Imath::Box3f>( sceneShape->boundingBox() ) );
}
// draw the scene if asked
if( request.token()==SceneDrawMode )
{
resetHilites();
IECoreGL::ConstScenePtr scene = sceneShape->glScene();
if( scene )
{
IECoreGL::State *displayState = m_displayStyle.baseState( (M3dView::DisplayStyle)request.displayStyle(), lightingMode );
if ( request.component() != MObject::kNullObj )
{
MDoubleArray col;
s = MGlobal::executeCommand( "colorIndex -q 21", col );
assert( s );
IECoreGL::WireframeColorStateComponentPtr hilite = new IECoreGL::WireframeColorStateComponent( Imath::Color4f( col[0], col[1], col[2], 1.0f ) );
MFnSingleIndexedComponent fnComp( request.component(), &s );
assert( s );
int len = fnComp.elementCount( &s );
assert( s );
std::vector<IECore::InternedString> groupNames;
for ( int j = 0; j < len; j++ )
{
int index = fnComp.element(j);
groupNames.push_back( sceneShape->selectionName( index ) );
}
// Sort by name to make sure we don't unhilite selected items that are further down the hierarchy
std::sort( groupNames.begin(), groupNames.end() );
for ( std::vector<IECore::InternedString>::iterator it = groupNames.begin(); it!= groupNames.end(); ++it)
{
IECoreGL::GroupPtr group = sceneShape->glGroup( *it );
hiliteGroups(
group,
hilite,
const_cast<IECoreGL::WireframeColorStateComponent *>( displayState->get< IECoreGL::WireframeColorStateComponent >() )
);
}
}
scene->render( displayState );
}
}
}
catch( const IECoreGL::Exception &e )
{
// much better to catch and report this than to let the application die
IECore::msg( IECore::Msg::Error, "SceneShapeUI::draw", boost::format( "IECoreGL Exception : %s" ) % e.what() );
}
if( restoreLightState )
{
restoreLights( &lightingState );
}
view.endGL();
}
