Imath::Box3d HoudiniScene::readBound( double time ) const
{
OP_Node *node = retrieveNode( true );
Imath::Box3d bounds;
UT_BoundingBox box;
OP_Context context( time );
/// \todo: this doesn't account for SOPs containing multiple shapes
/// if we fix it, we need to fix the condition below as well
if ( node->getBoundingBox( box, context ) )
{
bounds = IECore::convert<Imath::Box3d>( box );
}
// paths embedded within a sop already have bounds accounted for
if ( m_contentIndex )
{
return bounds;
}
NameList children;
childNames( children );
for ( NameList::iterator it=children.begin(); it != children.end(); ++it )
{
ConstSceneInterfacePtr childScene = child( *it );
Imath::Box3d childBound = childScene->readBound( time );
if ( !childBound.isEmpty() )
{
bounds.extendBy( Imath::transform( childBound, childScene->readTransformAsMatrix( time ) ) );
}
}
return bounds;
}
void SOP_SceneCacheSource::loadObjects( const IECore::SceneInterface *scene, Imath::M44d transform, double time, Space space, const UT_StringMMPattern &shapeFilter, const std::string &attributeFilter, size_t rootSize )
{
if ( scene->hasObject() && UT_String( scene->name() ).multiMatch( shapeFilter ) )
{
ObjectPtr object = scene->readObject( time );
std::string name = relativePath( scene, rootSize );
bool hasAnimatedTopology = scene->hasAttribute( SceneCache::animatedObjectTopologyAttribute );
bool hasAnimatedPrimVars = scene->hasAttribute( SceneCache::animatedObjectPrimVarsAttribute );
std::vector<InternedString> animatedPrimVars;
if ( hasAnimatedPrimVars )
{
const ObjectPtr animatedPrimVarObj = scene->readAttribute( SceneCache::animatedObjectPrimVarsAttribute, 0 );
const InternedStringVectorData *animatedPrimVarData = IECore::runTimeCast<const InternedStringVectorData>( animatedPrimVarObj );
if ( animatedPrimVarData )
{
const std::vector<InternedString> &values = animatedPrimVarData->readable();
animatedPrimVars.resize( values.size() );
std::copy( values.begin(), values.end(), animatedPrimVars.begin() );
}
}
modifyObject( object, name, hasAnimatedTopology, hasAnimatedPrimVars, animatedPrimVars );
Imath::M44d currentTransform;
if ( space == Local )
{
currentTransform = scene->readTransformAsMatrix( time );
}
else if ( space != Object )
{
currentTransform = transform;
}
// transform the object unless its an identity
if ( currentTransform != Imath::M44d() )
{
transformObject( object, currentTransform, hasAnimatedTopology, hasAnimatedPrimVars, animatedPrimVars );
}
// convert the object to Houdini
if ( !convertObject( object, name, attributeFilter, hasAnimatedTopology, hasAnimatedPrimVars, animatedPrimVars ) )
{
addError( SOP_LOAD_UNKNOWN_BINARY_FLAG, ( "Could not convert " + name + " to houdini" ).c_str() );
}
}
SceneInterface::NameList children;
scene->childNames( children );
for ( SceneInterface::NameList::const_iterator it=children.begin(); it != children.end(); ++it )
{
ConstSceneInterfacePtr child = scene->child( *it );
loadObjects( child, child->readTransformAsMatrix( time ) * transform, time, space, shapeFilter, attributeFilter, rootSize );
}
}
Imath::M44d SceneCacheNode<BaseType>::worldTransform( const std::string &fileName, const std::string &path, double time )
{
ConstSceneInterfacePtr scene = this->scene( fileName, SceneInterface::rootName );
SceneInterface::Path p;
SceneInterface::stringToPath( path, p );
Imath::M44d result = scene->readTransformAsMatrix( time );
for ( SceneInterface::Path::const_iterator it = p.begin(); scene && it != p.end(); ++it )
{
scene = scene->child( *it, SceneInterface::NullIfMissing );
if ( !scene )
{
break;
}
result = scene->readTransformAsMatrix( time ) * result;
}
return result;
}
Imath::M44f SceneReader::computeTransform( const ScenePath &path, const Gaffer::Context *context, const ScenePlug *parent ) const
{
ConstSceneInterfacePtr s = scene( path );
if( !s )
{
return M44f();
}
M44d t = s->readTransformAsMatrix( context->getTime() );
return M44f(
t[0][0], t[0][1], t[0][2], t[0][3],
t[1][0], t[1][1], t[1][2], t[1][3],
t[2][0], t[2][1], t[2][2], t[2][3],
t[3][0], t[3][1], t[3][2], t[3][3]
);
}
Imath::M44f SceneReader::computeTransform( const ScenePath &path, const Gaffer::Context *context, const ScenePlug *parent ) const
{
std::string fileName = fileNamePlug()->getValue();
if( !fileName.size() )
{
return M44f();
}
ConstSceneInterfacePtr s = SharedSceneInterfaces::get( fileName );
s = s->scene( path );
M44d t = s->readTransformAsMatrix( context->getFrame() / g_frameRate );
return M44f(
t[0][0], t[0][1], t[0][2], t[0][3],
t[1][0], t[1][1], t[1][2], t[1][3],
t[2][0], t[2][1], t[2][2], t[2][3],
t[3][0], t[3][1], t[3][2], t[3][3]
);
}
void SOP_SceneCacheSource::loadObjects( const IECore::SceneInterface *scene, Imath::M44d transform, double time, Space space, const UT_StringMMPattern &shapeFilter, const std::string &attributeFilter, GeometryType geometryType, size_t rootSize )
{
UT_Interrupt *progress = UTgetInterrupt();
progress->setLongOpText( ( "Loading " + scene->name().string() ).c_str() );
if ( progress->opInterrupt() )
{
return;
}
if ( scene->hasObject() && UT_String( scene->name() ).multiMatch( shapeFilter ) )
{
// \todo See if there are ways to avoid the Object copy below.
ObjectPtr object = scene->readObject( time )->copy();
std::string name = relativePath( scene, rootSize );
bool hasAnimatedTopology = scene->hasAttribute( SceneCache::animatedObjectTopologyAttribute );
bool hasAnimatedPrimVars = scene->hasAttribute( SceneCache::animatedObjectPrimVarsAttribute );
std::vector<InternedString> animatedPrimVars;
if ( hasAnimatedPrimVars )
{
const ConstObjectPtr animatedPrimVarObj = scene->readAttribute( SceneCache::animatedObjectPrimVarsAttribute, 0 );
const InternedStringVectorData *animatedPrimVarData = IECore::runTimeCast<const InternedStringVectorData>( animatedPrimVarObj );
if ( animatedPrimVarData )
{
const std::vector<InternedString> &values = animatedPrimVarData->readable();
animatedPrimVars.resize( values.size() );
std::copy( values.begin(), values.end(), animatedPrimVars.begin() );
}
}
modifyObject( object, name, attributeFilter, hasAnimatedTopology, hasAnimatedPrimVars, animatedPrimVars );
Imath::M44d currentTransform;
if ( space == Local )
{
currentTransform = scene->readTransformAsMatrix( time );
}
else if ( space != Object )
{
currentTransform = transform;
}
// transform the object unless its an identity
if ( currentTransform != Imath::M44d() )
{
transformObject( object, currentTransform, hasAnimatedTopology, hasAnimatedPrimVars, animatedPrimVars );
}
// load the Cortex object directly
if ( geometryType == Cortex )
{
holdObject( object, name, hasAnimatedTopology, hasAnimatedPrimVars, animatedPrimVars );
}
else
{
// convert the object to Houdini
if ( !convertObject( object, name, attributeFilter, geometryType, hasAnimatedTopology, hasAnimatedPrimVars, animatedPrimVars ) )
{
std::string fullName;
SceneInterface::Path path;
scene->path( path );
SceneInterface::pathToString( path, fullName );
addWarning( SOP_MESSAGE, ( "Could not convert " + fullName + " to houdini" ).c_str() );
}
}
}
if ( evalInt( pObjectOnly.getToken(), 0, 0 ) )
{
return;
}
SceneInterface::NameList children;
scene->childNames( children );
for ( SceneInterface::NameList::const_iterator it=children.begin(); it != children.end(); ++it )
{
ConstSceneInterfacePtr child = scene->child( *it );
loadObjects( child, child->readTransformAsMatrix( time ) * transform, time, space, shapeFilter, attributeFilter, geometryType, rootSize );
}
}
void SOP_SceneCacheSource::loadObjects( const IECore::SceneInterface *scene, Imath::M44d transform, double time, Space space, Parameters ¶ms, size_t rootSize )
{
UT_Interrupt *progress = UTgetInterrupt();
progress->setLongOpText( ( "Loading " + scene->name().string() ).c_str() );
if ( progress->opInterrupt() )
{
return;
}
if ( scene->hasObject() && UT_String( scene->name() ).multiMatch( params.shapeFilter ) && tagged( scene, params.tagFilter ) )
{
std::string name = relativePath( scene, rootSize );
Imath::M44d currentTransform;
if ( space == Local )
{
currentTransform = scene->readTransformAsMatrix( time );
}
else if ( space != Object )
{
currentTransform = transform;
}
ConstObjectPtr object = 0;
if ( params.geometryType == BoundingBox )
{
Imath::Box3d bound = scene->readBound( time );
object = MeshPrimitive::createBox( Imath::Box3f( bound.min, bound.max ) );
params.hasAnimatedTopology = false;
params.hasAnimatedPrimVars = true;
params.animatedPrimVars.clear();
params.animatedPrimVars.push_back( "P" );
}
else if ( params.geometryType == PointCloud )
{
std::vector<Imath::V3f> point( 1, scene->readBound( time ).center() );
PointsPrimitivePtr points = new PointsPrimitive( new V3fVectorData( point ) );
std::vector<Imath::V3f> basis1( 1, Imath::V3f( currentTransform[0][0], currentTransform[0][1], currentTransform[0][2] ) );
std::vector<Imath::V3f> basis2( 1, Imath::V3f( currentTransform[1][0], currentTransform[1][1], currentTransform[1][2] ) );
std::vector<Imath::V3f> basis3( 1, Imath::V3f( currentTransform[2][0], currentTransform[2][1], currentTransform[2][2] ) );
points->variables["basis1"] = PrimitiveVariable( PrimitiveVariable::Vertex, new V3fVectorData( basis1 ) );
points->variables["basis2"] = PrimitiveVariable( PrimitiveVariable::Vertex, new V3fVectorData( basis2 ) );
points->variables["basis3"] = PrimitiveVariable( PrimitiveVariable::Vertex, new V3fVectorData( basis3 ) );
params.hasAnimatedTopology = false;
params.hasAnimatedPrimVars = true;
params.animatedPrimVars.clear();
params.animatedPrimVars.push_back( "P" );
params.animatedPrimVars.push_back( "basis1" );
params.animatedPrimVars.push_back( "basis2" );
params.animatedPrimVars.push_back( "basis3" );
object = points;
}
else
{
object = scene->readObject( time );
params.hasAnimatedTopology = scene->hasAttribute( SceneCache::animatedObjectTopologyAttribute );
params.hasAnimatedPrimVars = scene->hasAttribute( SceneCache::animatedObjectPrimVarsAttribute );
if ( params.hasAnimatedPrimVars )
{
const ConstObjectPtr animatedPrimVarObj = scene->readAttribute( SceneCache::animatedObjectPrimVarsAttribute, 0 );
const InternedStringVectorData *animatedPrimVarData = IECore::runTimeCast<const InternedStringVectorData>( animatedPrimVarObj.get() );
if ( animatedPrimVarData )
{
const std::vector<InternedString> &values = animatedPrimVarData->readable();
params.animatedPrimVars.clear();
params.animatedPrimVars.resize( values.size() );
std::copy( values.begin(), values.end(), params.animatedPrimVars.begin() );
}
}
}
// modify the object if necessary
object = modifyObject( object.get(), params );
// transform the object unless its an identity
if ( currentTransform != Imath::M44d() )
{
object = transformObject( object.get(), currentTransform, params );
}
// convert the object to Houdini
if ( !convertObject( object.get(), name, scene, params ) )
{
std::string fullName;
SceneInterface::Path path;
scene->path( path );
SceneInterface::pathToString( path, fullName );
addWarning( SOP_MESSAGE, ( "Could not convert " + fullName + " to Houdini" ).c_str() );
}
}
if ( evalInt( pObjectOnly.getToken(), 0, 0 ) )
{
return;
}
SceneInterface::NameList children;
scene->childNames( children );
std::sort( children.begin(), children.end(), InternedStringSort() );
for ( SceneInterface::NameList::const_iterator it=children.begin(); it != children.end(); ++it )
{
ConstSceneInterfacePtr child = scene->child( *it );
if ( tagged( child.get(), params.tagFilter ) )
{
loadObjects( child.get(), child->readTransformAsMatrix( time ) * transform, time, space, params, rootSize );
}
}
}
bool OBJ_SceneCacheNode<BaseType>::getParmTransform( OP_Context &context, UT_DMatrix4 &xform )
{
std::string file = this->getFile();
std::string path = this->getPath();
OBJ_SceneCacheNode<OP_Node>::Space space = (OBJ_SceneCacheNode<OP_Node>::Space)this->getSpace();
MurmurHash hash;
hash.append( file );
hash.append( path );
hash.append( space );
// make sure the state is valid
if ( boost::indeterminate( this->m_static ) )
{
updateState();
}
// only update time dependency if Houdini thinks its static
if ( !BaseType::flags().getTimeDep() && !BaseType::getParmList()->getCookTimeDependent() )
{
BaseType::flags().setTimeDep( bool( !this->m_static ) );
BaseType::getParmList()->setCookTimeDependent( bool( !this->m_static ) );
}
if ( this->m_static == true && this->m_loaded && this->m_hash == hash )
{
xform = m_xform;
return true;
}
if ( !SceneCacheNode<BaseType>::ensureFile( file ) )
{
SceneCacheNode<BaseType>::addError( OBJ_ERR_CANT_FIND_OBJ, ( file + " is not a valid .scc" ).c_str() );
//BaseType::addError( OBJ_ERR_CANT_FIND_OBJ, ( file + " is not a valid .scc" ).c_str() );
//this->addError( OBJ_ERR_CANT_FIND_OBJ, ( file + " is not a valid .scc" ).c_str() );
return false;
}
ConstSceneInterfacePtr scene = this->scene( file, path );
if ( !scene )
{
SceneCacheNode<BaseType>::addError( OBJ_ERR_CANT_FIND_OBJ, ( path + " is not a valid location in " + file ).c_str() );
//this->addError( OBJ_ERR_CANT_FIND_OBJ, ( path + " is not a valid location in " + file ).c_str() );
return false;
}
Imath::M44d transform;
if ( space == SceneCacheNode<OP_Node>::World )
{
transform = SceneCacheNode<BaseType>::worldTransform( file, path, this->time( context ) );
}
else if ( space == SceneCacheNode<OP_Node>::Local )
{
transform = scene->readTransformAsMatrix( this->time( context ) );
}
xform = IECore::convert<UT_Matrix4D>( transform );
m_xform = xform;
this->m_hash = hash;
this->m_loaded = true;
return true;
}
