ObjectPtr FromHoudiniGroupConverter::doDetailConversion( const GU_Detail *geo, const CompoundObject *operands ) const
{
GU_DetailHandle handle;
handle.allocateAndSet( (GU_Detail*)geo, false );
FromHoudiniGeometryConverterPtr converter = FromHoudiniGeometryConverter::create( handle );
if ( !converter || converter->isInstanceOf( FromHoudiniGroupConverter::staticTypeId() ) )
{
/// \todo: if we're in PrimitiveGroup mode, but names exist, we return 0 when we should be returning a Group
return 0;
}
// transfer the common parameter values
CompoundParameter *parameters = converter->parameters();
const CompoundParameter::ParameterMap ¶meterMap = parameters->parameters();
const CompoundObject::ObjectMap &values = operands->members();
for ( CompoundObject::ObjectMap::const_iterator it = values.begin(); it != values.end(); ++it )
{
CompoundParameter::ParameterMap::const_iterator pIt = parameterMap.find( it->first );
if ( pIt != parameterMap.end() && pIt->second->defaultValue()->typeId() == it->second->typeId() )
{
parameters->setParameterValue( it->first, it->second );
}
}
return converter->convert();
}
static boost::python::list compoundParameterItems( const CompoundParameter &o )
{
boost::python::list result;
CompoundParameter::ParameterVector::const_iterator it;
for( it = o.orderedParameters().begin(); it!=o.orderedParameters().end(); it++ )
{
result.append( boost::python::make_tuple( (*it)->name(), *it ) );
}
return result;
}
static boost::python::list compoundParameterValues( const CompoundParameter &o )
{
boost::python::list result;
CompoundParameter::ParameterVector::const_iterator it;
for( it = o.orderedParameters().begin(); it!=o.orderedParameters().end(); it++ )
{
result.append( *it );
}
return result;
}
void ParameterisedHolderModificationCmd::restoreClassParameterStates( const IECore::CompoundData *classes, IECore::Parameter *parameter, const std::string &parentParameterPath )
{
std::string parameterPath = parentParameterPath;
if( parentParameterPath.size() )
{
parameterPath += ".";
}
parameterPath += parameter->name();
if( parameter->isInstanceOf( "ClassParameter" ) )
{
const CompoundData *c = classes->member<const CompoundData>( parameterPath );
if( c )
{
ClassParameterHandler::setClass(
parameter,
c->member<const IECore::StringData>( "className" )->readable().c_str(),
c->member<const IECore::IntData>( "classVersion" )->readable(),
c->member<const IECore::StringData>( "searchPathEnvVar" )->readable().c_str()
);
}
}
else if( parameter->isInstanceOf( "ClassVectorParameter" ) )
{
const CompoundData *c = classes->member<const CompoundData>( parameterPath );
if( c )
{
IECore::ConstStringVectorDataPtr parameterNames = c->member<const IECore::StringVectorData>( "parameterNames" );
IECore::ConstStringVectorDataPtr classNames = c->member<const IECore::StringVectorData>( "classNames" );
IECore::ConstIntVectorDataPtr classVersions = c->member<const IECore::IntVectorData>( "classVersions" );
MStringArray mParameterNames;
MStringArray mClassNames;
MIntArray mClassVersions;
int numClasses = parameterNames->readable().size();
for( int i=0; i<numClasses; i++ )
{
mParameterNames.append( parameterNames->readable()[i].c_str() );
mClassNames.append( classNames->readable()[i].c_str() );
mClassVersions.append( classVersions->readable()[i] );
}
ClassVectorParameterHandler::setClasses( parameter, mParameterNames, mClassNames, mClassVersions );
}
}
if( parameter->isInstanceOf( IECore::CompoundParameter::staticTypeId() ) )
{
CompoundParameter *compoundParameter = static_cast<CompoundParameter *>( parameter );
const CompoundParameter::ParameterVector &childParameters = compoundParameter->orderedParameters();
for( CompoundParameter::ParameterVector::const_iterator it = childParameters.begin(); it!=childParameters.end(); it++ )
{
restoreClassParameterStates( classes, it->get(), parameterPath );
}
}
}
void CompoundParameterHandler::setParameterValue( IECore::Parameter *parameter, ValueSource valueSource )
{
CompoundParameter *compoundParameter = static_cast<CompoundParameter *>( parameter );
const CompoundParameter::ParameterVector &childParameters = compoundParameter->orderedParameters();
for( CompoundParameter::ParameterVector::const_iterator cIt=childParameters.begin(); cIt!=childParameters.end(); cIt++ )
{
ParameterHandlerPtr h = handler( cIt->get(), false );
if( h )
{
h->setParameterValue( cIt->get(), valueSource );
}
}
}
void ParameterisedHolderModificationCmd::setNodeValue( IECore::Parameter *parameter ) const
{
m_parameterisedHolder->setNodeValue( parameter );
if( parameter->isInstanceOf( CompoundParameter::staticTypeId() ) )
{
// recurse to the children - this is the only reason this function
// is necessary as ParameterisedHolder::setNodeValue() doesn't recurse.
CompoundParameter *compoundParameter = static_cast<CompoundParameter *>( parameter );
const CompoundParameter::ParameterVector &childParameters = compoundParameter->orderedParameters();
for( CompoundParameter::ParameterVector::const_iterator it = childParameters.begin(); it!=childParameters.end(); it++ )
{
setNodeValue( it->get() );
}
}
}
static ParameterPtr compoundParameterGetItem( CompoundParameter &o, const char *n )
{
const CompoundParameter::ParameterMap &p = o.parameters();
CompoundParameter::ParameterMap::const_iterator it = p.find( n );
if( it!=p.end() )
{
return it->second;
}
throw Exception( std::string("Bad index: ") + n );
}
static boost::python::list parameterPath( CompoundParameter &o, ConstParameterPtr child )
{
std::vector<std::string> p;
o.parameterPath( child.get(), p );
boost::python::list result;
for( std::vector<std::string>::const_iterator it=p.begin(); it!=p.end(); it++ )
{
result.append( *it );
}
return result;
}
static void compoundParameterAddParameters( CompoundParameter &o, const boost::python::list &p )
{
int listLen = boost::python::len(p);
for( int i=0; i<listLen; i++ )
{
object m = p[i];
Parameter &p = extract<Parameter &>( m );
o.addParameter( &p );
}
}
static bool compoundParameterContains( const CompoundParameter &o, const std::string &n )
{
const CompoundParameter::ParameterMap &map = o.parameters();
return map.find( n ) != map.end();
}
static unsigned int compoundParameterLen( const CompoundParameter &o )
{
return o.parameters().size();
}
