Source/WebCore/platform/graphics/texmap/TextureMapper.h

   1 /*
   2  Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
   3
   4  This library is free software; you can redistribute it and/or
   5  modify it under the terms of the GNU Library General Public
   6  License as published by the Free Software Foundation; either
   7  version 2 of the License, or (at your option) any later version.
   8
   9  This library is distributed in the hope that it will be useful,
  10  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  Library General Public License for more details.
  13
  14  You should have received a copy of the GNU Library General Public License
  15  along with this library; see the file COPYING.LIB.  If not, write to
  16  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifndef TextureMapper_h
  21 #define TextureMapper_h
  22
  23 #if USE(ACCELERATED_COMPOSITING)
  24
  25 #if PLATFORM(QT)
  26 #include <qglobal.h>
  27 #if defined(QT_OPENGL_ES_2) && !defined(TEXMAP_OPENGL_ES_2)
  28     #define TEXMAP_OPENGL_ES_2
  29 #endif
  30 #endif
  31 #if (PLATFORM(GTK) || PLATFORM(EFL)) && USE(OPENGL_ES_2)
  32 #define TEXMAP_OPENGL_ES_2
  33 #endif
  34
  35 #include "FilterOperations.h"
  36 #include "GraphicsContext.h"
  37 #include "IntRect.h"
  38 #include "IntSize.h"
  39 #include "TransformationMatrix.h"
  40 #include <wtf/UnusedParam.h>
  41
  42 /*
  43     TextureMapper is a mechanism that enables hardware acceleration of CSS animations (accelerated compositing) without
  44     a need for a platform specific scene-graph library like CoreAnimations or QGraphicsView.
  45 */
  46
  47 namespace WebCore {
  48
  49 class BitmapTexturePool;
  50 class CustomFilterProgram;
  51 class GraphicsLayer;
  52 class TextureMapper;
  53
  54 // A 2D texture that can be the target of software or GL rendering.
  55 class BitmapTexture : public RefCounted<BitmapTexture> {
  56 public:
  57     enum Flag {
  58         SupportsAlpha = 0x01
  59     };
  60
  61     enum UpdateContentsFlag {
  62         UpdateCanModifyOriginalImageData,
  63         UpdateCannotModifyOriginalImageData
  64     };
  65
  66     typedef unsigned Flags;
  67
  68     BitmapTexture()
  69         : m_flags(0)
  70     {
  71     }
  72
  73     virtual ~BitmapTexture() { }
  74     virtual bool isBackedByOpenGL() const { return false; }
  75
  76     virtual IntSize size() const = 0;
  77     virtual void updateContents(Image*, const IntRect&, const IntPoint& offset, UpdateContentsFlag) = 0;
  78     virtual void updateContents(TextureMapper*, GraphicsLayer*, const IntRect& target, const IntPoint& offset, UpdateContentsFlag);
  79     virtual void updateContents(const void*, const IntRect& target, const IntPoint& offset, int bytesPerLine, UpdateContentsFlag) = 0;
  80     virtual bool isValid() const = 0;
  81     inline Flags flags() const { return m_flags; }
  82
  83     virtual int bpp() const { return 32; }
  84     virtual bool canReuseWith(const IntSize& /* contentsSize */, Flags = 0) { return false; }
  85     void reset(const IntSize& size, Flags flags = 0)
  86     {
  87         m_flags = flags;
  88         m_contentSize = size;
  89         didReset();
  90     }
  91     virtual void didReset() { }
  92
  93     inline IntSize contentSize() const { return m_contentSize; }
  94     inline int numberOfBytes() const { return size().width() * size().height() * bpp() >> 3; }
  95     inline bool isOpaque() const { return !(m_flags & SupportsAlpha); }
  96
  97 #if ENABLE(CSS_FILTERS)
  98     virtual PassRefPtr<BitmapTexture> applyFilters(TextureMapper*, const BitmapTexture& contentTexture, const FilterOperations&) { return this; }
  99 #endif
 100
 101 protected:
 102     IntSize m_contentSize;
 103
 104 private:
 105     Flags m_flags;
 106 };
 107
 108 // A "context" class used to encapsulate accelerated texture mapping functions: i.e. drawing a texture
 109 // onto the screen or into another texture with a specified transform, opacity and mask.
 110 class TextureMapper {
 111     WTF_MAKE_FAST_ALLOCATED;
 112     friend class BitmapTexture;
 113 public:
 114     enum AccelerationMode { SoftwareMode, OpenGLMode };
 115     enum PaintFlag {
 116         PaintingMirrored = 1 << 0,
 117     };
 118     typedef unsigned PaintFlags;
 119
 120     static PassOwnPtr<TextureMapper> create(AccelerationMode newMode = SoftwareMode);
 121     virtual ~TextureMapper();
 122
 123     enum ExposedEdges {
 124         NoEdges = 0,
 125         LeftEdge = 1 << 0,
 126         RightEdge = 1 << 1,
 127         TopEdge = 1 << 2,
 128         BottomEdge = 1 << 3,
 129         AllEdges = LeftEdge | RightEdge | TopEdge | BottomEdge,
 130     };
 131
 132     virtual void drawBorder(const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) = 0;
 133     virtual void drawNumber(int number, const Color&, const FloatPoint&, const TransformationMatrix&) = 0;
 134
 135     virtual void drawTexture(const BitmapTexture&, const FloatRect& target, const TransformationMatrix& modelViewMatrix = TransformationMatrix(), float opacity = 1.0f, unsigned exposedEdges = AllEdges) = 0;
 136     virtual void drawSolidColor(const FloatRect&, const TransformationMatrix&, const Color&) = 0;
 137
 138     // makes a surface the target for the following drawTexture calls.
 139     virtual void bindSurface(BitmapTexture* surface) = 0;
 140     void setGraphicsContext(GraphicsContext* context) { m_context = context; }
 141     GraphicsContext* graphicsContext() { return m_context; }
 142     virtual void beginClip(const TransformationMatrix&, const FloatRect&) = 0;
 143     virtual void endClip() = 0;
 144     virtual PassRefPtr<BitmapTexture> createTexture() = 0;
 145
 146     void setImageInterpolationQuality(InterpolationQuality quality) { m_interpolationQuality = quality; }
 147     void setTextDrawingMode(TextDrawingModeFlags mode) { m_textDrawingMode = mode; }
 148
 149     InterpolationQuality imageInterpolationQuality() const { return m_interpolationQuality; }
 150     TextDrawingModeFlags textDrawingMode() const { return m_textDrawingMode; }
 151     AccelerationMode accelerationMode() const { return m_accelerationMode; }
 152
 153     virtual void beginPainting(PaintFlags = 0) { }
 154     virtual void endPainting() { }
 155
 156     void setMaskMode(bool m) { m_isMaskMode = m; }
 157
 158     virtual IntSize maxTextureSize() const = 0;
 159
 160     virtual PassRefPtr<BitmapTexture> acquireTextureFromPool(const IntSize&);
 161
 162 #if ENABLE(CSS_SHADERS)
 163     virtual void removeCachedCustomFilterProgram(CustomFilterProgram*) { }
 164 #endif
 165
 166 protected:
 167     explicit TextureMapper(AccelerationMode);
 168
 169     GraphicsContext* m_context;
 170
 171     bool isInMaskMode() const { return m_isMaskMode; }
 172
 173 private:
 174 #if USE(TEXTURE_MAPPER_GL)
 175     static PassOwnPtr<TextureMapper> platformCreateAccelerated();
 176 #else
 177     static PassOwnPtr<TextureMapper> platformCreateAccelerated()
 178     {
 179         return PassOwnPtr<TextureMapper>();
 180     }
 181 #endif
 182     InterpolationQuality m_interpolationQuality;
 183     TextDrawingModeFlags m_textDrawingMode;
 184     OwnPtr<BitmapTexturePool> m_texturePool;
 185     AccelerationMode m_accelerationMode;
 186     bool m_isMaskMode;
 187 };
 188
 189 }
 190
 191 #endif
 192
 193 #endif