---

GlWindow.h

Go to the documentation of this file.

/*************** <auto-copyright.pl BEGIN do not edit this line> **************
 *
 * VR Juggler is (C) Copyright 1998-2003 by Iowa State University
 *
 * Original Authors:
 *   Allen Bierbaum, Christopher Just,
 *   Patrick Hartling, Kevin Meinert,
 *   Carolina Cruz-Neira, Albert Baker
 *
 * 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., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile: GlWindow.h,v $
 * Date modified: $Date: 2004/02/18 17:13:54 $
 * Version:       $Revision: 1.51 $
 * -----------------------------------------------------------------
 *
 *************** <auto-copyright.pl END do not edit this line> ***************/

#ifndef _VJ_GL_WINDOW_H_
#define _VJ_GL_WINDOW_H_

#include <vrj/vrjConfig.h>
#include <vector>

#include <stdio.h>
#include <vpr/vpr.h>

#ifdef VPR_OS_Darwin
#   include <OpenGL/gl.h>
#else
#   include <GL/gl.h>
#endif

#include <vrj/Display/Display.h>
#include <vrj/Display/Viewport.h>

#include <vpr/Util/Debug.h>

#include <boost/concept_check.hpp>


namespace vrj
{

class Projection;
class CameraProjection;

class VJ_CLASS_API GlWindow
{
public:
   GlWindow()
      : mVrjDisplay(NULL)
      , mDirtyContext(true)
      , mDirtyViewport(true)
      , in_stereo(false)
      , border(false)
      , window_is_open(false)
      , window_width(0)
      , window_height(0)
      , origin_x(0)
      , origin_y(0)
      // XXX: Sync problem on window id value assignment
      , mWindowId(getNextWindowId())
      , mAreEventSource(false)
   {
      // The context is always dirty when the window is first created
   }

   // Virtual destructor
   virtual ~GlWindow()
   {;}

public:

   virtual int open()
   {
      return 1;
   }

   virtual int close()
   {
      return 1;
   }

   virtual bool makeCurrent()
   {
      return false;
   }

   virtual void configWindow(vrj::Display* displayWindow);

   virtual void swapBuffers()
   {;}

   virtual void checkEvents()
   {;}

   virtual void finishSetup();

public:
   void setProjection(vrj::Projection* proj);

   void setLeftEyeProjection();

   void setRightEyeProjection();

   void setViewBuffer(vrj::Viewport::View view);

   void setViewport(float xo, float yo, float xSize, float ySize);

   void updateViewport();

   bool hasDirtyContext() const
   {
      return mDirtyContext;
   }

   void setDirtyContext(bool val=true)
   {
      mDirtyContext = val;
   }

   bool hasDirtyViewport() const
   {
      return mDirtyViewport;
   }

   void setDirtyViewport(bool val=true)
   {
      mDirtyViewport = val;
   }

   bool isOpen() const
   {
      return window_is_open;
   }

   bool isStereo() const
   {
      return in_stereo;
   }

   bool isEventSource() const
   {
      return mAreEventSource;
   }

   vrj::Display* getDisplay()
   {
      return mVrjDisplay;
   }

   int getId() const
   {
      return mWindowId;
   }

   // Called by event function to update size info
   // XXX: Should update Display configuration element in some way
   void updateOriginSize(int o_x, int o_y, int width, int height)
   {
      origin_x = o_x; origin_y = o_y;
      window_width = width; window_height = height;

      // Update the display configuration
      mVrjDisplay->setOriginAndSize(o_x, o_y, width, height);
   }

   void getOriginSize(unsigned& o_x, unsigned& o_y, unsigned& width,
                      unsigned& height) const
   {
      o_x = origin_x;
      o_y = origin_y;
      width = window_width;
      height = window_height;
   }

   friend std::ostream& operator<<(std::ostream& out, GlWindow& win);

public:
   virtual bool createHardwareSwapGroup(std::vector<GlWindow*> wins)
   {
      boost::ignore_unused_variable_warning(wins);
      vprDEBUG(vprDBG_ALL,vprDBG_WARNING_LVL)
         << "WARNING: hardware swap not supported.\n" << vprDEBUG_FLUSH;
      return false;
   }

protected:
     // we store a pointer to the display that we're
     // created from, to config & to get the viewing
     // transforms from.
   vrj::Display* mVrjDisplay;

   bool mDirtyContext;  
   bool mDirtyViewport; 
   bool in_stereo;

   bool border;         
   bool window_is_open; 
   int  window_width, window_height;
   int  origin_x, origin_y;         
   int  mWindowId;                  
   bool mAreEventSource;  
private:
   static vpr::Mutex mWinIdMutex;
   static int        mCurMaxWinId;  
   static int getNextWindowId();
};

// ostream& operator<<(ostream& out, GlWindow& win);


} // end namespace
#endif

---