conductor.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <GL/gl.h>

#include <archon/util/thread.H>

#include <archon/render/context.H>

#include <archon/render/conductor.H>

namespace Archon
{
  namespace Render
  {
    Conductor::Conductor():
      unfinishedSlaves(0), proceed(syncMutex), slaveFinished(syncMutex)
    {
    }

    Ref<Pipe> Conductor::addPipe(Ref<Display::Visual> visual,
                                 bool direct)
    {
      Ref<Pipe> pipe;
      Ref<Thread> thread;
      {
        Mutex::Lock l(syncMutex);
        pipe = new Pipe(visual, direct, masterPipe);
        if(masterPipe)
        {
          thread =
            Thread::run<Conductor, unsigned>(this, &Conductor::slaveThread,
                                             slaves.size(), false);
          slaves.push_back(Slave(pipe, thread));
        }
        else masterPipe = pipe;
      }
      if(thread) Thread::start(thread);
      return pipe;
    }

    void Conductor::addWindow(Ref<Display::Window> d, Ref<Pipe> p)
    {
      Mutex::Lock l(syncMutex);
      for(unsigned i=0; i<windows.size(); ++i)
        if(windows[i].first == d) return;
      windows.push_back(make_pair(d, p));
    }

    void Conductor::render()
    {
      // Clear all windows
      for(unsigned i=0; i<windows.size(); ++i)
      {
        pair<Ref<Display::Window>, Ref<Pipe> > &p = windows[i];
        Display::Bind b(p.second->context, p.first);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      }

      // Proceed slave threads
      {
        Mutex::Lock l(syncMutex);
        for(unsigned i=0; i<slaves.size(); ++i)
          slaves[i].hold = false;
        unfinishedSlaves = slaves.size();
      }
      proceed.notifyAll();

      // Render
      masterPipe->render();

      // Sync with slave threads
      {
        Mutex::Lock l(syncMutex);
        while(unfinishedSlaves) slaveFinished.wait();
      }

      // Swap all buffers
      for(unsigned i=0; i<windows.size(); ++i)
        windows[i].first->swapBuffers();
    }

    void Conductor::slaveThread(unsigned index)
    {
      Ref<Pipe> pipe;
      {
        Mutex::Lock l(syncMutex);
        pipe = slaves[index].pipe;
      }

      for(;;)
      {
        {
          Mutex::Lock l(syncMutex);
          while(slaves[index].hold) proceed.wait();
          slaves[index].hold = true;
        }

        pipe->render();

        {
          Mutex::Lock l(syncMutex);
          --unfinishedSlaves;
        }
        slaveFinished.notifyAll();
      }
    }

    Conductor::Slave::Slave(Ref<Pipe> pipe, Ref<Thread> thread):
      pipe(pipe), thread(thread), hold(true)
    {
    }

    void Conductor::terminate()
    {
      Mutex::Lock l(syncMutex);
      for(unsigned i=0; i<slaves.size(); ++i)
        slaves[i].thread->terminate();
    }
  }
}

---