• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMGLXRenderWindow_impl.h

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


 //
 // Getters & setters
 //

inline XDisplay::Pointer & GLXRenderWindow::getDisplay()
{
  return mDisplay;
}

 /*-------------------------------------------------------------------------*/

inline GLXGLContext::Pointer & GLXRenderWindow::getGLXGLContext()
{
  return mGLXGLContext;
}

 /*-------------------------------------------------------------------------*/

inline Process *GLXRenderWindow::getProcess() const
{
  return mProcess;
}

 /*-------------------------------------------------------------------------*/

inline const::Window & GLXRenderWindow::getWindow() const
{
  return mWindow;
}

 /*-------------------------------------------------------------------------*/

inline const bool & GLXRenderWindow::getInitialized() const
{
  return mInitialized;
}

 /*-------------------------------------------------------------------------*/

inline const bool & GLXRenderWindow::getVisible() const
{
  return mVisible;
}

 /*-------------------------------------------------------------------------*/

inline void GLXRenderWindow::setVisible(const bool & visible)
{
  if(!mInitialized && visible)
  {
        // Initialize
        initialize();

        // Set position and size
        _reposition();
        _resize();
  }

  mVisible = visible;
}

 /*-------------------------------------------------------------------------*/

inline const bool & GLXRenderWindow::getFullScreen() const
{
  return mFullScreen;
}

 /*-------------------------------------------------------------------------*/

inline void GLXRenderWindow::setFullScreen(const bool & fullscreen)
{
  mFullScreen = fullscreen;
}

 /*-------------------------------------------------------------------------*/

inline const std::string & GLXRenderWindow::getCaption() const
{
  return mCaption;
}

 /*-------------------------------------------------------------------------*/

inline void GLXRenderWindow::setCaption(const std::string & caption)
{
  mCaption = caption;

  _setCaption();
}

 /*-------------------------------------------------------------------------*/

inline const s32 & GLXRenderWindow::getLeft() const
{
  return mLeft;
}

 /*-------------------------------------------------------------------------*/

inline void GLXRenderWindow::setLeft(const s32 & left)
{
  reposition(left, mTop);
}

 /*-------------------------------------------------------------------------*/

inline const s32 & GLXRenderWindow::getTop() const
{
  return mTop;
}

 /*-------------------------------------------------------------------------*/

inline void GLXRenderWindow::setTop(const s32 & top)
{
  reposition(mLeft, top);
}

 /*-------------------------------------------------------------------------*/

inline const u32 & GLXRenderWindow::getWidth() const
{
  return mWidth;
}

 /*-------------------------------------------------------------------------*/

inline void GLXRenderWindow::setWidth(const u32 & width)
{
  resize(width, mHeight);
}

 /*-------------------------------------------------------------------------*/

inline const u32 & GLXRenderWindow::getHeight() const
{
  return mHeight;
}

 /*-------------------------------------------------------------------------*/

inline void GLXRenderWindow::setHeight(const u32 & height)
{
  resize(mWidth, height);
}

 /*-------------------------------------------------------------------------*/

inline const u32 & GLXRenderWindow::getColourDepth() const
{
  return mColourDepth;
}

 /*-------------------------------------------------------------------------*/

inline void GLXRenderWindow::setColourDepth(const u32 & colourdepth)
{
  mColourDepth = colourdepth;
}

 /*-------------------------------------------------------------------------*/

inline const u32 & GLXRenderWindow::getFSAASamples() const
{
  return mFSAASamples;
}

 /*-------------------------------------------------------------------------*/

inline void GLXRenderWindow::setFSAASamples(const u32 & fsaasamples)
{
  mFSAASamples = fsaasamples;
}

 /*-------------------------------------------------------------------------*/

inline const GLXRenderWindow::WindowStatistics & GLXRenderWindow::getWindowStatistics() const
{
  return mWindowStatistics;
}

 /*-------------------------------------------------------------------------*/

 //
 // Methods
 //

inline void GLXRenderWindow::reposition(const s32 & left, const s32 & top)
{
  mDisplay.lock();
  mLeft = (left == GLXRenderWindow::CENTERED ? (mDisplay->getWidth() - mWidth) / 2 : left);
  mTop = (top == GLXRenderWindow::CENTERED ? (mDisplay->getHeight() - mHeight) / 2 : top);
  mDisplay.unlock();

  if(mInitialized)
        _reposition();
}

 /*----------------------------------------------------------------------*/

inline void GLXRenderWindow::resize(const u32 & width, const u32 & height)
{
  mWidth = width;
  mHeight = height;

  if(mInitialized)
        _resize();
}

 /*----------------------------------------------------------------------*/

inline void GLXRenderWindow::startFrame()
{
  // Reset some stats
  mWindowStatistics.lastTriangleCount = 0;

  // Store frame starting time
  mWindowStatistics.frameBeginTime = Timer::getSystemTime();

  // Set context of the window to current
  setCurrent();
}

 /*----------------------------------------------------------------------*/

inline void GLXRenderWindow::finishFrame()
{
  // Do swapping
  mDisplay.lock();
  glXSwapBuffers(mDisplay->getDisplay(), mWindow);
  mDisplay.unlock();

  // Release context of the window
  releaseCurrent();

  // Store frame end time
  mWindowStatistics.frameEndTime = Timer::getSystemTime();

  // Update stats
  updateStatistics();
}

 /*----------------------------------------------------------------------*/

inline void GLXRenderWindow::_reposition()
{
  mDisplay.lock();
  XMoveWindow(mDisplay->getDisplay(), mWindow, mLeft, mTop);
  mDisplay.unlock();
}

 /*----------------------------------------------------------------------*/

inline void GLXRenderWindow::_resize()
{
  mDisplay.lock();
  XResizeWindow(mDisplay->getDisplay(), mWindow, mWidth, mHeight);
  // TODO: causes segfault
  //glViewport(0, 0, mWidth, mHeight);
  mDisplay.unlock();
}

 /*----------------------------------------------------------------------*/

© Copyright - 2006 (IT)² ParCompMark Dev. Team