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
|
/*
Copyright 2011 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 GrRenderTarget_DEFINED
#define GrRenderTarget_DEFINED
#include "GrRect.h"
#include "GrSurface.h"
class GrStencilBuffer;
class GrTexture;
/**
* GrRenderTarget represents a 2D buffer of pixels that can be rendered to.
* A context's render target is set by setRenderTarget(). Render targets are
* created by a createTexture with the kRenderTarget_TextureFlag flag.
* Additionally, GrContext provides methods for creating GrRenderTargets
* that wrap externally created render targets.
*/
class GrRenderTarget : public GrSurface {
public:
SK_DECLARE_INST_COUNT(GrRenderTarget)
// GrResource overrides
virtual size_t sizeInBytes() const SK_OVERRIDE;
// GrSurface overrides
/**
* @return the texture associated with the rendertarget, may be NULL.
*/
virtual GrTexture* asTexture() SK_OVERRIDE { return fTexture; }
virtual const GrTexture* asTexture() const SK_OVERRIDE { return fTexture; }
/**
* @return this render target.
*/
virtual GrRenderTarget* asRenderTarget() SK_OVERRIDE { return this; }
virtual const GrRenderTarget* asRenderTarget() const SK_OVERRIDE {
return this;
}
virtual bool readPixels(int left, int top, int width, int height,
GrPixelConfig config,
void* buffer,
size_t rowBytes = 0,
uint32_t pixelOpsFlags = 0) SK_OVERRIDE;
virtual void writePixels(int left, int top, int width, int height,
GrPixelConfig config,
const void* buffer,
size_t rowBytes = 0,
uint32_t pixelOpsFlags = 0) SK_OVERRIDE;
// GrRenderTarget
/**
* If this RT is multisampled, this is the multisample buffer
* @return the 3D API's handle to this object (e.g. FBO ID in OpenGL)
*/
virtual intptr_t getRenderTargetHandle() const = 0;
/**
* If this RT is multisampled, this is the buffer it is resolved to.
* Otherwise, same as getRenderTargetHandle().
* (In GL a separate FBO ID is used for the msaa and resolved buffers)
* @return the 3D API's handle to this object (e.g. FBO ID in OpenGL)
*/
virtual intptr_t getRenderTargetResolvedHandle() const = 0;
/**
* @return true if the surface is multisampled, false otherwise
*/
bool isMultisampled() const { return 0 != fDesc.fSampleCnt; }
/**
* @return the number of samples-per-pixel or zero if non-MSAA.
*/
int numSamples() const { return fDesc.fSampleCnt; }
/**
* Call to indicate the multisample contents were modified such that the
* render target needs to be resolved before it can be used as texture. Gr
* tracks this for its own drawing and thus this only needs to be called
* when the render target has been modified outside of Gr. Only meaningful
* for Gr-created RT/Textures and Platform RT/Textures created with the
* kGrCanResolve flag.
* @param rect a rect bounding the area needing resolve. NULL indicates
* the whole RT needs resolving.
*/
void flagAsNeedingResolve(const GrIRect* rect = NULL);
/**
* Call to override the region that needs to be resolved.
*/
void overrideResolveRect(const GrIRect rect);
/**
* Call to indicate that GrRenderTarget was externally resolved. This may
* allow Gr to skip a redundant resolve step.
*/
void flagAsResolved() { fResolveRect.setLargestInverted(); }
/**
* @return true if the GrRenderTarget requires MSAA resolving
*/
bool needsResolve() const { return !fResolveRect.isEmpty(); }
/**
* Returns a rect bounding the region needing resolving.
*/
const GrIRect& getResolveRect() const { return fResolveRect; }
/**
* If the render target is multisampled this will perform a multisample
* resolve. Any pending draws to the target are first flushed. This only
* applies to render targets that are associated with GrTextures. After the
* function returns the GrTexture will contain the resolved pixels.
*/
void resolve();
// a MSAA RT may require explicit resolving , it may auto-resolve (e.g. FBO
// 0 in GL), or be unresolvable because the client didn't give us the
// resolve destination.
enum ResolveType {
kCanResolve_ResolveType,
kAutoResolves_ResolveType,
kCantResolve_ResolveType,
};
virtual ResolveType getResolveType() const = 0;
/**
* GrStencilBuffer is not part of the public API.
*/
GrStencilBuffer* getStencilBuffer() const { return fStencilBuffer; }
void setStencilBuffer(GrStencilBuffer* stencilBuffer);
protected:
GrRenderTarget(GrGpu* gpu,
GrTexture* texture,
const GrTextureDesc& desc)
: INHERITED(gpu, desc)
, fStencilBuffer(NULL)
, fTexture(texture) {
fResolveRect.setLargestInverted();
}
friend class GrTexture;
// When a texture unrefs an owned rendertarget this func
// removes the back pointer. This could be called from
// texture's destructor but would have to be done in derived
// classes. By the time of texture base destructor it has already
// lost its pointer to the rt.
void onTextureReleaseRenderTarget() {
GrAssert(NULL != fTexture);
fTexture = NULL;
}
// override of GrResource
virtual void onAbandon() SK_OVERRIDE;
virtual void onRelease() SK_OVERRIDE;
private:
GrStencilBuffer* fStencilBuffer;
GrTexture* fTexture; // not ref'ed
GrIRect fResolveRect;
typedef GrSurface INHERITED;
};
#endif
|
