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

Search this page:

PCMGLXRenderWindow.cpp

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.

//
// Inner includes
//

#include "../include/PCMGLXRenderWindow.h"

#include "../include/PCMProcess.h"

#include "../include/PCMStringConverter.h"

//
// Outer includes
//

#include <GL/gl.h>
#include <GL/glu.h>
#if defined(HAVE_LIBXRANDR)
#  include <X11/extensions/Xrandr.h>
#endif

namespace ParCompMark
{

  //
  // Class constants
  //

  const s32 GLXRenderWindow::CENTERED = -1;
  const u32 GLXRenderWindow::MAXIMALSIZE = 0;
  const Real GLXRenderWindow::UNDEFINEDSTATISTICS = -1.0;
  const s32 GLXRenderWindow::UNDEFINEDXRRCONFIGURATION = -1;
  const u32 GLXRenderWindow::DEFAULTWINDOWWIDTH = 128;
  const u32 GLXRenderWindow::DEFAULTWINDOWHEIGHT = 128;

  //
  // Constructors & destructor
  //

   GLXRenderWindow::GLXRenderWindow(XDisplay::Pointer & display, Process * process, const std::string caption,
                                   const bool & fullScreen, const u32 & colourDepth,
                                   const u32 & width, const u32 & height, const s32 & left,
                                   const s32 & top, const u32 & fsaaSamples):
        // X Display pointer initializer 
   mDisplay(display             /* Corresponding X Display */
  ),
        // Process initializer 
   mProcess(process             /* Corresponding process */
        )
        // You have to initialize the following attributes:
        // - mDisplay
        // - mGLXGLContext
        // - mProcess
        // - mWindow
        // - mInitialized
        // - mVisible
        // - mFullScreen
        // - mCaption
        // - mLeft
        // - mTop
        // - mWidth
        // - mHeight
        // - mColourDepth
        // - mFSAASamples
        // - mOriginalXRRConfiguation
        // - mAtomDeleteWindow
        // - mWindowStatistics
        // - mRenderingBeginTime
        // - mFPSMeasuringBeginTime
        // - mFPSMeasuringFrameCount
        // - mSumTriangleCount
        // - mSumFPS
  {
        mWindow = 0;
        mInitialized = false;
        mVisible = false;
        mFullScreen = fullScreen;
        mCaption = caption;
        mLeft = left;
        mTop = top;
        mWidth = width;
        mHeight = height;
        mColourDepth = colourDepth;
        mFSAASamples = fsaaSamples;
        mOriginalXRRConfiguation = UNDEFINEDXRRCONFIGURATION;

        // Reset window stats
        resetStatistics();
  }

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

  GLXRenderWindow::~GLXRenderWindow()
  {
        if(mInitialized)
         finalize();
  }

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

  //
  // Methods
  //

  void GLXRenderWindow::setCurrent()
  {
        mGLXGLContext.lock();
        mGLXGLContext->setCurrent();
        mGLXGLContext.unlock();
  }

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

  void GLXRenderWindow::releaseCurrent()
  {
        mGLXGLContext.lock();
        mGLXGLContext->releaseCurrent();
        mGLXGLContext.unlock();
  }

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

  void GLXRenderWindow::initialize()
  {
        Assert(!mInitialized, INVALID_OPERATION_ERROR, "GLXRenderWindow::initalize()");

        // Create GLX window
        createWindow();

        // Reset accumulation attributes
        mSumTriangleCount = 0.0;
        mSumFPS = 0.0;

        // Init frame counter 
        mWindowStatistics.frameCount = 0;

        mInitialized = true;
  }

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

  void GLXRenderWindow::finalize()
  {
        Assert(mInitialized, INVALID_OPERATION_ERROR, "GLXRenderWindow::finalize()");

        // Finalize the glx context

        // Destroy GLX window
        destroyWindow();

        mGLXGLContext.lock();
        mGLXGLContext->finalize();
        mGLXGLContext.unlock();

        //TODO: VREGATH
        mGLXGLContext.kill();

        mInitialized = false;

  }

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

