framebufferobject.h

Go to the documentation of this file.

#ifndef ION_GFX_FRAMEBUFFEROBJECT_H_
#define ION_GFX_FRAMEBUFFEROBJECT_H_

#include "base/macros.h"
#include "ion/base/referent.h"
#include "ion/gfx/cubemaptexture.h"
#include "ion/gfx/image.h"
#include "ion/gfx/resourceholder.h"
#include "ion/gfx/texture.h"

namespace ion {
namespace gfx {

class ION_API FramebufferObject : public ResourceHolder {
 public:
  enum Changes {
    kColorAttachmentChanged = kNumBaseChanges,
    kDepthAttachmentChanged,
    kDimensionsChanged,
    kStencilAttachmentChanged,
    kNumChanges
  };

  enum AttachmentBinding {
    kCubeMapTexture,
    kRenderbuffer,
    kTexture,
    kUnbound,
  };

  class Attachment {
   public:
    Attachment();
    Attachment(Image::Format format, size_t samples);
    explicit Attachment(Image::Format format_in);
    explicit Attachment(const ImagePtr& image_in);
    explicit Attachment(const TexturePtr& texture_in);
    Attachment(const TexturePtr& texture_in, size_t mip_level);
    Attachment(const CubeMapTexturePtr& texture_in,
               CubeMapTexture::CubeFace face);
    Attachment(const CubeMapTexturePtr& texture_in,
               CubeMapTexture::CubeFace face,
               size_t mip_level);

    Image::Format GetFormat() const;
    AttachmentBinding GetBinding() const { return binding_; }
    const ImagePtr& GetImage() const { return image_; }
    const TexturePtr& GetTexture() const { return texture_; }
    const CubeMapTexturePtr& GetCubeMapTexture() const { return cubemap_; }
    CubeMapTexture::CubeFace GetCubeMapFace() const { return face_; }
    size_t GetMipLevel() const { return mip_level_; }
    size_t GetSamples() const { return samples_; }

    inline bool operator !=(const Attachment& other) const {
      return binding_ != other.binding_ || format_ != other.format_ ||
             texture_.Get() != other.texture_.Get() ||
             image_.Get() != other.image_.Get() ||
             cubemap_.Get() != other.cubemap_.Get() ||
             mip_level_ != other.mip_level_ || samples_ != other.samples_;
    }

   private:
    void Construct(AttachmentBinding binding,
                   size_t mip_level,
                   CubeMapTexture::CubeFace face);
    AttachmentBinding binding_;
    CubeMapTexture::CubeFace face_;
    CubeMapTexturePtr cubemap_;
    ImagePtr image_;
    TexturePtr texture_;
    Image::Format format_;
    size_t mip_level_;
    size_t samples_;
  };

  FramebufferObject(uint32 width, uint32 height);

  void Resize(uint32 width, uint32 height);
  uint32 GetWidth() const { return width_.Get(); }
  uint32 GetHeight() const { return height_.Get(); }

  const Attachment& GetColorAttachment(size_t i) const {
    DCHECK_EQ(0U, i) << "***ION: Only a single color attachment is supported";
    return color0_.Get();
  }
  void SetColorAttachment(size_t i, const Attachment& attachment);
  const Attachment& GetDepthAttachment() const { return depth_.Get(); }
  void SetDepthAttachment(const Attachment& attachment);
  const Attachment& GetStencilAttachment() const {
    return stencil_.Get();
  }
  void SetStencilAttachment(const Attachment& attachment);

  static bool IsColorRenderable(uint32 gl_format);
  static bool IsDepthRenderable(uint32 gl_format);
  static bool IsStencilRenderable(uint32 gl_format);

 protected:
  ~FramebufferObject() override;

 private:
  void OnNotify(const base::Notifier* notifier) override;

  void SetAttachment(Field<Attachment>* field, bool (*validator)(Image::Format),
                     const Attachment& attachment,
                     const std::string& type_name);

  Field<uint32> width_;
  Field<uint32> height_;
  Field<Attachment> color0_;
  Field<Attachment> depth_;
  Field<Attachment> stencil_;

  DISALLOW_COPY_AND_ASSIGN(FramebufferObject);
};

typedef base::ReferentPtr<FramebufferObject>::Type FramebufferObjectPtr;

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_FRAMEBUFFEROBJECT_H_