GraphComponent *GraphComponent::commonAncestor( const GraphComponent *other, IECore::TypeId ancestorType )
{
set<GraphComponent *> candidates;
GraphComponent *ancestor = m_parent;
while( ancestor )
{
if( ancestor->isInstanceOf( ancestorType ) )
{
candidates.insert( ancestor );
}
ancestor = ancestor->m_parent;
}
ancestor = other->m_parent;
while( ancestor )
{
if( ancestor->isInstanceOf( ancestorType ) )
{
if( candidates.find( ancestor )!=candidates.end() )
{
return ancestor;
}
}
ancestor = ancestor->m_parent;
}
return 0;
}
string ComponentFileName(size_t cnt, const string &folder, const GraphComponent<Graph>& component) {
stringstream ss;
ss << folder << cnt;
if(component.name().size() > 0)
ss << "graph_" << component.name();
ss << ".dot";
return ss.str();
}
//==============================================================================
void HostFilterComponent::loadPluginFromFile (const File& file)
{
DBG ("HostFilterComponent::loadPluginFromFile");
GraphComponent* graph = main->getGraph ();
if (graph) graph->loadAndAppendPlugin (file, 100, 100);
}
string ComponentName(const GraphComponent<Graph>& component) {
cnt_++;
stringstream ss;
ss << name_ << "_" << cnt_;
if(component.name().size() > 0)
ss << "_" << component.name();
ss << "." << extension_;
return ss.str();
}
void Visualize(const GraphComponent<Graph>& component, GraphPrinter<Graph> &printer) {
printer.open();
printer.AddVertices(component.vertices().begin(), component.vertices().end());
for (auto e_it = component.e_begin(); e_it != component.e_end();
++e_it) {
printer.AddEdge(*e_it);
}
printer.close();
}
bool Check(const GraphComponent<Graph> & component) const {
if (component.v_size() <= min_vertex_number_
|| component.v_size() >= max_vertex_number_)
return false;
for (auto iterator = component.e_begin(); iterator != component.e_end();
++iterator) {
if (this->graph().length(*iterator) <= max_length_) {
return true;
}
}
return false;
}
static void loadShaderParameters( const OSLQuery &query, Gaffer::CompoundPlug *parametersPlug, bool keepExistingValues )
{
// if we're not preserving existing values then remove all existing parameter plugs - the various
// plug creators above know that if a plug exists then they should preserve its values.
if( !keepExistingValues )
{
parametersPlug->clearChildren();
}
// make sure we have a plug to represent each parameter, reusing plugs wherever possible.
set<string> validPlugNames;
for( size_t i = 0; i < query.nparams(); ++i )
{
const OSLQuery::Parameter *parameter = query.getparam( i );
const Plug::Direction direction = parameter->isoutput ? Plug::Out : Plug::In;
if( direction != parametersPlug->direction() )
{
continue;
}
if( parameter->name.find( "." ) != string::npos )
{
// member of a struct - will be loaded when the struct is loaded
continue;
}
const Plug *plug = loadShaderParameter( query, parameter, parametersPlug, keepExistingValues );
if( plug )
{
validPlugNames.insert( parameter->name );
}
}
// remove any old plugs which it turned out we didn't need
if( keepExistingValues )
{
for( int i = parametersPlug->children().size() - 1; i >= 0; --i )
{
GraphComponent *child = parametersPlug->getChild<GraphComponent>( i );
if( validPlugNames.find( child->getName().string() ) == validPlugNames.end() )
{
parametersPlug->removeChild( child );
}
}
}
}
GraphComponent *GraphComponent::ancestor( IECore::TypeId type )
{
GraphComponent *a = m_parent;
while( a )
{
if( a->isInstanceOf( type ) )
{
return a;
}
a = a->m_parent;
}
return 0;
}
void Graph::buildDataStructure ()
{
int lastReachedVertex = 0;
while (lastReachedVertex < size)
{
if (!reachedVertices[lastReachedVertex])
{
GraphComponent *component = new GraphComponent(this);
std::list<int> *connectedVertices = new std::list<int>();
std::list<int> *nextVertices = new std::list<int>();
nextVertices->push_back(lastReachedVertex);
reachedVertices[lastReachedVertex] = true;
while (!nextVertices->empty())
{
int vertex = nextVertices->front();
nextVertices->pop_front();
connectedVertices->push_back(vertex);
graphComponents[vertex] = component;
Vertices *adjVertices = getAdjacentVertices(vertex,size);
for (Vertices::iterator it = adjVertices->begin(); it != adjVertices->end(); ++it)
{
int adjVertex = *it;
if (!reachedVertices[adjVertex])
{
nextVertices->push_back(adjVertex);
reachedVertices[adjVertex] = true;
}
}
delete adjVertices;
}
delete nextVertices;
component->setVertices(connectedVertices);
graphComponentSet->insert(component);
delete connectedVertices;
}
lastReachedVertex++;
}
for (GraphComponentSet::iterator it = graphComponentSet->begin(); it != graphComponentSet->end(); ++it)
(*it)->buildDataStructure();
}
void InternalGraph::assignPath(AntPath * pt)
{
GraphComponent * gc;
const std::vector<PathElement *> & path = pt->getPath();
for (int i = 0; i < path.size(); ++ i)
{
if (path[i]->request == 0) continue;
gc = vertices[path[i]->request-1];
if (gc->getType() == GraphComponent::VMACHINE)
{
curNodesRes[path[i]->resource] -= gc->getRequired();
curNodesRam[path[i]->resource] -= gc->getRequiredRam();
}
else if (gc->getType() == GraphComponent::STORAGE) curStoresRes[path[i]->resource] -= gc->getRequired();
}
}
void GraphComponent::addChildInternal( GraphComponentPtr child )
{
child->parentChanging( this );
GraphComponent *previousParent = child->m_parent;
if( previousParent )
{
// remove the child from the previous parent, but don't emit parentChangedSignal.
// this prevents a parent changed signal with new parent 0 followed by a parent
// changed signal with the new parent.
previousParent->removeChildInternal( child, false );
}
m_children.push_back( child );
child->m_parent = this;
child->setName( child->m_name.value() ); // to force uniqueness
childAddedSignal()( this, child.get() );
child->parentChangedSignal()( child.get(), previousParent );
}
void WriteSimpleComponent(const GraphComponent<Graph>& gc,
const string& file_name, shared_ptr<GraphColorer<Graph>> colorer,
const GraphLabeler<Graph> &labeler) {
EmptyGraphLinker<Graph> linker;
ofstream os;
os.open(file_name);
omnigraph::visualization::ComponentVisualizer<Graph>(gc.g(), false).Visualize(gc, os, labeler, *colorer, linker);
os.close();
}
void HostFilterComponent::menuItemSelected (int menuItemID,
int topLevelMenuIndex)
{
Config* config = Config::getInstance();
GraphComponent* graph = main->getGraph ();
switch (topLevelMenuIndex)
{
case 0: // CommandCategories::file
{
// handle recent plugins selection
int fileID = menuItemID - CommandIDs::recentPlugins;
if (fileID >= 0 && fileID < config->recentPlugins.getNumFiles())
{
File fileToLoad = config->recentPlugins.getFile (fileID);
if (graph)
graph->loadAndAppendPlugin (config->recentPlugins.getFile (fileID), 100, 100);
break;
}
// handle recent session selection
fileID = menuItemID - CommandIDs::recentSessions;
if (fileID >= 0 && fileID < config->recentSessions.getNumFiles())
{
MemoryBlock fileData;
File fileToLoad = config->recentSessions.getFile (fileID);
if (fileToLoad.existsAsFile()
&& fileToLoad.loadFileAsData (fileData))
{
getFilter ()->setStateInformation (fileData.getData (), fileData.getSize());
Config::getInstance()->addRecentSession (fileToLoad);
Config::getInstance()->lastSessionFile = fileToLoad;
}
}
break;
}
}
toFront (true);
}
void WriteComponent(const GraphComponent<Graph>& gc,
const string& file_name, shared_ptr<GraphColorer<Graph>> colorer,
const GraphLabeler<Graph> &labeler) {
EmptyGraphLinker<Graph> linker;
BorderDecorator<Graph> component_colorer(gc, *colorer, "yellow");
ofstream os;
os.open(file_name);
omnigraph::visualization::ComponentVisualizer<Graph>(gc.g(), true).Visualize(gc, os, labeler, component_colorer, linker);
os.close();
}
static boost::python::list values( GraphComponent &c )
{
const GraphComponent::ChildContainer &ch = c.children();
boost::python::list l;
for( GraphComponent::ChildContainer::const_iterator it=ch.begin(); it!=ch.end(); it++ )
{
l.append( *it );
}
return l;
}
void GraphComponent::addChildInternal( GraphComponentPtr child, size_t index )
{
child->parentChanging( this );
GraphComponent *previousParent = child->m_parent;
if( previousParent )
{
// remove the child from the previous parent, but don't emit parentChangedSignal.
// this prevents a parent changed signal with new parent null followed by a parent
// changed signal with the new parent.
previousParent->removeChildInternal( child, false );
}
m_children.insert( m_children.begin() + min( index, m_children.size() ), child );
child->m_parent = this;
child->setName( child->m_name.value() ); // to force uniqueness
Signals::emitLazily( m_signals.get(), &Signals::childAddedSignal, this, child.get() );
child->parentChanged( previousParent );
Signals::emitLazily( child->m_signals.get(), &Signals::parentChangedSignal, child.get(), previousParent );
}
static Plug *loadStructParameter( const OSLQuery &query, const OSLQuery::Parameter *parameter, Gaffer::CompoundPlug *parent, bool keepExistingValues )
{
CompoundPlug *result = NULL;
const string name = plugName( parameter );
CompoundPlug *existingPlug = parent->getChild<CompoundPlug>( name );
if( existingPlug )
{
if( !keepExistingValues )
{
existingPlug->clearChildren();
}
result = existingPlug;
}
else
{
result = new CompoundPlug( name, parent->direction(), Plug::Default | Plug::Dynamic );
}
for( vector<string>::const_iterator it = parameter->fields.begin(), eIt = parameter->fields.end(); it != eIt; ++it )
{
std::string fieldName = parameter->name + "." + *it;
loadShaderParameter( query, query.getparam( fieldName ), result, keepExistingValues );
}
// remove any old plugs which it turned out we didn't need
if( keepExistingValues )
{
for( int i = result->children().size() - 1; i >= 0; --i )
{
GraphComponent *child = result->getChild<GraphComponent>( i );
if( std::find( parameter->fields.begin(), parameter->fields.end(), child->getName().string() ) == parameter->fields.end() )
{
result->removeChild( child );
}
}
}
parent->setChild( name, result );
return result;
}
static boost::python::list keys( GraphComponent &c )
{
const GraphComponent::ChildContainer &ch = c.children();
boost::python::list l;
for( GraphComponent::ChildContainer::const_iterator it=ch.begin(); it!=ch.end(); it++ )
{
l.append( (*it)->getName().c_str() );
}
return l;
}
static void delItem( GraphComponent &g, const char *n )
{
GraphComponentPtr c = g.getChild<GraphComponent>( n );
if( c )
{
g.removeChild( c );
return;
}
PyErr_SetString( PyExc_KeyError, n );
throw_error_already_set();
}
static boost::python::tuple children( GraphComponent &c, IECore::TypeId typeId )
{
const GraphComponent::ChildContainer &ch = c.children();
boost::python::list l;
for( GraphComponent::ChildContainer::const_iterator it=ch.begin(); it!=ch.end(); it++ )
{
if( (*it)->isInstanceOf( typeId ) )
{
l.append( *it );
}
}
return boost::python::tuple( l );
}
static GraphComponentPtr getItem( GraphComponent &g, long index )
{
long s = g.children().size();
if( index < 0 )
{
index += s;
}
if( index >= s || index < 0 )
{
PyErr_SetString( PyExc_IndexError, "GraphComponent index out of range" );
throw_error_already_set();
}
return g.getChild<GraphComponent>( index );
}
unsigned int InternalGraph::selectVertex(AntPath* pt, unsigned int cur, std::set<unsigned int> & available, bool& s, std::map<Element *, std::set<Link *> >& chan)
{
// choose request
unsigned int vertex = 0;
unsigned int size = available.size();
std::vector<double> roulette(size);
std::vector<unsigned int> rouletteIndex(size);
double value = 0, sum = 0;
unsigned int index = 0;
std::set<unsigned int>::iterator itEnd = available.end();
for (std::set<unsigned int>::iterator i = available.begin(); i != itEnd; i ++, index ++)
{
value = pow(arcs[cur][*i]->pher, pherDeg)*pow(arcs[cur][*i]->heur, heurDeg);
sum += value;
roulette[index] = sum;
rouletteIndex[index] = *i;
}
double choose = rand()/(double)RAND_MAX * sum;
if (ZERO(sum))
{
std::set<unsigned int>::iterator sel = available.begin();
vertex = *sel;
available.erase(sel);
}
else
{
for (unsigned int i = 0; i < size; ++ i)
{
if (choose < roulette[i])
{
vertex = rouletteIndex[i];
unsigned int res = available.erase(rouletteIndex[i]);
assert(res == 1);
break;
}
}
}
// choose resource
GraphComponent * gc = vertices[vertex-1];
unsigned int res = gc->chooseResource(curNodesRam, pherDeg, heurDeg);
if (res >= gc->getResNum())
{
// failed to choose a resource
s = false;
return vertex;
}
if (gc->getType() == GraphComponent::VMACHINE)
{
curNodesRes[res] -= gc->getRequired();
curNodesRam[res] -= gc->getRequiredRam();
updateInternalHeuristic(res, GraphComponent::VMACHINE);
std::map<Element *, std::set<Link *> >::iterator iter = chan.find(gc->getPointer());
std::set<Link *> * chanPtr = (iter != chan.end()) ? &(iter->second) : NULL;
pt->addElement(new PathElement(vertex, gc->getPointer(), res, physNodes[res], chanPtr));
}
else if (gc->getType() == GraphComponent::STORAGE)
{
curStoresRes[res] -= gc->getRequired();
updateInternalHeuristic(res, GraphComponent::STORAGE);
std::map<Element *, std::set<Link *> >::iterator iter = chan.find(gc->getPointer());
std::set<Link *> * chanPtr = (iter != chan.end()) ? &(iter->second) : NULL;
pt->addElement(new PathElement(vertex, gc->getPointer(), res, physStores[res], chanPtr));
}
s = true;
return vertex;
}
bool HostFilterComponent::perform (const InvocationInfo& info)
{
Config* config = Config::getInstance();
GraphComponent* graph = main->getGraph ();
Transport* transport = getFilter()->getTransport();
switch (info.commandID)
{
//----------------------------------------------------------------------------------------------
case CommandIDs::pluginOpen:
{
graph->loadAndAppendPlugin ();
break;
}
case CommandIDs::pluginClose:
{
graph->closeSelectedPlugins ();
break;
}
case CommandIDs::pluginClear:
{
graph->closeAllPlugins ();
break;
}
case CommandIDs::showPluginListEditor:
{
if (PluginListWindow::currentPluginListWindow == 0)
PluginListWindow::currentPluginListWindow = new PluginListWindow (knownPluginList);
PluginListWindow::currentPluginListWindow->toFront (true);
break;
}
//----------------------------------------------------------------------------------------------
#ifndef JOST_VST_PLUGIN
case CommandIDs::audioOptions:
{
StandaloneFilterWindow* window = findParentComponentOfClass ((StandaloneFilterWindow*) 0);
if (window)
window->showAudioSettingsDialog ();
break;
}
#endif
case CommandIDs::audioPlay:
{
transport->play ();
break;
}
case CommandIDs::audioPlayPause:
{
transport->togglePlay ();
break;
}
case CommandIDs::audioStop:
{
transport->stop ();
break;
}
case CommandIDs::audioRecord:
{
transport->record ();
break;
}
case CommandIDs::audioRewind:
{
transport->rewind ();
break;
}
case CommandIDs::audioLoop:
{
transport->setLooping (! transport->isLooping());
break;
}
//----------------------------------------------------------------------------------------------
case CommandIDs::sessionNew:
{
bool retValue =
AlertWindow::showYesNoCancelBox (AlertWindow::WarningIcon,
T("Unsaved Changes"),
T("Are you sure you want to close the current session? You may lose any unsaved changes."));
if (retValue)
{
closePluginEditorWindows ();
getFilter()->getHost ()->closeAllPlugins (true);
clearComponents ();
Config::getInstance()->lastSessionFile = File::nonexistent;
rebuildComponents ();
}
break;
}
case CommandIDs::sessionLoad:
{
FileChooser myChooser (T("Load a session file..."),
Config::getInstance ()->lastSessionDirectory,
JOST_SESSION_WILDCARD, JOST_USE_NATIVE_FILE_CHOOSER);
if (myChooser.browseForFileToOpen())
{
bool retValue =
AlertWindow::showYesNoCancelBox (AlertWindow::WarningIcon,
T("Unsaved Changes"),
T("Are you sure you want to close the current session? You may lose any unsaved changes."));
if (retValue)
{
MemoryBlock fileData;
File fileToLoad = myChooser.getResult();
if (fileToLoad.existsAsFile()
&& fileToLoad.loadFileAsData (fileData))
{
getFilter ()->setStateInformation (fileData.getData (), fileData.getSize());
Config::getInstance()->addRecentSession (fileToLoad);
Config::getInstance()->lastSessionFile = fileToLoad;
}
}
}
break;
}
case CommandIDs::sessionSave:
{
handleSaveCommand();
break;
}
case CommandIDs::sessionSaveNoPrompt:
{
handleSaveCommand(true);
break;
}
case CommandIDs::audioStemsStartStop:
{
getHost()->toggleStemRendering();
break;
}
case CommandIDs::audioStemsSetup:
{
FileChooser myChooser (T("Save Rendered Stem Files To..."),
Config::getInstance ()->lastStemsDirectory);
if (myChooser.browseForDirectory ())
{
Config::getInstance ()->lastStemsDirectory = myChooser.getResult();
}
break;
}
//----------------------------------------------------------------------------------------------
case CommandIDs::appToolbar:
{
toolbar->showCustomisationDialog (*factory,
Toolbar::allCustomisationOptionsEnabled);
// (Toolbar::allowIconsOnlyChoice | Toolbar::showResetToDefaultsButton));
break;
}
case CommandIDs::appBrowser:
{
setBrowserVisible (! config->showBrowser, config->browserLeft);
break;
}
case CommandIDs::appFullScreen:
{
DocumentWindow* window = findParentComponentOfClass <DocumentWindow> ();
if (window) {
window->setFullScreen (! window->isFullScreen ());
window->setMenuBar (window->isFullScreen () ? 0 : this);
}
break;
}
case CommandIDs::appExit:
{
deleteAndZero(PluginListWindow::currentPluginListWindow);
JUCEApplication::getInstance()->systemRequestedQuit();
break;
}
case CommandIDs::appAbout:
{
// Image* splashImage = ImageCache::getFromMemory (Resource::jost_about,
// Resource::jost_about_size);
// todo: move appResourcesFolder() to somewhere everyone can use it
#if JUCE_MAC
File appResourcesFolder(File::getSpecialLocation(File::currentApplicationFile).getChildFile("./Contents/Resources"));
#else
File appResourcesFolder(File::getSpecialLocation(File::currentApplicationFile).getParentDirectory());
#endif
File splashImageFile(appResourcesFolder.getChildFile("JiveAbout.png"));
Image* splashImage = ImageFileFormat::loadFrom(splashImageFile);
SplashScreen* splash = new SplashScreen();
splash->show (T(JucePlugin_Name), splashImage, 3500, false);
break;
}
//----------------------------------------------------------------------------------------------
default:
return false;
}
return true;
}
bool Check(const GraphComponent<Graph> &component) const {
return component.v_size() >= min_vertex_number_;
}
static GraphComponentPtr commonAncestor( GraphComponent &g, const GraphComponent *other, IECore::TypeId t )
{
return g.commonAncestor( other, t );
}
static GraphComponentPtr ancestor( GraphComponent &g, IECore::TypeId t )
{
return g.ancestor( t );
}
static int length( GraphComponent &g )
{
return g.children().size();
}
bool ContainsEdge(const GraphComponent<Graph>& component, EdgeId e) const {
return component.edges().find(e) != component.edges().end();
}
void RenderManShader::loadShaderParameters( const IECore::Shader *shader, Gaffer::CompoundPlug *parametersPlug, bool keepExistingValues )
{
const CompoundData *typeHints = shader->blindData()->member<CompoundData>( "ri:parameterTypeHints", true );
const StringVectorData *orderedParameterNamesData = shader->blindData()->member<StringVectorData>( "ri:orderedParameterNames", true );
const vector<string> &orderedParameterNames = orderedParameterNamesData->readable();
const StringVectorData *outputParameterNamesData = shader->blindData()->member<StringVectorData>( "ri:outputParameterNames", true );
const vector<string> &outputParameterNames = outputParameterNamesData->readable();
const CompoundData *annotations = shader->blindData()->member<CompoundData>( "ri:annotations", true );
// if we're not preserving existing values then remove all existing parameter plugs - the various
// plug creators above know that if a plug exists then they should preserve its values.
if( !keepExistingValues )
{
for( int i = parametersPlug->children().size() - 1; i >= 0; --i )
{
parametersPlug->removeChild( parametersPlug->getChild<GraphComponent>( i ) );
}
}
// make sure we have a plug to represent each parameter, reusing plugs wherever possible.
set<string> validPlugNames;
for( vector<string>::const_iterator it = orderedParameterNames.begin(), eIt = orderedParameterNames.end(); it != eIt; it++ )
{
if( std::find( outputParameterNames.begin(), outputParameterNames.end(), *it ) != outputParameterNames.end() )
{
continue;
}
// splines are represented by two parameters matched by a naming convention, and we map
// those two parameters to a single SplinePlug.
const bool endsWithValues = ends_with( *it, "Values" );
const bool endsWithPositions = ends_with( *it, "Positions" );
if( endsWithPositions || endsWithValues )
{
string plugName( *it, 0, it->size() - ( endsWithValues ? 6 : 9 ) );
if( validPlugNames.find( plugName ) != validPlugNames.end() )
{
continue;
}
// must use a smart pointers here because we may assign the data the parser creates (and which we therefore own)
ConstFloatVectorDataPtr positions = shader->parametersData()->member<FloatVectorData>( plugName + "Positions" );
ConstDataPtr values = shader->parametersData()->member<Data>( plugName + "Values" );
if( positions && values )
{
const StringData *defaultValuesAnnotation = annotations->member<StringData>( plugName + "Values.defaultValue" );
const StringData *defaultPositionsAnnotation = annotations->member<StringData>( plugName + "Positions.defaultValue" );
if( defaultValuesAnnotation )
{
DataPtr parsedValues;
if( values->isInstanceOf( Color3fVectorData::staticTypeId() ) )
{
parsedValues = parseColors( defaultValuesAnnotation->readable() );
}
else
{
parsedValues = parseFloats( defaultValuesAnnotation->readable() );
}
if( parsedValues )
{
values = parsedValues;
}
else
{
msg(
Msg::Warning, "RenderManShader::loadShaderParameters",
boost::format( "Unable to parse default value \"%s\" for parameter \"%s\"" ) % defaultValuesAnnotation->readable() % ( plugName + "Values" )
);
}
}
if( defaultPositionsAnnotation )
{
FloatVectorDataPtr parsedPositions = parseFloats( defaultPositionsAnnotation->readable() );
if( parsedPositions )
{
positions = parsedPositions;
}
else
{
msg(
Msg::Warning, "RenderManShader::loadShaderParameters",
boost::format( "Unable to parse default value \"%s\" for parameter \"%s\"" ) % defaultPositionsAnnotation->readable() % ( plugName + "Positions" )
);
}
}
switch( values->typeId() )
{
case FloatVectorDataTypeId :
loadSplineParameter<SplineffPlug>( parametersPlug, plugName, positions, values );
break;
case Color3fVectorDataTypeId :
loadSplineParameter<SplinefColor3fPlug>( parametersPlug, plugName, positions, values );
break;
default :
msg(
Msg::Warning, "RenderManShader::loadShaderParameters",
boost::format( "Spline \"%s\" has unsupported value type \"%s\"" ) % plugName % values->typeName()
);
}
validPlugNames.insert( plugName );
continue;
}
}
// the other parameter types map more simply to a single plug each.
const StringData *typeHint = typeHints->member<StringData>( *it, false );
const Data *defaultValue = shader->parametersData()->member<Data>( *it );
switch( defaultValue->typeId() )
{
case StringDataTypeId :
if( typeHint && typeHint->readable() == "shader" )
{
loadCoshaderParameter( parametersPlug, *it );
}
else
{
loadParameter<StringPlug>( parametersPlug, *it, static_cast<const StringData *>( defaultValue )->readable() );
}
break;
case FloatDataTypeId :
loadNumericParameter( parametersPlug, *it, static_cast<const FloatData *>( defaultValue )->readable(), annotations );
break;
case Color3fDataTypeId :
loadCompoundNumericParameter<Color3fPlug>( parametersPlug, *it, static_cast<const Color3fData *>( defaultValue )->readable(), annotations );
break;
case V3fDataTypeId :
loadCompoundNumericParameter<V3fPlug>( parametersPlug, *it, static_cast<const V3fData *>( defaultValue )->readable(), annotations );
break;
case StringVectorDataTypeId :
if( typeHint && typeHint->readable() == "shader" )
{
loadCoshaderArrayParameter( parametersPlug, *it, static_cast<const StringVectorData *>( defaultValue ) );
}
else
{
loadArrayParameter<StringVectorDataPlug>( parametersPlug, *it, defaultValue, annotations );
}
break;
case FloatVectorDataTypeId :
loadArrayParameter<FloatVectorDataPlug>( parametersPlug, *it, defaultValue, annotations );
break;
case Color3fVectorDataTypeId :
loadArrayParameter<Color3fVectorDataPlug>( parametersPlug, *it, defaultValue, annotations );
break;
case V3fVectorDataTypeId :
loadArrayParameter<V3fVectorDataPlug>( parametersPlug, *it, defaultValue, annotations );
break;
default :
msg(
Msg::Warning, "RenderManShader::loadShaderParameters",
boost::format( "Parameter \"%s\" has unsupported type \"%s\"" ) % *it % defaultValue->typeName()
);
}
validPlugNames.insert( *it );
}
// remove any old plugs which it turned out we didn't need
if( keepExistingValues )
{
for( int i = parametersPlug->children().size() - 1; i >= 0; --i )
{
GraphComponent *child = parametersPlug->getChild<GraphComponent>( i );
if( validPlugNames.find( child->getName().string() ) == validPlugNames.end() )
{
parametersPlug->removeChild( child );
}
}
}
}
//may be used for conjugate closure
GraphComponent(const GraphComponent& component, bool add_conjugate, const string &name = "") : graph_(component.graph_), name_(name)
// vertices_(component.vertices_.begin(), component.vertices_.end()),
// edges_(component.edges_.begin(), component.edges_.end())
{
Fill(component.v_begin(), component.v_end(), add_conjugate);
}
