renderTarget.h

// -*- 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
    {
      unsigned int width;
      unsigned int height;

      Resolution() : width(0), height(0) { }
        
      Resolution(const unsigned width, const unsigned int height) : width(width),height(height) { }
    };


    class FrameBufferFormat
    {
    public:

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

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

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

      FrameBufferFormat(const FrameBufferFormat &format)
        : width(format.width), height(format.height), 
          pitch(format.pitch), pixelFormat(format.pixelFormat)
      {
      }

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

      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 width!=format.width || height!=format.height ||
             pitch!=format.pitch || pixelFormat!=format.pixelFormat;
      }

      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(const unsigned int newWidth, const unsigned int newHeight)
      {
        this->width = newWidth;
        this->height = newHeight;
      }

      const FrameBufferFormat resized(const unsigned int newWidth, 
                      const unsigned int 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;
    };

  } //namespace VIEW

} // namespace BALL

#endif // BALL_VIEW_RENDERING_RENDERTARGET_H 

---