---

sglCull.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: sglCull.hpp (was sglTraversal.hpp)
 *  Created: 13 February 1999
 *  Summary: contains the traversal state for cull traversals
 *****************************************************************************/

#ifndef __SGL_CULL_HPP
#define __SGL_CULL_HPP

#include <sgl.h>
#include <sglTraverser.hpp>
#include <sglMat4.hpp>

#include <vector>
#include <deque>

#include <sglDrawable.hpp>
#include <sglObjPool.hpp>
#include <sglCurrState.hpp>
#include <sglDrawablePool.hpp>
#include <sglLightProcessor.hpp>

template <class T> class sglFrustum;
class sglLight;

// ----------------------------------------------------------------------------

// This is the object stored in the transparency bin contains a pointer to a
// geoset/geostate/texcoord triplet with transparency enabled, the range (used
// for ordering), and any other state information needed to draw it

class sglRangeObject;
typedef sglRangeObject* sglRangeObjectPtr; // readability


class SGL_DLL_API sglRangeObject
{
public:
   sglRangeObject() {};
   virtual ~sglRangeObject() {};

   // Smaller range means lower priority for the transparency bin.
   // This SmallerRange function is used by the sort on the transparency bin
   // to determine proper ordering of objects
   static bool smallerRange(const sglRangeObjectPtr &x,
                            const sglRangeObjectPtr &y);

   // This GreaterRange function is used by the sort on the occlusion bin
   // to determine proper ordering of objects
   static bool greaterRange(const sglRangeObjectPtr &x,
                            const sglRangeObjectPtr &y);

   const sglFullState *getState() const { return m_fullstate; }

   void set(const sglDrawable *drawable,
            const sglFullState *state,
            float range)
      {
         m_range = range;
         m_fullstate = state;
         m_drawable = drawable;
      }

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

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

protected:
   float                m_range;
   const sglFullState  *m_fullstate;
   const sglDrawable   *m_drawable;
};

// ----------------------------------------------------------------------------
// This is the object stored in the occlusion bin.  An occlusiong test
// is done before attempting to draw.

class SGL_DLL_API sglOcclusionObject : public sglRangeObject
{
public:
   sglOcclusionObject() {};
   ~sglOcclusionObject() {};

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

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


//----------------------------------------------------------------------------

class SGL_DLL_API sglTransformStateletBase : public sglStatelet
{
public:
   sglTransformStateletBase() : sglStatelet(eTRANSFORM_MATRIX) {}
   virtual ~sglTransformStateletBase() {}
   virtual void mul(const sglVec3f &in, sglVec4f &out) const = 0;
};

template <class T>
class SGL_DLL_API sglTransformStatelet : public sglTransformStateletBase
{
public:
   sglTransformStatelet() {}
   virtual ~sglTransformStatelet() {}

   void setMatrix(const sglMat4<T>& matrix) { m_matrix = matrix; }
   const sglMat4<T>& getMatrix() const { return m_matrix; }

   void setRescale(bool rescale_flag) { m_rescale_flag = rescale_flag; }
   bool getRescale() const { return m_rescale_flag; }

   void setNormalize(bool normalize_flag) { m_normalize_flag = normalize_flag;}
   bool getNormalize() const { return m_normalize_flag; }

   virtual void mul(const sglVec3f &in, sglVec4f &out) const
      { ::mul(in, 1.0f, m_matrix, out); }

   void setIndex(unsigned int indx) { m_index = indx; }

   void apply(sglCurrState*) const;

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

private:
   sglMat4<T>  m_matrix;
   bool        m_rescale_flag;
   bool        m_normalize_flag;
};


//----------------------------------------------------------------------------
class SGL_DLL_API sglCullDrawablePool : public sglDrawablePool
{
public:
   sglCullDrawablePool(sglDrawablePoolSources &sources)
      : m_opaque_bin(NULL),
        m_transparency_sorted_flag(true),
        m_transparency_bin(),
        m_occlusion_sorted_flag(true),
        m_occlusion_bin(),
        m_range_pool(100, 100),
        m_occlusion_pool(0, 10),
        m_drawable_pair_pool(100, 100),
        m_drawable_pool_sources(sources) {};

   virtual ~sglCullDrawablePool() { delete m_opaque_bin; }

   void clear();

