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; }