Пример #1
0
bool GraphGadget::dragEnd( GadgetPtr gadget, const DragDropEvent &event )
{
	DragMode dragMode = m_dragMode;
	m_dragMode = None;
	Pointer::setCurrent( "" );

	if( !m_scriptNode )
	{
		return false;
	}

	V3f i;
	if( !event.line.intersect( Plane3f( V3f( 0, 0, 1 ), 0 ), i ) )
	{
		return false;
	}

	if( dragMode == Moving )
	{
		if ( m_dragReconnectCandidate )
		{
			if ( m_dragReconnectDstNodule || m_dragReconnectSrcNodule )
			{
				Gaffer::Plug *srcPlug = m_dragReconnectCandidate->srcNodule()->plug();
				Gaffer::Plug *dstPlug = m_dragReconnectCandidate->dstNodule()->plug();

				Gaffer::UndoContext undoContext( m_scriptNode );

				if ( m_dragReconnectDstNodule )
				{
					m_dragReconnectDstNodule->plug()->setInput( srcPlug );
					dstPlug->setInput( 0 );
				}

				if ( m_dragReconnectSrcNodule )
				{
					dstPlug->setInput( m_dragReconnectSrcNodule->plug() );
				}
			}
		}

		m_dragReconnectCandidate = 0;
		renderRequestSignal()( this );
	}
	else if( dragMode == Selecting )
	{
		updateDragSelection( true );
		renderRequestSignal()( this );
	}

	return true;
}
Пример #2
0
void GraphGadget::addConnectionGadget( Gaffer::Plug *dstPlug )
{
	Gaffer::Plug *srcPlug = dstPlug->getInput<Gaffer::Plug>();
	if( !srcPlug )
	{
		// there is no connection
		return;
	}
	
	Gaffer::Node *dstNode = dstPlug->node();
	NodeGadget *dstNodeGadget = findNodeGadget( dstNode );
	if( !dstNodeGadget )
	{
		return;
	}
	
	Nodule *dstNodule = dstNodeGadget->nodule( dstPlug );
	if( !dstNodule )
	{
		// the destination connection point is not represented in the graph
		return;
	}
	
	Gaffer::Node *srcNode = srcPlug->node();
	if( srcNode == dstNode )
	{
		// we don't want to visualise connections between plugs
		// on the same node.
		return;
	}
	
	// find the input nodule for the connection if there is one
	NodeGadget *srcNodeGadget = findNodeGadget( srcNode );
	Nodule *srcNodule = 0;
	if( srcNodeGadget )
	{
		srcNodule = srcNodeGadget->nodule( srcPlug );
	}
		
	ConnectionGadgetPtr connection = new ConnectionGadget( srcNodule, dstNodule );
	updateConnectionGadgetMinimisation( connection.get() );
	addChild( connection );

	m_connectionGadgets[dstPlug] = connection.get();
}
Пример #3
0
void GraphGadget::updateDragReconnectCandidate( const DragDropEvent &event )
{
	m_dragReconnectCandidate = 0;
	m_dragReconnectSrcNodule = 0;
	m_dragReconnectDstNodule = 0;
	
	if ( m_scriptNode->selection()->size() != 1 )
	{
		return;
	}
	
	// make sure the connection applies to this node.
	Gaffer::Node *node = IECore::runTimeCast<Gaffer::Node>( m_scriptNode->selection()->member( 0 ) );
	NodeGadget *selNodeGadget = nodeGadget( node );
	if ( !node || !selNodeGadget )
	{
		return;
	}
	
	m_dragReconnectCandidate = reconnectionGadgetAt( selNodeGadget, event.line );
	if ( !m_dragReconnectCandidate )
	{
		return;
	}
	
	// we don't want to reconnect the selected node to itself
	Gaffer::Plug *srcPlug = m_dragReconnectCandidate->srcNodule()->plug();
	Gaffer::Plug *dstPlug = m_dragReconnectCandidate->dstNodule()->plug();
	if ( srcPlug->node() == node || dstPlug->node() == node )
	{
		m_dragReconnectCandidate = 0;
		return;
	}
	
	Gaffer::DependencyNode *depNode = IECore::runTimeCast<Gaffer::DependencyNode>( node );
	for ( Gaffer::RecursiveOutputPlugIterator cIt( node ); cIt != cIt.end(); ++cIt )
	{
		// must be compatible
		Gaffer::Plug *p = cIt->get();
		if ( !dstPlug->acceptsInput( p ) )
		{
			continue;
		}
		
		// must have a nodule
		m_dragReconnectSrcNodule = selNodeGadget->nodule( p );
		if ( !m_dragReconnectSrcNodule )
		{
			continue;
		}
		
		// must not be connected to a nodule
		for ( Gaffer::Plug::OutputContainer::const_iterator oIt = p->outputs().begin(); oIt != p->outputs().end(); ++oIt )
		{
			NodeGadget *oNodeGadget = nodeGadget( (*oIt)->node() );
			if ( oNodeGadget && oNodeGadget->nodule( *oIt ) )
			{
				m_dragReconnectSrcNodule = 0;
				break;
			}
		}
		
		if ( !m_dragReconnectSrcNodule )
		{
			continue;
		}
		
		if ( !depNode )
		{
			// found the best option
			break;
		}
		
		// make sure its corresponding input is also free
		if ( Gaffer::Plug *in = depNode->correspondingInput( p ) )
		{
			if ( in->getInput<Gaffer::Plug>() )
			{
				m_dragReconnectSrcNodule = 0;
				continue;
			}
			
			m_dragReconnectDstNodule = selNodeGadget->nodule( in );
			if ( m_dragReconnectDstNodule )
			{
				break;
			}
		}
	}
	
	// check input plugs on non-dependencyNodes
	if ( !depNode && !m_dragReconnectDstNodule )
	{
		for ( Gaffer::RecursiveInputPlugIterator cIt( node ); cIt != cIt.end(); ++cIt )
		{
			Gaffer::Plug *p = cIt->get();
			if ( !p->getInput<Gaffer::Plug>() && p->acceptsInput( srcPlug ) )
			{
				m_dragReconnectDstNodule = selNodeGadget->nodule( p );
				if ( m_dragReconnectDstNodule )
				{
					break;
				}
			}
		}
	}
	
	if ( !m_dragReconnectSrcNodule && !m_dragReconnectDstNodule )
	{
		m_dragReconnectCandidate = 0;
	}
}
Пример #4
0
bool GraphGadget::dragEnd( GadgetPtr gadget, const DragDropEvent &event )
{
	DragMode dragMode = m_dragMode;
	m_dragMode = None;
	Pointer::set( 0 );
	
	if( !m_scriptNode )
	{
		return false;
	}
	
	V3f i;
	if( !event.line.intersect( Plane3f( V3f( 0, 0, 1 ), 0 ), i ) )
	{
		return false;
	}
	
	if( dragMode == Moving )
	{
		if ( m_dragReconnectCandidate )
		{
			if ( m_dragReconnectDstNodule || m_dragReconnectSrcNodule )
			{
				Gaffer::Plug *srcPlug = m_dragReconnectCandidate->srcNodule()->plug();
				Gaffer::Plug *dstPlug = m_dragReconnectCandidate->dstNodule()->plug();
				
				Gaffer::UndoContext undoContext( m_scriptNode );
				
				if ( m_dragReconnectDstNodule )
				{
					m_dragReconnectDstNodule->plug()->setInput( srcPlug );
					dstPlug->setInput( 0 );
				}

				if ( m_dragReconnectSrcNodule )
				{
					dstPlug->setInput( m_dragReconnectSrcNodule->plug() );
				}
			}
		}
		
		m_dragReconnectCandidate = 0;
		renderRequestSignal()( this );
	}
	else if( dragMode == Selecting )
	{
		Box2f selectionBound;
		selectionBound.extendBy( m_dragStartPosition );
		selectionBound.extendBy( m_lastDragPosition );
	
		for( ChildContainer::const_iterator it=children().begin(); it!=children().end(); it++ )
		{
			NodeGadgetPtr nodeGadget = runTimeCast<NodeGadget>( *it );
			if( nodeGadget )
			{
				Box3f nodeBound3 = nodeGadget->transformedBound();
				Box2f nodeBound2( V2f( nodeBound3.min.x, nodeBound3.min.y ), V2f( nodeBound3.max.x, nodeBound3.max.y ) );
				if( boxContains( selectionBound, nodeBound2 ) )
				{
					m_scriptNode->selection()->add( nodeGadget->node() );
				}
			}
		}
	
		renderRequestSignal()( this );
	}

	return true;
}
Пример #5
0
void AppleseedLight::setupPlugs( const std::string &shaderName, const asf::DictionaryArray &metadata )
{
	bool needsRadianceTexture = shaderName.find( "map" ) != std::string::npos;

	for( size_t i = 0, e = metadata.size(); i < e; ++i )
	{
		const asf::Dictionary &inputMetadata = metadata[i];
		std::string inputName = inputMetadata.get( "name" );
		std::string inputType = inputMetadata.get( "type" );

		Gaffer::Plug *plug = nullptr;

		// some environment lights need their radiance color input
		// replaced by a texture input: latlong map and mirrorball map.
		if( needsRadianceTexture && inputName == "radiance" )
		{
			plug = new Gaffer::StringPlug( "radiance_map", Gaffer::Plug::In );
		}
		else
		{
			if( inputType == "numeric" )
			{
				float defaultValue = inputMetadata.get<float>( "default" );
				float minValue = get_min_max_value( inputMetadata, "min" );
				float maxValue = get_min_max_value( inputMetadata, "max" );
				plug = new Gaffer::FloatPlug( inputName, Gaffer::Plug::In, defaultValue, minValue, maxValue );
			}
			else if( inputType == "colormap" )
			{
				// override the plug type for the exposure param (usually it's a color in appleseed).
				if ( inputName == "exposure" )
				{
					plug = new Gaffer::FloatPlug( inputName, Gaffer::Plug::In, 0.0f );
				}
				// multiplier inputs make more sense in Gaffer as float plugs.
				else if( inputName.find( "multiplier" ) != std::string::npos )
				{
					plug = new Gaffer::FloatPlug( inputName, Gaffer::Plug::In, 1.0f, 0.0f );
				}
				else
				{
					plug = new Gaffer::Color3fPlug( inputName, Gaffer::Plug::In, Imath::Color3f( 1.0f ) );
				}
			}
			else if( inputType == "boolean" )
			{
				bool defaultValue = strcmp( inputMetadata.get( "default" ), "true" ) == 0;
				plug = new Gaffer::BoolPlug( inputName, Gaffer::Plug::In, defaultValue );
			}
			// text are non-texturable float inputs.
			else if( inputType == "text" )
			{
				float defaultValue = inputMetadata.get<float>( "default" );
				plug = new Gaffer::FloatPlug( inputName, Gaffer::Plug::In, defaultValue );
			}
		}

		if( plug )
		{
			plug->setFlags( Gaffer::Plug::Dynamic, true );
			parametersPlug()->addChild( plug );
		}
	}
}
Пример #6
0
void AppleseedLight::setupPlugs( const std::string &shaderName, const asf::DictionaryArray &metadata )
{
	bool needsRadianceTexture = shaderName.find( "map" ) != std::string::npos;

	for( size_t i = 0, e = metadata.size(); i < e; ++i )
	{
		const asf::Dictionary &inputMetadata = metadata[i];
		std::string inputName = inputMetadata.get( "name" );
		std::string inputType = inputMetadata.get( "type" );

		Gaffer::Plug *plug = 0;

		// some environment lights need their radiance color input
		// replaced by a texture input: latlong map and mirrorball map.
		if( needsRadianceTexture && inputName == "radiance" )
		{
			plug = new Gaffer::StringPlug( "radiance_map", Gaffer::Plug::In );
		}
		else
		{
			if( inputType == "numeric" )
			{
				float defaultValue = boost::lexical_cast<float>( inputMetadata.get( "default" ) );
				float minValue = boost::lexical_cast<float>( inputMetadata.get( "min_value" ) );
				float maxValue = boost::lexical_cast<float>( inputMetadata.get( "max_value" ) );
				plug = new Gaffer::FloatPlug( inputName, Gaffer::Plug::In, defaultValue, minValue, maxValue );
			}
			else if( inputType == "colormap" )
			{
				// multiplier inputs make more sense is Gaffer as float plugs.
				if( inputName.find( "multiplier" ) != std::string::npos )
				{
					plug = new Gaffer::FloatPlug( inputName, Gaffer::Plug::In, 1.0f, 0.0f );
				}
				else
				{
					plug = new Gaffer::Color3fPlug( inputName, Gaffer::Plug::In, Imath::Color3f( 1.0f ) );
				}
			}
			else if( inputType == "boolean" )
			{
				bool defaultValue = strcmp( inputMetadata.get( "default" ), "true" ) == 0;
				plug = new Gaffer::BoolPlug( inputName, Gaffer::Plug::In, defaultValue );
			}
			// text are non-texturable float inputs.
			else if( inputType == "text" )
			{
				float defaultValue = boost::lexical_cast<float>( inputMetadata.get( "default" ) );
				plug = new Gaffer::FloatPlug( inputName, Gaffer::Plug::In, defaultValue );
			}
			// entity represent connections between entities that can work together,
			// like the sky environments and the sun light.
			else if( inputType == "entity" )
			{
				plug = new Gaffer::StringPlug( inputName, Gaffer::Plug::In );
			}
		}

		if( plug )
		{
			plug->setFlags( Gaffer::Plug::Dynamic, true );
			parametersPlug()->addChild( plug );
		}
	}
}