void SceneView::contextChanged( const IECore::InternedString &name )
{
if( name.value() == "ui:scene:selectedPaths" )
{
// if only the selection has changed then we can just update the selection
// on our existing scene representation.
const StringVectorData *sc = getContext()->get<StringVectorData>( "ui:scene:selectedPaths" );
RenderableGadget::Selection sr;
sr.insert( sc->readable().begin(), sc->readable().end() );
BlockedConnection blockedConnection( m_selectionChangedConnection );
m_renderableGadget->setSelection( sr );
return;
}
if(
name.value().compare( 0, 3, "ui:" ) == 0 &&
name.value() != "ui:scene:expandedPaths"
)
{
// if it's just a ui context entry that has changed, and it doesn't
// affect our expansion, then early out.
return;
}
// the context change might affect the scene itself, so we must
// schedule an update.
updateRequestSignal()( this );
}
void SceneView::contextChanged( const IECore::InternedString &name )
{
if( name.value() == "ui:scene:selectedPaths" )
{
// If only the selection has changed then we can just update the selection
// on our existing scene representation.
const StringVectorData *sc = getContext()->get<StringVectorData>( "ui:scene:selectedPaths" );
/// \todo Store selection as PathMatcherData within the context, so we don't need
/// this conversion.
GafferScene::PathMatcherDataPtr sg = new GafferScene::PathMatcherData;
sg->writable().init( sc->readable().begin(), sc->readable().end() );
m_sceneGadget->setSelection( sg );
return;
}
else if( name.value() == "ui:scene:expandedPaths" )
{
const GafferScene::PathMatcherData *expandedPaths = getContext()->get<GafferScene::PathMatcherData>( "ui:scene:expandedPaths" );
m_sceneGadget->setExpandedPaths( expandedPaths );
return;
}
else if( boost::starts_with( name.value(), "ui:" ) )
{
// ui context entries shouldn't affect computation.
return;
}
}
void Shader::NetworkBuilder::parameterValueWalk( const Shader *shaderNode, const Gaffer::Plug *parameterPlug, const IECore::InternedString ¶meterName, IECore::CompoundDataMap &values )
{
for( InputPlugIterator it( parameterPlug ); it != it.end(); ++it )
{
IECore::InternedString childParameterName;
if( parameterName.string().size() )
{
childParameterName = parameterName.string() + "." + (*it)->getName().string();
}
else
{
childParameterName = (*it)->getName();
}
if( (*it)->typeId() == CompoundPlug::staticTypeId() )
{
parameterValueWalk( shaderNode, it->get(), childParameterName, values );
}
else
{
if( IECore::DataPtr value = shaderNode->parameterValue( it->get(), *this ) )
{
values[childParameterName] = value;
}
}
}
}
void addParameterWalk( const Gaffer::Plug *parameter, const IECore::InternedString ¶meterName, IECoreScene::Shader *shader, vector<IECoreScene::ShaderNetwork::Connection> &connections )
{
if( !isLeafParameter( parameter ) || parameter->parent<Node>() )
{
// Compound parameter - recurse
for( InputPlugIterator it( parameter ); !it.done(); ++it )
{
IECore::InternedString childParameterName;
if( parameterName.string().size() )
{
childParameterName = parameterName.string() + "." + (*it)->getName().string();
}
else
{
childParameterName = (*it)->getName();
}
addParameterWalk( it->get(), childParameterName, shader, connections );
}
}
else if( const Gaffer::ArrayPlug *array = IECore::runTimeCast<const Gaffer::ArrayPlug>( parameter ) )
{
int i = 0;
for( InputPlugIterator it( array ); !it.done(); ++it, ++i )
{
IECore::InternedString childParameterName = parameterName.string() + "[" + std::to_string( i ) + "]";
addParameter( it->get(), childParameterName, shader, connections );
}
}
else
{
addParameter( parameter, parameterName, shader, connections );
}
}
IECore::ConstInternedStringVectorDataPtr ObjectSource::computeSetNames( const Gaffer::Context *context, const ScenePlug *parent ) const
{
IECore::InternedStringVectorDataPtr result = new IECore::InternedStringVectorData;
Gaffer::tokenize( setsPlug()->getValue(), ' ', result->writable() );
IECore::InternedString n = standardSetName();
if( n.string().size() )
{
result->writable().push_back( n );
}
return result;
}
void Path::checkName( const IECore::InternedString &name ) const
{
if( name.string().find( '/' ) != string::npos )
{
throw IECore::Exception( "Path name contains '/'." );
}
if( name.string().empty() )
{
throw IECore::Exception( "Path name is empty." );
}
}
void ScenePath::contextChanged( const IECore::InternedString &key )
{
if( !boost::starts_with( key.c_str(), "ui:" ) )
{
emitPathChanged();
}
}
void NoduleLayout::nodeMetadataChanged( IECore::TypeId nodeTypeId, IECore::InternedString key, const Gaffer::Node *node )
{
const Node *typedParent = runTimeCast<const Node>( m_parent.get() );
if( !typedParent || !affectedByChange( typedParent, nodeTypeId, node ) )
{
return;
}
if( affectsSpacing( key, m_section ) )
{
updateSpacing();
}
if( affectsDirection( key, m_section ) )
{
updateDirection();
}
if( affectsOrientation( key, m_section ) )
{
updateOrientation();
}
if( boost::starts_with( key.string(), "noduleLayout:customGadget" ) )
{
updateLayout();
}
}
void addParameterComponentConnections( const Gaffer::Plug *parameter, const IECore::InternedString ¶meterName, vector<IECoreScene::ShaderNetwork::Connection> &connections )
{
if( !isCompoundNumericPlug( parameter ) )
{
return;
}
for( InputPlugIterator it( parameter ); !it.done(); ++it )
{
const Gaffer::Plug *effectiveParameter = this->effectiveParameter( it->get() );
if( effectiveParameter && isOutputParameter( effectiveParameter ) )
{
const Shader *effectiveShader = static_cast<const Shader *>( effectiveParameter->node() );
IECore::InternedString outputName;
if( effectiveShader->outPlug()->isAncestorOf( effectiveParameter ) )
{
outputName = effectiveParameter->relativeName( effectiveShader->outPlug() );
}
IECore::InternedString inputName = parameterName.string() + "." + (*it)->getName().string();
connections.push_back( {
{ this->handle( effectiveShader ), outputName },
{ IECore::InternedString(), inputName }
} );
}
}
}
void contextChanged( const IECore::InternedString &name )
{
if( !boost::starts_with( name.value(), "ui:" ) )
{
m_lookThroughCameraDirty = m_viewportCameraDirty = true;
}
}
void CameraTool::contextChanged( const IECore::InternedString &name )
{
if( !boost::starts_with( name.string(), "ui:" ) )
{
m_cameraSelectionDirty = true;
view()->viewportGadget()->renderRequestSignal()( view()->viewportGadget() );
}
}
void ImageGadget::contextChanged( const IECore::InternedString &name )
{
if( !boost::starts_with( name.string(), "ui:" ) )
{
m_dirtyFlags = AllDirty;
requestRender();
}
}
boost::signals::detail::unusable operator()( boost::python::object slot, ConstContextPtr context, const IECore::InternedString &name )
{
try
{
slot( IECore::constPointerCast<Context>( context ), name.value() );
}
catch( const error_already_set &e )
{
PyErr_PrintEx( 0 ); // clears the error status
}
return boost::signals::detail::unusable();
}
void removeShader( const IECore::InternedString &handle )
{
auto it = m_nodes.find( handle );
if( it == m_nodes.end() )
{
throw IECore::Exception( boost::str(
boost::format(
"Shader \"%1%\" not in network"
) % handle.c_str()
) );
}
removeShader( it );
}
void Set::hashSet( const IECore::InternedString &setName, const Gaffer::Context *context, const ScenePlug *parent, IECore::MurmurHash &h ) const
{
const std::string allSets = " " + namePlug()->getValue() + " ";
const std::string setNameToFind = " " + setName.string() + " ";
if( allSets.find( setNameToFind ) == std::string::npos )
{
h = inPlug()->setPlug()->hash();
return;
}
FilteredSceneProcessor::hashSet( setName, context, parent, h );
inPlug()->setPlug()->hash( h );
modePlug()->hash( h );
pathMatcherPlug()->hash( h );
}
ShaderNetwork::ConnectionRange outputConnections( const IECore::InternedString &handle ) const
{
auto it = m_nodes.find( handle );
if( it == m_nodes.end() )
{
throw IECore::Exception( boost::str(
boost::format(
"Source shader \"%1%\" not in network"
) % handle.c_str()
) );
}
return ConnectionRange(
ConnectionIterator( &it->outputConnections, it->outputConnections.size() ? &*it->outputConnections.begin() : nullptr ),
ConnectionIterator( &it->outputConnections, nullptr )
);
}
InteractiveRender::InteractiveRender( const IECore::InternedString &rendererType, const std::string &name )
: Node( name ),
m_state( Stopped )
{
storeIndexOfNextChild( g_firstPlugIndex );
addChild( new ScenePlug( "in" ) );
addChild( new StringPlug( rendererType.string().empty() ? "renderer" : "__renderer", Plug::In, rendererType.string() ) );
addChild( new IntPlug( "state", Plug::In, Stopped, Stopped, Paused, Plug::Default & ~Plug::Serialisable ) );
addChild( new ScenePlug( "out", Plug::Out, Plug::Default & ~Plug::Serialisable ) );
addChild( new ScenePlug( "__adaptedIn", Plug::In, Plug::Default & ~Plug::Serialisable ) );
SceneProcessorPtr adaptors = RendererAlgo::createAdaptors();
setChild( "__adaptors", adaptors );
adaptors->inPlug()->setInput( inPlug() );
adaptedInPlug()->setInput( adaptors->outPlug() );
outPlug()->setInput( inPlug() );
plugDirtiedSignal().connect( boost::bind( &InteractiveRender::plugDirtied, this, ::_1 ) );
}
GafferScene::ConstPathMatcherDataPtr Set::computeSet( const IECore::InternedString &setName, const Gaffer::Context *context, const ScenePlug *parent ) const
{
const std::string allSets = " " + namePlug()->getValue() + " ";
const std::string setNameToFind = " " + setName.string() + " ";
if( allSets.find( setNameToFind ) == std::string::npos )
{
return inPlug()->setPlug()->getValue();
}
ConstPathMatcherDataPtr pathMatcher = pathMatcherPlug()->getValue();
switch( modePlug()->getValue() )
{
case Add : {
ConstPathMatcherDataPtr inputSet = inPlug()->setPlug()->getValue();
if( !inputSet->readable().isEmpty() )
{
PathMatcherDataPtr result = inputSet->copy();
result->writable().addPaths( pathMatcher->readable() );
return result;
}
// Input set empty - fall through to create mode.
}
case Create : {
return pathMatcher;
}
case Remove :
default : {
ConstPathMatcherDataPtr inputSet = inPlug()->setPlug()->getValue();
if( inputSet->readable().isEmpty() )
{
return inputSet;
}
PathMatcherDataPtr result = inputSet->copy();
result->writable().removePaths( pathMatcher->readable() );
return result;
}
}
}
void NoduleLayout::plugMetadataChanged( IECore::TypeId nodeTypeId, const Gaffer::MatchPattern &plugPath, IECore::InternedString key, const Gaffer::Plug *plug )
{
if( childAffectedByChange( m_parent.get(), nodeTypeId, plugPath, plug ) )
{
if(
key == g_sectionKey || key == g_indexKey || key == g_visibleKey ||
key == g_noduleTypeKey ||
key == g_nodulePositionKey || key == g_noduleIndexKey
)
{
updateLayout();
}
}
if( const Plug *typedParent = runTimeCast<const Plug>( m_parent.get() ) )
{
if( affectedByChange( typedParent, nodeTypeId, plugPath, plug ) )
{
if( affectsSpacing( key, m_section ) )
{
updateSpacing();
}
if( affectsDirection( key, m_section ) )
{
updateDirection();
}
if( affectsOrientation( key, m_section ) )
{
updateOrientation();
}
if( boost::starts_with( key.string(), "noduleLayout:customGadget" ) )
{
updateLayout();
}
}
}
}
const std::string &handleKey() const { return handle.string(); }
const IECore::InternedString &GraphComponent::setName( const IECore::InternedString &name )
{
// make sure the name is valid
static boost::regex validator( "^[A-Za-z_]+[A-Za-z_0-9]*" );
if( !regex_match( name.c_str(), validator ) )
{
std::string what = boost::str( boost::format( "Invalid name \"%s\"" ) % name.string() );
throw IECore::Exception( what );
}
// make sure the name is unique
IECore::InternedString newName = name;
if( m_parent )
{
bool uniqueAlready = true;
for( ChildContainer::const_iterator it=m_parent->m_children.begin(), eIt=m_parent->m_children.end(); it != eIt; it++ )
{
if( *it != this && (*it)->m_name == m_name )
{
uniqueAlready = false;
break;
}
}
if( !uniqueAlready )
{
// split name into a prefix and a numeric suffix. if no suffix
// exists then it defaults to 1.
std::string prefix;
int suffix = numericSuffix( newName.value(), 1, &prefix );
// iterate over all the siblings to find the minimum value for the suffix which
// will be greater than any existing suffix.
for( ChildContainer::const_iterator it=m_parent->m_children.begin(), eIt=m_parent->m_children.end(); it != eIt; it++ )
{
if( *it == this )
{
continue;
}
if( (*it)->m_name.value().compare( 0, prefix.size(), prefix ) == 0 )
{
char *endPtr = 0;
long siblingSuffix = strtol( (*it)->m_name.value().c_str() + prefix.size(), &endPtr, 10 );
if( *endPtr == '\0' )
{
suffix = max( suffix, (int)siblingSuffix + 1 );
}
}
}
static boost::format formatter( "%s%d" );
newName = boost::str( formatter % prefix % suffix );
}
}
// set the new name if it's different to the old
if( newName==m_name )
{
return m_name;
}
Action::enact(
this,
// ok to bind raw pointers to this, because enact() guarantees
// the lifetime of the subject.
boost::bind( &GraphComponent::setNameInternal, this, newName ),
boost::bind( &GraphComponent::setNameInternal, this, m_name )
);
return m_name;
}
inline PathMatcher::Name::Name( IECore::InternedString name )
: name( name ), type( name == g_ellipsis || Gaffer::hasWildcards( name.c_str() ) ? Wildcarded : Plain )
{
}
IECoreGL::ConstRenderablePtr StandardLightVisualiser::visualise( const IECore::InternedString &attributeName, const IECore::ObjectVector *shaderVector, IECoreGL::ConstStatePtr &state ) const
{
if( !shaderVector || shaderVector->members().size() == 0 )
{
return NULL;
}
IECore::InternedString metadataTarget;
const IECore::CompoundData *shaderParameters = NULL;
if( const IECore::Shader *shader = IECore::runTimeCast<const IECore::Shader>( shaderVector->members().back().get() ) )
{
metadataTarget = attributeName.string() + ":" + shader->getName();
shaderParameters = shader->parametersData();
}
else if( const IECore::Light *light = IECore::runTimeCast<const IECore::Light>( shaderVector->members().back().get() ) )
{
/// \todo Remove once all Light node derived classes are
/// creating only shaders.
metadataTarget = attributeName.string() + ":" + light->getName();
shaderParameters = light->parametersData().get();
}
if( !shaderParameters )
{
return NULL;
}
ConstStringDataPtr type = Metadata::value<StringData>( metadataTarget, "type" );
ConstM44fDataPtr orientation = Metadata::value<M44fData>( metadataTarget, "visualiserOrientation" );
const Color3f color = parameter<Color3f>( metadataTarget, shaderParameters, "colorParameter", Color3f( 1.0f ) );
const float intensity = parameter<float>( metadataTarget, shaderParameters, "intensityParameter", 1 );
const float exposure = parameter<float>( metadataTarget, shaderParameters, "exposureParameter", 0 );
const Color3f finalColor = color * intensity * pow( 2.0f, exposure );
if( type && type->readable() == "area" )
{
const std::string textureName = parameter<std::string>( metadataTarget, shaderParameters, "textureNameParameter", "" );
const bool flipNormal = parameter<bool>( metadataTarget, shaderParameters, "flipNormalParameter", 0 );
const bool doubleSided = parameter<bool>( metadataTarget, shaderParameters, "doubleSidedParameter", 0 );
const bool sphericalProjection = parameter<bool>( metadataTarget, shaderParameters, "sphericalProjectionParameter", 0 );
M44f projectionTransform = parameter<M44f>( metadataTarget, shaderParameters, "projectionTransformParameter", M44f() );
const std::vector<float> projectionTransformVector = parameter<std::vector<float> >( metadataTarget, shaderParameters, "projectionTransformParameter", std::vector<float>() );
if( projectionTransformVector.size() == 16 )
{
projectionTransform = M44f( (float(*)[4])(&projectionTransformVector[0]) );
}
addAreaLightVisualiser( state, finalColor, textureName, flipNormal, doubleSided,
sphericalProjection, projectionTransform );
return NULL;
}
GroupPtr result = new Group;
const float locatorScale = parameter<float>( metadataTarget, shaderParameters, "locatorScaleParameter", 1 );
Imath::M44f topTrans;
if( orientation )
{
topTrans = orientation->readable();
}
topTrans.scale( V3f( locatorScale ) );
result->setTransform( topTrans );
if( type && type->readable() == "environment" )
{
const std::string textureName = parameter<std::string>( metadataTarget, shaderParameters, "textureNameParameter", "" );
addEnvLightVisualiser( result, finalColor, textureName );
}
else
{
float coneAngle = parameter<float>( metadataTarget, shaderParameters, "coneAngleParameter", 0.0f );
float penumbraAngle = parameter<float>( metadataTarget, shaderParameters, "penumbraAngleParameter", 0.0f );
if( ConstStringDataPtr angleUnit = Metadata::value<StringData>( metadataTarget, "angleUnit" ) )
{
if( angleUnit->readable() == "radians" )
{
coneAngle *= 180.0 / M_PI;
penumbraAngle *= 180 / M_PI;
}
}
const std::string *penumbraType = NULL;
ConstStringDataPtr penumbraTypeData = Metadata::value<StringData>( metadataTarget, "penumbraType" );
if( penumbraTypeData )
{
penumbraType = &penumbraTypeData->readable();
}
float lensRadius = 0.0f;
if( parameter<bool>( metadataTarget, shaderParameters, "lensRadiusEnableParameter", true ) )
{
lensRadius = parameter<float>( metadataTarget, shaderParameters, "lensRadiusParameter", 0.0f );
}
addBasicLightVisualiser( type, result, finalColor, coneAngle, penumbraAngle, penumbraType, lensRadius / locatorScale );
}
return result;
}