  void GLXRenderWindow::resetStatistics()
  {
        mWindowStatistics.lastTriangleCount = 0;
        mWindowStatistics.frameCount = 0;

        // Initialize window statistics with undefined values
        mWindowStatistics.lastFrameTime = UNDEFINEDSTATISTICS;
        mWindowStatistics.bestFrameTime = UNDEFINEDSTATISTICS;
        mWindowStatistics.worstFrameTime = UNDEFINEDSTATISTICS;

        mWindowStatistics.avgTriangleCount = UNDEFINEDSTATISTICS;
        mWindowStatistics.maxTriangleCount = UNDEFINEDSTATISTICS;
        mWindowStatistics.minTriangleCount = UNDEFINEDSTATISTICS;

        mWindowStatistics.lastFPS = UNDEFINEDSTATISTICS;
        mWindowStatistics.avgFPS = UNDEFINEDSTATISTICS;
        mWindowStatistics.bestFPS = UNDEFINEDSTATISTICS;
        mWindowStatistics.worstFPS = UNDEFINEDSTATISTICS;

        // Store frame staring time and the start of the rendering
        mRenderingBeginTime = mWindowStatistics.frameBeginTime = Timer::getSystemTime();

        // Initialize FPS calculation
        mFPSMeasuringBeginTime = Timer::getSystemTime();
        mFPSMeasuringFrameCount = 0;
  }

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

  void GLXRenderWindow::reportTriangles(const u32 & triangleCount)
  {
        mWindowStatistics.lastTriangleCount += triangleCount;
  }

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

