void FullMasterCM::addSlave( Command& command, NodeMapObjectReplyPacket& reply ) { EQ_TS_THREAD( _cmdThread ); EQASSERT( command->type == PACKETTYPE_CO_NODE ); EQASSERT( command->command == CMD_NODE_MAP_OBJECT ); NodePtr node = command.getNode(); const NodeMapObjectPacket* packet = command.get< NodeMapObjectPacket >(); const uint128_t requested = packet->requestedVersion; const uint32_t instanceID = packet->instanceID; Mutex mutex( _slaves ); EQASSERT( _version != VERSION_NONE ); _checkConsistency(); // add to subscribers ++_slavesCount[ node->getNodeID() ]; _slaves->push_back( node ); stde::usort( *_slaves ); if( requested == VERSION_NONE ) // no data to send { _sendEmptyVersion( node, instanceID, _version ); reply.version = _version; return; } const uint128_t oldest = _instanceDatas.front()->os.getVersion(); uint128_t start = (requested == VERSION_OLDEST || requested < oldest ) ? oldest : requested; uint128_t end = _version; const bool useCache = packet->masterInstanceID == _object->getInstanceID(); #ifndef NDEBUG if( requested != VERSION_OLDEST && requested < start ) EQINFO << "Mapping version " << start << " instead of requested version " << requested << std::endl; #endif reply.version = start; reply.useCache = packet->useCache && useCache; if( reply.useCache ) { if( packet->minCachedVersion <= start && packet->maxCachedVersion >= start ) { #ifdef EQ_INSTRUMENT_MULTICAST _hit += packet->maxCachedVersion + 1 - start; #endif start = packet->maxCachedVersion + 1; } else if( packet->maxCachedVersion == end ) { end = EQ_MAX( start, packet->minCachedVersion - 1 ); #ifdef EQ_INSTRUMENT_MULTICAST _hit += _version - end; #endif } // TODO else cached block in the middle, send head and tail elements } #if 0 EQLOG( LOG_OBJECTS ) << *_object << ", instantiate on " << node->getNodeID() << " with v" << ((requested == VERSION_OLDEST) ? oldest : requested) << " (" << requested << ") sending " << start << ".." << end << " have " << _version - _nVersions << ".." << _version << " " << _instanceDatas.size() << std::endl; #endif EQASSERT( start >= oldest ); // send all instance datas from start..end InstanceDataDeque::iterator i = _instanceDatas.begin(); while( i != _instanceDatas.end() && (*i)->os.getVersion() < start ) ++i; for( ; i != _instanceDatas.end() && (*i)->os.getVersion() <= end; ++i ) { InstanceData* data = *i; EQASSERT( data ); data->os.sendMapData( node, instanceID ); #ifdef EQ_INSTRUMENT_MULTICAST ++_miss; #endif } #ifdef EQ_INSTRUMENT_MULTICAST if( _miss % 100 == 0 ) EQINFO << "Cached " << _hit << "/" << _hit + _miss << " instance data transmissions" << std::endl; #endif }
Path get_shorten_path(GameMap &gmap, const NodePtr &src, const NodePtr &dest) { OpenSet open_set; CloseSet closed_set; Path _tmpPath; bool found = false; NodePtr cur_node; NodePtr next_node; NodesMap nodes_map; // add to OPEN_SET open_set.insert(make_pair<unsigned long, Coordinate>(src->get_f(),src->get_coordinate())); nodes_map.insert(make_pair<Coordinate,NodePtr>(src->get_coordinate(), src)); while (!open_set.empty() && !found) { cur_node = nodes_map[open_set.begin()->second]; closed_set.insert(cur_node->get_coordinate()); open_set.erase(find_if(open_set.begin(), open_set.end(),\ boost::lambda::bind(&OpenSet::value_type::second,boost::lambda::_1) == \ cur_node->get_coordinate())); if (cur_node->get_coordinate() == dest->get_coordinate()) { // arrived found = true; // re-path; NodePtr _res_tmp = cur_node; while (_res_tmp != NULL) { _tmpPath.push_front(_res_tmp); _res_tmp = _res_tmp->get_parent(); } break; // open_set } AdjNodes adjnode_set = gmap.get_adjnodes(cur_node->get_coordinate()); AdjNodes::iterator it = adjnode_set.begin(); for (; it != adjnode_set.end(); ++it) { // can't get through, like wall; // already in closed set; // ignore it; if (!gmap.can_get_through(*it) || \ closed_set.count(*it) != 0) { continue; } unsigned long new_g = cur_node->get_g() + gmap.get_steps(*it); bool better = false; OpenSet::iterator fit = find_if(open_set.begin(), open_set.end(), boost::lambda::bind(&OpenSet::value_type::second,\ boost::lambda::_1)== (*it)); if (fit == open_set.end()) { better = true; } else { if (new_g < nodes_map[fit->second]->get_g()) { better = true; } } if (better) { NodePtr _tmp(new Node(*it)); _tmp->set_g(new_g); _tmp->set_f(gmap.get_distance(*it, dest->get_coordinate())); _tmp->set_parent(cur_node); open_set.insert(make_pair<unsigned long,Coordinate>(_tmp->get_f(),*it)); // update nodes_map[*it] = _tmp; } } // for } // while return _tmpPath; }
void GuiAppInstance::createNodeGui(const NodePtr &node, const NodePtr& parentMultiInstance, const CreateNodeArgs& args) { NodeCollectionPtr group = node->getGroup(); NodeGraph* graph; if (group) { NodeGraphI* graph_i = group->getNodeGraph(); assert(graph_i); graph = dynamic_cast<NodeGraph*>(graph_i); assert(graph); } else { graph = _imp->_gui->getNodeGraph(); } if (!graph) { throw std::logic_error(""); } NodesGuiList selectedNodes = graph->getSelectedNodes(); NodeGuiPtr nodegui = _imp->_gui->createNodeGUI(node, args); assert(nodegui); if (parentMultiInstance && nodegui) { nodegui->hideGui(); NodeGuiIPtr parentNodeGui_i = parentMultiInstance->getNodeGui(); assert(parentNodeGui_i); nodegui->setParentMultiInstance( boost::dynamic_pointer_cast<NodeGui>(parentNodeGui_i) ); } bool isViewer = node->isEffectViewerInstance() != 0; if (isViewer) { _imp->_gui->createViewerGui(node); } // Must be done after the viewer gui has been created _imp->_gui->createNodeViewerInterface(nodegui); NodeGroupPtr isGroup = node->isEffectNodeGroup(); if ( isGroup && isGroup->isSubGraphUserVisible() ) { _imp->_gui->createGroupGui(node, args); } ///Don't initialize inputs if it is a multi-instance child since it is not part of the graph if (!parentMultiInstance) { nodegui->initializeInputs(); } NodeSerializationPtr serialization = args.getProperty<NodeSerializationPtr >(kCreateNodeArgsPropNodeSerialization); if ( !serialization && !isViewer ) { ///we make sure we can have a clean preview. node->computePreviewImage( getTimeLine()->currentFrame() ); triggerAutoSave(); } ///only move main instances if ( node->getParentMultiInstanceName().empty() && !serialization) { bool autoConnect = args.getProperty<bool>(kCreateNodeArgsPropAutoConnect); if ( selectedNodes.empty() || serialization) { autoConnect = false; } double xPosHint = serialization ? INT_MIN : args.getProperty<double>(kCreateNodeArgsPropNodeInitialPosition, 0); double yPosHint = serialization ? INT_MIN : args.getProperty<double>(kCreateNodeArgsPropNodeInitialPosition, 1); if ( (xPosHint != INT_MIN) && (yPosHint != INT_MIN) && (!autoConnect) ) { QPointF pos = nodegui->mapToParent( nodegui->mapFromScene( QPointF(xPosHint, yPosHint) ) ); nodegui->refreshPosition( pos.x(), pos.y(), true ); } else { BackdropGuiPtr isBd = toBackdropGui(nodegui); if (!isBd) { NodeGuiPtr selectedNode; if ( !serialization && (selectedNodes.size() == 1) ) { selectedNode = selectedNodes.front(); BackdropGuiPtr isBdGui = toBackdropGui(selectedNode); if (isBdGui) { selectedNode.reset(); } } nodegui->getDagGui()->moveNodesForIdealPosition(nodegui, selectedNode, autoConnect); } } } } // createNodeGui
//------------------------------------------------------------------------- bool Node::walk(WalkSink &inWalker, const FilterList *inFilterList) const { // walks the tree in a non-recursive way to protect the stack from overflowing ULONG mask = ZS_INTERNAL_XML_FILTER_BIT_MASK_ALL; if (inFilterList) { mask = 0; for (FilterList::const_iterator iter = inFilterList->begin(); iter != inFilterList->end(); ++iter) { mask = mask | getMaskBit(*iter); } } NodePtr startChild = toNode(); NodePtr child = startChild; bool allowChildren = true; while (child) { NodePtr nextSibling = child->getNextSibling(); // just in case the current element was orphaned NodePtr nextParent = child->getParent(); bool doContinue = false; while (allowChildren) // using as a scope rather than as a loop { if (0 != (mask & getMaskBit(child->getNodeType()))) { bool result = false; switch (child->getNodeType()) { case NodeType::Document: result = inWalker.onDocumentEnter(child->toDocument()); break; case NodeType::Element: result = inWalker.onElementEnter(child->toElement()); break; case NodeType::Attribute: result = inWalker.onAttribute(child->toAttribute()); break; case NodeType::Text: result = inWalker.onText(child->toText()); break; case NodeType::Comment: result = inWalker.onComment(child->toComment()); break; case NodeType::Declaration: result = inWalker.onDeclarationEnter(child->toDeclaration()); break; case NodeType::Unknown: result = inWalker.onUnknown(child->toUnknown()); break; } if (result) return true; if ((child->getNextSibling() != nextSibling) || (child->getParent() != nextParent)) { // the node was orphaned, do not process its children anymore break; } } AttributePtr attribute; if (child->isElement()) { ElementPtr element = child->toElement(); attribute = element->getFirstAttribute(); } else if (child->isDeclaration()) { DeclarationPtr declaration = child->toDeclaration(); attribute = declaration->getFirstAttribute(); } // walk the attributes if (attribute) { if (0 != (mask & getMaskBit(attribute->getNodeType()))) { while (attribute) { NodePtr next = attribute->getNextSibling(); // need to do this in advanced in case the attribute is orphaned if (inWalker.onAttribute(attribute)) return true; if (!next) break; attribute = next->toAttribute(); } } } if (child->getFirstChild()) { child = child->getFirstChild(); doContinue = true; break; } break; // not really intending to loop } if (doContinue) continue; if ((child->isDeclaration()) && (0 != (mask & ZS_INTERNAL_XML_FILTER_BIT_DECLARATION))) { // reached the exit point for the declaration if (inWalker.onDeclarationExit(child->toDeclaration())) return true; } // going to be exiting this node node by way of the sibling or the parent (but only do exit for nodes that have exit) if ((child->isElement()) && (0 != (mask & ZS_INTERNAL_XML_FILTER_BIT_ELEMENT))) { if (inWalker.onElementExit(child->toElement())) return true; } if ((child->isDocument()) && (0 != (mask & ZS_INTERNAL_XML_FILTER_BIT_DOCUMENT))) { if (inWalker.onDocumentExit(child->toDocument())) return true; } if (nextSibling) { // can't go to the next sibling if on the root if (child == startChild) break; allowChildren = true; child = nextSibling; continue; } // cannot walk above the start child if (child == startChild) break; child = nextParent; allowChildren = false; } return false; }
bool Project::restoreGroupFromSerialization(const SERIALIZATION_NAMESPACE::NodeSerializationList & serializedNodes, const NodeCollectionPtr& group, std::list<std::pair<NodePtr, SERIALIZATION_NAMESPACE::NodeSerializationPtr > >* createdNodesOut) { bool mustShowErrorsLog = false; NodeGroupPtr isGrp = toNodeGroup(group); QString groupName; if (isGrp) { groupName = QString::fromUtf8( isGrp->getNode()->getLabel().c_str() ); } else { groupName = tr("top-level"); } group->getApplication()->updateProjectLoadStatus( tr("Creating nodes in group: %1").arg(groupName) ); std::list<std::pair<NodePtr, SERIALIZATION_NAMESPACE::NodeSerializationPtr > > createdNodes; // Loop over all node serialization and create them first for (SERIALIZATION_NAMESPACE::NodeSerializationList::const_iterator it = serializedNodes.begin(); it != serializedNodes.end(); ++it) { NodePtr node = appPTR->createNodeForProjectLoading(*it, group); if (!node) { QString text( tr("ERROR: The node %1 version %2.%3" " was found in the script but does not" " exist in the loaded plug-ins.") .arg( QString::fromUtf8( (*it)->_pluginID.c_str() ) ) .arg((*it)->_pluginMajorVersion).arg((*it)->_pluginMinorVersion) ); appPTR->writeToErrorLog_mt_safe(tr("Project"), QDateTime::currentDateTime(), text); mustShowErrorsLog = true; continue; } else { if (node->getPluginID() == PLUGINID_NATRON_STUB) { // If the node could not be created and we made a stub instead, warn the user QString text( tr("WARNING: The node %1 (%2 version %3.%4) " "was found in the script but the plug-in could not be found. It has been replaced by a pass-through node instead.") .arg( QString::fromUtf8( (*it)->_nodeScriptName.c_str() ) ) .arg( QString::fromUtf8( (*it)->_pluginID.c_str() ) ) .arg((*it)->_pluginMajorVersion) .arg((*it)->_pluginMinorVersion)); appPTR->writeToErrorLog_mt_safe(tr("Project"), QDateTime::currentDateTime(), text); mustShowErrorsLog = true; } else if ( (*it)->_pluginMajorVersion != -1 && (node->getMajorVersion() != (int)(*it)->_pluginMajorVersion) ) { // If the node has a IOContainer don't do this check: when loading older projects that had a // ReadOIIO node for example in version 2, we would now create a new Read meta-node with version 1 instead QString text( tr("WARNING: The node %1 (%2 version %3.%4) " "was found in the script but was loaded " "with version %5.%6 instead.") .arg( QString::fromUtf8( (*it)->_nodeScriptName.c_str() ) ) .arg( QString::fromUtf8( (*it)->_pluginID.c_str() ) ) .arg((*it)->_pluginMajorVersion) .arg((*it)->_pluginMinorVersion) .arg( node->getPlugin()->getPropertyUnsafe<unsigned int>(kNatronPluginPropVersion, 0) ) .arg( node->getPlugin()->getPropertyUnsafe<unsigned int>(kNatronPluginPropVersion, 1) ) ); appPTR->writeToErrorLog_mt_safe(tr("Project"), QDateTime::currentDateTime(), text); } } assert(node); createdNodes.push_back(std::make_pair(node, *it)); } // for all node serialization group->getApplication()->updateProjectLoadStatus( tr("Restoring graph links in group: %1").arg(groupName) ); // Connect the nodes together for (std::list<std::pair<NodePtr, SERIALIZATION_NAMESPACE::NodeSerializationPtr > >::const_iterator it = createdNodes.begin(); it != createdNodes.end(); ++it) { // Loop over the inputs map // This is a map <input label, input node name> // // When loading projects before Natron 2.2, the inputs contain both masks and inputs. // restoreInputs(it->first, it->second->_inputs, createdNodes, false /*isMasks*/); // After Natron 2.2, masks are saved separatly restoreInputs(it->first, it->second->_masks, createdNodes, true /*isMasks*/); } // for (std::list< NodeSerializationPtr >::const_iterator it = serializedNodes.begin(); it != serializedNodes.end(); ++it) { if (createdNodesOut) { *createdNodesOut = createdNodes; } // If we created all sub-groups recursively, then we are in the top-level group. We may now restore all links if (!group->getApplication()->isCreatingNode()) { // Now that we created all nodes. There may be cross-graph link(s) and they can only be truely restored now. restoreLinksRecursive(group, serializedNodes, createdNodesOut); } return !mustShowErrorsLog; } // ProjectPrivate::restoreGroupFromSerialization
int main(int argc, char **argv) { osgInit(argc,argv); // GLUT init glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); int id=glutCreateWindow("OpenSG"); glutReshapeFunc(reshape); glutDisplayFunc(display); glutIdleFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(keyboard); GLUTWindowPtr gwin=GLUTWindow::create(); gwin->setId(id); gwin->init(); // create the scene // NodePtr scene = makeTorus(.5, 2, 16, 16); NodePtr scene = Node::create(); beginEditCP(scene); scene->setCore(Group::create()); endEditCP(scene); // create the SimpleSceneManager helper mgr = new SimpleSceneManager; // tell the manager what to manage mgr->setWindow(gwin ); mgr->setRoot (scene); DisplayFilterForegroundPtr fg = DisplayFilterForeground::create(); beginEditCP(fg); // add filter endEditCP(fg); // take the viewport ViewportPtr vp = gwin->getPort(0); beginEditCP(vp); vp->editMFForegrounds()->push_back(fg); endEditCP (vp); colorFilterPtr = ColorDisplayFilter::create(); distortionFilterPtr = DistortionDisplayFilter::create(); resolutionFilterPtr = ResolutionDisplayFilter::create(); beginEditCP(colorFilterPtr); beginEditCP(resolutionFilterPtr); beginEditCP(distortionFilterPtr); beginEditCP(fg); colorFilterPtr->setMatrix(osg::Matrix(0,0,1,0, 1,0,0,0, 0,1,0,0, 0,0,0,1)); resolutionFilterPtr->setDownScale(0.25); distortionFilterPtr->setColumns(2); distortionFilterPtr->setRows(2); distortionFilterPtr->editMFPositions()->push_back(Vec2f(0,.5)); distortionFilterPtr->editMFPositions()->push_back(Vec2f(.5,0)); distortionFilterPtr->editMFPositions()->push_back(Vec2f(.5,1)); distortionFilterPtr->editMFPositions()->push_back(Vec2f(1,.5)); fg->editMFFilter()->push_back(colorFilterPtr); fg->editMFFilter()->push_back(resolutionFilterPtr); fg->editMFFilter()->push_back(distortionFilterPtr); endEditCP(distortionFilterPtr); endEditCP(colorFilterPtr); endEditCP(resolutionFilterPtr); endEditCP(fg); for(UInt32 a=1 ; a<argc ;a++) { NodePtr file = SceneFileHandler::the().read(argv[a],0); if(file != NullFC) scene->addChild(file); else std::cerr << "Couldn't load file, ignoring " << argv[a] << std::endl; } if ( scene->getNChildren() == 0 ) { scene->addChild(makeTorus( .5, 2, 16, 16 )); // scene->addChild(makeBox(.6,.6,.6,5,5,5)); } // show the whole scene mgr->showAll(); // GLUT main loop glutMainLoop(); return 0; }
typename ThetaStar<ProblemType, Hasher>::SolutionPtr ThetaStar<ProblemType, Hasher>::operator() ( const ProblemType& problem ) { SolutionPtr solution(nullptr); this->visits = 0; this->maxNodesInMemory = 0; NodePtr initialStateNode = this->createNode( problem.initialState() ); this->fringe->push(initialStateNode); //clock_t begin = clock(); while( !solution && !this->fringe->empty() ) { if(this->fringe->size() + this->closedList.size() > this->maxNodesInMemory) this->maxNodesInMemory = this->fringe->size() + this->closedList.size(); this->visits++; NodePtr currentNode = this->fringe->pop(); this->notifyNodeVisitListeners(currentNode); if( problem.isGoal( currentNode->getState() ) ) { solution = SolutionPtr(new SolutionType(currentNode)); continue; } std::pair<const State*, NodePtr> entry(¤tNode->getState(), currentNode); this->closedList.insert(entry); this->notifyNodeClosureListeners(currentNode); std::list<NodePtr>&& successors = this->expand(currentNode, problem); for(NodePtr node: successors) { auto nodeIt = this->closedList.find(&node->getState()); if(nodeIt == this->closedList.end()) { if(node->hasParent()) { if(node->getParent()->hasParent()) { auto grandParent = node->getParent()->getParent(); auto actionAndCost = (*lineOfSight)(node->getState(), grandParent->getState()); if(actionAndCost.first != nullptr) { node->setParent(grandParent, *actionAndCost.first, actionAndCost.second); } } } this->fringe->push(node); } } } //clock_t end = clock(); //double timeSpend = (double)(end - begin) / CLOCKS_PER_SEC; //std::cout << "Spent " << timeSpend << " seconds on " << visit << " visits (" << visit/timeSpend << " n/s)" << std::endl; this->cleanUp(); return solution; }
void ProgressPanel::startTask(const NodePtr& node, const int firstFrame, const int lastFrame, const int frameStep, const bool canPause, const bool canCancel, const QString& message, const boost::shared_ptr<ProcessHandler>& process) { assert(QThread::currentThread() == qApp->thread()); if (!node) { return; } assert((canPause && firstFrame != INT_MIN && lastFrame != INT_MAX) || !canPause); ProgressTaskInfoPtr task; { QMutexLocker k(&_imp->tasksMutex); task = _imp->findTask(node); } if (task) { task->cancelTask(false, 1); removeTaskFromTable(task); } QMutexLocker k(&_imp->tasksMutex); task.reset(new ProgressTaskInfo(this, node, firstFrame, lastFrame, frameStep, canPause, canCancel, message, process)); if (canPause || node->getEffectInstance()->isOutput()) { task->createItems(); QTimer::singleShot(NATRON_DISPLAY_PROGRESS_PANEL_AFTER_MS, this, SLOT(onShowProgressPanelTimerTriggered())); } if (process) { connectProcessSlots(task.get(), process.get()); } if (!process) { if (node->getEffectInstance()->isOutput()) { OutputEffectInstance* isOutput = dynamic_cast<OutputEffectInstance*>(node->getEffectInstance().get()); if (isOutput) { RenderEngine* engine = isOutput->getRenderEngine(); assert(engine); QObject::connect(engine,SIGNAL(frameRendered(int,double)), task.get(), SLOT(onRenderEngineFrameComputed(int,double))); QObject::connect(engine, SIGNAL(renderFinished(int)), task.get(), SLOT(onRenderEngineStopped(int))); QObject::connect(task.get(),SIGNAL(taskCanceled()),engine,SLOT(abortRendering_Blocking())); } } }
PickKnobDialog::PickKnobDialog(DockablePanel* panel, QWidget* parent) : QDialog(parent) , _imp( new PickKnobDialogPrivate(panel) ) { NodeSettingsPanel* nodePanel = dynamic_cast<NodeSettingsPanel*>(panel); assert(nodePanel); if (!nodePanel) { throw std::logic_error("PickKnobDialog::PickKnobDialog()"); } NodeGuiPtr nodeGui = nodePanel->getNodeGui(); NodePtr node = nodeGui->getNode(); NodeGroupPtr isGroup = node->isEffectNodeGroup(); NodeCollectionPtr collec = node->getGroup(); NodeGroupPtr isCollecGroup = toNodeGroup(collec); NodesList collectNodes = collec->getNodes(); for (NodesList::iterator it = collectNodes.begin(); it != collectNodes.end(); ++it) { if ((*it)->isActivated() && (*it)->getNodeGui() && ( (*it)->getKnobs().size() > 0 ) ) { _imp->allNodes.push_back(*it); } } if (isCollecGroup) { _imp->allNodes.push_back( isCollecGroup->getNode() ); } if (isGroup) { NodesList groupnodes = isGroup->getNodes(); for (NodesList::iterator it = groupnodes.begin(); it != groupnodes.end(); ++it) { if ( (*it)->getNodeGui() && (*it)->isActivated() && ( (*it)->getKnobs().size() > 0 ) ) { _imp->allNodes.push_back(*it); } } } QStringList nodeNames; for (NodesList::iterator it = _imp->allNodes.begin(); it != _imp->allNodes.end(); ++it) { QString name = QString::fromUtf8( (*it)->getLabel().c_str() ); nodeNames.push_back(name); } nodeNames.sort(); _imp->mainLayout = new QGridLayout(this); _imp->selectNodeLabel = new Label( tr("Node:") ); _imp->nodeSelectionCombo = new CompleterLineEdit(nodeNames, nodeNames, false, this); _imp->nodeSelectionCombo->setToolTip( NATRON_NAMESPACE::convertFromPlainText(tr("Input the name of a node in the current project."), NATRON_NAMESPACE::WhiteSpaceNormal) ); _imp->nodeSelectionCombo->setFocus(Qt::PopupFocusReason); _imp->knobSelectionCombo = new ComboBox(this); QObject::connect( _imp->knobSelectionCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(onKnobComboIndexChanged(int)) ); QString useAliasTt = NATRON_NAMESPACE::convertFromPlainText(tr("If checked, an alias of the selected parameter will be created, coyping entirely its state. " "Only the script-name, label and tooltip will be editable.\n" "For choice parameters this will also " "dynamically refresh the menu entries when the original parameter's menu is changed.\n" "When unchecked, a simple expression will be set linking the two parameters, but things such as dynamic menus " "will be disabled."), NATRON_NAMESPACE::WhiteSpaceNormal); _imp->useAliasLabel = new Label(tr("Make Alias:"), this); _imp->useAliasLabel->setToolTip(useAliasTt); _imp->useAliasCheckBox = new QCheckBox(this); _imp->useAliasCheckBox->setToolTip(useAliasTt); _imp->useAliasCheckBox->setChecked(true); QObject::connect( _imp->nodeSelectionCombo, SIGNAL(itemCompletionChosen()), this, SLOT(onNodeComboEditingFinished()) ); _imp->destPageLabel = new Label(tr("Page:"), this); QString pagett = NATRON_NAMESPACE::convertFromPlainText(tr("Select the page into which the parameter will be created."), NATRON_NAMESPACE::WhiteSpaceNormal); _imp->destPageLabel->setToolTip(pagett); _imp->destPageCombo = new ComboBox(this); _imp->destPageCombo->setToolTip(pagett); QObject::connect( _imp->destPageCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(onPageComboIndexChanged(int)) ); const KnobsVec& knobs = node->getKnobs(); for (std::size_t i = 0; i < knobs.size(); ++i) { if ( knobs[i]->isUserKnob() ) { KnobPagePtr isPage = toKnobPage(knobs[i]); if (isPage) { _imp->pages.push_back(isPage); _imp->destPageCombo->addItem( QString::fromUtf8( isPage->getName().c_str() ) ); } else { KnobGroupPtr isGrp = toKnobGroup(knobs[i]); if (isGrp) { _imp->groups.push_back(isGrp); } } } } if (_imp->destPageCombo->count() == 0) { _imp->destPageLabel->hide(); _imp->destPageCombo->hide(); } _imp->groupLabel = new Label(tr("Group:"), this); QString grouptt = NATRON_NAMESPACE::convertFromPlainText(tr("Select the group into which the parameter will be created."), NATRON_NAMESPACE::WhiteSpaceNormal); _imp->groupCombo = new ComboBox(this); _imp->groupLabel->setToolTip(grouptt); _imp->groupCombo->setToolTip(grouptt); onPageComboIndexChanged(0); _imp->buttons = new DialogButtonBox(QDialogButtonBox::StandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel), Qt::Horizontal, this); QObject::connect( _imp->buttons, SIGNAL(accepted()), this, SLOT(accept()) ); QObject::connect( _imp->buttons, SIGNAL(rejected()), this, SLOT(reject()) ); _imp->mainLayout->addWidget(_imp->selectNodeLabel, 0, 0, 1, 1); _imp->mainLayout->addWidget(_imp->nodeSelectionCombo, 0, 1, 1, 1); _imp->mainLayout->addWidget(_imp->knobSelectionCombo, 0, 2, 1, 1); _imp->mainLayout->addWidget(_imp->useAliasLabel, 1, 0, 1, 1); _imp->mainLayout->addWidget(_imp->useAliasCheckBox, 1, 1, 1, 1); _imp->mainLayout->addWidget(_imp->destPageLabel, 2, 0, 1, 1); _imp->mainLayout->addWidget(_imp->destPageCombo, 2, 1, 1, 1); _imp->mainLayout->addWidget(_imp->groupLabel, 2, 2, 1, 1); _imp->mainLayout->addWidget(_imp->groupCombo, 2, 3, 1, 1); _imp->mainLayout->addWidget(_imp->buttons, 3, 0, 1, 3); QTimer::singleShot( 25, _imp->nodeSelectionCombo, SLOT(showCompleter()) ); }
//------------------------------------------------------------------------------ // The main method //------------------------------------------------------------------------------ int main(int argc, char **argv) { osgInit(argc, argv); // initialize OpenSG int winid = setupGLUT(&argc, argv); // initialize GLUT // the connection between GLUT and OpenSG is established GLUTWindowPtr gwin = GLUTWindow::create(); gwin->setId(winid); gwin->init(); //----------------------------------------------------------------------------// // Snippet-1-1 - BEGIN // //----------------------------------------------------------------------------// // very first step: load the configuration of the file structures, basically // paths are set. The Configuration always has to be loaded first since each // module uses the paths set in the configuration-file if (!Configuration::loadConfig("config/general.xml")) { printf("Error: could not load config-file!\n"); return -1; } //----------------------------------------------------------------------------// // Snippet-1-1 - END // //----------------------------------------------------------------------------// //----------------------------------------------------------------------------// // Snippet-2-4 - BEGIN // //----------------------------------------------------------------------------// // register callbacks InputInterface::registerModuleInitCallback(initInputInterface); SystemCore::registerModuleInitCallback(initModules); //----------------------------------------------------------------------------// // Snippet-2-4 - END // //----------------------------------------------------------------------------// //----------------------------------------------------------------------------// // Snippet-3-3 - BEGIN // //----------------------------------------------------------------------------// SystemCore::registerCoreComponentInitCallback(initCoreComponents); //----------------------------------------------------------------------------// // Snippet-3-3 - END // //----------------------------------------------------------------------------// //----------------------------------------------------------------------------// // Snippet-1-2 - BEGIN // //----------------------------------------------------------------------------// std::string systemCoreConfigFile = Configuration::getString( "SystemCore.systemCoreConfiguration"); std::string outputInterfaceConfigFile = Configuration::getString( "Interfaces.outputInterfaceConfiguration"); // // !!!!!! Remove in tutorial part 2, Snippet-2-1 - BEGIN // if (!SystemCore::configure(systemCoreConfigFile, outputInterfaceConfigFile)) { // printf("Error: failed to setup SystemCore!\n"); // return -1; // } // // !!!!!! Remove - END //----------------------------------------------------------------------------// // Snippet-1-2 - END // //----------------------------------------------------------------------------// //----------------------------------------------------------------------------// // Snippet-2-1 - BEGIN // //----------------------------------------------------------------------------// // !!!!!! Remove part of Snippet-1-2 (right above) // in addition to the SystemCore config file, modules and interfaces config // files have to be loaded. std::string modulesConfigFile = Configuration::getString( "Modules.modulesConfiguration"); std::string inputInterfaceConfigFile = Configuration::getString( "Interfaces.inputInterfaceConfiguration"); if (!SystemCore::configure(systemCoreConfigFile, outputInterfaceConfigFile, inputInterfaceConfigFile, modulesConfigFile)) { printf("Error: failed to setup SystemCore!\n"); printf("Please check if the Plugins-path is correctly set to the inVRs-lib directory in the "); printf("'final/config/general.xml' config file, e.g.:\n"); printf("<path name=\"Plugins\" path=\"/home/guest/inVRs/lib\"/>\n"); return -1; } //----------------------------------------------------------------------------// // Snippet-2-1 - END // //----------------------------------------------------------------------------// //----------------------------------------------------------------------------// // Snippet-3-1 - BEGIN // //----------------------------------------------------------------------------// // generate or load and configure height maps of the used tiles HeightMapManager::generateTileHeightMaps(); //----------------------------------------------------------------------------// // Snippet-3-1 - END // //----------------------------------------------------------------------------// //----------------------------------------------------------------------------// // Snippet-2-15 - BEGIN // //----------------------------------------------------------------------------// // generate and configure the SkyBox std::string skyPath = Configuration::getPath("Skybox"); skybox.init(5,5,5, 1000, (skyPath+"lostatseaday/lostatseaday_dn.jpg").c_str(), (skyPath+"lostatseaday/lostatseaday_up.jpg").c_str(), (skyPath+"lostatseaday/lostatseaday_ft.jpg").c_str(), (skyPath+"lostatseaday/lostatseaday_bk.jpg").c_str(), (skyPath+"lostatseaday/lostatseaday_rt.jpg").c_str(), (skyPath+"lostatseaday/lostatseaday_lf.jpg").c_str()); //----------------------------------------------------------------------------// // Snippet-2-15 - END // //----------------------------------------------------------------------------// NodePtr root = Node::create(); beginEditCP(root); root->setCore(Group::create()); //----------------------------------------------------------------------------// // Snippet-1-3 - BEGIN // //----------------------------------------------------------------------------// OpenSGSceneGraphInterface* sgIF = dynamic_cast<OpenSGSceneGraphInterface*>(OutputInterface::getSceneGraphInterface()); if (!sgIF) { printf("Error: Failed to get OpenSGSceneGraphInterface!\n"); printf("Please check if the OutputInterface configuration is correct!\n"); return -1; } // retrieve root node of the SceneGraphInterface (method is OpenSG specific) NodePtr scene = sgIF->getNodePtr(); root->addChild(scene); //----------------------------------------------------------------------------// // Snippet-1-3 - END // //----------------------------------------------------------------------------// //----------------------------------------------------------------------------// // Snippet-2-16 - BEGIN // //----------------------------------------------------------------------------// // add the SkyBox to the scene root->addChild(skybox.getNodePtr()); //----------------------------------------------------------------------------// // Snippet-2-16 - END // //----------------------------------------------------------------------------// endEditCP(root); //----------------------------------------------------------------------------// // Snippet-2-5 - BEGIN // //----------------------------------------------------------------------------// // fetch users camera, it is used to tell the Navigator where we are localUser = UserDatabase::getLocalUser(); if (!localUser) { printd(ERROR, "Error: Could not find localUser!\n"); return -1; } camera = localUser->getCamera(); if (!camera) { printd(ERROR, "Error: Could not find camera!\n"); return -1; } avatar = localUser->getAvatar(); if (!avatar) { printd(ERROR, "Error: Could not find avatar!\n"); return -1; } avatar->showAvatar(false); // set our transformation to the start transformation TransformationData startTrans = WorldDatabase::getEnvironmentWithId(1)->getStartTransformation(0); localUser->setNavigatedTransformation(startTrans); //----------------------------------------------------------------------------// // Snippet-2-5 - END // //----------------------------------------------------------------------------// mgr = new SimpleSceneManager; // create the SimpleSceneManager mgr->setWindow(gwin); // tell the manager what to manage mgr->setRoot(root); // attach the scenegraph to the root node mgr->showAll(); // show the whole scene mgr->getCamera()->setNear(0.1); //----------------------------------------------------------------------------// // Snippet-2-6 - BEGIN // //----------------------------------------------------------------------------// // Navigator is part of SimpleSceneManager and not of the inVRs framework Navigator *nav = mgr->getNavigator(); nav->setMode(Navigator::NONE); // turn off the navigator lastTimeStamp = timer.getTime(); // initialize timestamp; camMatrix = gmtl::MAT_IDENTITY44F; // initial setting of the camera matrix //----------------------------------------------------------------------------// // Snippet-2-6 - END // //----------------------------------------------------------------------------// //----------------------------------------------------------------------------// // Snippet-5-2 // //----------------------------------------------------------------------------// glutMainLoop(); // GLUT main loop return 0; }
bool StatCache::handleEvent(const struct inotify_event* event) { if (event->mask & IN_Q_OVERFLOW) { // The event queue overflowed, so all bets are off. Start over. TRACE(0, "StatCache: event queue overflowed\n"); reset(); return true; } assertx(event->wd != -1); NodePtr node = folly::get_default(m_watch2Node, event->wd); if (!node.get()) { TRACE(1, "StatCache: inotify event (obsolete) %s\n", eventToString(event).c_str()); return false; } TRACE(1, "StatCache: inotify event for '%s': %s\n", node->path().c_str(), eventToString(event).c_str()); if (event->mask & (IN_MODIFY|IN_ATTRIB)) { bool touched = false; NodePtr child = node->getChild(event->name, true); if (child.get() != nullptr) { if ((event->mask & IN_MODIFY) && child->isLink()) { // A modified link is logically equivalent to IN_MOVED_FROM. child->expirePaths(); node->removeChild(event->name); } else { child->touch(); } touched = true; } child = node->getChild(event->name, false); if (child.get() != nullptr) { // The follow=false child is equivalent to the follow=true child unless // it's a link. Avoid duplicate invalidations for non-links. child->touch(!touched || child->isLink()); } } if (event->mask & (IN_MOVED_FROM|IN_MOVED_TO|IN_CREATE|IN_DELETE)) { // The directory itself was modified, so invalidate its cached stat // structure. node->touch(); // Recursively invalidate the cached paths rooted at "node/name". bool expired = false; NodePtr child = node->getChild(event->name, true); if (child.get() != nullptr) { child->expirePaths(); expired = true; } child = node->getChild(event->name, false); if (child.get() != nullptr) { // The follow=false child is equivalent to the follow=true child unless // it's a link. Avoid duplicate invalidations for non-links. child->expirePaths(!expired || child->isLink()); expired = true; } if (expired) { node->removeChild(event->name); } } if (event->mask & IN_IGNORED) { // The kernel removed the directory watch, either as a side effect of // directory deletion, or because inotify_rm_watch() was explicitly called // during Node destruction. Delete the corresponding entry from // m_watch2Node. Removal should always succeed here because no other code // performs removal. m_watch2Node.erase(event->wd); } return false; }
SceneView::SceneView( const std::string &name ) : View3D( name, new GafferScene::ScenePlug() ), m_sceneGadget( new SceneGadget ) { // add plugs and signal handling for them storeIndexOfNextChild( g_firstPlugIndex ); addChild( new IntPlug( "minimumExpansionDepth", Plug::In, 0, 0, Imath::limits<int>::max(), Plug::Default & ~Plug::AcceptsInputs ) ); plugSetSignal().connect( boost::bind( &SceneView::plugSet, this, ::_1 ) ); // set up our gadgets viewportGadget()->setPrimaryChild( m_sceneGadget ); viewportGadget()->keyPressSignal().connect( boost::bind( &SceneView::keyPress, this, ::_1, ::_2 ) ); m_sceneGadget->baseState()->add( const_cast<IECoreGL::State *>( baseState() ) ); m_sceneGadget->setContext( getContext() ); baseStateChangedSignal().connect( boost::bind( &SceneView::baseStateChanged, this ) ); m_lookThrough = boost::shared_ptr<LookThrough>( new LookThrough( this ) ); m_grid = boost::shared_ptr<Grid>( new Grid( this ) ); m_gnomon = boost::shared_ptr<Gnomon>( new Gnomon( this ) ); m_shadingMode = boost::shared_ptr<ShadingMode>( new ShadingMode( this ) ); ////////////////////////////////////////////////////////////////////////// // add a preprocessor which monkeys with the scene before it is displayed. ////////////////////////////////////////////////////////////////////////// NodePtr preprocessor = new Node(); ScenePlugPtr preprocessorInput = new ScenePlug( "in" ); preprocessor->addChild( preprocessorInput ); // add a node for hiding things StandardAttributesPtr hide = new StandardAttributes( "hide" ); hide->attributesPlug()->getChild<ValuePlug>( "visibility" )->getChild<BoolPlug>( "enabled" )->setValue( true ); hide->attributesPlug()->getChild<ValuePlug>( "visibility" )->getChild<BoolPlug>( "value" )->setValue( false ); preprocessor->addChild( hide ); hide->inPlug()->setInput( preprocessorInput ); PathFilterPtr hideFilter = new PathFilter( "hideFilter" ); preprocessor->addChild( hideFilter ); hide->filterPlug()->setInput( hideFilter->outPlug() ); // add in the node from the ShadingMode preprocessor->addChild( m_shadingMode->preprocessor() ); m_shadingMode->preprocessor()->inPlug()->setInput( hide->outPlug() ); // make the output for the preprocessor ScenePlugPtr preprocessorOutput = new ScenePlug( "out", Plug::Out ); preprocessor->addChild( preprocessorOutput ); preprocessorOutput->setInput( m_shadingMode->preprocessor()->outPlug() ); setPreprocessor( preprocessor ); // connect up our scene gadget m_sceneGadget->setScene( preprocessedInPlug<ScenePlug>() ); }
// Initialize GLUT & OpenSG and set up the scene int main(int argc, char **argv) { // OSG init osgInit(argc,argv); // GLUT init glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); int winid = glutCreateWindow("OpenSG CGFX Shader"); // the connection between GLUT and OpenSG _gwin = GLUTWindow::create(); _gwin->setId(winid); _gwin->setSize( 800, 800 ); _gwin->init(); // init callbacks glutSetWindow(winid); glutReshapeFunc(reshape); glutDisplayFunc(display); glutIdleFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(keyboard); const char *effectFile = "BumpGlossedShiny.fx"; if(argc > 1) { effectFile = argv[1]; } _cgfxmat = CGFXMaterial::create(); beginEditCP(_cgfxmat); _cgfxmat->setEffectFile(effectFile); // this multipass technique leads to a render bug, I have no idea what's wrong :-( //_cgfxmat->setTechnique(1); endEditCP(_cgfxmat); ChunkMaterialPtr mat2 = ChunkMaterial::create(); MaterialChunkPtr matc = MaterialChunk::create(); beginEditCP(matc); matc->setDiffuse(Color4f(1, 0, 0, 1)); endEditCP(matc); beginEditCP(mat2); mat2->addChunk(matc); //mat2->addChunk(texc); endEditCP(mat2); // create root node _scene = Node::create(); GeometryPtr geo1 = makeLatLongSphereGeo(50, 50, 1.0f); OSG::calcVertexTangents(geo1, 0, Geometry::TexCoords1FieldId, Geometry::TexCoords2FieldId); beginEditCP( geo1, Geometry::MaterialFieldMask); geo1->setMaterial(_cgfxmat); endEditCP(geo1, Geometry::MaterialFieldMask); NodePtr sphere1 = Node::create(); beginEditCP(sphere1, Node::CoreFieldMask); sphere1->setCore(geo1); endEditCP(sphere1, Node::CoreFieldMask); TransformPtr trans1 = Transform::create(); beginEditCP(trans1); trans1->getMatrix().setTranslate(-2 , 0, 0); endEditCP(trans1); NodePtr transn1 = Node::create(); beginEditCP(transn1); transn1->setCore(trans1); transn1->addChild(sphere1); beginEditCP(transn1); // GeometryPtr geo2 = makeLatLongSphereGeo(50, 50, 1.0f); beginEditCP( geo2, Geometry::MaterialFieldMask); geo2->setMaterial(mat2); endEditCP(geo2, Geometry::MaterialFieldMask); NodePtr sphere2 = Node::create(); beginEditCP(sphere2, Node::CoreFieldMask); sphere2->setCore(geo2); endEditCP(sphere2, Node::CoreFieldMask); TransformPtr trans2 = Transform::create(); beginEditCP(trans2); trans2->getMatrix().setTranslate(2 , 0, 0); endEditCP(trans2); NodePtr transn2 = Node::create(); beginEditCP(transn2); transn2->setCore(trans2); transn2->addChild(sphere2); beginEditCP(transn2); beginEditCP(_scene); _scene->setCore(Group::create()); _scene->addChild(transn1); _scene->addChild(transn2); endEditCP(_scene); // create the SimpleSceneManager _mgr = new SimpleSceneManager; // tell the manager what to manage _mgr->setWindow(_gwin); _mgr->setRoot(_scene); // show the whole scene _mgr->showAll(); // create a gradient background. GradientBackgroundPtr gback = GradientBackground::create(); beginEditCP(gback, GradientBackground::LineFieldMask); gback->clearLines(); gback->addLine(Color3f(0.7, 0.7, 0.8), 0); gback->addLine(Color3f(0.0, 0.1, 0.3), 1); endEditCP(gback, GradientBackground::LineFieldMask); WindowPtr win = _mgr->getWindow(); beginEditCP(win); for(int i=0;i<win->getPort().size();++i) { ViewportPtr vp = win->getPort()[i]; beginEditCP(vp); vp->setBackground(gback); endEditCP(vp); } endEditCP(win); // GLUT main loop glutMainLoop(); return 0; }
void Node::addChildNode(NodePtr pNode) { auto pair = std::make_pair(pNode->getName(), pNode); this->childNodes.insert(pair); }
void keyboard(unsigned char k, int x, int y) { switch(k) { case 27: { OpenSGDeformActionManager::Destroy(); osgExit(); exit(0); } case '1': { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); break; } case '2': { glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); break; } case '3': { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break; } case '5': { chairIndex = (chairIndex + 1) % 6; model = chairNodes[chairIndex]; cout << "Selected model is: "; if (getName(model)) cout << getName(model); cout << " " << model << endl; break; } case '6': { ax *= -1; break; } case '7': { if (ax < 0) ax = -1; else ax = 1; break; } case '8': { if (ax < 0) ax = -2; else ax = 2; break; } case '9': { if (ax < 0) ax = -3; else ax = 3; break; } case 'p': { #if OSG_MAJOR_VERSION >= 2 traverse(scene, boost::bind(printSceneGraph,_1)); #else traverse(scene, osgTypedFunctionFunctor1CPtrRef <Action::ResultE, NodePtr>(printSceneGraph)); #endif break; } case 'h': { printUsage(); break; } case 'i': { gmtl::AABoxf aabb; osgdam = OpenSGDeformActionManager::GetInstance(); if (osgdam != 0) { osgdam->insertLattice(model, 2, 2, 2, 3); } break; } case 'j': { osgdam = OpenSGDeformActionManager::GetInstance(); if(osgdam != 0) { gmtl::AABoxf aabb; Pnt3f aabbMin, aabbMax; #if OSG_MAJOR_VERSION >= 2 model->editVolume(true).getBounds(aabbMin, aabbMax); #else model->getVolume(true).getBounds(aabbMin, aabbMax); #endif for (int i = 0; i < 3; i++) { aabbMin[i] = aabbMin[i] - 1.0f; aabbMax[i] = aabbMax[i]/2 + 1.0f; } aabb = gmtl::AABoxf(gmtl::Vec3f(aabbMin[0], aabbMin[1], aabbMin[2]), gmtl::Vec3f(aabbMax[0], aabbMax[1], aabbMax[2])); osgdam->insertLattice(model, 2, 2, 2, 3, true, aabb); } break; } case 'q': { NodePtr tmp = model; while (tmp != NullFC) { TransformPtr tcore = TransformPtr::dcast(tmp->getCore()); if (tcore != NullFC) { Matrix mm = tcore->getMatrix(); Matrix tm = Matrix::identity(); tm.setScale(1,2,1); mm.mult(tm); beginEditCP(tcore, Transform::MatrixFieldMask); tcore->setMatrix(mm); endEditCP(tcore, Transform::MatrixFieldMask); mm = tcore->getMatrix(); break; } tmp = tmp->getParent(); } break; } default: break; } if (osgdam != 0) { switch(k) { case '4': { all = !all; osgdam->setShowAll(model, all); break; } case 'e': { doExecute = !doExecute; osgdam->setInstantExecution(model, doExecute); break; } case 'r': { osgdam->removeLattice(model); break; } case 't': { osgdam->taper(model, 1.0f, ax); break; } case 'g': { osgdam->twist(model, gmtl::Math::deg2Rad(5.0f), ax); break; } case 'b': { osgdam->bend(model, gmtl::Math::deg2Rad(5.0f), 0.5f, ax); break; } case 'v': { osgdam->bend(model, -gmtl::Math::deg2Rad(5.0f), 0.0f, ax); break; } case 'c': { osgdam->bend(model, -gmtl::Math::deg2Rad(5.0f), 1.0f, ax); break; } case 'f': { osgdam->bend(model, -gmtl::Math::deg2Rad(5.0f), 0.5f, ax); break; } case 'd': { gmtl::Matrix44f dMatrix; dMatrix[0][0] = 0.5f; dMatrix[1][1] = 1.0f; dMatrix[2][2] = -1.5f; osgdam->deform(model, dMatrix, false); break; } case 'l': { selectPoints.clear(); selectPositions.clear(); osgdam->unselectLatticeCellPoints(model); break; } case 'm': { osgdam->selectLatticeCellPoint(mgr, model, x, y, true); break; } case 'n': { osgdam->unselectLatticeCellPoint(mgr, model, x, y); break; } case '-': { gmtl::Vec3f pos; selectPositions.clear(); selectPoints = osgdam->getSelection(model); for (size_t i = 0; i < selectPoints.size(); ++i) { osgdam->getPoint(model, selectPoints[i], pos); if (ax == 1) pos[0] -= 0.5f; else if (ax == 2) pos[1] -= 0.5f; else pos[2] -= 0.5f; selectPositions.push_back(pos); } osgdam->setPoints(model, selectPoints, selectPositions); break; } case '+': { gmtl::Vec3f pos; selectPositions.clear(); selectPoints = osgdam->getSelection(model); for (size_t i = 0; i < selectPoints.size(); ++i) { osgdam->getPoint(model, selectPoints[i], pos); if (ax == 1) pos[0] += 0.5f; else if (ax == 2) pos[1] += 0.5f; else pos[2] += 0.5f; selectPositions.push_back(pos); } osgdam->setPoints(model, selectPoints, selectPositions); break; } case 'u': { osgdam->undo(model); break; } case 'x': { osgdam->executeFfd(model); break; } case 'o': { osgdam->dump(model); break; } default: break; } } }
// Initialize GLUT & OpenSG and set up the scene int main(int argc, char **argv) { // OSG init osgInit(argc,argv); // GLUT init int winid = setupGLUT(&argc, argv); // the connection between GLUT and OpenSG GLUTWindowPtr gwin= GLUTWindow::create(); gwin->setId(winid); gwin->init(); // load the scene NodePtr scene = NullFC; if(argc < 2) { FWARNING(("No file given!\n")); FWARNING(("Supported file formats:\n")); std::list<const char*> suffixes; SceneFileHandler::the().getSuffixList(suffixes, SceneFileType::OSG_READ_SUPPORTED); for(std::list<const char*>::iterator it = suffixes.begin(); it != suffixes.end(); ++it) { FWARNING(("%s\n", *it)); } scene = makeTorus(.5, 2, 16, 16); } else { /* All scene file loading is handled via the SceneFileHandler. */ scene = SceneFileHandler::the().read(argv[1]); } // calc size of the scene Vec3f min, max; #ifndef OSG_2_PREP DynamicVolume vol; #else BoxVolume vol; #endif scene->getWorldVolume(vol); vol.getBounds(min, max); Vec3f d = max - min; Real32 offset = d.length() / 2.0f; // now create a deep clone // we share the GenericAtt from the wrl loader without it crashes in deepClone setAbstrValue ... NodePtr sceneClone = deepCloneTree(scene, "GenericAtt"); // this clones all nodes but the cores of type Material and Transform are shared. //NodePtr sceneClone = deepCloneTree(scene, "Material, Transform"); // now change all geometries from the cloned scene just to show // that it is a real deep copy. traverse(sceneClone, osgTypedFunctionFunctor1CPtrRef<Action::ResultE, NodePtr >(changeGeo)); // create a small scene graph with two transformation nodes. NodePtr root = makeCoredNode<Group>(); ComponentTransformPtr t1; NodePtr tn1 = makeCoredNode<ComponentTransform>(&t1); ComponentTransformPtr t2; NodePtr tn2 = makeCoredNode<ComponentTransform>(&t2); beginEditCP(t1); t1->setTranslation(Vec3f(- offset, 0.0f, 0.0f)); endEditCP(t1); beginEditCP(t2); t2->setTranslation(Vec3f(offset, 0.0f, 0.0f)); endEditCP(t2); beginEditCP(tn1); tn1->addChild(scene); endEditCP(tn1); beginEditCP(tn2); tn2->addChild(sceneClone); endEditCP(tn2); beginEditCP(root); root->addChild(tn1); root->addChild(tn2); endEditCP(root); // create the SimpleSceneManager helper mgr = new SimpleSceneManager; // tell the manager what to manage mgr->setWindow(gwin ); mgr->setRoot (root); // show the whole scene mgr->showAll(); // GLUT main loop glutMainLoop(); return 0; }
NodePtr Puck::init() { // CREATE THE PUCK NodePtr puck_trans_node = makeCoredNode<Transform>(&transPtr); beginEditCP(transPtr); { transPtr->getMatrix().setTranslate(position[0],position[1],position[2]); } endEditCP(transPtr); NodePtr puck = OSG::makeCylinder(PUCK_HALF_HEIGHT*2.0,radius, 32, true, true ,true); beginEditCP(puck_trans_node); { puck_trans_node->addChild(puck); } endEditCP(puck_trans_node); SimpleMaterialPtr puck_mat = SimpleMaterial::create(); beginEditCP(puck_mat); { puck_mat->setAmbient(Color3f(0.0,0.0,0.0)); puck_mat->setDiffuse(Color3f(1.0,0.0,0.0)); } endEditCP(puck_mat); GeometryPtr puck_geo = GeometryPtr::dcast(puck->getCore()); beginEditCP(puck_geo); puck_geo->setMaterial(puck_mat); beginEditCP(puck_geo); ///////////////////////////// // SETUP THE INTERSECTION TEST COMPONENTS // Create a small geometry to show the ray and what was hit // Contains a line and a single triangle. // The line shows the ray, the triangle whatever was hit. isectPoints = GeoPositions3f::create(); beginEditCP(isectPoints); { isectPoints->addValue(Pnt3f(0,0,0)); isectPoints->addValue(Pnt3f(0,0,0)); isectPoints->addValue(Pnt3f(0,0,0)); isectPoints->addValue(Pnt3f(0,0,0)); isectPoints->addValue(Pnt3f(0,0,0)); } endEditCP(isectPoints); GeoIndicesUI32Ptr index = GeoIndicesUI32::create(); beginEditCP(index); { index->addValue(0); index->addValue(1); index->addValue(2); index->addValue(3); index->addValue(4); } endEditCP(index); GeoPLengthsUI32Ptr lens = GeoPLengthsUI32::create(); beginEditCP(lens); { lens->addValue(2); lens->addValue(3); } endEditCP(lens); GeoPTypesUI8Ptr type = GeoPTypesUI8::create(); beginEditCP(type); { type->addValue(GL_LINES); type->addValue(GL_TRIANGLES); } endEditCP(type); SimpleMaterialPtr red = SimpleMaterial::create(); beginEditCP(red); { red->setDiffuse (Color3f( 1,0,0 )); red->setTransparency(0.5); red->setLit (false); } endEditCP (red); testgeocore = Geometry::create(); beginEditCP(testgeocore); { testgeocore->setPositions(isectPoints); testgeocore->setIndices(index); testgeocore->setLengths(lens); testgeocore->setTypes(type); testgeocore->setMaterial(red); } endEditCP(testgeocore); NodePtr testgeo = Node::create(); beginEditCP(testgeo); { testgeo->setCore(testgeocore); } endEditCP(testgeo); beginEditCP(puck_trans_node); { puck_trans_node->addChild(testgeo); } return puck_trans_node; }
int main(int argc, char **argv) { // OSG init osgInit(argc,argv); // Set up Window TutorialWindowEventProducer = createDefaultWindowEventProducer(); WindowPtr MainWindow = TutorialWindowEventProducer->initWindow(); TutorialWindowEventProducer->setDisplayCallback(display); TutorialWindowEventProducer->setReshapeCallback(reshape); TutorialUpdateListener TheUpdateListener; TutorialWindowEventProducer->addUpdateListener(&TheUpdateListener); TutorialKeyListener TheKeyListener; TutorialWindowEventProducer->addKeyListener(&TheKeyListener); // Create the SimpleSceneManager helper mgr = new SimpleSceneManager; // Tell the Manager what to manage mgr->setWindow(MainWindow); // Make Main Scene Node and add the Torus NodePtr scene = osg::Node::create(); beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask); scene->setCore(osg::Group::create()); endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask); //Create a FBO Source FBOSourceTextureFilterPtr TutorialFBOSourceTextureFilter = FBOSourceTextureFilter::create(); beginEditCP(TutorialFBOSourceTextureFilter, FBOSourceTextureFilter::FBOFieldMask | FBOSourceTextureFilter::FBOSizeFieldMask); TutorialFBOSourceTextureFilter->setFBO(createSceneFBO()); TutorialFBOSourceTextureFilter->setFBOSize(Vec2f(-1.0,-1.0)); endEditCP(TutorialFBOSourceTextureFilter, FBOSourceTextureFilter::FBOFieldMask | FBOSourceTextureFilter::FBOSizeFieldMask); //Create a HDR filter std::string HDRFragProg = ""; HDRFragProg += "uniform sampler2D Slot0Texture;" "uniform float Exposure;" "uniform float MaxLuminance;" "uniform float Gamma;" "void main()" "{" " vec3 Color = texture2D(Slot0Texture,gl_TexCoord[0].st).rgb;" //" float Intensity = dot(vec3(0.3,0.59,0.11),Color);" " float TonePercent = Exposure * ((Exposure/MaxLuminance + 1.0)/(Exposure + 1.0));" //Apply Tone Mapping And Gamma Correction " Color = pow(Color * TonePercent, vec3(Gamma));" " gl_FragColor = vec4(Color, 1.0);" "}"; //Create a shader Filter HDRTextureFilter = ShaderTextureFilter::create(); HDRTextureFilter->attachSource(TutorialFBOSourceTextureFilter, 0, 0); HDRTextureFilter->setFragmentSource(HDRFragProg); HDRTextureFilter->setUniformParameter("Exposure", Exposure); HDRTextureFilter->setUniformParameter("MaxLuminance", MaxLuminance); HDRTextureFilter->setUniformParameter("Gamma", Gamma); // Create the ImageProcessed Foreground Object ImageProcessedForegroundPtr TutorialImageProcessedForeground = ImageProcessedForeground::create(); beginEditCP(TutorialImageProcessedForeground, ImageProcessedForeground::FilterFieldMask | ImageProcessedForeground::OutputSlotFieldMask); TutorialImageProcessedForeground->setFilter(HDRTextureFilter); TutorialImageProcessedForeground->setOutputSlot(0); endEditCP(TutorialImageProcessedForeground, ImageProcessedForeground::FilterFieldMask | ImageProcessedForeground::OutputSlotFieldMask); mgr->setRoot(scene); // Add the ImageProcessed Foreground Object to the Scene ViewportPtr TutorialViewport = mgr->getWindow()->getPort(0); beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask); TutorialViewport->getForegrounds().push_back(TutorialImageProcessedForeground); beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask); // Show the whole Scene mgr->showAll(); //Open Window Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f); Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5); TutorialWindowEventProducer->openWindow(WinPos, WinSize, "03ScenePostProcessing"); //Enter main Loop TutorialWindowEventProducer->mainLoop(); osgExit(); return 0; }
int MAST (NTree &T1, NTree &T2) { int result = 0; // 1. create lists of the nodes in T1 and T2 in postorder int count = 0; NodeVector pot1; NodeIterator <Node> n1 (T1.GetRoot()); Node *q = n1.begin(); while (q) { q->SetIndex (count); pot1.push_back ((NNode *)q); count++; q = n1.next(); } count = 0; NodeVector pot2; NodeIterator <Node> n2 (T2.GetRoot()); q = n2.begin(); while (q) { q->SetIndex (count); pot2.push_back ((NNode *)q); count++; q = n2.next(); } // Matrix to hold solutions int **m; m = new int *[T1.GetNumNodes()]; for (int i = 0; i < T1.GetNumNodes(); i++) m[i] = new int [T2.GetNumNodes()]; for (int i = 0; i < T1.GetNumNodes(); i++) for (int j = 0; j <T2.GetNumNodes(); j++) m[i][j] = 0; // 2. Visit all pairs of nodes in T1 and T2 for (int i = 0; i < T1.GetNumNodes(); i++) { for (int j = 0; j <T2.GetNumNodes(); j++) { if (pot1[i]->IsLeaf() || pot2[j]->IsLeaf()) { // Both are leaves, so MAST[i,j] is 1 if labels are identical if (pot1[i]->IsLeaf() && pot2[j]->IsLeaf()) { if ( pot1[i]->GetLabel() == pot2[j]->GetLabel()) m[i][j] = 1; } else { // Only one is a leaf, so MAST[i,j] is 1 if leaf is element in cluster IntegerSet common; std::set_intersection (pot1[i]->Cluster.begin(), pot1[i]->Cluster.end(), pot2[j]->Cluster.begin(), pot2[j]->Cluster.end(), std::inserter (common, common.end())); int w = common.size(); m[i][j] = w; } } else { // Both are internals so MAST[i,j] is MAX (diag, match) std::vector <NodePtr> pchildren, qchildren; // diag int diag = 0; // Get MAST of base of subtree in t1 and immediate children of // base of subtree in t2, and at the same time store list of // immediate children NodePtr p = pot2[j]->GetChild(); while (p) { qchildren.push_back(p); diag = std::max (diag, m[i][p->GetIndex()]); p = p->GetSibling(); } // get MAST of base of subtree in t2 and immediate children of // base of subtree in t1, and at the same time store list of // immediate children NodePtr q = pot1[i]->GetChild(); while (q) { pchildren.push_back(q); diag = std::max (diag, m[q->GetIndex()][j]); q = q->GetSibling(); } // maximum weighted bipartite matching #if USE_MATCHING int match = 0; graph g; g.make_directed(); // Nodes for p and q children map <int, node, less <int> > p_node; map <int, node, less <int> > q_node; for (int k = 0; k < pchildren.size(); k++) { node n = g.new_node(); p_node[k] = n; } for (int k = 0; k < qchildren.size(); k++) { node n = g.new_node(); q_node[k] = n; } // Edges edge_map<int> weights(g, 0); for (int k = 0; k < pchildren.size(); k++) { for (int r = 0; r < qchildren.size(); r++) { int v = pchildren[k]->GetIndex(); int w = qchildren[r]->GetIndex(); // It seems that if the partition "from" is much larger than "to, // the matching algorithm can blow up with a memory access error // in fheap.c. Reversing the graph seems to help. edge e; if (pchildren.size() < qchildren.size()) e = g.new_edge (p_node[k], q_node[r]); else e = g.new_edge (q_node[r], p_node[k]); weights[e] = m[v][w]; } } // cout << "g" << endl; // cout << g; // g.save(); // cout << "Start matching..."; if (g.number_of_nodes() == 0) { match = 0; } else { mwbmatching mwbm; mwbm.set_vars (weights); if (mwbm.check(g) != algorithm::GTL_OK) { cout << "Maximum weight bipartite matching algorithm check failed" << endl; exit(1); } else { if (mwbm.run(g) != algorithm::GTL_OK) { cout << "Error running maximum weight bipartite matching algorithm" << endl; exit(1); } else { match = mwbm.get_mwbm(); } } } // cout << "matching done (" << match << ")" << endl; #else // For now (sigh) brute force generation of all matchings. Eventually // will need to do this more efficiently int n = std::max (pchildren.size(), qchildren.size()); // Store a vector of indices of children of subtree in t2. // We will permute this to generate all matchings. If t2 // has fewer children than subtree in t1, vector will contain // one or more "null" (-1) values. std::vector <int> perm; for (int k = 0; k < n; k++) { if (k < qchildren.size()) perm.push_back (k); else perm.push_back (-1); } // Generate all matchings // First matching int match = 0; for (int k = 0; k < n; k++) { if ((k < pchildren.size()) && (perm[k] != -1)) { int v = pchildren[k]->GetIndex(); int w = qchildren[perm[k]]->GetIndex(); match += m[v][w]; } } // Remaining matchings while (next_permutation (perm.begin(), perm.end()) ) { int this_match = 0; for (int k = 0; k < n; k++) { if ((k < pchildren.size()) && (perm[k] != -1)) { int v = pchildren[k]->GetIndex(); int w = qchildren[perm[k]]->GetIndex(); this_match += m[v][w]; } } match = std::max (match, this_match); } #endif m[i][j] = std::max (diag, match); } } } result = m[T1.GetNumNodes() - 1][T2.GetNumNodes() - 1]; // Show matrix /* for (int i = 0; i < T1.GetNumNodes(); i++) { cout << setw(3) << i << "|"; for (int j = 0; j < T2.GetNumNodes(); j++) cout << setw(3) << m[i][j]; cout << endl; } */ // clean up for (int i = 0; i < T1.GetNumNodes(); i++) delete [] m[i]; delete [] m; return result; }
FBOViewportPtr createSceneFBO(void) { //Create Camera Beacon Matrix CameraMat; CameraMat.setTranslate(0.0f,0.0f,4.0f); TransformPtr CameraBeconCore = Transform::create(); beginEditCP(CameraBeconCore, Transform::MatrixFieldMask); CameraBeconCore->setMatrix(CameraMat); endEditCP(CameraBeconCore, Transform::MatrixFieldMask); NodePtr CameraBeconNode = Node::create(); beginEditCP(CameraBeconNode, Node::CoreFieldMask); CameraBeconNode->setCore(CameraBeconCore); endEditCP(CameraBeconNode, Node::CoreFieldMask); //Create Camera PerspectiveCameraPtr TheCamera = PerspectiveCamera::create(); beginEditCP(TheCamera); TheCamera->setFov(deg2rad(60.0f)); TheCamera->setAspect(1.0f); TheCamera->setNear(0.1f); TheCamera->setFar(100.0f); TheCamera->setBeacon(CameraBeconNode); endEditCP(TheCamera); //Make the Material BlinnMaterialPtr TheMaterial = BlinnMaterial::create(); beginEditCP(TheMaterial); TheMaterial->setDiffuse(0.8); TheMaterial->setColor(Color3f(1.0,1.0,1.0)); TheMaterial->setAmbientColor(Color3f(1.0,1.0,1.0)); TheMaterial->setNumLights(1); endEditCP(TheMaterial); // Make Torus Node (creates Torus in background of scene) NodePtr TorusGeometryNode = makeTorus(.5, 2, 24, 48); beginEditCP(TorusGeometryNode->getCore()); GeometryPtr::dcast(TorusGeometryNode->getCore())->setMaterial(TheMaterial); endEditCP(TorusGeometryNode->getCore()); calcVertexNormals(GeometryPtr::dcast(TorusGeometryNode->getCore())); calcVertexTangents(GeometryPtr::dcast(TorusGeometryNode->getCore()),0,Geometry::TexCoords7FieldId, Geometry::TexCoords6FieldId); RootTransformCore = Transform::create(); NodePtr TorusTransformNode = Node::create(); beginEditCP(TorusTransformNode, Node::CoreFieldMask); TorusTransformNode->setCore(RootTransformCore); TorusTransformNode->addChild(TorusGeometryNode); endEditCP(TorusTransformNode, Node::CoreFieldMask); //Create Light Beacon Matrix LightMat; LightMat.setTranslate(0.0f,10.0f,1.0f); TransformPtr LightBeconCore = Transform::create(); beginEditCP(LightBeconCore, Transform::MatrixFieldMask); LightBeconCore->setMatrix(LightMat); endEditCP(LightBeconCore, Transform::MatrixFieldMask); NodePtr LightBeconNode = Node::create(); beginEditCP(LightBeconNode, Node::CoreFieldMask); LightBeconNode->setCore(LightBeconCore); endEditCP(LightBeconNode, Node::CoreFieldMask); //Create Light TheLight = PointLight::create(); beginEditCP(TheLight); TheLight->setBeacon(LightBeconNode); endEditCP(TheLight); NodePtr LightNode = Node::create(); beginEditCP(LightNode, Node::CoreFieldMask); LightNode->setCore(TheLight); LightNode->addChild(TorusTransformNode); endEditCP(LightNode, Node::CoreFieldMask); //Create Root NodePtr TheRoot = Node::create(); beginEditCP(TheRoot); TheRoot->setCore(Group::create()); TheRoot->addChild(CameraBeconNode); TheRoot->addChild(LightNode); TheRoot->addChild(LightBeconNode); endEditCP(TheRoot); //Create Background SolidBackgroundPtr TheBackground = SolidBackground::create(); TheBackground->setColor(Color3f(1.0,0.0,0.0)); //DepthClearBackgroundPtr TheBackground = DepthClearBackground::create(); //Create the Image ImagePtr TheColorImage = Image::create(); TheColorImage->set(Image::OSG_RGB_PF,2,2,1,1,1,0.0f,0,Image::OSG_FLOAT16_IMAGEDATA); //Create the texture TextureChunkPtr TheColorTextureChunk = TextureChunk::create(); beginEditCP(TheColorTextureChunk); TheColorTextureChunk->setImage(TheColorImage); TheColorTextureChunk->setMinFilter(GL_NEAREST); TheColorTextureChunk->setMagFilter(GL_NEAREST); TheColorTextureChunk->setWrapS(GL_CLAMP_TO_EDGE); TheColorTextureChunk->setWrapR(GL_CLAMP_TO_EDGE); TheColorTextureChunk->setScale(false); TheColorTextureChunk->setNPOTMatrixScale(true); TheColorTextureChunk->setEnvMode(GL_REPLACE); TheColorTextureChunk->setInternalFormat(GL_RGB16F); endEditCP(TheColorTextureChunk); //Create FBO FBOViewportPtr TheFBO = FBOViewport::create(); beginEditCP(TheFBO); TheFBO->setBackground(TheBackground); TheFBO->setRoot(TheRoot); TheFBO->setCamera(TheCamera); TheFBO->setEnabled(true); TheFBO->getTextures().push_back(TheColorTextureChunk); TheFBO->setStorageWidth(TheColorTextureChunk->getImage()->getWidth()); TheFBO->setStorageHeight(TheColorTextureChunk->getImage()->getHeight()); TheFBO->setSize(0,0,TheColorTextureChunk->getImage()->getWidth()-1, TheColorTextureChunk->getImage()->getHeight()-1); endEditCP(TheFBO); return TheFBO; }
void NodeVisitor::visit(NodePtr node) { node->accept(this, node); }
bool Object::send( NodePtr node, ObjectPacket& packet ) { EQASSERT( isAttached( )); packet.objectID = _id; return node->send( packet ); }
void Project::restoreInput(const NodePtr& node, const std::string& inputLabel, const std::string& inputNodeScriptName, const std::list<std::pair<NodePtr, SERIALIZATION_NAMESPACE::NodeSerializationPtr > >& allCreatedNodesInGroup, bool isMaskInput) { if ( inputNodeScriptName.empty() ) { return; } int index = inputLabel.empty() ? -1 : node->getInputNumberFromLabel(inputLabel); if (index == -1) { // If the name of the input was not serialized, the string is the index bool ok; index = QString::fromUtf8(inputLabel.c_str()).toInt(&ok); if (!ok) { index = -1; } if (index == -1) { appPTR->writeToErrorLog_mt_safe(QString::fromUtf8(node->getScriptName().c_str()), QDateTime::currentDateTime(), tr("Could not find input named %1") .arg( QString::fromUtf8( inputNodeScriptName.c_str() ) ) ); } // If the node had a single mask, the inputLabel was "0", indicating the index of the mask // So iterate through masks to find it if (isMaskInput) { // Find the mask corresponding to the index int nInputs = node->getMaxInputCount(); int maskIndex = 0; for (int i = 0; i < nInputs; ++i) { if (node->getEffectInstance()->isInputMask(i)) { if (maskIndex == index) { index = i; break; } ++maskIndex; break; } } } } NodeCollectionPtr nodeGroup = node->getGroup(); if (!nodeGroup) { return; } // The nodes created from the serialization may have changed name if another node with the same script-name already existed. // By chance since we created all nodes within the same Group at the same time, we have a list of the old node serialization // and the corresponding created node (with its new script-name). // If we find a match, make sure we use the new node script-name to restore the input. NodePtr foundNode = findNodeWithScriptName(inputNodeScriptName, allCreatedNodesInGroup); if (!foundNode) { return; // Commented-out: Do not attempt to get the node in the nodes list: all nodes within a sub-graph should be connected to nodes at this level. // If it cannot be found in the allCreatedNodesInGroup then this is likely the user does not want the input to connect. //foundNode = nodeGroup->getNodeByName(inputNodeScriptName); } bool ok = node->getGroup()->connectNodes(index, foundNode, node); (void)ok; } //restoreInput
void OutputEffectInstance::reportStats(int time, ViewIdx view, double wallTime, const std::map<NodePtr, NodeRenderStats > & stats) { std::string filename; KnobPtr fileKnob = getKnobByName(kOfxImageEffectFileParamName); if (fileKnob) { KnobOutputFile* strKnob = dynamic_cast<KnobOutputFile*>( fileKnob.get() ); if (strKnob) { QString qfileName = QString::fromUtf8( SequenceParsing::generateFileNameFromPattern(strKnob->getValue( 0, ViewIdx(view) ), getApp()->getProject()->getProjectViewNames(), time, view).c_str() ); QtCompat::removeFileExtension(qfileName); qfileName.append( QString::fromUtf8("-stats.txt") ); filename = qfileName.toStdString(); } } //If there's no filename knob, do not write anything if ( filename.empty() ) { std::cout << tr("Cannot write render statistics file: " "%1 does not seem to have a parameter named \"filename\" " "to determine the location where to write the stats file.") .arg( QString::fromUtf8( getScriptName_mt_safe().c_str() ) ).toStdString(); return; } FStreamsSupport::ofstream ofile; FStreamsSupport::open(&ofile, filename); if (!ofile) { std::cout << tr("Failure to write render statistics file.").toStdString() << std::endl; return; } ofile << "Time spent to render frame (wall clock time): " << Timer::printAsTime(wallTime, false).toStdString() << std::endl; for (std::map<NodePtr, NodeRenderStats >::const_iterator it = stats.begin(); it != stats.end(); ++it) { ofile << "------------------------------- " << it->first->getScriptName_mt_safe() << "------------------------------- " << std::endl; ofile << "Time spent rendering: " << Timer::printAsTime(it->second.getTotalTimeSpentRendering(), false).toStdString() << std::endl; const RectD & rod = it->second.getRoD(); ofile << "Region of definition: x1 = " << rod.x1 << " y1 = " << rod.y1 << " x2 = " << rod.x2 << " y2 = " << rod.y2 << std::endl; ofile << "Is Identity to Effect? "; NodePtr identity = it->second.getInputImageIdentity(); if (identity) { ofile << "Yes, to " << identity->getScriptName_mt_safe() << std::endl; } else { ofile << "No" << std::endl; } ofile << "Has render-scale support? "; if ( it->second.isRenderScaleSupportEnabled() ) { ofile << "Yes"; } else { ofile << "No"; } ofile << std::endl; ofile << "Has tiles support? "; if ( it->second.isTilesSupportEnabled() ) { ofile << "Yes"; } else { ofile << "No"; } ofile << std::endl; ofile << "Channels processed: "; std::bitset<4> processChannels = it->second.getChannelsRendered(); if (processChannels[0]) { ofile << "red "; } if (processChannels[1]) { ofile << "green "; } if (processChannels[2]) { ofile << "blue "; } if (processChannels[3]) { ofile << "alpha"; } ofile << std::endl; ofile << "Output alpha premultiplication: "; switch ( it->second.getOutputPremult() ) { case eImagePremultiplicationOpaque: ofile << "opaque"; break; case eImagePremultiplicationPremultiplied: ofile << "premultiplied"; break; case eImagePremultiplicationUnPremultiplied: ofile << "unpremultiplied"; break; } ofile << std::endl; ofile << "Mipmap level(s) rendered: "; for (std::set<unsigned int>::const_iterator it2 = it->second.getMipMapLevelsRendered().begin(); it2 != it->second.getMipMapLevelsRendered().end(); ++it2) { ofile << *it2 << ' '; } ofile << std::endl; int nbCacheMiss, nbCacheHit, nbCacheHitButDownscaled; it->second.getCacheAccessInfos(&nbCacheMiss, &nbCacheHit, &nbCacheHitButDownscaled); ofile << "Nb cache hit: " << nbCacheMiss << std::endl; ofile << "Nb cache miss: " << nbCacheMiss << std::endl; ofile << "Nb cache hit requiring mipmap downscaling: " << nbCacheHitButDownscaled << std::endl; const std::set<std::string> & planes = it->second.getPlanesRendered(); ofile << "Plane(s) rendered: "; for (std::set<std::string>::const_iterator it2 = planes.begin(); it2 != planes.end(); ++it2) { ofile << *it2 << ' '; } ofile << std::endl; std::list<std::pair<RectI, NodePtr > > identityRectangles = it->second.getIdentityRectangles(); const std::list<RectI> & renderedRectangles = it->second.getRenderedRectangles(); ofile << "Identity rectangles: " << identityRectangles.size() << std::endl; for (std::list<std::pair<RectI, NodePtr > > ::iterator it2 = identityRectangles.begin(); it2 != identityRectangles.end(); ++it2) { ofile << "Origin: " << it2->second->getScriptName_mt_safe() << ", rect: x1 = " << it2->first.x1 << " y1 = " << it2->first.y1 << " x2 = " << it2->first.x2 << " y2 = " << it2->first.y2 << std::endl; } ofile << "Rectangles rendered: " << renderedRectangles.size() << std::endl; for (std::list<RectI>::const_iterator it2 = renderedRectangles.begin(); it2 != renderedRectangles.end(); ++it2) { ofile << "x1 = " << it2->x1 << " y1 = " << it2->y1 << " x2 = " << it2->x2 << " y2 = " << it2->y2 << std::endl; } } } // OutputEffectInstance::reportStats
void post(NIFFile *nif) { Controller::post(nif); emitter.post(nif); extra.post(nif); }
static void drop(DrawActionBase *action, NodePtr node, Color3f col) { node->updateVolume(); drop(action, node->getVolume(), col); }
// Initialize GLUT & OpenSG and set up the scene int main(int argc, char **argv) { // OSG init osgInit(argc,argv); // GLUT init int winid = setupGLUT(&argc, argv); gwin = GLUTWindow::create(); // create root rootNode = makeCoredNode<Group>(); NodePtr scene = makeCoredNode<Group>(); // create lights TransformPtr point1_trans; NodePtr point1 = makeCoredNode<PointLight>(&_point1_core); NodePtr point1_beacon = makeCoredNode<Transform>(&point1_trans); beginEditCP(point1_trans); point1_trans->editMatrix().setTranslate(0.0, 0.0, 25.0); endEditCP(point1_trans); beginEditCP(_point1_core); _point1_core->setAmbient(0.15,0.15,0.15,1); _point1_core->setDiffuse(0.4,0.4,0.4,1); _point1_core->setSpecular(0.0,0.0,0.0,1); _point1_core->setBeacon(point1_beacon); _point1_core->setOn(true); endEditCP(_point1_core); TransformPtr point2_trans; NodePtr point2 = makeCoredNode<PointLight>(&_point2_core); NodePtr point2_beacon = makeCoredNode<Transform>(&point2_trans); beginEditCP(point2_trans); point2_trans->editMatrix().setTranslate(5.0, 5.0, 20.0); endEditCP(point2_trans); beginEditCP(_point2_core); _point2_core->setAmbient(0.15,0.15,0.15,1); _point2_core->setDiffuse(0.4,0.4,0.4,1); _point2_core->setSpecular(0.0,0.0,0.0,1); _point2_core->setBeacon(point2_beacon); _point2_core->setOn(true); endEditCP(_point2_core); beginEditCP(point1); point1->addChild(point2); endEditCP(point1); beginEditCP(point2); point2->addChild(scene); endEditCP(point2); // create scene // bottom NodePtr plane = makePlane(25.0, 25.0, 128, 128); int size = imageWinWidth*imageWinHeight*256; ImagePtr plane_img = Image::create(); beginEditCP(plane_img); plane_img->set(Image::OSG_RGBA_PF, imageWinWidth, imageWinHeight, 1, 1, 1, 0, NULL); endEditCP(plane_img); TextureChunkPtr plane_tex = TextureChunk::create(); beginEditCP(plane_tex); plane_tex->setImage(plane_img); plane_tex->setMinFilter(GL_LINEAR); plane_tex->setMagFilter(GL_LINEAR); plane_tex->setTarget(GL_TEXTURE_2D); plane_tex->setInternalFormat(GL_RGBA16F_ARB); endEditCP(plane_tex); SHLChunkPtr shl = SHLChunk::create(); beginEditCP(shl); shl->setVertexProgram(_vp_program); shl->setFragmentProgram(_fp_program); shl->setUniformParameter("tex0", 0); endEditCP(shl); SimpleMaterialPtr plane_mat = SimpleMaterial::create(); beginEditCP(plane_mat); plane_mat->setAmbient(Color3f(0.3,0.3,0.3)); plane_mat->setDiffuse(Color3f(1.0,1.0,1.0)); plane_mat->addChunk(plane_tex); plane_mat->addChunk(shl); endEditCP(plane_mat); GeometryPtr plane_geo = GeometryPtr::dcast(plane->getCore()); beginEditCP(plane_geo); plane_geo->setMaterial(plane_mat); beginEditCP(plane_geo); // box box_trans_node = makeCoredNode<Transform>(&_box_trans); beginEditCP(_box_trans); _box_trans->editMatrix().setTranslate(0.0, 0.0, 12.0); endEditCP(_box_trans); NodePtr box = makeBox(4.0, 4.0, 0.8, 10, 10 , 10); beginEditCP(box_trans_node); box_trans_node->addChild(box); endEditCP(box_trans_node); PolygonChunkPtr pchunk = osg::PolygonChunk::create(); beginEditCP(pchunk); pchunk->setCullFace(GL_BACK); endEditCP(pchunk); SimpleMaterialPtr box_mat = SimpleMaterial::create(); beginEditCP(box_mat); box_mat->setAmbient(Color3f(0.0,0.0,0.0)); box_mat->setDiffuse(Color3f(0.0,0.0,1.0)); box_mat->addChunk(pchunk); endEditCP(box_mat); GeometryPtr box_geo = GeometryPtr::dcast(box->getCore()); beginEditCP(box_geo); box_geo->setMaterial(box_mat); beginEditCP(box_geo); // cylinder1 NodePtr cylinder1_trans_node = makeCoredNode<Transform>(&_cylinder1_trans); beginEditCP(_cylinder1_trans); _cylinder1_trans->editMatrix().setTranslate(0.0, 0.0, 5.0); endEditCP(_cylinder1_trans); NodePtr cylinder1 = OSG::makeCylinder(10.0, 0.4, 32, true, true ,true); beginEditCP(cylinder1_trans_node); cylinder1_trans_node->addChild(cylinder1); endEditCP(cylinder1_trans_node); SimpleMaterialPtr cylinder1_mat = SimpleMaterial::create(); beginEditCP(cylinder1_mat); cylinder1_mat->setAmbient(Color3f(0.0,0.0,0.0)); cylinder1_mat->setDiffuse(Color3f(1.0,0.0,0.0)); cylinder1_mat->addChunk(pchunk); endEditCP(cylinder1_mat); GeometryPtr cylinder1_geo = GeometryPtr::dcast(cylinder1->getCore()); beginEditCP(cylinder1_geo); cylinder1_geo->setMaterial(cylinder1_mat); beginEditCP(cylinder1_geo); // cylinder2 NodePtr cylinder2_trans_node = makeCoredNode<Transform>(&_cylinder2_trans); beginEditCP(_cylinder2_trans); _cylinder2_trans->editMatrix().setTranslate(0.0, 0.0, 8.0); endEditCP(_cylinder2_trans); NodePtr cylinder2 = OSG::makeCylinder(10.0, 0.4, 32, true, true ,true); beginEditCP(cylinder2_trans_node); cylinder2_trans_node->addChild(cylinder2); endEditCP(cylinder2_trans_node); SimpleMaterialPtr cylinder2_mat = SimpleMaterial::create(); beginEditCP(cylinder2_mat); cylinder2_mat->setAmbient(Color3f(0.0,0.0,0.0)); cylinder2_mat->setDiffuse(Color3f(0.0,1.0,0.0)); cylinder2_mat->addChunk(pchunk); endEditCP(cylinder2_mat); GeometryPtr cylinder2_geo = GeometryPtr::dcast(cylinder2->getCore()); beginEditCP(cylinder2_geo); cylinder2_geo->setMaterial(cylinder2_mat); beginEditCP(cylinder2_geo); // scene beginEditCP(scene); scene->addChild(plane); scene->addChild(box_trans_node); scene->addChild(cylinder1_trans_node); scene->addChild(cylinder2_trans_node); endEditCP(scene); vp = ShadowViewport::create(); GradientBackgroundPtr gbg = GradientBackground::create(); SolidBackgroundPtr sbg = SolidBackground::create(); UChar8 imgdata[] = { 255,0,0, 0,255,0, 0,0,255, 255,255,0 }; ImagePtr img1 = Image::create(); img1->set(Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, imgdata); TextureChunkPtr tcPtr = TextureChunk::create(); beginEditCP(tcPtr); tcPtr->setImage(img1); endEditCP(tcPtr); TextureBackgroundPtr bkg = TextureBackground::create(); beginEditCP(bkg); bkg->setTexture(tcPtr); endEditCP(bkg); beginEditCP(sbg); sbg->setColor(Color3f(0.2,0.4,0.6)); endEditCP(sbg); beginEditCP(gbg); gbg->addLine(Color3f(0.7, 0.7, 0.8), 0); gbg->addLine(Color3f(0.1, 0.1, 0.3), 1); endEditCP(gbg); beginEditCP(rootNode); rootNode->addChild(point1); rootNode->addChild(point1_beacon); rootNode->addChild(point2_beacon); endEditCP(rootNode); //FBOViewportPtr fbo_vp = FBOViewport::create(); addRefCP(fbo_vp); // the Camera for the map cam = PerspectiveCamera::create(); beginEditCP(cam); cam->setFov(osgdegree2rad(90)); cam->setAspect(1); cam->setNear(0.001); cam->setFar(10000); cam->setBeacon(box_trans_node); endEditCP(cam); beginEditCP(fbo_vp); fbo_vp->setBackground(bkg); fbo_vp->setRoot(rootNode); fbo_vp->setCamera(cam); fbo_vp->setSize(0,0,imageWinWidth-1, imageWinHeight-1); fbo_vp->setStorageWidth(imageWinWidth); fbo_vp->setStorageHeight(imageWinHeight); fbo_vp->setDirty(true); fbo_vp->editMFTextures ()->push_back(plane_tex); fbo_vp->editMFExcludeNodes()->push_back(plane); fbo_vp->setFboOn(true); endEditCP(fbo_vp); // normal shadow viewport beginEditCP(vp); vp->setBackground(gbg); vp->setRoot(rootNode); vp->setSize(0,0,1,1); endEditCP(vp); beginEditCP(gwin); //Window gwin->setId(winid); gwin->addPort(vp); gwin->init(); endEditCP(gwin); Vec3f min,max; rootNode->updateVolume(); rootNode->getVolume().getBounds( min, max ); // create the SimpleSceneManager helper mgr = new SimpleSceneManager; mgr->setWindow(gwin); mgr->setRoot(rootNode); //Viewport beginEditCP(vp); vp->setCamera(mgr->getCamera()); endEditCP(vp); mgr->turnHeadlightOff(); mgr->showAll(); // GLUT main loop glutMainLoop(); return 0; }
void BaseTest::disconnectNodes(const NodePtr& input, const NodePtr& output, bool expectedReturnvalue) { if (expectedReturnvalue) { ///check that the connections are internally all set as "expected" ///the input must have in its output the node 'output' EXPECT_TRUE( input->hasOutputConnected() ); const NodesWList & outputs = input->getGuiOutputs(); bool foundOutput = false; for (NodesWList::const_iterator it = outputs.begin(); it != outputs.end(); ++it) { if (it->lock() == output) { foundOutput = true; break; } } ///the output must have in its inputs the node 'input' const std::vector<NodeWPtr> & inputs = output->getGuiInputs(); int inputIndex = 0; bool foundInput = false; for (U32 i = 0; i < inputs.size(); ++i) { if (inputs[i].lock() == input) { foundInput = true; break; } ++inputIndex; } EXPECT_TRUE(foundInput); EXPECT_TRUE(foundOutput); EXPECT_EQ(output->getInput(inputIndex), input); EXPECT_TRUE( output->isInputConnected(inputIndex) ); } ///call disconnect bool ret = getApp()->getProject()->disconnectNodes(input, output); EXPECT_EQ(expectedReturnvalue, ret); if (expectedReturnvalue) { ///check that the disconnection went OK const NodesWList & outputs = input->getGuiOutputs(); bool foundOutput = false; for (NodesWList::const_iterator it = outputs.begin(); it != outputs.end(); ++it) { if (it->lock() == output) { foundOutput = true; break; } } ///the output must have in its inputs the node 'input' const std::vector<NodeWPtr> & inputs = output->getGuiInputs(); int inputIndex = 0; bool foundInput = false; for (U32 i = 0; i < inputs.size(); ++i) { if (inputs[i].lock() == input) { foundInput = true; break; } ++inputIndex; } EXPECT_FALSE(foundOutput); EXPECT_FALSE(foundInput); EXPECT_EQ( (Node*)NULL, output->getInput(inputIndex).get() ); EXPECT_FALSE( output->isInputConnected(inputIndex) ); } } // disconnectNodes
virtual bool equalTo(const NodePtr& other) { NumericType* nt = dynamic_cast<NumericType*>(other.get()); if (!nt) return false; return (name == nt->name); }
void read(NIFStream *nif) { data.read(nif); root.read(nif); bones.read(nif); }