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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
/*
Copyright 2010 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#ifndef GrGLTexture_DEFINED
#define GrGLTexture_DEFINED
#include "GrTexture.h"
#include "GrScalar.h"
#include "GrGLIRect.h"
class GrGpuGL;
class GrGLTexture;
class GrGLRenderTarget : public GrRenderTarget {
public:
virtual ~GrGLRenderTarget();
bool resolveable() const { return fRTFBOID != fTexFBOID; }
bool needsResolve() const { return fNeedsResolve; }
void setDirty(bool dirty) { fNeedsResolve = resolveable() && dirty; }
GLuint renderFBOID() const { return fRTFBOID; }
GLuint textureFBOID() const { return fTexFBOID; }
GLuint getStencilBits() const { return fStencilBits; }
const GrGLIRect& viewport() const { return fViewport; }
void abandon();
protected:
struct GLRenderTargetIDs {
GLuint fRTFBOID;
GLuint fTexFBOID;
GLuint fStencilRenderbufferID;
GLuint fMSColorRenderbufferID;
bool fOwnIDs;
};
GrGLRenderTarget(const GLRenderTargetIDs& ids,
GLuint stencilBits,
const GrGLIRect& fViewport,
GrGLTexture* texture,
GrGpuGL* gl);
void setViewport(const GrGLIRect& rect) { fViewport = rect; }
virtual int width() const { return fViewport.fWidth; }
virtual int height() const { return fViewport.fHeight; }
private:
GrGpuGL* fGL;
GLuint fRTFBOID;
GLuint fTexFBOID;
GLuint fStencilRenderbufferID;
GLuint fMSColorRenderbufferID;
GLuint fStencilBits;
// Should this object delete IDs when it is destroyed or does someone
// else own them.
bool fOwnIDs;
// If there separate Texture and RenderTarget FBO IDs then the rendertarget
// must be resolved to the texture FBO before it is used as a texture.
bool fNeedsResolve;
// when we switch to this rendertarget we want to set the viewport to
// only render to to content area (as opposed to the whole allocation) and
// we want the rendering to be at top left (GL has origin in bottom left)
GrGLIRect fViewport;
friend class GrGpuGL;
friend class GrGLTexture;
typedef GrRenderTarget INHERITED;
};
class GrGLTexture : public GrTexture {
public:
enum Orientation {
kBottomUp_Orientation,
kTopDown_Orientation,
};
struct TexParams {
GLenum fFilter;
GLenum fWrapS;
GLenum fWrapT;
};
protected:
struct GLTextureDesc {
uint32_t fContentWidth;
uint32_t fContentHeight;
uint32_t fAllocWidth;
uint32_t fAllocHeight;
PixelConfig fFormat;
GLuint fTextureID;
GLenum fUploadFormat;
GLenum fUploadByteCount;
GLenum fUploadType;
GLuint fStencilBits;
Orientation fOrientation;
};
typedef GrGLRenderTarget::GLRenderTargetIDs GLRenderTargetIDs;
GrGLTexture(const GLTextureDesc& textureDesc,
const GLRenderTargetIDs& rtIDs,
const TexParams& initialTexParams,
GrGpuGL* gl);
public:
virtual ~GrGLTexture();
// overloads of GrTexture
virtual void abandon();
virtual bool isRenderTarget() const;
virtual GrRenderTarget* asRenderTarget();
virtual void removeRenderTarget();
virtual void uploadTextureData(uint32_t x,
uint32_t y,
uint32_t width,
uint32_t height,
const void* srcData);
virtual intptr_t getTextureHandle();
const TexParams& getTexParams() const { return fTexParams; }
void setTexParams(const TexParams& texParams) { fTexParams = texParams; }
GLuint textureID() const { return fTextureID; }
GLenum uploadFormat() const { return fUploadFormat; }
GLenum uploadByteCount() const { return fUploadByteCount; }
GLenum uploadType() const { return fUploadType; }
/**
* Retrieves the texture width actually allocated in texels.
*
* @return the width in texels
*/
int allocWidth() const { return fAllocWidth; }
/**
* Retrieves the texture height actually allocated in texels.
*
* @return the height in texels
*/
int allocHeight() const { return fAllocHeight; }
/**
* @return width() / allocWidth()
*/
GrScalar contentScaleX() const { return fScaleX; }
/**
* @return height() / allocHeight()
*/
GrScalar contentScaleY() const { return fScaleY; }
// Ganesh assumes texture coordinates have their origin
// in the top-left corner of the image. OpenGL, however,
// has the origin in the lower-left corner. For content that
// is loaded by Ganesh we just push the content "upside down"
// (by GL's understanding of the world ) in glTex*Image and the
// addressing just works out. However, content generated by GL
// (FBO or externally imported texture) will be updside down
// and it is up to the GrGpuGL derivative to handle y-mirroing.
Orientation orientation() const { return fOrientation; }
private:
TexParams fTexParams;
GLuint fTextureID;
GLenum fUploadFormat;
GLenum fUploadByteCount;
GLenum fUploadType;
int fAllocWidth;
int fAllocHeight;
// precomputed content / alloc ratios
GrScalar fScaleX;
GrScalar fScaleY;
Orientation fOrientation;
GrGLRenderTarget* fRenderTarget;
GrGpuGL* fGpuGL;
static const GLenum gWrapMode2GLWrap[];
friend class GrGpuGL;
typedef GrTexture INHERITED;
};
#endif
|