  void GLXRenderWindow::createWindow()
  {
        mDisplay.lock();

        // Initialize display if needed
        if(!mDisplay->getInitialized())
         mDisplay->initialize();

        ::Display * display = mDisplay->getDisplay();

        // We will attempt to create new window on default screen op display 0
        // unless external window handle passed below
        int screen = DefaultScreen(display);
        int depth = DisplayPlanes(display, screen);
        Window rootWindow = RootWindow(display, screen);
        Window parentWindow = rootWindow;

        // Determine position and dimensions (consider special values)
        if(mWidth == MAXIMALSIZE)
         mWidth = mDisplay->getWidth();
        if(mHeight == MAXIMALSIZE)
         mWidth = mDisplay->getHeight();
        if(mLeft == CENTERED)
         mLeft = (mDisplay->getWidth() - mWidth) / 2;
        if(mTop == CENTERED)
         mTop = (mDisplay->getHeight() - mHeight) / 2;

        // Check for full screen mode if FSAA was asked for
        if(!mFullScreen && mFSAASamples > 0)
        {
         Logger::getInstance()->log(Logger::WARNING, "FSAA only supported in fullscreen mode");
         mFSAASamples = 0;
        }
#ifdef HAVE_LIBXRANDR
        // Attempt mode switch for fullscreen -- only if RANDR extension is there
        int dummy;

        if(mFullScreen && !XQueryExtension(display, "RANDR", &dummy, &dummy, &dummy))
        {
         Logger::getInstance()->log(Logger::WARNING,
                                   "Could not switch to full screen mode: No XRANDR extension found");
        } else if(mFullScreen)
        {
         // Use Xrandr extension to switch video modes. This is much better than
         // XVidMode as you can't scroll away from the full-screen applications.
         XRRScreenConfiguration *config;
         XRRScreenSize *sizes;
         Rotation current_rotation;
         int nsizes;

         // Get current screen info
         config = XRRGetScreenInfo(display, rootWindow);
         // Get available sizes
         if(config)
                sizes = XRRConfigSizes(config, &nsizes);

         if(config && nsizes > 0)
         {
                // Get current size and rotation
                mOriginalXRRConfiguation = XRRConfigCurrentConfiguration(config, &current_rotation);
                // Find smallest matching mode
                int mode = -1;
                int mode_width = INT_MAX;
                int mode_height = INT_MAX;

                for(int i = 0; i < nsizes; i++)
                {
                 if((u32) sizes[i].width >= mWidth && (u32) sizes[i].height >= mHeight && sizes[i].width < mode_width
                   && sizes[i].height < mode_height)
                 {
                        mode = i;
                        mode_width = sizes[i].width;
                        mode_height = sizes[i].height;
                 }
                }
                if(mode >= 0)
                {
                 // Finally, set the screen configuration
                 Logger::getInstance()->log(Logger::NOTICE, "Entering full screen mode");

                 XRRSetScreenConfig(display, config, rootWindow, mode, current_rotation, CurrentTime);
                } else
                {
                 Logger::getInstance()->log(Logger::WARNING,
                                           "Could not switch to full screen mode: No conforming mode was found");
                }
                // Free configuration data
                XRRFreeScreenConfigInfo(config);
         } else
         {
                Logger::getInstance()->log(Logger::WARNING,
                                         "Could not switch to full screen mode: XRRGetScreenInfo failed");
         }
        }
#endif

        XVisualInfo *visualInfo = NULL;

        // Apply some magic algorithm to get the best visual
        int best_visual = mDisplay->findBestVisual(screen, mFSAASamples);

        if(best_visual == -1)
        {
         best_visual = mDisplay->findBestVisual(screen);
         Logger::getInstance()->log(Logger::WARNING,
                                   "Requested FSAA was not acquirable, defaulting to first suitable visual");
        }
        // Get information about this so-called-best visual
        XVisualInfo templ;
        int nmatch;

        templ.visualid = best_visual;
        visualInfo = XGetVisualInfo(display, VisualIDMask, &templ, &nmatch);
        Assert(visualInfo && nmatch, INVALID_OPERATION_ERROR, "GLXRenderWindow::createWindow()");

        XSetWindowAttributes attr;
        unsigned long mask;

        attr.background_pixel = 0;
        attr.border_pixel = 0;
        attr.colormap = XCreateColormap(display, rootWindow, visualInfo->visual, AllocNone);
        attr.event_mask = StructureNotifyMask | VisibilityChangeMask;
        if(mFullScreen)
        {
         mask = CWBackPixel | CWColormap | CWOverrideRedirect | CWSaveUnder | CWBackingStore | CWEventMask;
         attr.override_redirect = True;
         attr.backing_store = NotUseful;
         attr.save_under = False;

         // Fullscreen windows are always in the top left origin with full size
         mLeft = mTop = 0;
         mWidth = (u32) DisplayWidth(display, screen);
         mHeight = (u32) DisplayHeight(display, screen);

        } else
         mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;

        // Create window on server
        mWindow =
         XCreateWindow(display, parentWindow, mLeft, mTop, mWidth, mHeight, 0, visualInfo->depth, InputOutput,
                        visualInfo->visual, mask, &attr);
        Assert(mWindow, INVALID_OPERATION_ERROR, "GLXRenderWindow::createWindow()");

        // Make sure the window is in normal state
        XWMHints *wm_hints;

        if((wm_hints = XAllocWMHints()) != NULL)
        {
         wm_hints->initial_state = NormalState;
         wm_hints->input = True;
         wm_hints->flags = StateHint | InputHint;

         // Check if we can give it an icon
         if(depth == 24 || depth == 32)
         {
                // TODO: The right bit depth, we can load an icon
                // if(GLXUtils::LoadIcon(display, rootWindow, "GLX_icon.png", &wm_hints->icon_pixmap, &wm_hints->icon_mask))
                // wm_hints->flags |= IconPixmapHint | IconMaskHint;
         }
        }
        // Set size and location hints
        XSizeHints *size_hints;

        if((size_hints = XAllocSizeHints()) != NULL)
        {
         // Otherwise some window managers ignore our position request
         size_hints->flags = USPosition;
        }
        // Make text property from title
        XTextProperty titleprop;
        char *lst = (char *) mCaption.c_str();

        XStringListToTextProperty((char **) &lst, 1, &titleprop);

        XSetWMProperties(display, mWindow, &titleprop, NULL, NULL, 0, size_hints, wm_hints, NULL);

        // We don't like memory leaks. Free the clientside storage, but not the
        // pixmaps as they're still being used by the server.
        XFree(titleprop.value);
        XFree(wm_hints);
        XFree(size_hints);

        // TODO: not needed currently
        // Acquire atom to recognize window close events
        mAtomDeleteWindow = XInternAtom(display, "WM_DELETE_WINDOW", False);
        XSetWMProtocols(display, mWindow, &mAtomDeleteWindow, 1);

        // Map window unto screen and focus it.
        XMapWindow(display, mWindow);

        // Make sure the server is up to date and focus the window
        // TODO: causes error with remote X
        XFlush(display);

        // Unlock display (passing to glxcontext will need to lock it)
        mDisplay.unlock();

        // Create context for this window
        mGLXGLContext = new GLXGLContext(mDisplay, this, visualInfo);
        mGLXGLContext.lock();
        mGLXGLContext->initialize();
        mGLXGLContext.unlock();

        // Free visual info
        XFree(visualInfo);

        Logger::getInstance()->log(Logger::NOTICE,
                                 "GLX Window `" + mCaption + "\' has been created on display `" +
                                 mDisplay->getDisplayName() + "\'");
  }

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

  void GLXRenderWindow::destroyWindow()
  {
        Assert(mWindow, NULL_POINTER_ERROR, "GLXRenderWindow::destroyWindow()");

        mDisplay.lock();
        XDestroyWindow(mDisplay->getDisplay(), mWindow);
        mDisplay.unlock();

        Logger::getInstance()->log(Logger::NOTICE, "GLX Window: `" + mCaption + "\' has been destroyed.");
  }

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

