---

sglView.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: sglView.hpp
 *   Author: Scott McMillan
 *  Created: 6 November 2000
 *  Summary: Encapsulate view port, fov, etc functionality
 *****************************************************************************/

#ifndef __SGL_VIEW_HPP
#define __SGL_VIEW_HPP

#include <sgl.h>
#include <sglTimespec.hpp>
#include <sglVector.hpp>
#include <sglCallback.hpp>

#if defined(vxw)
#include <iterator>
#endif

#include <deque>

class sglScene;
class sglViewPlatform;
class sglStatelet;
class sglGeode;
class sglGeoSet;
class sglLightProcessor;
template <class T> class sglCull;
template <class T> class sglStatsCull;

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

class SGL_DLL_API sglView
{
public:
   sglView();
   virtual ~sglView();

   // Miscellaneous OpenGL functionality not in SGL (yet?)

   void setClearColor(const sglVec4f &color);
   void setClearColor(float r, float g, float b, float a);
   const sglVec4f &getClearColor() const { return m_clear_color; }

   void setClearDepth(double depth);
   double getClearDepth() const { return m_clear_depth; }

   void setViewport(int origin_x, int origin_y,
                    unsigned int width, unsigned int height);
   void getViewport(int &origin_x, int &origin_y,
                    unsigned int &width, unsigned int &height);

   void setScene(sglScene *root);
   sglScene *getScene() const { return m_root; }

   void setViewPlatform(sglViewPlatform *view_platform);
   sglViewPlatform *getViewPlatform() const { return m_view_platform; }

   void setScene(sglScene *root, sglViewPlatform *view_platform);

   void setTraversalType(bool dp_flag, bool stats_flag);
   bool getDPTraversalFlag() const { return m_dptrav_flag; }
   bool getStatsFlag() const { return m_stats_flag; }

   void enableFrameRateOutput(bool on) { m_frame_rate_flag = on; }
   bool getFrameRateOutputFlag() const { return m_frame_rate_flag; }

   void setStatsInterval(double seconds) { m_stats_interval = seconds; }
   double getStatsInterval() const { return m_stats_interval; }

   void setOverrideStatelets(const deque<const sglStatelet*> &statelets)
      {
         m_override_statelets = statelets;
      }

   void setDiscriminatorMask(unsigned int mask) { m_discriminator_mask = mask;}
   unsigned int getDiscriminatorMask() const { return m_discriminator_mask;}

   void setStateMask(unsigned int mask) { m_state_mask = mask; }
   unsigned int getStateMask() const { return m_state_mask; }

   void setDrawCallback(sglCallbackFunc callback, void *data)
      {
         m_draw_callback = callback;
         m_draw_callback_data = data;
      }
   sglCallbackFunc getDrawCallback() const { return m_draw_callback; }
   void *getDrawCallbackData() const { return m_draw_callback_data; }

   void cullAndDraw() { preDraw(); cull(); draw(); }

   void cullAndDraw(const sglTimespec &frame_time, unsigned int frame_count)
        {
            preDraw(frame_time, frame_count);
            cull();
            draw();
        }

   void setLightProcessor(sglLightProcessor *light_processor);

   sglLightProcessor *getLightProcessor() const;

protected:
   void outputFramerate();

   // clean the scene graph
   void preDraw(const sglTimespec &frame_time, unsigned int frame_count);
   void preDraw();

   // cull the scene
   void cull();

   // draw what was culled -- OpenGL gfx context must be current
   void draw();

private:
   sglVec4f         m_clear_color;
   double           m_clear_depth;

   // the view port
   int              m_origin_x;
   int              m_origin_y;
   unsigned int     m_width;
   unsigned int     m_height;

   // stuff in the scene graph
   sglScene        *m_root;
   sglViewPlatform *m_view_platform;

   // the view platform's view_matrix used in the last cull process
   sglMat4f         m_view_matrix_f;
   sglMat4d         m_view_matrix_d;

   // internal traverser objects and their arguments
   bool             m_dptrav_flag;
   bool             m_stats_flag;

   sglCull<float>  *m_trav_state;
   sglCull<double> *m_trav_state_dp;

   sglStatsCull<float>   *m_stats_trav_state;
   sglStatsCull<double>  *m_stats_trav_state_dp;

   deque<const sglStatelet *> m_override_statelets;

   unsigned int     m_discriminator_mask;
   unsigned int     m_state_mask;

   sglCallbackFunc  m_draw_callback;
   void *           m_draw_callback_data;

   // timing for statistics
   sglTimespec      m_last_ts;
   sglTimespec      m_ts1, m_ts2, m_ts3;
   double           m_cull_time;
   double           m_draw_time;
   unsigned int     m_frame_count;
   double           m_stats_interval;

   bool             m_frame_rate_flag;
   double           m_frame_rate;
};

#endif

---