/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 4; -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef GLTEXTUREIMAGE_H_
#define GLTEXTUREIMAGE_H_
#include "nsRegion.h"
#include "nsTArray.h"
#include "gfxTypes.h"
#include "GLContextTypes.h"
#include "mozilla/gfx/Rect.h"
#include "mozilla/RefPtr.h"
class gfxASurface;
namespace mozilla {
namespace gfx {
class DataSourceSurface;
class DrawTarget;
}
// namespace gfx
}
// namespace mozilla
namespace mozilla {
namespace gl {
class GLContext;
/**
* A TextureImage provides a mechanism to synchronize data from a
* surface to a texture in the server. TextureImages are associated
* with one and only one GLContext.
*/
class TextureImage {
NS_INLINE_DECL_REFCOUNTING(TextureImage)
public:
enum TextureState {
Created,
// Texture created, but has not had glTexImage called to
// initialize it.
Allocated,
// Texture memory exists, but contents are invalid.
Valid
// Texture fully ready to use.
};
enum Flags {
NoFlags = 0x0,
UseNearestFilter = 0x1,
OriginBottomLeft = 0x2,
DisallowBigImage = 0x4
};
typedef gfxContentType ContentType;
typedef gfxImageFormat ImageFormat;
static already_AddRefed<TextureImage> Create(
GLContext* gl,
const gfx::IntSize& aSize,
TextureImage::ContentType aContentType, GLenum aWrapMode,
TextureImage::Flags aFlags = TextureImage::NoFlags);
/**
* The Image may contain several textures for different regions (tiles).
* These functions iterate over each sub texture image tile.
*/
virtual void BeginBigImageIteration() {}
virtual bool NextTile() {
return false; }
// Function prototype for a tile iteration callback. Returning false will
// cause iteration to be interrupted (i.e. the corresponding NextTile call
// will return false).
typedef bool (*BigImageIterationCallback)(TextureImage* aImage,
int aTileNumber,
void* aCallbackData);
// Sets a callback to be called every time NextTile is called.
virtual void SetIterationCallback(BigImageIterationCallback aCallback,
void* aCallbackData) {}
virtual gfx::IntRect GetTileRect();
virtual GLuint GetTextureID() = 0;
virtual uint32_t GetTileCount() {
return 1; }
/**
* Set this TextureImage's size, and ensure a texture has been
* allocated.
* After a resize, the contents are undefined.
*/
virtual void Resize(
const gfx::IntSize& aSize) = 0;
/**
* Mark this texture as having valid contents. Call this after modifying
* the texture contents externally.
*/
virtual void MarkValid() {}
/**
* aSurf - the source surface to update from
* aRegion - the region in this image to update
* aSrcOffset - offset in the source to update from
* aDstOffset - offset in the destination to update to
*/
virtual bool DirectUpdate(
gfx::DataSourceSurface* aSurf,
const nsIntRegion& aRegion,
const gfx::IntPoint& aSrcOffset = gfx::IntPoint(0, 0),
const gfx::IntPoint& aDstOffset = gfx::IntPoint(0, 0)) = 0;
bool UpdateFromDataSource(gfx::DataSourceSurface* aSurf,
const nsIntRegion* aDstRegion = nullptr,
const gfx::IntPoint* aSrcOffset = nullptr,
const gfx::IntPoint* aDstOffset = nullptr);
virtual void BindTexture(GLenum aTextureUnit) = 0;
/**
* Returns the image format of the texture. Only valid after
* DirectUpdate has been called.
*/
virtual gfx::SurfaceFormat GetTextureFormat() {
return mTextureFormat; }
/** Can be called safely at any time. */
/**
* If this TextureImage has a permanent gfxASurface backing,
* return it. Otherwise return nullptr.
*/
virtual already_AddRefed<gfxASurface> GetBackingSurface() {
return nullptr; }
gfx::IntSize GetSize()
const;
ContentType GetContentType()
const {
return mContentType; }
GLenum GetWrapMode()
const {
return mWrapMode; }
void SetSamplingFilter(gfx::SamplingFilter aSamplingFilter) {
mSamplingFilter = aSamplingFilter;
}
protected:
friend class GLContext;
void UpdateUploadSize(size_t amount);
/**
* After the ctor, the TextureImage is invalid. Implementations
* must allocate resources successfully before returning the new
* TextureImage from GLContext::CreateTextureImage(). That is,
* clients must not be given partially-constructed TextureImages.
*/
TextureImage(
const gfx::IntSize& aSize, GLenum aWrapMode,
ContentType aContentType, Flags aFlags = NoFlags);
// Protected destructor, to discourage deletion outside of Release():
virtual ~TextureImage() { UpdateUploadSize(0); }
virtual gfx::IntRect GetSrcTileRect();
gfx::IntSize mSize;
GLenum mWrapMode;
ContentType mContentType;
gfx::SurfaceFormat mTextureFormat;
gfx::SamplingFilter mSamplingFilter;
Flags mFlags;
size_t mUploadSize;
};
/**
* BasicTextureImage is the baseline TextureImage implementation ---
* it updates its texture by allocating a scratch buffer for the
* client to draw into, then using glTexSubImage2D() to upload the new
* pixels. Platforms must provide the code to create a new surface
* into which the updated pixels will be drawn, and the code to
* convert the update surface's pixels into an image on which we can
* glTexSubImage2D().
*/
class BasicTextureImage :
public TextureImage {
public:
virtual ~BasicTextureImage();
BasicTextureImage(GLuint aTexture,
const gfx::IntSize& aSize,
GLenum aWrapMode, ContentType aContentType,
GLContext* aContext,
TextureImage::Flags aFlags = TextureImage::NoFlags);
void BindTexture(GLenum aTextureUnit) override;
bool DirectUpdate(
gfx::DataSourceSurface* aSurf,
const nsIntRegion& aRegion,
const gfx::IntPoint& aSrcOffset = gfx::IntPoint(0, 0),
const gfx::IntPoint& aDstOffset = gfx::IntPoint(0, 0)) override;
GLuint GetTextureID() override {
return mTexture; }
void MarkValid() override { mTextureState = Valid; }
void Resize(
const gfx::IntSize& aSize) override;
protected:
GLuint mTexture;
TextureState mTextureState;
RefPtr<GLContext> mGLContext;
};
/**
* A container class that complements many sub TextureImages into a big
* TextureImage. Aims to behave just like the real thing.
*/
class TiledTextureImage final :
public TextureImage {
public:
TiledTextureImage(
GLContext* aGL, gfx::IntSize aSize, TextureImage::ContentType,
TextureImage::Flags aFlags = TextureImage::NoFlags,
TextureImage::ImageFormat aImageFormat = gfx::SurfaceFormat::UNKNOWN);
virtual ~TiledTextureImage();
void DumpDiv();
void Resize(
const gfx::IntSize& aSize) override;
uint32_t GetTileCount() override;
void BeginBigImageIteration() override;
bool NextTile() override;
void SetIterationCallback(BigImageIterationCallback aCallback,
void* aCallbackData) override;
gfx::IntRect GetTileRect() override;
GLuint GetTextureID() override {
return mImages[mCurrentImage]->GetTextureID();
}
bool DirectUpdate(
gfx::DataSourceSurface* aSurf,
const nsIntRegion& aRegion,
const gfx::IntPoint& aSrcOffset = gfx::IntPoint(0, 0),
const gfx::IntPoint& aDstOffset = gfx::IntPoint(0, 0)) override;
void BindTexture(GLenum) override;
protected:
gfx::IntRect GetSrcTileRect() override;
unsigned int mCurrentImage;
BigImageIterationCallback mIterationCallback;
void* mIterationCallbackData;
nsTArray<RefPtr<TextureImage> > mImages;
unsigned int mTileSize;
unsigned int mRows, mColumns;
GLContext* mGL;
TextureState mTextureState;
TextureImage::ImageFormat mImageFormat;
};
/**
* Creates a TextureImage of the basic implementation, can be useful in cases
* where we know we don't want to use platform-specific TextureImage.
* In doubt, use GLContext::CreateTextureImage instead.
*/
already_AddRefed<TextureImage> CreateBasicTextureImage(
GLContext* aGL,
const gfx::IntSize& aSize,
TextureImage::ContentType aContentType, GLenum aWrapMode,
TextureImage::Flags aFlags);
/**
* Creates a TiledTextureImage backed by platform-specific or basic
* TextureImages. In doubt, use GLContext::CreateTextureImage instead.
*/
already_AddRefed<TextureImage> CreateTiledTextureImage(
GLContext* aGL,
const gfx::IntSize& aSize,
TextureImage::ContentType aContentType, TextureImage::Flags aFlags,
TextureImage::ImageFormat aImageFormat);
/**
* Return a valid, allocated TextureImage of |aSize| with
* |aContentType|. If |aContentType| is COLOR, |aImageFormat| can be used
* to hint at the preferred RGB format, however it is not necessarily
* respected. The TextureImage's texture is configured to use
* |aWrapMode| (usually GL_CLAMP_TO_EDGE or GL_REPEAT) and by
* default, GL_LINEAR filtering. Specify
* |aFlags=UseNearestFilter| for GL_NEAREST filtering. Specify
* |aFlags=OriginBottomLeft| if the image is origin-bottom-left, instead of the
* default origin-top-left. Return
* nullptr if creating the TextureImage fails.
*
* The returned TextureImage may only be used with this GLContext.
* Attempting to use the returned TextureImage after this
* GLContext is destroyed will result in undefined (and likely
* crashy) behavior.
*/
already_AddRefed<TextureImage> CreateTextureImage(
GLContext* gl,
const gfx::IntSize& aSize,
TextureImage::ContentType aContentType, GLenum aWrapMode,
TextureImage::Flags aFlags = TextureImage::NoFlags,
TextureImage::ImageFormat aImageFormat = gfx::SurfaceFormat::UNKNOWN);
}
// namespace gl
}
// namespace mozilla
#endif /* GLTEXTUREIMAGE_H_ */
