Beispiel #1
0
bool Z3DNetworkEvaluator::initializeNetwork()
{
  if (m_locked) {
    LDEBUG() << "locked.";
    return false;
  }

  lock();

  bool failed = false;
  for (size_t i = 0; i < m_renderingOrder.size(); ++i) {
    Z3DProcessor* processor = m_renderingOrder[i];
    if (!processor->isInitialized()) {
      try {
        getGLFocus();
        processor->initialize();
        processor->m_initialized = true;
        CHECK_GL_ERROR;
      }
      catch (const Exception& e) {
        LERROR() << "Failed to initialize processor" << processor->getClassName() << e.what();

        // deinitialize processor, in order to make sure that all resources are freed
        LINFO() << "Deinitializing" << processor->getClassName() << "...";
        getGLFocus();
        processor->m_initialized = true;
        processor->deinitialize();
        processor->m_initialized = false;

        // don't break, try to initialize the other processors even if one failed
        failed = true;
      }
    }
  }

  // update size
  sizeChangedFromProcessor();
  for (size_t i=0; i<m_reverseSortedRenderProcessors.size(); i++) {
    QObject::disconnect(m_reverseSortedRenderProcessors[i],
                        SIGNAL(requestUpstreamSizeChange(Z3DRenderProcessor*)),
                        0, 0);
    connect(m_reverseSortedRenderProcessors[i], SIGNAL(requestUpstreamSizeChange(Z3DRenderProcessor*)),
            this, SLOT(sizeChangedFromProcessor(Z3DRenderProcessor*)));
  }

  unlock();
  CHECK_GL_ERROR;
  return !failed;
}
Beispiel #2
0
void GLCanvas::initPainter() {
    if (painter_) {
        getGLFocus();
        painter_->init();
        painter_->sizeChanged(size_);
    }
}
Beispiel #3
0
bool Z3DNetworkEvaluator::deinitializeNetwork()
{
  if (m_locked) {
    LWARN() << "locked.";
    return false;
  }

  if (!m_canvasRenderer) {
    LWARN() << "no network.";
    return false;
  }

  lock();

  bool failed = false;
  for (size_t i = 0; i < m_renderingOrder.size(); ++i) {
    Z3DProcessor* processor = m_renderingOrder[i];
    if (processor->isInitialized()) {
      try {
        getGLFocus();
        processor->deinitialize();
        processor->m_initialized = false;
        CHECK_GL_ERROR;
      }
      catch (const Exception& e) {
        LERROR() << "Failed to deinitialize processor" << processor->getClassName() << e.what();
        // don't break, try to deinitialize the other processors even if one failed
        failed = true;
      }
    }
  }

  unlock();
  return !failed;
}
Beispiel #4
0
void GLUTCanvas::update() {
    getGLFocus();
    glutPostRedisplay();
}
Beispiel #5
0
void GLUTCanvas::repaint() {
    getGLFocus();
    display();
}
Beispiel #6
0
QString Z3DNetworkEvaluator::process(bool stereo)
{
  if (!m_canvasRenderer)
    return "No Network";

  if (m_locked) {
    LDEBUG() << "locked. Scheduling.";
    m_processPending = true;
    return "";
  }

  lock();

  QString error;

  // notify process wrappers
  for (size_t j = 0; j < m_processWrappers.size(); ++j)
    m_processWrappers[j]->beforeNetworkProcess();
  CHECK_GL_ERROR;

  // Iterate over processing in rendering order
  for (size_t i = 0; i < m_renderingOrder.size(); ++i) {
    Z3DProcessor* currentProcessor = m_renderingOrder[i];

    // all processors should have been initialized at this point
    if (!currentProcessor->isInitialized()) {
      LWARN() << "Skipping uninitialized processor" << currentProcessor->getClassName();
      continue;
    }

    Z3DEye eye = stereo ? LeftEye : CenterEye;

    // run the processor, if it needs processing and is ready
    if (!currentProcessor->isValid(eye) && currentProcessor->isReady(eye)) {
      // notify process wrappers
      for (size_t j=0; j < m_processWrappers.size(); ++j)
        m_processWrappers[j]->beforeProcess(currentProcessor);
      CHECK_GL_ERROR;

      try {
        getGLFocus();
        currentProcessor->process(eye);
        currentProcessor->setValid(eye);
        CHECK_GL_ERROR;
      }
      catch (Exception& e) {
        LERROR() << "Exception from"
                 << currentProcessor->getClassName() << ":" << e.what();
        error += e.what();
        break;
      }
      catch (std::exception& e) {
        LERROR() << "std exception from"
                 << currentProcessor->getClassName() << ":" << e.what();
        error += e.what();
        break;
      }

      // notify process wrappers
      getGLFocus();
      for (size_t j = 0; j < m_processWrappers.size(); ++j)
        m_processWrappers[j]->afterProcess(currentProcessor);
      CHECK_GL_ERROR;
    }

    if (stereo && !currentProcessor->isValid(RightEye) && currentProcessor->isReady(RightEye)) {
      // notify process wrappers
      for (size_t j=0; j < m_processWrappers.size(); ++j)
        m_processWrappers[j]->beforeProcess(currentProcessor);
      CHECK_GL_ERROR;

      try {
        getGLFocus();
        currentProcessor->process(RightEye);
        currentProcessor->setValid(RightEye);
        CHECK_GL_ERROR;
      }
      catch (Exception& e) {
        LERROR() << "Exception from"
                 << currentProcessor->getClassName() << ":" << e.what();
        error += e.what();
        break;
      }
      catch (std::exception& e) {
        LERROR() << "std exception from"
                 << currentProcessor->getClassName() << ":" << e.what();
        error += e.what();
        break;
      }

      // notify process wrappers
      getGLFocus();
      for (size_t j = 0; j < m_processWrappers.size(); ++j)
        m_processWrappers[j]->afterProcess(currentProcessor);
      CHECK_GL_ERROR;
    }
  }

  // notify process wrappers
  for (size_t j = 0; j < m_processWrappers.size(); ++j)
    m_processWrappers[j]->afterNetworkProcess();
  CHECK_GL_ERROR;

  unlock();

  // make sure that canvases are repainted, if their update has been blocked by the locked evaluator
  if (m_processPending) {
    m_processPending = false;
    m_canvasRenderer->invalidate();
  }

  return error;
}
Beispiel #7
0
void Z3DNetworkEvaluator::buildNetwork()
{
  std::set<Z3DProcessor*> prevProcessors(
        m_renderingOrder.begin(), m_renderingOrder.end());

  m_renderingOrder.clear();
  m_processorToVertexMapper.clear();
  m_processorGraph.clear();
  m_reverseSortedRenderProcessors.clear();

  // nothing more to do, if no network sink is present
  if (!m_canvasRenderer)
    return;

  std::set<Z3DProcessor*> processed;
  std::queue<Z3DProcessor*> processQueue;

  processQueue.push(m_canvasRenderer);
  Vertex v = boost::add_vertex(VertexInfo(m_canvasRenderer), m_processorGraph);
  m_processorToVertexMapper[m_canvasRenderer] = v;

  // build graph of all connected processors
  while (!processQueue.empty()) {
    Z3DProcessor *processor = processQueue.front();
    const std::vector<Z3DInputPortBase*> inports = processor->getInputPorts();
    for (size_t i = 0; i < inports.size(); ++i) {
      const std::vector<Z3DOutputPortBase*> connected = inports[i]->getConnected();
      for (size_t j = 0; j < connected.size(); ++j) {
        Z3DProcessor *outProcessor = connected[j]->getProcessor();
        if (m_processorToVertexMapper.find(outProcessor) ==
            m_processorToVertexMapper.end()) {
          processQueue.push(outProcessor);
          Vertex v = boost::add_vertex(VertexInfo(outProcessor), m_processorGraph);
          m_processorToVertexMapper[outProcessor] = v;
        }
        boost::add_edge(m_processorToVertexMapper[outProcessor],
                        m_processorToVertexMapper[processor],
                        EdgeInfo(connected[j], inports[i]),
                        m_processorGraph);
      }
    }

    processed.insert(processor);
    processQueue.pop();
  }

  // sort to get rendering order
  std::vector<Vertex> sorted;
  boost::topological_sort(m_processorGraph, std::back_inserter(sorted));
  for (std::vector<Vertex>::reverse_iterator rit = sorted.rbegin();
       rit != sorted.rend(); rit++) {
    m_renderingOrder.push_back(m_processorGraph[*rit].processor);
  }

#ifdef _DEBUG_
  LINFO() << "Rendering Order: ";
  for (size_t i=0; i<m_renderingOrder.size(); i++) {
    LINFO() << "  " << i << ": " << m_renderingOrder[i]->getClassName();
  }
  LINFO() << "";
#endif

  // compare processors in network before and after updating, deinitialize removed processors
  std::set<Z3DProcessor*> currProcessors(m_renderingOrder.begin(), m_renderingOrder.end());
  std::set<Z3DProcessor*> removedProcessors;
  std::set_difference(prevProcessors.begin(), prevProcessors.end(),
                      currProcessors.begin(), currProcessors.end(),
                      std::inserter(removedProcessors, removedProcessors.end()));

  if (!removedProcessors.empty()) {
#ifdef _DEBUG_
    LINFO() << "Deinitialized processors after updating: ";
#endif
    for (std::set<Z3DProcessor*>::iterator it=removedProcessors.begin();
         it != removedProcessors.end(); ++it) {
#ifdef _DEBUG_
      LINFO() << "  " << " : " << (*it)->getClassName();
#endif
      try {
        getGLFocus();
        (*it)->deinitialize();
        (*it)->m_initialized = false;
        CHECK_GL_ERROR;
      }
      catch (const Exception& e) {
        LERROR() << "Failed to deinitialize processor" << (*it)->getClassName() << e.what();
      }
    }
#ifdef _DEBUG_
    LINFO() << "";
#endif
  }

  // update reverse sorted renderprocessors
  for (std::vector<Z3DProcessor*>::reverse_iterator rit = m_renderingOrder.rbegin();
       rit != m_renderingOrder.rend(); rit++) {
    if (qobject_cast<Z3DRenderProcessor*>(*rit) == 0)
      continue;
    m_reverseSortedRenderProcessors.push_back(qobject_cast<Z3DRenderProcessor*>(*rit));
  }
}