1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*
Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef GraphicsSurface_h
#define GraphicsSurface_h
#if USE(GRAPHICS_SURFACE)
#include "GraphicsContext.h"
#include "GraphicsContext3D.h"
#include "GraphicsSurfaceToken.h"
#include "IntRect.h"
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
#if OS(DARWIN)
typedef struct __IOSurface* IOSurfaceRef;
typedef IOSurfaceRef PlatformGraphicsSurface;
#endif
#if OS(LINUX)
typedef uint32_t PlatformGraphicsSurface;
#endif
#if OS(WINDOWS)
typedef HANDLE PlatformGraphicsSurface;
#endif
namespace WebCore {
class BitmapTexture;
class TextureMapper;
struct GraphicsSurfacePrivate;
class GraphicsSurface : public RefCounted<GraphicsSurface> {
public:
enum Flag {
SupportsAlpha = 0x01,
SupportsSoftwareWrite = 0x02,
SupportsSoftwareRead = 0x04,
SupportsTextureTarget = 0x08,
SupportsTextureSource = 0x10,
SupportsCopyToTexture = 0x20,
SupportsCopyFromTexture = 0x40,
SupportsSharing = 0x80,
SupportsSingleBuffered = 0x100
};
enum LockOption {
RetainPixels = 0x01,
ReadOnly = 0x02
};
typedef int Flags;
typedef int LockOptions;
Flags flags() const { return m_flags; }
PlatformGraphicsSurface platformSurface() const { return m_platformSurface; }
IntSize size() const;
static PassRefPtr<GraphicsSurface> create(const IntSize&, Flags, const PlatformGraphicsContext3D shareContext = 0);
static PassRefPtr<GraphicsSurface> create(const IntSize&, Flags, const GraphicsSurfaceToken&);
void copyToGLTexture(uint32_t target, uint32_t texture, const IntRect& targetRect, const IntPoint& sourceOffset);
void copyFromTexture(uint32_t texture, const IntRect& sourceRect);
void paintToTextureMapper(TextureMapper*, const FloatRect& targetRect, const TransformationMatrix&, float opacity, BitmapTexture* mask);
uint32_t frontBuffer();
uint32_t swapBuffers();
GraphicsSurfaceToken exportToken();
uint32_t getTextureID();
PassOwnPtr<GraphicsContext> beginPaint(const IntRect&, LockOptions);
PassRefPtr<Image> createReadOnlyImage(const IntRect&);
~GraphicsSurface();
protected:
static PassRefPtr<GraphicsSurface> platformCreate(const IntSize&, Flags, const PlatformGraphicsContext3D);
static PassRefPtr<GraphicsSurface> platformImport(const IntSize&, Flags, const GraphicsSurfaceToken&);
GraphicsSurfaceToken platformExport();
void platformDestroy();
uint32_t platformGetTextureID();
char* platformLock(const IntRect&, int* stride, LockOptions);
void platformUnlock();
void platformCopyToGLTexture(uint32_t target, uint32_t texture, const IntRect&, const IntPoint&);
void platformCopyFromTexture(uint32_t texture, const IntRect& sourceRect);
void platformPaintToTextureMapper(TextureMapper*, const FloatRect& targetRect, const TransformationMatrix&, float opacity, BitmapTexture* mask);
uint32_t platformFrontBuffer() const;
uint32_t platformSwapBuffers();
IntSize platformSize() const;
PassOwnPtr<GraphicsContext> platformBeginPaint(const IntSize&, char* bits, int stride);
protected:
LockOptions m_lockOptions;
Flags m_flags;
private:
GraphicsSurface(const IntSize&, Flags);
#if PLATFORM(QT)
static void didReleaseImage(void*);
#endif
private:
PlatformGraphicsSurface m_platformSurface;
uint32_t m_texture;
uint32_t m_fbo;
GraphicsSurfacePrivate* m_private;
};
}
#endif // USE(GRAPHICS_SURFACE)
#endif // GraphicsSurface_h
|