   void insert(const sglDrawable *geom, sglFullState *full_state)
      {
         bool occlusion_cull =
            static_cast<const sglOcclusionCull*>(
               full_state->m_statelet[sglStatelet::eOCCLUSION_CULL])
            ->isEnabled();
         bool transparency =
            static_cast<const sglTransparency*>(
               full_state->m_statelet[sglStatelet::eTRANSPARENCY])
            ->isEnabled();

#if 1
         // For best rendering results antialiased primitives need to be
         // sorted due to the blending.
         transparency |=
            (static_cast<const sglAntiAliasPoint*>(
               full_state->m_statelet[sglStatelet::eANTI_ALIAS_POINT])
             ->isEnabled() && geom->getAAType() == sglDrawable::ePOINT_AA) ||
            (!sgl::s_multisample_capable &&
             static_cast<const sglAntiAliasLine*>(
               full_state->m_statelet[sglStatelet::eANTI_ALIAS_LINE])
             ->isEnabled() && geom->getAAType() == sglDrawable::eLINE_AA);
#endif

         if (occlusion_cull || transparency)
         {
            // compute the range to ?the center of the bounding box?
            sglVec3f center(geom->getPrevBound().getMax());
            center += geom->getPrevBound().getMin();
            center *= 0.5;

            sglVec4f offset;
            static_cast<const sglTransformStateletBase*>(
               full_state->m_statelet[sglStatelet::eTRANSFORM_MATRIX])->mul(
                  center, offset);

            float range = (offset[0]*offset[0] +
                           offset[1]*offset[1] +
                           offset[2]*offset[2]);

            if (occlusion_cull)
            {
               if (transparency)
               {
                  sglRangeObject *obj = m_occlusion_pool.newObject();
                  obj->set(geom, full_state, range);
                  m_transparency_bin.push_back(obj);
                  m_transparency_sorted_flag = false;
               }
               else
               {
                  sglRangeObject *obj = m_occlusion_pool.newObject();
                  obj->set(geom, full_state, range);
                  m_occlusion_bin.push_back(obj);
                  m_occlusion_sorted_flag = false;
               }
            }
            else
            {
               sglRangeObject *obj = m_range_pool.newObject();
               obj->set(geom, full_state, range);
               m_transparency_bin.push_back(obj);
               m_transparency_sorted_flag = false;
            }
         }
         else
         {
            sglDrawablePair* d_pair = m_drawable_pair_pool.newObject();
            d_pair->set(geom, full_state);
            m_opaque_bin->insert(d_pair);
         }
      }

   void insert(sglDrawItem *d_item);

   void sortBins();

   void draw(sglCurrState *curr_state) const;

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

   const sglFullState* getFirstState() const;

   sglDrawablePair* getDrawablePair()
      { return m_drawable_pair_pool.newObject(); }

   void setSortOrder(const vector<unsigned int> &sort_order);

   const vector<unsigned int>& getSortOrder() const
      { return m_sort_order; }

   void setupSort(const vector<const sglStatelet*> &statelets);

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

private:
   sglDrawablePool                      *m_opaque_bin;

   bool                                  m_transparency_sorted_flag;
   vector<sglRangeObjectPtr>             m_transparency_bin;

   bool                                  m_occlusion_sorted_flag;
   vector<sglRangeObjectPtr>             m_occlusion_bin;

   sglObjPool< sglRangeObject >          m_range_pool;
   sglObjPool< sglOcclusionObject >      m_occlusion_pool;
   sglObjPool< sglDrawablePair >         m_drawable_pair_pool;

   vector<unsigned int>                  m_sort_order;
   sglDrawablePoolSources               &m_drawable_pool_sources;
};


//----------------------------------------------------------------------------

template <class T>
class SGL_DLL_API sglCull : public sglTraverser
{
public:
   sglCull();
   virtual ~sglCull();

   void setSortOrder(const vector<unsigned int> &sort_order)
      { m_default_bin.setSortOrder(sort_order); }
   const vector<unsigned int>& getSortOrder() const
      { return m_default_bin.getSortOrder(); }

   void initialize(float lod_scale,
                   unsigned int discriminator_mask,
                   unsigned int state_mask,
                   const sglMat4<T>  &view_matrix,
                   const sglFrustum<T> &frustum,
                   unsigned int viewport_x, unsigned int viewport_y,
                   const vector<const sglStatelet*> &default_statelets,
                   const deque<const sglStatelet*> &override_statelets,
                   unsigned int frame_count,
                   const sglTimespec &frame_time);

   unsigned int getStateMask() const { return m_state_mask; }

   void getViewportSize(unsigned int &x, unsigned int &y)
      { x = m_viewport_x; y = m_viewport_y; }