  void GLXRenderWindow::updateStatistics()
  {
        mWindowStatistics.frameCount++;
        mWindowStatistics.renderingTime = mWindowStatistics.frameEndTime - mRenderingBeginTime;

        //
        // Frame times
        //
        mWindowStatistics.lastFrameTime = mWindowStatistics.frameEndTime - mWindowStatistics.frameBeginTime;
        if(mWindowStatistics.bestFrameTime == UNDEFINEDSTATISTICS)
        {
         mWindowStatistics.bestFrameTime = mWindowStatistics.lastFrameTime;
        } else
        {
         mWindowStatistics.bestFrameTime =
                mWindowStatistics.lastFrameTime <
                mWindowStatistics.bestFrameTime ? mWindowStatistics.lastFrameTime : mWindowStatistics.bestFrameTime;
        }

        if(mWindowStatistics.worstFrameTime == UNDEFINEDSTATISTICS)
        {
         mWindowStatistics.worstFrameTime = mWindowStatistics.lastFrameTime;
        } else
        {
         mWindowStatistics.worstFrameTime =
                mWindowStatistics.lastFrameTime >
                mWindowStatistics.worstFrameTime ? mWindowStatistics.lastFrameTime : mWindowStatistics.worstFrameTime;
        }

        //
        // Triangle count
        //
        if(mWindowStatistics.minTriangleCount == UNDEFINEDSTATISTICS)
        {
         mWindowStatistics.minTriangleCount = mWindowStatistics.lastTriangleCount;
        } else
        {
         mWindowStatistics.minTriangleCount =
                mWindowStatistics.lastTriangleCount <
                mWindowStatistics.minTriangleCount ? mWindowStatistics.lastTriangleCount : mWindowStatistics.
                minTriangleCount;
        }

        if(mWindowStatistics.maxTriangleCount == UNDEFINEDSTATISTICS)
        {
         mWindowStatistics.maxTriangleCount = mWindowStatistics.lastTriangleCount;
        } else
        {
         mWindowStatistics.maxTriangleCount =
                mWindowStatistics.lastTriangleCount >
                mWindowStatistics.maxTriangleCount ? mWindowStatistics.lastTriangleCount : mWindowStatistics.
                maxTriangleCount;
        }

        mSumTriangleCount += mWindowStatistics.lastTriangleCount;
        mWindowStatistics.avgTriangleCount = mSumTriangleCount / mWindowStatistics.frameCount;

        //
        // Frame rates
        //
        mFPSMeasuringFrameCount++;
        Real delay = Timer::getSystemTime() - mFPSMeasuringBeginTime;

        if(delay >= 1.0)
        {
         mWindowStatistics.lastFPS = mFPSMeasuringFrameCount / delay;
         mFPSMeasuringFrameCount = 0;
         mFPSMeasuringBeginTime = Timer::getSystemTime();
        }

        if(mWindowStatistics.bestFPS == UNDEFINEDSTATISTICS)
        {
         mWindowStatistics.bestFPS = mWindowStatistics.lastFPS;
        } else
        {
         mWindowStatistics.bestFPS =
                mWindowStatistics.lastFPS >
                mWindowStatistics.bestFPS ? mWindowStatistics.lastFPS : mWindowStatistics.bestFPS;
        }

        if(mWindowStatistics.worstFPS == UNDEFINEDSTATISTICS)
        {
         mWindowStatistics.worstFPS = mWindowStatistics.lastFPS;
        } else
        {
         mWindowStatistics.worstFPS =
                mWindowStatistics.lastFPS <
                mWindowStatistics.worstFPS ? mWindowStatistics.lastFPS : mWindowStatistics.worstFPS;
        }

        if(mWindowStatistics.renderingTime > Timer::EPSILONDELAY)
        {
         mWindowStatistics.avgFPS = mWindowStatistics.frameCount / mWindowStatistics.renderingTime;
        }
        //
        // Update caption
        //
        setCaption(mCaption);
  }

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

  void GLXRenderWindow::_setCaption()
  {
        mDisplay.lock();
        XStoreName(mDisplay->getDisplay(), mWindow,
                 (mCaption + " @" + StringConverter::toString(mWindowStatistics.lastFPS, 6, 2) + " fps, frame #" +
                 StringConverter::toString((*(mProcess->getContexts().begin()))->getFrameID())).c_str());
        mDisplay.unlock();

  }

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

}

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