---

sglDrawablePool.hpp

/*****************************************************************************
 * SGL: A Scene Graph Library
 *
 * Copyright (C) 1997-2001  Scott McMillan   All Rights Reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *****************************************************************************
 *     File: sglDrawablePool.hpp
 *   Author: Tom Stimson
 *  Created: 9 July 2000
 *  Summary: 
 *****************************************************************************/

#ifndef __SGL_DRAWABLE_POOL_HPP
#define __SGL_DRAWABLE_POOL_HPP

#include <sgl.h>
#include <list>
#include <vector>
#include <map>

#include <sglCurrState.hpp>
#include <sglObjPool.hpp>

class sglDrawable;
class sglStats;
struct sglDrawablePoolSources;

//----------------------------------------------------------------------------
class SGL_DLL_API sglDrawItem
{
public:
   sglDrawItem() {}
   virtual ~sglDrawItem() {}

   virtual void draw(sglCurrState *curr_state) const = 0;
   virtual void statsDraw(sglCurrState *curr_state,
                          sglStats& stats) const = 0;
   virtual const sglFullState* getFirstState() const = 0;
};

//----------------------------------------------------------------------------
class SGL_DLL_API sglDrawablePair : public sglDrawItem
{
public:
   sglDrawablePair() : m_drawable(NULL), m_fullstate(NULL) {}
   virtual ~sglDrawablePair() {}

   virtual void draw(sglCurrState *curr_state) const;
   virtual void statsDraw(sglCurrState *curr_state,
                          sglStats& stats) const;
   virtual const sglFullState* getFirstState() const;

   void set(const sglDrawable *drawable, sglFullState *fullstate)
      { m_drawable = drawable; m_fullstate = fullstate; }

private:
   const sglDrawable *m_drawable;
   sglFullState      *m_fullstate;
};

//----------------------------------------------------------------------------
class SGL_DLL_API sglDrawablePool : public sglDrawItem
{
public:
   sglDrawablePool() {};
   virtual ~sglDrawablePool() {};

   virtual void clear() = 0;
   virtual void insert(sglDrawItem *d_item) = 0;

private:  // not implemented
   sglDrawablePool(const sglDrawablePool &);
   sglDrawablePool &operator=(const sglDrawablePool &);
};

//----------------------------------------------------------------------------
class SGL_DLL_API sglUnSortedDrawablePool : public sglDrawablePool
{
public:
   sglUnSortedDrawablePool() {}
   virtual ~sglUnSortedDrawablePool() {}

   void clear()
      { m_list.clear(); }

   void insert(sglDrawItem *d_item)
      { m_list.push_back(d_item); }

   void draw(sglCurrState *curr_state) const;

   void statsDraw(sglCurrState *curr_state,
                  sglStats& stats) const;

   const sglFullState* getFirstState() const;

private:  // not implemented
   sglUnSortedDrawablePool(const sglUnSortedDrawablePool &);
   sglUnSortedDrawablePool &operator=(const sglUnSortedDrawablePool &);

private:
   vector<sglDrawItem*>  m_list;
};

//----------------------------------------------------------------------------
class SGL_DLL_API sglSortedDrawablePool : public sglDrawablePool
{
public:
   sglSortedDrawablePool();
   virtual ~sglSortedDrawablePool();

   void setSortKey(vector<unsigned int>::iterator sort_key)
      { m_sort_key = sort_key; }

   void setSources(sglDrawablePoolSources *sources)
      { m_sources = sources; }

   void clear();

   void insert(sglDrawItem *d_item);

   void draw(sglCurrState *curr_state) const;

   void statsDraw(sglCurrState *curr_state,
                  sglStats& stats) const;

   const sglFullState* getFirstState() const;

private:  // not implemented
   sglSortedDrawablePool(const sglSortedDrawablePool &);
   sglSortedDrawablePool &operator=(const sglSortedDrawablePool &);

private:
   sglDrawablePoolSources                   *m_sources;
   vector<unsigned int>::iterator            m_sort_key;
   map<const void*,sglDrawablePool*>         m_map;
};

//----------------------------------------------------------------------------
class SGL_DLL_API sglIndexedDrawablePool : public sglDrawablePool
{
public:
   sglIndexedDrawablePool() {}
   virtual ~sglIndexedDrawablePool() {}

   void setSortKey(vector<unsigned int>::iterator sort_key)
      { m_sort_key = sort_key; }

   void setSources(sglDrawablePoolSources *sources)
      { m_sources = sources; }

   void clear()
      { m_list.clear(); }

   void insert(sglDrawItem *d_item);

   void draw(sglCurrState *curr_state) const;

   void statsDraw(sglCurrState *curr_state,
                  sglStats& stats) const;

   const sglFullState* getFirstState() const;

private:  // not implemented
   sglIndexedDrawablePool(const sglIndexedDrawablePool &);
   sglIndexedDrawablePool &operator=(const sglIndexedDrawablePool &);

private:
   sglDrawablePoolSources                   *m_sources;
   vector<unsigned int>::iterator            m_sort_key;
   vector<sglDrawablePool*>                  m_list;
};

//----------------------------------------------------------------------------
struct SGL_DLL_API sglDrawablePoolSources
{
public:
   sglDrawablePoolSources()
      : m_unsorted_dp_pool(100, 100),
        m_sorted_dp_pool(100, 100),
        m_indexed_dp_pool(100, 100) {}

   void reset()
      {
         m_unsorted_dp_pool.reset();
         m_sorted_dp_pool.reset();
         m_indexed_dp_pool.reset();
      }

public:
   sglObjPool< sglUnSortedDrawablePool >  m_unsorted_dp_pool;
   sglObjPool< sglSortedDrawablePool >    m_sorted_dp_pool;
   sglObjPool< sglIndexedDrawablePool >   m_indexed_dp_pool;
};

#endif

---