---

sglDrawable.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: sglDrawable.hpp
 *  Created: 18 August 1999
 *  Summary: Base class for all sglObjects that can be collected by the cull
 *           traversal (sglCull) for rendering.
 *****************************************************************************/

#ifndef __SGL_DRAWABLE_HPP
#define __SGL_DRAWABLE_HPP

#include <sgl.h>
#include <sglObject.hpp>

#include <sglBoxBound.hpp>
#include <sglFrustum.hpp>

#include <sglIntersect.hpp>
#include <sglTexCoords.hpp>
#include <sglStatelet.hpp>
#include <sglStats.hpp>
#include <sglOStream.hpp>

#include <vector>

// foward reference this stuff
class sglGeode;
template <class T> class sglIntersect;

// ===========================================================================

class SGL_DLL_API sglDrawable : public sglObject
{
public:
   class SGL_DLL_API StateElement
   {
   public:
      StateElement(unsigned int mask);
      StateElement(unsigned int mask,
                   const vector<sglStatelet*> &statelets,
                   const vector<sglTexCoords> &tex_coords);
      StateElement(unsigned int mask,
                   const vector<sglStatelet*> &statelets,
                   const sglTexCoords &tex_coords);
      ~StateElement();

      unsigned int getMask() const { return m_mask; }

      const vector<sglStatelet*>& getStatelets() const { return m_statelets; }

      const sglTexCoords *getTexCoords() const
         { return (m_tex_coords.empty() ? NULL : &m_tex_coords[0]); }

      const vector<sglTexCoords>& getTexCoordList() const
         { return m_tex_coords; }
      const vector<sglTexCoords>* getTexCoordListPtr() const
         { return &m_tex_coords; }

      GLuint getDisplayList() const { return m_dlist; }

      bool getDirty() const { return m_dirty; }

      void printInfo(ostream &ostrm, const char *indent_string) const;

   private:
      // Not implemented.
      StateElement();
      StateElement(const StateElement &);
      StateElement &operator=(const StateElement &);

      friend class sglDrawable;

      void setStatelets(const vector<sglStatelet*> &statelets);
      void clearStatelets();
      void setTexCoordList(const vector<sglTexCoords> &tex_coords);
      void setTexCoordList(const sglTexCoords &tex_coords);
      void clearTexCoordList();
      void setDisplayList(GLuint dlist);
      void setDirty(bool dirty) { m_dirty = dirty; }

   private:
      unsigned int          m_mask;
      vector<sglStatelet*>  m_statelets;
      vector<sglTexCoords>  m_tex_coords;
      GLuint                m_dlist;
      bool                  m_dirty;

      // tex coord bounds could go here if I ever want to support clip texture
   };

public:
   sglDrawable();
   virtual ~sglDrawable();

   void enableDisplayList(bool on);
   bool getDisplayListFlag() const { return m_use_dlist; }

   unsigned int getNumParents() const { return m_parent_list.size(); }
   sglGeode* getParent(unsigned int i);

   unsigned int getNumStates() { return m_state_list.size(); }
   StateElement *getState(unsigned int index = 0);
   StateElement *getStateByMask(unsigned int mask = 0) const;

   StateElement *findState(unsigned int mask) const;

   void setState(unsigned int mask,
                 const vector<sglStatelet*> &statelets);
   void setState(unsigned int mask,
                 const vector<sglStatelet*> &statelets,
                 sglVec2f *tex_coords);
   void setState(unsigned int mask,
                 const vector<sglStatelet*> &statelets,
                 const sglTexCoords &tex_coords);
   void setState(unsigned int mask,
                 const vector<sglStatelet*> &statelets,
                 const vector<sglTexCoords> &tex_coords);

   void setTexCoordList(sglVec2f* tex_coords);

   void setTexCoordList(const sglTexCoords &tex_coords);

   void setTexCoordList(const vector<sglTexCoords> &tex_coords_list);

   bool removeState(unsigned int mask);

   void setBound(const sglBoxBound *bbox, sglBound::ModeEnum mode);

   virtual const sglBoxBound &getBound();
   sglBound::ModeEnum getBoundMode() {return m_bound_mode;}

   const sglBoxBound &getPrevBound() const { return m_bbox; }

   virtual void addStats(sglStats &stats) const = 0;

   void preDraw();

   sglBound::IntersectResultEnum intersectBBox(sglIntersectf &segset);
   sglBound::IntersectResultEnum intersectBBox(sglIntersectd &segset);

   virtual sglBound::IntersectResultEnum intersectPrim(sglIntersectf &)
      { return sglBound::eOUTSIDE; }
   virtual sglBound::IntersectResultEnum intersectPrim(sglIntersectd &)
      { return sglBound::eOUTSIDE; }

   virtual bool isValid() const { return true; }

   enum AAEnum {ePOINT_AA, eLINE_AA, ePOLYGON_AA, eNO_AA};
   virtual AAEnum getAAType() const { return eNO_AA; }

   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

   void drawImmediate(const vector<sglTexCoords> &tex_coords) const;

   typedef void (sglDrawable::*DrawFunc)(
      const vector<sglTexCoords> &tex_coords) const;

protected:
   friend class sglGeode;

   virtual bool computeBounds() = 0;

   virtual void computeNoBounds();
   virtual void computeBoundsRecursiveDown();

   void dirty(unsigned char mask, bool all);

   void addParent(sglGeode *parent);
   void removeParent(sglGeode *parent);

   bool cull(const sglFrustum<float> &frustum, unsigned int cull_flags) const;
   bool cull(const sglFrustum<double> &frustum, unsigned int cull_flags) const;

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

protected:
   sglBoxBound m_bbox;

   // the first element of the following list is set in the ctor, to
   // something with mask==0, empty statelet list, and NULL tex coords.
   vector<StateElement *> m_state_list;
   bool m_use_dlist;

   DrawFunc m_draw_func;

   sglBound::ModeEnum m_bound_mode;

   enum DirtyEnum { eBOUND = 0x01, eDLIST = 0x02 };
   unsigned char m_dirty;

   vector<sglGeode*> m_parent_list;
};

#endif

---