GlWindow.h

Go to the documentation of this file.

/*************** <auto-copyright.pl BEGIN do not edit this line> **************
 *
 * VR Juggler is (C) Copyright 1998-2005 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$
 * Date modified: $Date: 2006-07-12 17:21:40 -0500 (Wed, 12 Jul 2006) $
 * Version:       $Revision: 19032 $
 * -----------------------------------------------------------------
 *
 *************** <auto-copyright.pl END do not edit this line> ***************/

#ifndef _VJ_GL_WINDOW_H_
#define _VJ_GL_WINDOW_H_

#include <vrj/Draw/OGL/Config.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>


namespace vrj
{

class Projection;
class CameraProjection;

class VJ_OGL_CLASS_API GlWindow
{
public:
   GlWindow()
      : mVrjDisplay(NULL)
      , mSwapCount(0)
      // The context is always dirty when the window is first created
      , mDirtyContext(true)
      , mDirtyViewport(true)
      , mInStereo(false)
      , mHasBorder(false)
      , mHideMouse(false)
      , mWindowIsOpen(false)
      , mWindowWidth(0)
      , mWindowHeight(0)
      , mOriginX(0)
      , mOriginY(0)
      // XXX: Sync problem on window id value assignment
      , mWindowId(getNextWindowId())
      , mIsEventSource(false)
   {
      /* Do nothing. */ ;
   }

   virtual ~GlWindow()
   {
      /* Do nothing. */ ;
   }

public:

   virtual bool open()
   {
      return 1;
   }

   virtual bool 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 mWindowIsOpen;
   }

   bool isStereo() const
   {
      return mInStereo;
   }

   bool isEventSource() const
   {
      return mIsEventSource;
   }

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

   int getId() const
   {
      return mWindowId;
   }

   // XXX: Should update Display configuration element in some way.
   void updateOriginSize(const int originX, const int originY, const int width,
                         const int height)
   {
      mOriginX      = originX;
      mOriginY      = originY;
      mWindowWidth  = width;
      mWindowHeight = height;

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

   void getOriginSize(int& originX, int& originY, int& width,
                      int& height) const
   {
      originX = mOriginX;
      originY = mOriginY;
      width   = mWindowWidth;
      height  = mWindowHeight;
   }

   vpr::Uint64 getSwapCount()
   {
      return mSwapCount;
   }

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

protected:
   vrj::Display* mVrjDisplay;

   vpr::Uint64 mSwapCount; 
   bool mDirtyContext;  
   bool mDirtyViewport; 
   bool mInStereo;

   bool mHasBorder;     
   bool mHideMouse;     
   bool mWindowIsOpen;  
   int  mWindowWidth;
   int  mWindowHeight;
   int  mOriginX;       
   int  mOriginY;       
   int  mWindowId;      
   bool mIsEventSource; 
private:
   static vpr::Mutex mWinIdMutex;
   static int        mCurMaxWinId;  
   static int getNextWindowId();
};

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

} // end namespace

#endif

---