   sglFrustum<T> &getOrigFrustum() { return m_orig_frustum; }
   sglFrustum<T> &getFrustum() { return m_current_frustum; }

   void pushModelViewMatrix(const sglMat4<T>& matrix,
                            bool rescale, bool normalize)
      {
         sglTransformStatelet<T>* trans = m_transform_pool.newObject();
         trans->setMatrix(matrix);

         trans->setRescale(
            m_current_matrix_statelet.back()->getRescale() || rescale);
         trans->setNormalize(
            m_current_matrix_statelet.back()->getNormalize() || normalize);
         trans->setIndex(m_num_matrices++);

         m_current_matrix_statelet.push_back(trans);

         m_statelet[sglStatelet::eTRANSFORM_MATRIX] = trans;
      }
   const sglMat4<T> &getModelViewMatrix()
      {
         return m_current_matrix_statelet.back()->getMatrix();
      }
   void popModelViewMatrix()
      {
         m_current_matrix_statelet.pop_back();
         m_statelet[sglStatelet::eTRANSFORM_MATRIX] =
            m_current_matrix_statelet.back();
      }

   void pushDefaultStatelet(const sglStatelet *state);
   void popDefaultStatelet();
   void pushOverrideStatelet(const sglStatelet *state);
   void popOverrideStatelet();

   void addDrawable(const sglDrawable *geom,
                    const sglDrawable::StateElement *state)
      {
         if (!geom->isValid()) return;

         sglFullState* full_state = m_state_pool.newObject();
         full_state->m_tex_coords = state->getTexCoordListPtr();
         full_state->m_dlist = state->getDisplayList();

         for (unsigned int ii = 0; ii < sgl::s_num_statelet_types; ++ii)
            full_state->m_statelet[ii] = m_statelet[ii];

         vector<sglStatelet*>::const_iterator end =
            state->getStatelets().end();
         for (vector<sglStatelet*>::const_iterator jj =
                 state->getStatelets().begin(); jj != end; ++jj)
         {
            unsigned int statelet_type = (*jj)->getType();
            if (statelet_type < sgl::s_num_statelet_types &&
                !m_override[statelet_type])
               full_state->m_statelet[statelet_type] = *jj;
         }

         if (m_drawable_pool_stack.empty())
         {
            m_default_bin.insert(geom, full_state);
         }
         else
         {
            sglDrawablePair *d_pair = m_default_bin.getDrawablePair();
            d_pair->set(geom, full_state);
            m_drawable_pool_stack.back()->insert(d_pair);
         }
      }

   sglDrawablePool* pushDrawablePool();
   void popDrawablePool();

   void addLight(const sglLight* light)
      { m_light_processor->addLight(getModelViewMatrix(), light); }

   void setLightProcessor(sglLightProcessor *light_processor);

   sglLightProcessor *getLightProcessor() const
      { return m_light_processor; }

   virtual void draw();

protected:
   bool initState();

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

protected:
   unsigned int                          m_state_mask;
   unsigned int                          m_viewport_x;
   unsigned int                          m_viewport_y;
   sglFrustum<T>                         m_orig_frustum;
   sglFrustum<T>                         m_current_frustum;
   vector<sglTransformStatelet<T>*>      m_current_matrix_statelet;
   unsigned int                          m_num_matrices;

   vector<const sglStatelet*>            m_statelet;
   vector<bool>                          m_override;
   vector<const sglStatelet*>            m_default_state_stack;
   vector<const sglStatelet*>            m_override_state_stack;

   sglCurrState                          m_curr_state;

   sglDrawablePoolSources                m_drawable_pool_sources;
   sglCullDrawablePool                   m_default_bin;
   vector< sglDrawablePool* >            m_drawable_pool_stack;

   sglObjPool< sglTransformStatelet<T> > m_transform_pool;
   sglObjPool< sglFullState >            m_state_pool;

   sglLightProcessor                    *m_light_processor;
};


//----------------------------------------------------------------------------
template <class T>
class SGL_DLL_API sglStatsCull : public sglCull<T>
{
public:
   sglStatsCull() : sglCull<T>() {};
   virtual ~sglStatsCull() {};

   sglStats& getStats() { return m_stats; }

   virtual void draw();

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

protected:
   sglStats  m_stats;
};

//----------------------------------------------------------------------------
// convenience types:
//    template class 'should' only be float or double

typedef sglCull<float>       sglCullf;
typedef sglCull<double>      sglCulld;
typedef sglStatsCull<float>  sglStatsCullf;
typedef sglStatsCull<double> sglStatsCulld;

#endif

---