void LiveScene::attributeNames( NameList &attrs ) const
{
if( !m_isRoot && m_dagPath.length() == 0 )
{
throw Exception( "IECoreMaya::LiveScene::attributeNames: Dag path no longer exists!" );
}
tbb::mutex::scoped_lock l( s_mutex );
attrs.clear();
attrs.push_back( SceneInterface::visibilityName );
// translate attributes with names starting with "ieAttr_":
MFnDependencyNode fnNode( m_dagPath.node() );
unsigned int n = fnNode.attributeCount();
for( unsigned int i=0; i<n; i++ )
{
MObject attr = fnNode.attribute( i );
MFnAttribute fnAttr( attr );
MString attrName = fnAttr.name();
if( attrName.length() > 7 && ( strstr( attrName.asChar(),"ieAttr_" ) == attrName.asChar() ) )
{
attrs.push_back( ( "user:" + attrName.substring( 7, attrName.length()-1 ) ).asChar() );
}
}
// add attributes from custom readers:
for ( std::vector< CustomAttributeReader >::const_iterator it = customAttributeReaders().begin(); it != customAttributeReaders().end(); it++ )
{
it->m_names( m_dagPath, attrs );
}
// remove duplicates:
std::sort( attrs.begin(), attrs.end() );
attrs.erase( std::unique( attrs.begin(), attrs.end() ), attrs.end() );
}
void MayaScene::readTags( NameList &tags, int filter ) const
{
tags.clear();
if ( m_isRoot )
{
return;
}
if( m_dagPath.length() == 0 )
{
throw Exception( "MayaScene::attributeNames: Dag path no longer exists!" );
}
std::set<Name> uniqueTags;
std::vector<CustomTagReader> &tagReaders = customTagReaders();
for ( std::vector<CustomTagReader>::const_iterator it = tagReaders.begin(); it != tagReaders.end(); ++it )
{
NameList values;
it->m_read( m_dagPath, values, filter );
uniqueTags.insert( values.begin(), values.end() );
}
tags.insert( tags.end(), uniqueTags.begin(), uniqueTags.end() );
}
void HoudiniScene::attributeNames( NameList &attrs ) const
{
attrs.clear();
for ( std::map<Name, CustomReader>::const_iterator it = customAttributeReaders().begin(); it != customAttributeReaders().end(); ++it )
{
if ( it->second.m_has( retrieveNode() ) )
{
attrs.push_back( it->first );
}
}
}
void MayaScene::attributeNames( NameList &attrs ) const
{
if( !m_isRoot && m_dagPath.length() == 0 )
{
throw Exception( "MayaScene::attributeNames: Dag path no longer exists!" );
}
tbb::mutex::scoped_lock l( s_mutex );
attrs.clear();
attrs.push_back( SceneInterface::visibilityName );
for ( std::vector< CustomAttributeReader >::const_iterator it = customAttributeReaders().begin(); it != customAttributeReaders().end(); it++ )
{
it->m_names( m_dagPath, attrs );
}
}
void LiveScene::readTags( NameList &tags, int filter ) const
{
tags.clear();
if ( m_isRoot )
{
return;
}
if( m_dagPath.length() == 0 )
{
throw Exception( "IECoreMaya::LiveScene::attributeNames: Dag path no longer exists!" );
}
std::set<Name> uniqueTags;
// read tags from ieTags attribute:
MStatus st;
MFnDependencyNode fnNode( m_dagPath.node() );
MPlug tagsPlug = fnNode.findPlug( "ieTags", false, &st );
if( st )
{
std::string tagsStr( tagsPlug.asString().asChar() );
boost::tokenizer<boost::char_separator<char> > t( tagsStr, boost::char_separator<char>( " " ) );
for (
boost::tokenizer<boost::char_separator<char> >::iterator it = t.begin();
it != t.end();
++it
)
{
uniqueTags.insert( Name( *it ) );
}
}
// read tags from custom readers:
std::vector<CustomTagReader> &tagReaders = customTagReaders();
for ( std::vector<CustomTagReader>::const_iterator it = tagReaders.begin(); it != tagReaders.end(); ++it )
{
NameList values;
it->m_read( m_dagPath, values, filter );
uniqueTags.insert( values.begin(), values.end() );
}
tags.insert( tags.end(), uniqueTags.begin(), uniqueTags.end() );
}
void MayaScene::attributeNames( NameList &attrs ) const
{
if ( m_isRoot )
{
return;
}
if( m_dagPath.length() == 0 )
{
throw Exception( "MayaScene::attributeNames: Dag path no longer exists!" );
}
attrs.clear();
for ( std::vector< CustomAttributeReader >::const_iterator it = customAttributeReaders().begin(); it != customAttributeReaders().end(); it++ )
{
it->m_names( m_dagPath, attrs );
}
}
void LiveScene::attributeNames( NameList &attrs ) const
{
attrs.clear();
OP_Node *node = retrieveNode();
const std::vector<CustomAttributeReader> &attributeReaders = customAttributeReaders();
for ( std::vector<CustomAttributeReader>::const_iterator it = attributeReaders.begin(); it != attributeReaders.end(); ++it )
{
NameList names;
it->m_names( node, names );
/// \todo: investigate using a set here if performance becomes an issue
for ( NameList::const_iterator nIt = names.begin(); nIt != names.end(); ++nIt )
{
if ( std::find( attrs.begin(), attrs.end(), *nIt ) == attrs.end() )
{
attrs.push_back( *nIt );
}
}
}
}
void HoudiniScene::readTags( NameList &tags, bool includeChildren ) const
{
tags.clear();
const OP_Node *node = retrieveNode();
if ( !node )
{
return;
}
// add user supplied tags if we're not inside a SOP
if ( !m_contentIndex && node->hasParm( pTags.getToken() ) )
{
UT_String parmTagStr;
node->evalString( parmTagStr, pTags.getToken(), 0, 0 );
if ( !parmTagStr.equal( UT_String::getEmptyString() ) )
{
UT_WorkArgs tokens;
parmTagStr.tokenize( tokens, " " );
for ( int i = 0; i < tokens.getArgc(); ++i )
{
tags.push_back( tokens[i] );
}
}
}
// add tags from the registered tag readers
std::vector<CustomTagReader> &tagReaders = customTagReaders();
for ( std::vector<CustomTagReader>::const_iterator it = tagReaders.begin(); it != tagReaders.end(); ++it )
{
NameList values;
it->m_read( node, values, includeChildren );
tags.insert( tags.end(), values.begin(), values.end() );
}
// add tags based on primitive groups
OBJ_Node *contentNode = retrieveNode( true )->castToOBJNode();
if ( contentNode && contentNode->getObjectType() == OBJ_GEOMETRY && m_splitter )
{
GU_DetailHandle newHandle = m_splitter->split( contentPathValue() );
if ( !newHandle.isNull() )
{
GU_DetailHandleAutoReadLock readHandle( newHandle );
if ( const GU_Detail *geo = readHandle.getGdp() )
{
GA_Range prims = geo->getPrimitiveRange();
for ( GA_GroupTable::iterator<GA_ElementGroup> it=geo->primitiveGroups().beginTraverse(); !it.atEnd(); ++it )
{
GA_PrimitiveGroup *group = static_cast<GA_PrimitiveGroup*>( it.group() );
if ( group->getInternal() || group->isEmpty() )
{
continue;
}
const UT_String &groupName = group->getName();
if ( groupName.startsWith( tagGroupPrefix ) && group->containsAny( prims ) )
{
UT_String tag;
groupName.substr( tag, tagGroupPrefix.length() );
tag.substitute( "_", ":" );
tags.push_back( tag.buffer() );
}
}
}
}
}
}
void LinkedScene::writeAttribute( const Name &name, const Object *attribute, double time )
{
if ( m_readOnly )
{
throw Exception( "No write access to scene file!" );
}
if ( name == linkAttribute )
{
bool firstTime = !m_mainScene->hasAttribute( fileNameLinkAttribute );
if ( firstTime )
{
// if it's the first time, we better check if this level already has objects, tags or children
// and raise exceptions to prevent weird configurations...
if ( m_mainScene->hasObject() )
{
throw Exception( "Links to external scenes cannot be created on locations where there's already an object saved!" );
}
NameList names;
m_mainScene->childNames( names );
if ( names.size() )
{
throw Exception( "Links to external scenes cannot be created on locations where there are already child locations!" );
}
}
// we are creating a link!
const CompoundData *d = runTimeCast< const CompoundData >(attribute);
if ( !d )
{
throw Exception( "SceneInterface:link attribute must be of type CompoundData!" );
}
// open the linked scene
int linkDepth;
ConstDoubleDataPtr timeData = d->member< const DoubleData >( g_time );
const StringData *fileName = d->member< const StringData >( g_fileName );
const InternedStringVectorData *sceneRoot = d->member< const InternedStringVectorData >( g_root );
ConstSceneInterfacePtr linkedScene = expandLink( fileName, sceneRoot, linkDepth );
if ( !linkedScene )
{
throw Exception( "Trying to store a broken link!" );
}
// get the bounds of the linked scene
const SampledSceneInterface *sampledScene = runTimeCast< const SampledSceneInterface >(linkedScene.get());
if ( sampledScene && !timeData )
{
// When there's no time remapping we get all the bounding box samples from the linked scene, using the same time.
if ( firstTime )
{
size_t bounds = sampledScene->numBoundSamples();
for ( size_t b = 0; b < bounds; b++ )
{
m_mainScene->writeBound( sampledScene->readBoundAtSample(b), sampledScene->boundSampleTime(b) );
}
}
}
else
{
/// we store just the current bounding box
if ( timeData )
{
m_mainScene->writeBound( linkedScene->readBound(timeData->readable()), time );
}
else
{
m_mainScene->writeBound( linkedScene->readBound(time), time );
}
}
if ( firstTime )
{
// save the tags from the linked file to the current location so it gets propagated to the root.
NameList tags;
// Check if the position of the file we are trying to link to, has ancestor tags.
// This situation is undesirable, as it will make LinkedScene return inconsistent ancestor tags before and after the link location.
linkedScene->readTags(tags, SceneInterface::AncestorTag );
if ( tags.size() )
{
std::string pathStr;
SceneInterface::pathToString( sceneRoot->readable(), pathStr );
msg( Msg::Warning, "LinkedScene::writeAttribute", ( boost::format( "Detected ancestor tags while creating link to file %s at location %s." ) % fileName->readable() % pathStr ).str() );
}
tags.clear();
/// copy all descendent and local tags as descendent tags (so we can distinguish from tags added in the LinkedScene)
linkedScene->readTags(tags, SceneInterface::LocalTag|SceneInterface::DescendantTag );
static_cast< SceneCache *>(m_mainScene.get())->writeTags(tags, true);
m_mainScene->writeAttribute( fileNameLinkAttribute, d->member< const StringData >( g_fileName ), time );
m_mainScene->writeAttribute( rootLinkAttribute, d->member< const InternedStringVectorData >( g_root ), time );
}
/// we keep the information this level has a link, so we can prevent attempts to
/// create children or save objects at this level.
m_atLink = true;
if( timeData )
{
m_mainScene->writeAttribute( timeLinkAttribute, timeData, time );
}
return;
}
m_mainScene->writeAttribute(name,attribute,time);
}