void hashParameter( const Gaffer::Plug *parameter, IECore::MurmurHash &h ) { const Gaffer::Plug *effectiveParameter = this->effectiveParameter( parameter ); if( !effectiveParameter ) { return; } const Shader *effectiveShader = static_cast<const Shader *>( effectiveParameter->node() ); if( isInputParameter( effectiveParameter ) ) { effectiveShader->parameterHash( effectiveParameter, h ); hashParameterComponentConnections( parameter, h ); } else { assert( isOutputParameter( effectiveParameter ) ); h.append( shaderHash( effectiveShader ) ); if( effectiveShader->outPlug()->isAncestorOf( effectiveParameter ) ) { h.append( effectiveParameter->relativeName( effectiveShader->outPlug() ) ); } return; } }
unsigned long int Random::computeSeed( const Context *context ) const { unsigned long int seed = seedPlug()->getValue(); std::string contextEntry = contextEntryPlug()->getValue(); if( contextEntry.size() ) { const IECore::Data *contextData = 0; try { contextData = context->get<IECore::Data>( contextEntry ); } catch( ... ) { } if( contextData ) { IECore::MurmurHash hash = contextData->Object::hash(); /// \todo It'd be nice if there was a way of getting the hash folded into an /// int so we could avoid this jiggery pokery. std::string s = hash.toString(); seed += boost::hash<std::string>()( s ); } } return seed; }
IECore::MurmurHash Shader::NetworkBuilder::shaderHash( const Shader *shaderNode ) { shaderNode = effectiveNode( shaderNode ); if( !shaderNode ) { IECore::MurmurHash h; h.append( Shader::staticTypeId() ); return h; } ShaderAndHash &shaderAndHash = m_shaders[shaderNode]; if( shaderAndHash.hash != IECore::MurmurHash() ) { return shaderAndHash.hash; } shaderAndHash.hash.append( shaderNode->typeId() ); shaderNode->namePlug()->hash( shaderAndHash.hash ); shaderNode->typePlug()->hash( shaderAndHash.hash ); parameterHashWalk( shaderNode, shaderNode->parametersPlug(), shaderAndHash.hash ); shaderNode->nodeNamePlug()->hash( shaderAndHash.hash ); shaderNode->nodeColorPlug()->hash( shaderAndHash.hash ); return shaderAndHash.hash; }
void Shader::parameterHash( const Gaffer::Plug *parameterPlug, NetworkBuilder &network, IECore::MurmurHash &h ) const { const Plug *inputPlug = parameterPlug->source<Plug>(); if( inputPlug != parameterPlug ) { const Shader *n = IECore::runTimeCast<const Shader>( inputPlug->node() ); if( n && ( inputPlug == n->outPlug() || n->outPlug()->isAncestorOf( inputPlug ) ) ) { h.append( network.shaderHash( n ) ); if( inputPlug != n->outPlug() ) { // shader has multiple outputs - we need to make sure the particular // output in question is taken into account by the hash. h.append( inputPlug->relativeName( n->outPlug() ) ); } return; } // fall through to hash plug value } const ValuePlug *vplug = IECore::runTimeCast<const ValuePlug>( parameterPlug ); if( vplug ) { vplug->hash( h ); } else { h.append( parameterPlug->typeId() ); } }
void Shape::hashChannelData( const GafferImage::ImagePlug *parent, const Gaffer::Context *context, IECore::MurmurHash &h ) const { assert( parent == shapePlug() ); const std::string &channelName = context->get<std::string>( ImagePlug::channelNameContextName ); if( channelName == g_shapeChannelName ) { // Private channel we use for caching the shape but don't advertise via channelNames. hashShapeChannelData( context->get<V2i>( ImagePlug::tileOriginContextName ), context, h ); } else { const MurmurHash shapeHash = parent->channelDataHash( g_shapeChannelName, context->get<V2i>( ImagePlug::tileOriginContextName ) ); const float c = channelValue( parent, channelName ); if( c == 1 ) { h = shapeHash; } else { ImageProcessor::hashChannelData( parent, context, h ); h.append( shapeHash ); h.append( c ); } } }
AtNode *InstancingConverter::convert( const std::vector<const IECore::Primitive *> &samples, const std::vector<float> &sampleTimes, const IECore::MurmurHash &additionalHash ) { IECore::MurmurHash h; for( std::vector<const IECore::Primitive *>::const_iterator it = samples.begin(), eIt = samples.end(); it != eIt; ++it ) { (*it)->hash( h ); } h.append( additionalHash ); MemberData::Cache::accessor a; if( m_data->cache.insert( a, h ) ) { std::vector<const IECore::Object *> objectSamples( samples.begin(), samples.end() ); a->second = NodeAlgo::convert( objectSamples, sampleTimes ); return a->second; } else { if( a->second ) { AtNode *instance = AiNode( "ginstance" ); AiNodeSetPtr( instance, "node", a->second ); return instance; } } return NULL; }
void AlembicSource::hashObject( const ScenePath &path, const Gaffer::Context *context, const ScenePlug *parent, IECore::MurmurHash &h ) const { SceneNode::hashObject( path, context, parent, h ); fileNamePlug()->hash( h ); refreshCountPlug()->hash( h ); h.append( &(path[0]), path.size() ); h.append( context->getTime() ); }
IECore::MurmurHash Context::hash() const { IECore::MurmurHash result; for( Map::const_iterator it = m_map.begin(), eIt = m_map.end(); it != eIt; it++ ) { result.append( it->first ); it->second.data->hash( result ); } return result; }
void MapProjection::hashProcessedObject( const ScenePath &path, const Gaffer::Context *context, IECore::MurmurHash &h ) const { ScenePath cameraPath; ScenePlug::stringToPath( cameraPlug()->getValue(), cameraPath ); h.append( inPlug()->objectHash( cameraPath ) ); h.append( inPlug()->transformHash( cameraPath ) ); inPlug()->transformPlug()->hash( h ); uvSetPlug()->hash( h ); }
void Sampler::hash( IECore::MurmurHash &h ) const { for ( int x = m_cacheWindow.min.x; x < m_cacheWindow.max.x; x += GafferImage::ImagePlug::tileSize() ) { for ( int y = m_cacheWindow.min.y; y < m_cacheWindow.max.y; y += GafferImage::ImagePlug::tileSize() ) { h.append( m_plug->channelDataHash( m_channelName, Imath::V2i( x, y ) ) ); } } h.append( m_boundingMode ); h.append( m_dataWindow ); h.append( m_sampleWindow ); }
void ArnoldDisplacement::attributesHash( IECore::MurmurHash &h ) const { h.append( typeId() ); if( !enabledPlug()->getValue() ) { return; } h.append( mapPlug()->attributesHash() ); heightPlug()->hash( h ); paddingPlug()->hash( h ); zeroValuePlug()->hash( h ); autoBumpPlug()->hash( h ); }
void BranchCreator::hashMapping( const Gaffer::Context *context, IECore::MurmurHash &h ) const { string parentAsString = parentPlug()->getValue(); h.append( parentAsString ); ScenePlug::ScenePath parent; ScenePlug::stringToPath( parentAsString, parent ); h.append( inPlug()->childNamesHash( parent ) ); MurmurHash branchChildNamesHash; hashBranchChildNames( parent, ScenePath(), context, branchChildNamesHash ); h.append( branchChildNamesHash ); }
void Reformat::hashDataWindow( const GafferImage::ImagePlug *output, const Gaffer::Context *context, IECore::MurmurHash &h ) const { ImageProcessor::hashDataWindow( output, context, h ); Format format = formatPlug()->getValue(); h.append( format.getDisplayWindow() ); h.append( format.getPixelAspect() ); Format inFormat = inPlug()->formatPlug()->getValue(); h.append( inFormat.getDisplayWindow() ); h.append( inFormat.getPixelAspect() ); inPlug()->dataWindowPlug()->hash( h ); }
void Instancer::hashBranchTransform( const ScenePath &parentPath, const ScenePath &branchPath, const Gaffer::Context *context, IECore::MurmurHash &h ) const { ContextPtr ic = instanceContext( context, branchPath ); if( ic ) { Context::Scope scopedContext( ic ); h = instancePlug()->transformPlug()->hash(); } if( branchPath.size() == 1 ) { h.append( inPlug()->objectHash( parentPath ) ); h.append( instanceIndex( branchPath ) ); } }
IECore::MurmurHash AtomicFormatPlug::hash() const { Format v = getValue(); if( v.getDisplayWindow().isEmpty() ) { v = FormatPlug::getDefaultFormat( Context::current() ); } IECore::MurmurHash result; result.append( v.getDisplayWindow() ); result.append( v.getPixelAspect() ); return result; return ValuePlug::hash(); }
void OSLObject::hashProcessedObject( const ScenePath &path, const Gaffer::Context *context, IECore::MurmurHash &h ) const { const OSLShader *shader = runTimeCast<const OSLShader>( shaderPlug()->source()->node() ); ConstShadingEnginePtr shadingEngine = shader ? shader->shadingEngine() : nullptr; if( !shadingEngine ) { return; } shadingEngine->hash( h ); interpolationPlug()->hash( h ); h.append( inPlug()->fullTransformHash( path ) ); h.append( resampledInPlug()->objectPlug()->hash() ); }
void hash( IECore::MurmurHash &h ) const { std::unique_lock<std::mutex> lock( m_hashMutex ); if( m_hashDirty ) { m_hash = MurmurHash(); for( const auto &node : m_nodes ) { m_hash.append( node.handle ); node.shader->hash( m_hash ); for( const auto &connection : node.inputConnections ) { m_hash.append( connection.source.shader ); m_hash.append( connection.source.name ); m_hash.append( connection.destination.name ); } } m_hash.append( m_output.shader ); m_hash.append( m_output.name ); m_hashDirty = false; } lock.unlock(); h.append( m_hash ); }
void Shader::attributesHash( const Gaffer::Plug *output, IECore::MurmurHash &h ) const { attributeSuffixPlug()->hash( h ); NetworkBuilder networkBuilder( output ); h.append( networkBuilder.networkHash() ); }
void SceneReader::hashSet( const IECore::InternedString &setName, const Gaffer::Context *context, const ScenePlug *parent, IECore::MurmurHash &h ) const { SceneNode::hashSet( setName, context, parent, h ); fileNamePlug()->hash( h ); refreshCountPlug()->hash( h ); h.append( setName ); }
void Expression::hash( const ValuePlug *output, const Context *context, IECore::MurmurHash &h ) const { ComputeNode::hash( output, context, h ); if( output == getChild<ValuePlug>( "out" ) ) { enginePlug()->hash( h ); expressionPlug()->hash( h ); const CompoundPlug *in = getChild<CompoundPlug>( "in" ); if( in ) { in->hash( h ); } if( m_engine ) { std::vector<std::string> contextNames; m_engine->contextNames( contextNames ); for( std::vector<std::string>::const_iterator it = contextNames.begin(); it != contextNames.end(); it++ ) { const IECore::Data *d = context->get<IECore::Data>( *it, 0 ); if( d ) { d->hash( h ); } else { h.append( 0 ); } } } } }
void Expression::hash( const ValuePlug *output, const Context *context, IECore::MurmurHash &h ) const { ComputeNode::hash( output, context, h ); if( output == executePlug() ) { enginePlug()->hash( h ); expressionPlug()->hash( h ); inPlug()->hash( h ); if( m_engine ) { for( std::vector<IECore::InternedString>::const_iterator it = m_contextNames.begin(); it != m_contextNames.end(); it++ ) { const IECore::Data *d = context->get<IECore::Data>( *it, 0 ); if( d ) { d->hash( h ); } else { h.append( 0 ); } } } } else if( outPlug()->isAncestorOf( output ) ) { executePlug()->hash( h ); } }
void Instancer::hashBranchBound( const ScenePath &parentPath, const ScenePath &branchPath, const Gaffer::Context *context, IECore::MurmurHash &h ) const { if( branchPath.size() <= 1 ) { // "/" or "/name" BranchCreator::hashBranchBound( parentPath, branchPath, context, h ); ConstV3fVectorDataPtr p = sourcePoints( parentPath ); if( p ) { p->hash( h ); ScenePath branchChildPath( branchPath ); if( branchChildPath.size() == 0 ) { branchChildPath.push_back( namePlug()->getValue() ); } BoundHash hasher( this, branchChildPath, context ); parallel_deterministic_reduce( blocked_range<size_t>( 0, p->readable().size(), 100 ), hasher ); h.append( hasher.result() ); } } else { InstanceScope instanceScope( context, branchPath ); h = instancePlug()->boundPlug()->hash(); } }
void Grid::hashObject( const SceneNode::ScenePath &path, const Gaffer::Context *context, const ScenePlug *parent, IECore::MurmurHash &h ) const { if( path.size() == 2 ) { SceneNode::hashObject( path, context, parent, h ); h.append( path.back() ); dimensionsPlug()->hash( h ); if( path.back() == g_gridLinesName ) { spacingPlug()->hash( h ); gridColorPlug()->hash( h ); } else if( path.back() == g_centerLinesName ) { centerColorPlug()->hash( h ); } else if( path.back() == g_borderLinesName ) { borderColorPlug()->hash( h ); } } else { h = outPlug()->objectPlug()->defaultValue()->hash(); } }
IECore::MurmurHash ExecutableRender::hash( const Gaffer::Context *context ) const { const ScenePlug *scenePlug = inPlug()->source<ScenePlug>(); if ( scenePlug == inPlug() ) { return IECore::MurmurHash(); } Context::Scope scope( context ); IECore::MurmurHash h = TaskNode::hash( context ); /// \todo hash the actual scene when we have a hierarchyHash h.append( (uint64_t)scenePlug ); h.append( context->hash() ); return h; }
void DisplayTransform::hashTransform( const Gaffer::Context *context, IECore::MurmurHash &h ) const { std::string colorSpace = inputColorSpacePlug()->getValue(); std::string display = displayPlug()->getValue(); std::string view = viewPlug()->getValue(); if( colorSpace.empty() || display.empty() || view.empty() ) { h = MurmurHash(); return; } h.append( colorSpace ); h.append( display ); h.append( view ); }
void UVWarp::hashEngine( const std::string &channelName, const Imath::V2i &tileOrigin, const Gaffer::Context *context, IECore::MurmurHash &h ) const { Warp::hashEngine( channelName, tileOrigin, context, h ); h.append( tileOrigin ); uvPlug()->dataWindowPlug()->hash( h ); ConstStringVectorDataPtr channelNames = uvPlug()->channelNamesPlug()->getValue(); ContextPtr tmpContext = new Context( *context, Context::Borrowed ); Context::Scope scopedContext( tmpContext.get() ); if( channelExists( channelNames->readable(), "R" ) ) { tmpContext->set<std::string>( ImagePlug::channelNameContextName, "R" ); uvPlug()->channelDataPlug()->hash( h ); } if( channelExists( channelNames->readable(), "G" ) ) { tmpContext->set<std::string>( ImagePlug::channelNameContextName, "G" ); uvPlug()->channelDataPlug()->hash( h ); } if( channelExists( channelNames->readable(), "A" ) ) { tmpContext->set<std::string>( ImagePlug::channelNameContextName, "A" ); uvPlug()->channelDataPlug()->hash( h ); } inPlug()->formatPlug()->hash( h ); }
IECore::MurmurHash ExecutableOpHolder::executionHash( const Context *context ) const { IECore::MurmurHash h; std::string className; int classVersion; getParameterised( &className, &classVersion ); h.append( className ); h.append( classVersion ); Context::Scope scope( context ); const ValuePlug *parametersPlug = getChild<ValuePlug>( "parameters" ); if( parametersPlug ) { parametersPlug->hash( h ); } return h; }
void Duplicate::hashBranchTransform( const ScenePath &parentPath, const ScenePath &branchPath, const Gaffer::Context *context, IECore::MurmurHash &h ) const { ScenePath source; sourcePath( branchPath, source ); if( branchPath.size() == 1 ) { BranchCreator::hashBranchTransform( parentPath, branchPath, context, h ); h.append( inPlug()->transformHash( source ) ); transformPlug()->hash( h ); childNamesPlug()->hash( h ); h.append( branchPath[0] ); } else { h = inPlug()->transformHash( source ); } }
IECore::MurmurHash SceneWriter::hash( const Gaffer::Context *context ) const { Context::Scope scope( context ); const ScenePlug *scenePlug = inPlug()->source<ScenePlug>(); if ( ( fileNamePlug()->getValue() == "" ) || ( scenePlug == inPlug() ) ) { return IECore::MurmurHash(); } IECore::MurmurHash h = ExecutableNode::hash( context ); h.append( fileNamePlug()->hash() ); /// \todo hash the actual scene when we have a hierarchyHash h.append( (uint64_t)scenePlug ); h.append( context->hash() ); return h; }
void Mirror::hashDataWindow( const GafferImage::ImagePlug *parent, const Gaffer::Context *context, IECore::MurmurHash &h ) const { const bool horizontal = horizontalPlug()->getValue(); const bool vertical = verticalPlug()->getValue(); if( !horizontal && !vertical ) { h = inPlug()->dataWindowPlug()->hash(); return; } ImageProcessor::hashDataWindow( parent, context, h ); inPlug()->dataWindowPlug()->hash( h ); inPlug()->formatPlug()->hash( h ); h.append( horizontal ); h.append( vertical ); }