void SceneWriter::writeLocation( const GafferScene::ScenePlug *scene, const ScenePlug::ScenePath &scenePath, Context *context, IECore::SceneInterface *output, double time ) const
{
context->set( ScenePlug::scenePathContextName, scenePath );
ConstCompoundObjectPtr attributes = scene->attributesPlug()->getValue();
for( CompoundObject::ObjectMap::const_iterator it = attributes->members().begin(), eIt = attributes->members().end(); it != eIt; it++ )
{
output->writeAttribute( it->first, it->second.get(), time );
}
if( scenePath.empty() )
{
ConstCompoundObjectPtr globals = scene->globalsPlug()->getValue();
output->writeAttribute( "gaffer:globals", globals.get(), time );
}
ConstObjectPtr object = scene->objectPlug()->getValue();
if( object->typeId() != IECore::NullObjectTypeId && scenePath.size() > 0 )
{
output->writeObject( object.get(), time );
}
Imath::Box3f b = scene->boundPlug()->getValue();
output->writeBound( Imath::Box3d( Imath::V3f( b.min ), Imath::V3f( b.max ) ), time );
if( scenePath.size() )
{
Imath::M44f t = scene->transformPlug()->getValue();
Imath::M44d transform(
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]
);
output->writeTransform( new IECore::M44dData( transform ), time );
}
ConstInternedStringVectorDataPtr childNames = scene->childNamesPlug()->getValue();
ScenePlug::ScenePath childScenePath = scenePath;
childScenePath.push_back( InternedString() );
for( vector<InternedString>::const_iterator it=childNames->readable().begin(); it!=childNames->readable().end(); it++ )
{
childScenePath[scenePath.size()] = *it;
SceneInterfacePtr outputChild = output->child( *it, SceneInterface::CreateIfMissing );
writeLocation( scene, childScenePath, context, outputChild.get(), time );
}
}
void SceneWriter::executeSequence( const std::vector<float> &frames ) const
{
const ScenePlug *scene = inPlug()->getInput<ScenePlug>();
if( !scene )
{
throw IECore::Exception( "No input scene" );
}
ContextPtr context = new Context( *Context::current(), Context::Borrowed );
Context::Scope scopedContext( context.get() );
std::string fileName = context->substitute( fileNamePlug()->getValue() );
createDirectories( fileName );
SceneInterfacePtr output = SceneInterface::create( fileName, IndexedIO::Write );
for ( std::vector<float>::const_iterator it = frames.begin(); it != frames.end(); ++it )
{
context->setFrame( *it );
double time = *it / g_frameRate;
writeLocation( scene, ScenePlug::ScenePath(), context.get(), output.get(), time );
}
}
SceneInterfacePtr LiveScene::retrieveScene( const Path &path, MissingBehaviour missingBehaviour ) const
{
Path rootPath, emptyPath;
rootPath.resize( m_rootIndex );
std::copy( m_path.begin(), m_path.begin() + m_rootIndex, rootPath.begin() );
LiveScenePtr rootScene = new LiveScene();
rootScene->setDefaultTime( m_defaultTime );
for ( Path::const_iterator it = rootPath.begin(); it != rootPath.end(); ++it )
{
rootScene = IECore::runTimeCast<LiveScene>( rootScene->child( *it ) );
if ( !rootScene )
{
return 0;
}
}
UT_String rootNodePath;
OP_Node *node = rootScene->retrieveNode();
if ( !node )
{
return 0;
}
node->getFullPath( rootNodePath );
/// \todo: is this really what we want? can we just pass rootIndex and contentIndex instead?
SceneInterfacePtr scene = new LiveScene( rootNodePath, emptyPath, rootPath, m_defaultTime, m_splitter.get() );
for ( Path::const_iterator it = path.begin(); it != path.end(); ++it )
{
scene = scene->child( *it, missingBehaviour );
if ( !scene )
{
return 0;
}
}
return scene;
}
void Scene::draw(SceneInterfacePtr pScene, double dt) {
m_modelController.callCommandsCallback();
SIAAssert(pScene.get() == this);
SIAAssert(m_pGameLayer);
m_viewMath.setWindowSize(m_pGameLayer->getContentSize());
m_pGameLayer->draw(m_viewMath);
for (ObjectPtr pObject : m_pObjects) {
SIAAssert(pObject.get());
pObject->draw(pScene);
}
}
SceneInterfacePtr LinkedScene::child( const Name &name, MissingBehaviour missingBehaviour )
{
if ( missingBehaviour == SceneInterface::CreateIfMissing )
{
if ( m_readOnly )
{
throw Exception( "No write access to scene file!" );
}
if ( m_atLink )
{
throw Exception( "Locations with links to external scene cannot have child locations themselves!" );
}
}
if ( m_linkedScene )
{
ConstSceneInterfacePtr c = m_linkedScene->child( name, missingBehaviour );
if ( !c )
{
return 0;
}
return new LinkedScene( m_mainScene, c, m_rootLinkDepth, m_readOnly, false, m_timeRemapped );
}
else
{
SceneInterfacePtr c = m_mainScene->child( name, missingBehaviour );
if ( !c )
{
return 0;
}
if ( m_readOnly )
{
if( c->hasAttribute( fileNameLinkAttribute ) && c->hasAttribute( rootLinkAttribute ) )
{
ConstStringDataPtr fileName = runTimeCast< const StringData >( c->readAttribute( fileNameLinkAttribute, 0 ) );
ConstInternedStringVectorDataPtr root = runTimeCast< const InternedStringVectorData >( c->readAttribute( rootLinkAttribute, 0 ) );
/// we found the link attribute...
int linkDepth;
bool timeRemapped = c->hasAttribute( timeLinkAttribute );
ConstSceneInterfacePtr l = expandLink( fileName, root, linkDepth );
if ( l )
{
return new LinkedScene( c, l, linkDepth, m_readOnly, true, timeRemapped );
}
}
else if( c->hasAttribute( linkAttribute ) )
{
// read from old school link attribute.
// \todo: remove this when it doesn't break everyone's stuff!
ConstCompoundDataPtr d = runTimeCast< const CompoundData >( c->readAttribute( linkAttribute, 0 ) );
/// we found the link attribute...
int linkDepth;
bool timeRemapped = false;
ConstSceneInterfacePtr l = expandLink( d->member< const StringData >( g_fileName ), d->member< const InternedStringVectorData >( g_root ), linkDepth );
if ( l )
{
return new LinkedScene( c, l, linkDepth, m_readOnly, true, timeRemapped );
}
}
}
return new LinkedScene( c, 0, 0, m_readOnly, false, false );
}
}
SceneInterfacePtr LinkedScene::scene( const Path &path, MissingBehaviour missingBehaviour )
{
if ( missingBehaviour == SceneInterface::CreateIfMissing )
{
throw Exception( "createIfMissing is not supported!" );
}
SceneInterfacePtr s = m_mainScene->scene( SceneInterface::rootPath );
Path::const_iterator pIt;
/// first try to get as close as possible using the m_mainScene...
for ( pIt = path.begin(); pIt != path.end(); pIt++ )
{
SceneInterfacePtr n = s->child( *pIt, SceneInterface::NullIfMissing );
if ( !n )
{
break;
}
s = n;
}
ConstSceneInterfacePtr l = 0;
int linkDepth = 0;
bool atLink = false;
bool timeRemapped = false;
if ( s->hasAttribute( fileNameLinkAttribute ) && s->hasAttribute( rootLinkAttribute ) )
{
atLink = true;
timeRemapped = s->hasAttribute( timeLinkAttribute );
ConstStringDataPtr fileName = runTimeCast< const StringData >( s->readAttribute( fileNameLinkAttribute, 0 ) );
ConstInternedStringVectorDataPtr root = runTimeCast< const InternedStringVectorData >( s->readAttribute( rootLinkAttribute, 0 ) );
l = expandLink( fileName.get(), root.get(), linkDepth );
if (!l)
{
atLink = false;
timeRemapped = false;
}
}
else if( s->hasAttribute( linkAttribute ) )
{
atLink = true;
ConstCompoundDataPtr d = runTimeCast< const CompoundData >( s->readAttribute( linkAttribute, 0 ) );
l = expandLink( d->member< const StringData >( g_fileName ), d->member< const InternedStringVectorData >( g_root ), linkDepth );
if ( !l )
{
atLink = false;
}
}
if ( pIt != path.end() )
{
if ( !atLink )
{
if ( missingBehaviour == SceneInterface::NullIfMissing )
{
return 0;
}
throw Exception( "Could not find child '" + pIt->value() + "'" );
}
for ( ; pIt != path.end(); pIt++ )
{
l = l->child( *pIt, missingBehaviour );
if ( !l )
{
return 0;
}
}
atLink = false;
}
return new LinkedScene( s, l, linkDepth, m_readOnly, atLink, timeRemapped );
}
