renderTarget.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_VIEW_RENDERING_RENDERTARGET_H
#define BALL_VIEW_RENDERING_RENDERTARGET_H

#include <BALL/COMMON/global.h>
#include <BALL/COMMON/exception.h>

#include <assert.h>
#include <vector>
#include <boost/smart_ptr.hpp>
#include <boost/shared_array.hpp>

#include <BALL/VIEW/RENDERING/pixelFormat.h>

namespace BALL
{
  namespace VIEW
  {

    struct Resolution
    {
      Size width;
      Size height;

      Resolution() 
        : width(0), 
          height(0) 
      { }
        
      Resolution(Size width, Size height) 
        : width(width),
          height(height) 
      { }
    };


    class FrameBufferFormat
    {
      public:

        FrameBufferFormat() 
          : width(0), 
            height(0), 
            pitch(0), 
            pixelFormat(PixelFormat::RGB_32)
        { }

        FrameBufferFormat(Size width, Size height, const PixelFormat &pixelFormat)
          : width(width), 
            height(height), 
            pitch(width * pixelFormat.computeByteSize()), 
            pixelFormat(pixelFormat)
        {
          assert(pitch >= width * pixelFormat.computeByteSize());
        }

        FrameBufferFormat(Size width, Size height, Size pitch, const PixelFormat &pixelFormat)
          : width(width), 
            height(height), 
            pitch(pitch), 
            pixelFormat(pixelFormat)
        {
          assert(pitch >= width * pixelFormat.computeByteSize());
        }

        bool operator==(const FrameBufferFormat& format) const
        {
          return     width==format.width 
                 && height==format.height 
                 &&  pitch==format.pitch
                 && pixelFormat==format.pixelFormat;
        }                                                                                                                   

        bool operator!=(const FrameBufferFormat& format) const
        {
          return !(*this == format);
        }

        bool isValid() const { return width > 0 && height > 0 && pitch > 0; }

        unsigned int getWidth() const { return width; }

        void setWidth(unsigned int width) { this->width = width; }

        unsigned int getHeight() const { return height; }

        void setHeight(unsigned int height) { this->height = height; }

        unsigned int getPitch() const { return pitch; }

        void setPitch(unsigned int pitch) { this->pitch = pitch; }

        const PixelFormat &getPixelFormat() const { return pixelFormat; }

        void setPixelFormat(const PixelFormat &pixelFormat)
        { 
          this->pixelFormat = pixelFormat; 
        }

        size_t computeSize() const
        {
          // pitch is in bytes
          return isValid() ? (getPitch() * getHeight()) : 0;
        }

        void resize(Size newWidth, Size newHeight)
        {
          this->width = newWidth;
          this->height = newHeight;
        }

        const FrameBufferFormat resized(Size newWidth, Size newHeight) const
        {
          return FrameBufferFormat(newWidth, newHeight, pitch, pixelFormat);
        }

      private:

        unsigned int width;

        unsigned int height;

        unsigned int pitch;

        PixelFormat pixelFormat;
    };

    inline std::ostream &operator<<(std::ostream &o, const FrameBufferFormat &f)
    {
      o << f.getWidth() << "x" << f.getHeight() << ", pitch " << f.getPitch()
        << ", pixel format: " << f.getPixelFormat();
      return o;
    }

    typedef std::vector<FrameBufferFormat> BufferFormatList;

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

    class FrameBuffer
    {
      public:

        FrameBuffer(void* data, const FrameBufferFormat &format) 
          : data(data),
            format(format)
        {
        }

        virtual ~FrameBuffer() {}

        void *getData() { return data; }

        const void *getData() const { return data; }

        const FrameBufferFormat &getFormat() const { return format; }

      protected:

        void setData(void *data) { this->data = data; }

        void setFormat(const FrameBufferFormat &format) { this->format = format; }

      private:
        void *data;

        FrameBufferFormat format;
    };

    typedef boost::shared_ptr<FrameBuffer> FrameBufferPtr;
    
    //-----------------------------------------------------------------------------

    class RenderTarget
    {
      public:

      virtual ~RenderTarget() { }

      virtual FrameBufferPtr getBuffer() throw(BALL::Exception::NoBufferAvailable) = 0;

      virtual FrameBufferFormat getFormat() const = 0;

      virtual void releaseBuffer(FrameBufferPtr buffer) = 0;

      virtual bool init() = 0;

      virtual bool resize(const unsigned int width, const unsigned int height) = 0;

      virtual void refresh() = 0;

      /* Prepare the window for rendering, e.g., make it current if necessary.
       */
      virtual void prepareRendering() = 0;

      virtual void setupStereo(float /*eye_separation*/, float /*focal_length*/) {};

      virtual bool doNotResize() const = 0;
    };

  } //namespace VIEW

} // namespace BALL

#endif // BALL_VIEW_RENDERING_RENDERTARGET_H