reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 1 | /* |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 2 | * Copyright 2011 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 6 | */ |
| 7 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 8 | #ifndef GrGpu_DEFINED |
| 9 | #define GrGpu_DEFINED |
| 10 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 11 | #include "GrDrawTarget.h" |
robertphillips@google.com | 1e945b7 | 2012-04-16 18:03:03 +0000 | [diff] [blame] | 12 | #include "GrClipMaskManager.h" |
sugoi@google.com | 12b4e27 | 2012-12-06 20:13:11 +0000 | [diff] [blame] | 13 | #include "SkPath.h" |
| 14 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 15 | class GrContext; |
commit-bot@chromium.org | 089a780 | 2014-05-02 21:38:22 +0000 | [diff] [blame] | 16 | class GrGpuObject; |
bsalomon@google.com | 1c13c96 | 2011-02-14 16:51:21 +0000 | [diff] [blame] | 17 | class GrIndexBufferAllocPool; |
bsalomon@google.com | 64aef2b | 2012-06-11 15:36:13 +0000 | [diff] [blame] | 18 | class GrPath; |
bsalomon@google.com | 3008519 | 2011-08-19 15:42:31 +0000 | [diff] [blame] | 19 | class GrPathRenderer; |
| 20 | class GrPathRendererChain; |
bsalomon@google.com | 81c3f8d | 2011-08-03 15:18:33 +0000 | [diff] [blame] | 21 | class GrStencilBuffer; |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 22 | class GrVertexBufferAllocPool; |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 23 | |
| 24 | class GrGpu : public GrDrawTarget { |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 25 | public: |
bsalomon@google.com | 18c9c19 | 2011-09-22 21:01:31 +0000 | [diff] [blame] | 26 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 27 | /** |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 28 | * Additional blend coefficients for dual source blending, not exposed |
bsalomon@google.com | 271cffc | 2011-05-20 14:13:56 +0000 | [diff] [blame] | 29 | * through GrPaint/GrContext. |
| 30 | */ |
| 31 | enum ExtendedBlendCoeffs { |
| 32 | // source 2 refers to second output color when |
| 33 | // using dual source blending. |
bsalomon@google.com | 4705954 | 2012-06-06 20:51:20 +0000 | [diff] [blame] | 34 | kS2C_GrBlendCoeff = kPublicGrBlendCoeffCount, |
| 35 | kIS2C_GrBlendCoeff, |
| 36 | kS2A_GrBlendCoeff, |
| 37 | kIS2A_GrBlendCoeff, |
bsalomon@google.com | 271cffc | 2011-05-20 14:13:56 +0000 | [diff] [blame] | 38 | |
bsalomon@google.com | 4705954 | 2012-06-06 20:51:20 +0000 | [diff] [blame] | 39 | kTotalGrBlendCoeffCount |
bsalomon@google.com | 271cffc | 2011-05-20 14:13:56 +0000 | [diff] [blame] | 40 | }; |
| 41 | |
| 42 | /** |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 43 | * Create an instance of GrGpu that matches the specified backend. If the requested backend is |
bsalomon@google.com | 6e4e650 | 2013-02-25 20:12:45 +0000 | [diff] [blame] | 44 | * not supported (at compile-time or run-time) this returns NULL. The context will not be |
| 45 | * fully constructed and should not be used by GrGpu until after this function returns. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 46 | */ |
bsalomon@google.com | 6e4e650 | 2013-02-25 20:12:45 +0000 | [diff] [blame] | 47 | static GrGpu* Create(GrBackend, GrBackendContext, GrContext* context); |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 48 | |
| 49 | //////////////////////////////////////////////////////////////////////////// |
| 50 | |
bsalomon@google.com | 6e4e650 | 2013-02-25 20:12:45 +0000 | [diff] [blame] | 51 | GrGpu(GrContext* context); |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 52 | virtual ~GrGpu(); |
| 53 | |
bsalomon@google.com | 6e4e650 | 2013-02-25 20:12:45 +0000 | [diff] [blame] | 54 | GrContext* getContext() { return this->INHERITED::getContext(); } |
| 55 | const GrContext* getContext() const { return this->INHERITED::getContext(); } |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 56 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 57 | /** |
| 58 | * The GrGpu object normally assumes that no outsider is setting state |
| 59 | * within the underlying 3D API's context/device/whatever. This call informs |
bsalomon@google.com | a7f84e1 | 2011-03-10 14:13:19 +0000 | [diff] [blame] | 60 | * the GrGpu that the state was modified and it shouldn't make assumptions |
| 61 | * about the state. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 62 | */ |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 63 | void markContextDirty(uint32_t state = kAll_GrBackendState) { |
| 64 | fResetBits |= state; |
| 65 | } |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 66 | |
| 67 | void unimpl(const char[]); |
| 68 | |
| 69 | /** |
bsalomon@google.com | 0748f21 | 2011-02-01 22:56:16 +0000 | [diff] [blame] | 70 | * Creates a texture object. If desc width or height is not a power of |
| 71 | * two but underlying API requires a power of two texture then srcData |
| 72 | * will be embedded in a power of two texture. The extra width and height |
| 73 | * is filled as though srcData were rendered clamped into the texture. |
krajcevski | 9c0e629 | 2014-06-02 07:38:14 -0700 | [diff] [blame^] | 74 | * The exception is when using compressed data formats. In this case, the |
| 75 | * desc width and height must be a multiple of the compressed format block |
| 76 | * size otherwise this function returns NULL. Similarly, if the underlying |
| 77 | * API requires a power of two texture and the source width and height are not |
| 78 | * a power of two, then this function returns NULL. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 79 | * |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 80 | * If kRenderTarget_TextureFlag is specified the GrRenderTarget is |
bsalomon@google.com | 1da0746 | 2011-03-10 14:51:57 +0000 | [diff] [blame] | 81 | * accessible via GrTexture::asRenderTarget(). The texture will hold a ref |
krajcevski | 9c0e629 | 2014-06-02 07:38:14 -0700 | [diff] [blame^] | 82 | * on the render target until the texture is destroyed. Compressed textures |
| 83 | * cannot have the kRenderTarget_TextureFlag set. |
bsalomon@google.com | 1da0746 | 2011-03-10 14:51:57 +0000 | [diff] [blame] | 84 | * |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 85 | * @param desc describes the texture to be created. |
| 86 | * @param srcData texel data to load texture. Begins with full-size |
krajcevski | 9c0e629 | 2014-06-02 07:38:14 -0700 | [diff] [blame^] | 87 | * palette data for paletted textures. For compressed |
| 88 | * formats it contains the compressed pixel data. Otherwise, |
| 89 | * it contains width*height texels. If NULL texture data |
| 90 | * is uninitialized. |
| 91 | * @param rowBytes the number of bytes between consecutive rows. Zero |
| 92 | * means rows are tightly packed. This field is ignored |
| 93 | * for compressed formats. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 94 | * |
| 95 | * @return The texture object if successful, otherwise NULL. |
| 96 | */ |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 97 | GrTexture* createTexture(const GrTextureDesc& desc, |
bsalomon@google.com | a7f84e1 | 2011-03-10 14:13:19 +0000 | [diff] [blame] | 98 | const void* srcData, size_t rowBytes); |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 99 | |
bsalomon@google.com | e269f21 | 2011-11-07 13:29:52 +0000 | [diff] [blame] | 100 | /** |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 101 | * Implements GrContext::wrapBackendTexture |
bsalomon@google.com | e269f21 | 2011-11-07 13:29:52 +0000 | [diff] [blame] | 102 | */ |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 103 | GrTexture* wrapBackendTexture(const GrBackendTextureDesc&); |
bsalomon@google.com | e269f21 | 2011-11-07 13:29:52 +0000 | [diff] [blame] | 104 | |
| 105 | /** |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 106 | * Implements GrContext::wrapBackendTexture |
bsalomon@google.com | e269f21 | 2011-11-07 13:29:52 +0000 | [diff] [blame] | 107 | */ |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 108 | GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc&); |
bsalomon@google.com | e269f21 | 2011-11-07 13:29:52 +0000 | [diff] [blame] | 109 | |
| 110 | /** |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 111 | * Creates a vertex buffer. |
| 112 | * |
| 113 | * @param size size in bytes of the vertex buffer |
| 114 | * @param dynamic hints whether the data will be frequently changed |
commit-bot@chromium.org | 8341eb7 | 2014-05-07 20:51:05 +0000 | [diff] [blame] | 115 | * by either GrVertexBuffer::map() or |
| 116 | * GrVertexBuffer::updateData(). |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 117 | * |
| 118 | * @return The vertex buffer if successful, otherwise NULL. |
| 119 | */ |
robertphillips@google.com | adacc70 | 2013-10-14 21:53:24 +0000 | [diff] [blame] | 120 | GrVertexBuffer* createVertexBuffer(size_t size, bool dynamic); |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 121 | |
| 122 | /** |
| 123 | * Creates an index buffer. |
| 124 | * |
| 125 | * @param size size in bytes of the index buffer |
| 126 | * @param dynamic hints whether the data will be frequently changed |
commit-bot@chromium.org | 8341eb7 | 2014-05-07 20:51:05 +0000 | [diff] [blame] | 127 | * by either GrIndexBuffer::map() or |
| 128 | * GrIndexBuffer::updateData(). |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 129 | * |
| 130 | * @return The index buffer if successful, otherwise NULL. |
| 131 | */ |
robertphillips@google.com | adacc70 | 2013-10-14 21:53:24 +0000 | [diff] [blame] | 132 | GrIndexBuffer* createIndexBuffer(size_t size, bool dynamic); |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 133 | |
| 134 | /** |
bsalomon@google.com | 64aef2b | 2012-06-11 15:36:13 +0000 | [diff] [blame] | 135 | * Creates a path object that can be stenciled using stencilPath(). It is |
| 136 | * only legal to call this if the caps report support for path stenciling. |
| 137 | */ |
commit-bot@chromium.org | 32184d8 | 2013-10-09 15:14:18 +0000 | [diff] [blame] | 138 | GrPath* createPath(const SkPath& path, const SkStrokeRec& stroke); |
bsalomon@google.com | 64aef2b | 2012-06-11 15:36:13 +0000 | [diff] [blame] | 139 | |
| 140 | /** |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 141 | * Returns an index buffer that can be used to render quads. |
bsalomon@google.com | 86afc2a | 2011-02-16 16:12:19 +0000 | [diff] [blame] | 142 | * Six indices per quad: 0, 1, 2, 0, 2, 3, etc. |
| 143 | * The max number of quads can be queried using GrIndexBuffer::maxQuads(). |
bsalomon@google.com | 4705954 | 2012-06-06 20:51:20 +0000 | [diff] [blame] | 144 | * Draw with kTriangles_GrPrimitiveType |
bsalomon@google.com | 86afc2a | 2011-02-16 16:12:19 +0000 | [diff] [blame] | 145 | * @ return the quad index buffer |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 146 | */ |
bsalomon@google.com | 86afc2a | 2011-02-16 16:12:19 +0000 | [diff] [blame] | 147 | const GrIndexBuffer* getQuadIndexBuffer() const; |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 148 | |
| 149 | /** |
bsalomon@google.com | 75f9f25 | 2012-01-31 13:35:56 +0000 | [diff] [blame] | 150 | * Resolves MSAA. |
| 151 | */ |
| 152 | void resolveRenderTarget(GrRenderTarget* target); |
| 153 | |
| 154 | /** |
commit-bot@chromium.org | 5d1d79a | 2013-05-24 18:52:52 +0000 | [diff] [blame] | 155 | * Gets a preferred 8888 config to use for writing/reading pixel data to/from a surface with |
| 156 | * config surfaceConfig. The returned config must have at least as many bits per channel as the |
| 157 | * readConfig or writeConfig param. |
bsalomon@google.com | 0a97be2 | 2011-11-08 19:20:57 +0000 | [diff] [blame] | 158 | */ |
commit-bot@chromium.org | 5d1d79a | 2013-05-24 18:52:52 +0000 | [diff] [blame] | 159 | virtual GrPixelConfig preferredReadPixelsConfig(GrPixelConfig readConfig, |
| 160 | GrPixelConfig surfaceConfig) const { |
| 161 | return readConfig; |
| 162 | } |
| 163 | virtual GrPixelConfig preferredWritePixelsConfig(GrPixelConfig writeConfig, |
| 164 | GrPixelConfig surfaceConfig) const { |
| 165 | return writeConfig; |
| 166 | } |
bsalomon@google.com | 0a97be2 | 2011-11-08 19:20:57 +0000 | [diff] [blame] | 167 | |
| 168 | /** |
bsalomon@google.com | 9c68058 | 2013-02-06 18:17:50 +0000 | [diff] [blame] | 169 | * Called before uploading writing pixels to a GrTexture when the src pixel config doesn't |
| 170 | * match the texture's config. |
bsalomon@google.com | a85449d | 2011-11-19 02:36:05 +0000 | [diff] [blame] | 171 | */ |
bsalomon@google.com | 9c68058 | 2013-02-06 18:17:50 +0000 | [diff] [blame] | 172 | virtual bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const = 0; |
bsalomon@google.com | a85449d | 2011-11-19 02:36:05 +0000 | [diff] [blame] | 173 | |
| 174 | /** |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 175 | * OpenGL's readPixels returns the result bottom-to-top while the skia |
| 176 | * API is top-to-bottom. Thus we have to do a y-axis flip. The obvious |
| 177 | * solution is to have the subclass do the flip using either the CPU or GPU. |
| 178 | * However, the caller (GrContext) may have transformations to apply and can |
| 179 | * simply fold in the y-flip for free. On the other hand, the subclass may |
| 180 | * be able to do it for free itself. For example, the subclass may have to |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 181 | * do memcpys to handle rowBytes that aren't tight. It could do the y-flip |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 182 | * concurrently. |
| 183 | * |
| 184 | * This function returns true if a y-flip is required to put the pixels in |
| 185 | * top-to-bottom order and the subclass cannot do it for free. |
| 186 | * |
| 187 | * See read pixels for the params |
| 188 | * @return true if calling readPixels with the same set of params will |
| 189 | * produce bottom-to-top data |
| 190 | */ |
| 191 | virtual bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget, |
| 192 | int left, int top, |
| 193 | int width, int height, |
| 194 | GrPixelConfig config, |
bsalomon@google.com | 56d11e0 | 2011-11-30 19:59:08 +0000 | [diff] [blame] | 195 | size_t rowBytes) const = 0; |
| 196 | /** |
| 197 | * This should return true if reading a NxM rectangle of pixels from a |
| 198 | * render target is faster if the target has dimensons N and M and the read |
| 199 | * rectangle has its top-left at 0,0. |
| 200 | */ |
| 201 | virtual bool fullReadPixelsIsFasterThanPartial() const { return false; }; |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 202 | |
| 203 | /** |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 204 | * Reads a rectangle of pixels from a render target. |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 205 | * |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 206 | * @param renderTarget the render target to read from. NULL means the |
| 207 | * current render target. |
| 208 | * @param left left edge of the rectangle to read (inclusive) |
| 209 | * @param top top edge of the rectangle to read (inclusive) |
| 210 | * @param width width of rectangle to read in pixels. |
| 211 | * @param height height of rectangle to read in pixels. |
| 212 | * @param config the pixel config of the destination buffer |
| 213 | * @param buffer memory to read the rectangle into. |
bsalomon@google.com | c698097 | 2011-11-02 19:57:21 +0000 | [diff] [blame] | 214 | * @param rowBytes the number of bytes between consecutive rows. Zero |
| 215 | * means rows are tightly packed. |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 216 | * @param invertY buffer should be populated bottom-to-top as opposed |
| 217 | * to top-to-bottom (skia's usual order) |
bsalomon@google.com | a7f84e1 | 2011-03-10 14:13:19 +0000 | [diff] [blame] | 218 | * |
| 219 | * @return true if the read succeeded, false if not. The read can fail |
| 220 | * because of a unsupported pixel config or because no render |
| 221 | * target is currently set. |
| 222 | */ |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 223 | bool readPixels(GrRenderTarget* renderTarget, |
| 224 | int left, int top, int width, int height, |
senorblanco@chromium.org | 3cb406b | 2013-02-05 19:50:46 +0000 | [diff] [blame] | 225 | GrPixelConfig config, void* buffer, size_t rowBytes); |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 226 | |
bsalomon@google.com | 6f37951 | 2011-11-16 20:36:03 +0000 | [diff] [blame] | 227 | /** |
| 228 | * Updates the pixels in a rectangle of a texture. |
bsalomon@google.com | a85449d | 2011-11-19 02:36:05 +0000 | [diff] [blame] | 229 | * |
bsalomon@google.com | 6f37951 | 2011-11-16 20:36:03 +0000 | [diff] [blame] | 230 | * @param left left edge of the rectangle to write (inclusive) |
| 231 | * @param top top edge of the rectangle to write (inclusive) |
| 232 | * @param width width of rectangle to write in pixels. |
| 233 | * @param height height of rectangle to write in pixels. |
| 234 | * @param config the pixel config of the source buffer |
| 235 | * @param buffer memory to read pixels from |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 236 | * @param rowBytes number of bytes between consecutive rows. Zero |
bsalomon@google.com | 6f37951 | 2011-11-16 20:36:03 +0000 | [diff] [blame] | 237 | * means rows are tightly packed. |
| 238 | */ |
bsalomon@google.com | 9c68058 | 2013-02-06 18:17:50 +0000 | [diff] [blame] | 239 | bool writeTexturePixels(GrTexture* texture, |
bsalomon@google.com | 6f37951 | 2011-11-16 20:36:03 +0000 | [diff] [blame] | 240 | int left, int top, int width, int height, |
| 241 | GrPixelConfig config, const void* buffer, |
| 242 | size_t rowBytes); |
| 243 | |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 244 | /** |
commit-bot@chromium.org | 089a780 | 2014-05-02 21:38:22 +0000 | [diff] [blame] | 245 | * Called to tell GrGpu that all GrGpuObjects have been lost and should |
bsalomon@google.com | 81c3f8d | 2011-08-03 15:18:33 +0000 | [diff] [blame] | 246 | * be abandoned. Overrides must call INHERITED::abandonResources(). |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 247 | */ |
junov@google.com | 53a5584 | 2011-06-08 22:55:10 +0000 | [diff] [blame] | 248 | virtual void abandonResources(); |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 249 | |
| 250 | /** |
commit-bot@chromium.org | 089a780 | 2014-05-02 21:38:22 +0000 | [diff] [blame] | 251 | * Called to tell GrGpu to release all GrGpuObjects. Overrides must call |
bsalomon@google.com | 81c3f8d | 2011-08-03 15:18:33 +0000 | [diff] [blame] | 252 | * INHERITED::releaseResources(). |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 253 | */ |
| 254 | void releaseResources(); |
| 255 | |
| 256 | /** |
commit-bot@chromium.org | 089a780 | 2014-05-02 21:38:22 +0000 | [diff] [blame] | 257 | * Add object to list of objects. Should only be called by GrGpuObject. |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 258 | * @param resource the resource to add. |
| 259 | */ |
commit-bot@chromium.org | 089a780 | 2014-05-02 21:38:22 +0000 | [diff] [blame] | 260 | void insertObject(GrGpuObject* object); |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 261 | |
| 262 | /** |
commit-bot@chromium.org | 089a780 | 2014-05-02 21:38:22 +0000 | [diff] [blame] | 263 | * Remove object from list of objects. Should only be called by GrGpuObject. |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 264 | * @param resource the resource to remove. |
| 265 | */ |
commit-bot@chromium.org | 089a780 | 2014-05-02 21:38:22 +0000 | [diff] [blame] | 266 | void removeObject(GrGpuObject* object); |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 267 | |
bsalomon@google.com | 471d471 | 2011-08-23 15:45:25 +0000 | [diff] [blame] | 268 | // GrDrawTarget overrides |
commit-bot@chromium.org | fd03d4a | 2013-07-17 21:39:42 +0000 | [diff] [blame] | 269 | virtual void clear(const SkIRect* rect, |
robertphillips@google.com | c82a8b7 | 2012-06-21 20:15:48 +0000 | [diff] [blame] | 270 | GrColor color, |
robertphillips@google.com | 56ce48a | 2013-10-31 21:44:25 +0000 | [diff] [blame] | 271 | bool canIgnoreRect, |
robertphillips@google.com | c82a8b7 | 2012-06-21 20:15:48 +0000 | [diff] [blame] | 272 | GrRenderTarget* renderTarget = NULL) SK_OVERRIDE; |
bsalomon@google.com | 471d471 | 2011-08-23 15:45:25 +0000 | [diff] [blame] | 273 | |
robertphillips@google.com | ff17584 | 2012-05-14 19:31:39 +0000 | [diff] [blame] | 274 | virtual void purgeResources() SK_OVERRIDE { |
| 275 | // The clip mask manager can rebuild all its clip masks so just |
| 276 | // get rid of them all. |
| 277 | fClipMaskManager.releaseResources(); |
| 278 | } |
| 279 | |
bsalomon@google.com | 80d09b9 | 2011-11-05 21:21:13 +0000 | [diff] [blame] | 280 | // After the client interacts directly with the 3D context state the GrGpu |
| 281 | // must resync its internal state and assumptions about 3D context state. |
| 282 | // Each time this occurs the GrGpu bumps a timestamp. |
| 283 | // state of the 3D context |
| 284 | // At 10 resets / frame and 60fps a 64bit timestamp will overflow in about |
| 285 | // a billion years. |
| 286 | typedef uint64_t ResetTimestamp; |
| 287 | |
| 288 | // This timestamp is always older than the current timestamp |
| 289 | static const ResetTimestamp kExpiredTimestamp = 0; |
| 290 | // Returns a timestamp based on the number of times the context was reset. |
| 291 | // This timestamp can be used to lazily detect when cached 3D context state |
| 292 | // is dirty. |
| 293 | ResetTimestamp getResetTimestamp() const { |
| 294 | return fResetTimestamp; |
| 295 | } |
| 296 | |
robertphillips@google.com | 99a5ac0 | 2012-04-10 19:26:38 +0000 | [diff] [blame] | 297 | /** |
bsalomon@google.com | a320194 | 2012-06-21 19:58:20 +0000 | [diff] [blame] | 298 | * These methods are called by the clip manager's setupClipping function |
bsalomon@google.com | 74749cd | 2013-01-30 16:12:41 +0000 | [diff] [blame] | 299 | * which (called as part of GrGpu's implementation of onDraw and |
bsalomon@google.com | a320194 | 2012-06-21 19:58:20 +0000 | [diff] [blame] | 300 | * onStencilPath member functions.) The GrGpu subclass should flush the |
| 301 | * stencil state to the 3D API in its implementation of flushGraphicsState. |
| 302 | */ |
commit-bot@chromium.org | fd03d4a | 2013-07-17 21:39:42 +0000 | [diff] [blame] | 303 | void enableScissor(const SkIRect& rect) { |
bsalomon@google.com | a320194 | 2012-06-21 19:58:20 +0000 | [diff] [blame] | 304 | fScissorState.fEnabled = true; |
| 305 | fScissorState.fRect = rect; |
| 306 | } |
| 307 | void disableScissor() { fScissorState.fEnabled = false; } |
| 308 | |
| 309 | /** |
| 310 | * Like the scissor methods above this is called by setupClipping and |
| 311 | * should be flushed by the GrGpu subclass in flushGraphicsState. These |
| 312 | * stencil settings should be used in place of those on the GrDrawState. |
| 313 | * They have been adjusted to account for any interactions between the |
| 314 | * GrDrawState's stencil settings and stencil clipping. |
| 315 | */ |
| 316 | void setStencilSettings(const GrStencilSettings& settings) { |
| 317 | fStencilSettings = settings; |
| 318 | } |
| 319 | void disableStencil() { fStencilSettings.setDisabled(); } |
robertphillips@google.com | 730ebe5 | 2012-04-16 16:33:13 +0000 | [diff] [blame] | 320 | |
| 321 | // GrGpu subclass sets clip bit in the stencil buffer. The subclass is |
| 322 | // free to clear the remaining bits to zero if masked clears are more |
| 323 | // expensive than clearing all bits. |
commit-bot@chromium.org | fd03d4a | 2013-07-17 21:39:42 +0000 | [diff] [blame] | 324 | virtual void clearStencilClip(const SkIRect& rect, bool insideClip) = 0; |
robertphillips@google.com | 730ebe5 | 2012-04-16 16:33:13 +0000 | [diff] [blame] | 325 | |
bsalomon@google.com | 8f9cbd6 | 2011-12-09 15:55:34 +0000 | [diff] [blame] | 326 | enum PrivateDrawStateStateBits { |
| 327 | kFirstBit = (GrDrawState::kLastPublicStateBit << 1), |
bsalomon@google.com | d302f14 | 2011-03-03 13:54:13 +0000 | [diff] [blame] | 328 | |
| 329 | kModifyStencilClip_StateBit = kFirstBit, // allows draws to modify |
| 330 | // stencil bits used for |
| 331 | // clipping. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 332 | }; |
| 333 | |
commit-bot@chromium.org | c4dc0ad | 2013-10-09 14:11:33 +0000 | [diff] [blame] | 334 | void getPathStencilSettingsForFillType(SkPath::FillType fill, GrStencilSettings* outStencilSettings); |
| 335 | |
bsalomon@google.com | 64aef2b | 2012-06-11 15:36:13 +0000 | [diff] [blame] | 336 | enum DrawType { |
| 337 | kDrawPoints_DrawType, |
| 338 | kDrawLines_DrawType, |
| 339 | kDrawTriangles_DrawType, |
| 340 | kStencilPath_DrawType, |
commit-bot@chromium.org | 32184d8 | 2013-10-09 15:14:18 +0000 | [diff] [blame] | 341 | kDrawPath_DrawType, |
commit-bot@chromium.org | 9b62aa1 | 2014-03-25 11:59:40 +0000 | [diff] [blame] | 342 | kDrawPaths_DrawType, |
bsalomon@google.com | 64aef2b | 2012-06-11 15:36:13 +0000 | [diff] [blame] | 343 | }; |
| 344 | |
commit-bot@chromium.org | 0a6fe71 | 2014-04-23 19:26:26 +0000 | [diff] [blame] | 345 | protected: |
bsalomon@google.com | 64aef2b | 2012-06-11 15:36:13 +0000 | [diff] [blame] | 346 | DrawType PrimTypeToDrawType(GrPrimitiveType type) { |
| 347 | switch (type) { |
| 348 | case kTriangles_GrPrimitiveType: |
| 349 | case kTriangleStrip_GrPrimitiveType: |
| 350 | case kTriangleFan_GrPrimitiveType: |
| 351 | return kDrawTriangles_DrawType; |
| 352 | case kPoints_GrPrimitiveType: |
| 353 | return kDrawPoints_DrawType; |
| 354 | case kLines_GrPrimitiveType: |
| 355 | case kLineStrip_GrPrimitiveType: |
| 356 | return kDrawLines_DrawType; |
| 357 | default: |
commit-bot@chromium.org | 88cb22b | 2014-04-30 14:17:00 +0000 | [diff] [blame] | 358 | SkFAIL("Unexpected primitive type"); |
bsalomon@google.com | 64aef2b | 2012-06-11 15:36:13 +0000 | [diff] [blame] | 359 | return kDrawTriangles_DrawType; |
| 360 | } |
| 361 | } |
| 362 | |
bsalomon@google.com | 86afc2a | 2011-02-16 16:12:19 +0000 | [diff] [blame] | 363 | // prepares clip flushes gpu state before a draw |
bsalomon@google.com | eb6879f | 2013-06-13 19:34:18 +0000 | [diff] [blame] | 364 | bool setupClipAndFlushState(DrawType, |
| 365 | const GrDeviceCoordTexture* dstCopy, |
commit-bot@chromium.org | 3ae0e6c | 2014-02-11 18:24:25 +0000 | [diff] [blame] | 366 | GrDrawState::AutoRestoreEffects* are, |
| 367 | const SkRect* devBounds); |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 368 | |
bsalomon@google.com | d302f14 | 2011-03-03 13:54:13 +0000 | [diff] [blame] | 369 | // Functions used to map clip-respecting stencil tests into normal |
| 370 | // stencil funcs supported by GPUs. |
bsalomon@google.com | a7f84e1 | 2011-03-10 14:13:19 +0000 | [diff] [blame] | 371 | static GrStencilFunc ConvertStencilFunc(bool stencilInClip, |
bsalomon@google.com | d302f14 | 2011-03-03 13:54:13 +0000 | [diff] [blame] | 372 | GrStencilFunc func); |
| 373 | static void ConvertStencilFuncAndMask(GrStencilFunc func, |
| 374 | bool clipInStencil, |
| 375 | unsigned int clipBit, |
| 376 | unsigned int userBits, |
| 377 | unsigned int* ref, |
| 378 | unsigned int* mask); |
| 379 | |
robertphillips@google.com | 730ebe5 | 2012-04-16 16:33:13 +0000 | [diff] [blame] | 380 | GrClipMaskManager fClipMaskManager; |
| 381 | |
bsalomon@google.com | 25fb21f | 2011-06-21 18:17:25 +0000 | [diff] [blame] | 382 | struct GeometryPoolState { |
| 383 | const GrVertexBuffer* fPoolVertexBuffer; |
| 384 | int fPoolStartVertex; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 385 | |
bsalomon@google.com | 25fb21f | 2011-06-21 18:17:25 +0000 | [diff] [blame] | 386 | const GrIndexBuffer* fPoolIndexBuffer; |
| 387 | int fPoolStartIndex; |
| 388 | }; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 389 | const GeometryPoolState& getGeomPoolState() { |
| 390 | return fGeomPoolStateStack.back(); |
bsalomon@google.com | 25fb21f | 2011-06-21 18:17:25 +0000 | [diff] [blame] | 391 | } |
bsalomon@google.com | 1c13c96 | 2011-02-14 16:51:21 +0000 | [diff] [blame] | 392 | |
bsalomon@google.com | a320194 | 2012-06-21 19:58:20 +0000 | [diff] [blame] | 393 | // The state of the scissor is controlled by the clip manager |
| 394 | struct ScissorState { |
| 395 | bool fEnabled; |
commit-bot@chromium.org | fd03d4a | 2013-07-17 21:39:42 +0000 | [diff] [blame] | 396 | SkIRect fRect; |
bsalomon@google.com | a320194 | 2012-06-21 19:58:20 +0000 | [diff] [blame] | 397 | } fScissorState; |
| 398 | |
| 399 | // The final stencil settings to use as determined by the clip manager. |
| 400 | GrStencilSettings fStencilSettings; |
| 401 | |
bsalomon@google.com | 1c13c96 | 2011-02-14 16:51:21 +0000 | [diff] [blame] | 402 | // Helpers for setting up geometry state |
| 403 | void finalizeReservedVertices(); |
| 404 | void finalizeReservedIndices(); |
| 405 | |
bsalomon@google.com | 02ddc8b | 2013-01-28 15:35:28 +0000 | [diff] [blame] | 406 | private: |
| 407 | // GrDrawTarget overrides |
jvanverth@google.com | b75b0a0 | 2013-02-05 20:33:30 +0000 | [diff] [blame] | 408 | virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) SK_OVERRIDE; |
bsalomon@google.com | 02ddc8b | 2013-01-28 15:35:28 +0000 | [diff] [blame] | 409 | virtual bool onReserveIndexSpace(int indexCount, void** indices) SK_OVERRIDE; |
| 410 | virtual void releaseReservedVertexSpace() SK_OVERRIDE; |
| 411 | virtual void releaseReservedIndexSpace() SK_OVERRIDE; |
| 412 | virtual void onSetVertexSourceToArray(const void* vertexArray, int vertexCount) SK_OVERRIDE; |
| 413 | virtual void onSetIndexSourceToArray(const void* indexArray, int indexCount) SK_OVERRIDE; |
| 414 | virtual void releaseVertexArray() SK_OVERRIDE; |
| 415 | virtual void releaseIndexArray() SK_OVERRIDE; |
| 416 | virtual void geometrySourceWillPush() SK_OVERRIDE; |
| 417 | virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) SK_OVERRIDE; |
| 418 | |
| 419 | |
bsalomon@google.com | b635d39 | 2011-11-05 12:47:43 +0000 | [diff] [blame] | 420 | // called when the 3D context state is unknown. Subclass should emit any |
bsalomon@google.com | c8f7f47 | 2012-06-18 13:44:51 +0000 | [diff] [blame] | 421 | // assumed 3D context state and dirty any state cache. |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 422 | virtual void onResetContext(uint32_t resetBits) = 0; |
bsalomon@google.com | a7f84e1 | 2011-03-10 14:13:19 +0000 | [diff] [blame] | 423 | |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 424 | // overridden by backend-specific derived class to create objects. |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 425 | virtual GrTexture* onCreateTexture(const GrTextureDesc& desc, |
bsalomon@google.com | bcdbbe6 | 2011-04-12 15:40:00 +0000 | [diff] [blame] | 426 | const void* srcData, |
| 427 | size_t rowBytes) = 0; |
krajcevski | 9c0e629 | 2014-06-02 07:38:14 -0700 | [diff] [blame^] | 428 | virtual GrTexture* onCreateCompressedTexture(const GrTextureDesc& desc, |
| 429 | const void* srcData) = 0; |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 430 | virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) = 0; |
| 431 | virtual GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) = 0; |
robertphillips@google.com | adacc70 | 2013-10-14 21:53:24 +0000 | [diff] [blame] | 432 | virtual GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) = 0; |
| 433 | virtual GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) = 0; |
commit-bot@chromium.org | 32184d8 | 2013-10-09 15:14:18 +0000 | [diff] [blame] | 434 | virtual GrPath* onCreatePath(const SkPath& path, const SkStrokeRec&) = 0; |
bsalomon@google.com | a7f84e1 | 2011-03-10 14:13:19 +0000 | [diff] [blame] | 435 | |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 436 | // overridden by backend-specific derived class to perform the clear and |
robertphillips@google.com | 56ce48a | 2013-10-31 21:44:25 +0000 | [diff] [blame] | 437 | // clearRect. NULL rect means clear whole target. If canIgnoreRect is |
| 438 | // true, it is okay to perform a full clear instead of a partial clear |
| 439 | virtual void onClear(const SkIRect* rect, GrColor color, bool canIgnoreRect) = 0; |
bsalomon@google.com | a7f84e1 | 2011-03-10 14:13:19 +0000 | [diff] [blame] | 440 | |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 441 | // overridden by backend-specific derived class to perform the draw call. |
bsalomon@google.com | 74749cd | 2013-01-30 16:12:41 +0000 | [diff] [blame] | 442 | virtual void onGpuDraw(const DrawInfo&) = 0; |
commit-bot@chromium.org | c4dc0ad | 2013-10-09 14:11:33 +0000 | [diff] [blame] | 443 | |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 444 | // overridden by backend-specific derived class to perform the path stenciling. |
sugoi@google.com | 12b4e27 | 2012-12-06 20:13:11 +0000 | [diff] [blame] | 445 | virtual void onGpuStencilPath(const GrPath*, SkPath::FillType) = 0; |
commit-bot@chromium.org | 32184d8 | 2013-10-09 15:14:18 +0000 | [diff] [blame] | 446 | virtual void onGpuDrawPath(const GrPath*, SkPath::FillType) = 0; |
commit-bot@chromium.org | ecc4536 | 2014-03-28 21:31:34 +0000 | [diff] [blame] | 447 | virtual void onGpuDrawPaths(int, const GrPath**, const SkMatrix*, |
commit-bot@chromium.org | 9b62aa1 | 2014-03-25 11:59:40 +0000 | [diff] [blame] | 448 | SkPath::FillType, SkStrokeRec::Style) = 0; |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 449 | |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 450 | // overridden by backend-specific derived class to perform the read pixels. |
bsalomon@google.com | 5877ffd | 2011-04-11 17:58:48 +0000 | [diff] [blame] | 451 | virtual bool onReadPixels(GrRenderTarget* target, |
| 452 | int left, int top, int width, int height, |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 453 | GrPixelConfig, |
| 454 | void* buffer, |
senorblanco@chromium.org | 3cb406b | 2013-02-05 19:50:46 +0000 | [diff] [blame] | 455 | size_t rowBytes) = 0; |
bsalomon@google.com | a7f84e1 | 2011-03-10 14:13:19 +0000 | [diff] [blame] | 456 | |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 457 | // overridden by backend-specific derived class to perform the texture update |
bsalomon@google.com | 9c68058 | 2013-02-06 18:17:50 +0000 | [diff] [blame] | 458 | virtual bool onWriteTexturePixels(GrTexture* texture, |
bsalomon@google.com | 6f37951 | 2011-11-16 20:36:03 +0000 | [diff] [blame] | 459 | int left, int top, int width, int height, |
| 460 | GrPixelConfig config, const void* buffer, |
| 461 | size_t rowBytes) = 0; |
| 462 | |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 463 | // overridden by backend-specific derived class to perform the resolve |
bsalomon@google.com | 75f9f25 | 2012-01-31 13:35:56 +0000 | [diff] [blame] | 464 | virtual void onResolveRenderTarget(GrRenderTarget* target) = 0; |
| 465 | |
bsalomon@google.com | 81c3f8d | 2011-08-03 15:18:33 +0000 | [diff] [blame] | 466 | // width and height may be larger than rt (if underlying API allows it). |
| 467 | // Should attach the SB to the RT. Returns false if compatible sb could |
| 468 | // not be created. |
bsalomon@google.com | 74749cd | 2013-01-30 16:12:41 +0000 | [diff] [blame] | 469 | virtual bool createStencilBufferForRenderTarget(GrRenderTarget*, int width, int height) = 0; |
bsalomon@google.com | 81c3f8d | 2011-08-03 15:18:33 +0000 | [diff] [blame] | 470 | |
| 471 | // attaches an existing SB to an existing RT. |
bsalomon@google.com | 74749cd | 2013-01-30 16:12:41 +0000 | [diff] [blame] | 472 | virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*) = 0; |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 473 | |
| 474 | // The GrGpu typically records the clients requested state and then flushes |
| 475 | // deltas from previous state at draw time. This function does the |
bsalomon@google.com | 26e18b5 | 2013-03-29 19:22:36 +0000 | [diff] [blame] | 476 | // backend-specific flush of the state. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 477 | // returns false if current state is unsupported. |
bsalomon@google.com | 26e18b5 | 2013-03-29 19:22:36 +0000 | [diff] [blame] | 478 | virtual bool flushGraphicsState(DrawType, const GrDeviceCoordTexture* dstCopy) = 0; |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 479 | |
bsalomon@google.com | edc177d | 2011-08-05 15:46:40 +0000 | [diff] [blame] | 480 | // clears the entire stencil buffer to 0 |
| 481 | virtual void clearStencil() = 0; |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 482 | |
bsalomon@google.com | 81c3f8d | 2011-08-03 15:18:33 +0000 | [diff] [blame] | 483 | // Given a rt, find or create a stencil buffer and attach it |
| 484 | bool attachStencilBufferToRenderTarget(GrRenderTarget* target); |
| 485 | |
bsalomon@google.com | 25fb21f | 2011-06-21 18:17:25 +0000 | [diff] [blame] | 486 | // GrDrawTarget overrides |
bsalomon@google.com | 74749cd | 2013-01-30 16:12:41 +0000 | [diff] [blame] | 487 | virtual void onDraw(const DrawInfo&) SK_OVERRIDE; |
commit-bot@chromium.org | 32184d8 | 2013-10-09 15:14:18 +0000 | [diff] [blame] | 488 | virtual void onStencilPath(const GrPath*, SkPath::FillType) SK_OVERRIDE; |
| 489 | virtual void onDrawPath(const GrPath*, SkPath::FillType, |
commit-bot@chromium.org | c4dc0ad | 2013-10-09 14:11:33 +0000 | [diff] [blame] | 490 | const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE; |
commit-bot@chromium.org | ecc4536 | 2014-03-28 21:31:34 +0000 | [diff] [blame] | 491 | virtual void onDrawPaths(int, const GrPath**, const SkMatrix*, |
commit-bot@chromium.org | 9b62aa1 | 2014-03-25 11:59:40 +0000 | [diff] [blame] | 492 | SkPath::FillType, SkStrokeRec::Style, |
| 493 | const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE; |
commit-bot@chromium.org | c4dc0ad | 2013-10-09 14:11:33 +0000 | [diff] [blame] | 494 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 495 | // readies the pools to provide vertex/index data. |
| 496 | void prepareVertexPool(); |
| 497 | void prepareIndexPool(); |
| 498 | |
bsalomon@google.com | b635d39 | 2011-11-05 12:47:43 +0000 | [diff] [blame] | 499 | void resetContext() { |
bsalomon@google.com | c8f7f47 | 2012-06-18 13:44:51 +0000 | [diff] [blame] | 500 | // We call this because the client may have messed with the |
| 501 | // stencil buffer. Perhaps we should detect whether it is a |
| 502 | // internally created stencil buffer and if so skip the invalidate. |
| 503 | fClipMaskManager.invalidateStencilMask(); |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 504 | this->onResetContext(fResetBits); |
| 505 | fResetBits = 0; |
bsalomon@google.com | b635d39 | 2011-11-05 12:47:43 +0000 | [diff] [blame] | 506 | ++fResetTimestamp; |
| 507 | } |
| 508 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 509 | void handleDirtyContext() { |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 510 | if (fResetBits) { |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 511 | this->resetContext(); |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 512 | } |
| 513 | } |
| 514 | |
bsalomon@google.com | 02ddc8b | 2013-01-28 15:35:28 +0000 | [diff] [blame] | 515 | enum { |
| 516 | kPreallocGeomPoolStateStackCnt = 4, |
| 517 | }; |
commit-bot@chromium.org | 089a780 | 2014-05-02 21:38:22 +0000 | [diff] [blame] | 518 | typedef SkTInternalLList<GrGpuObject> ObjectList; |
bsalomon@google.com | 02ddc8b | 2013-01-28 15:35:28 +0000 | [diff] [blame] | 519 | SkSTArray<kPreallocGeomPoolStateStackCnt, GeometryPoolState, true> fGeomPoolStateStack; |
bsalomon@google.com | 02ddc8b | 2013-01-28 15:35:28 +0000 | [diff] [blame] | 520 | ResetTimestamp fResetTimestamp; |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 521 | uint32_t fResetBits; |
bsalomon@google.com | 02ddc8b | 2013-01-28 15:35:28 +0000 | [diff] [blame] | 522 | GrVertexBufferAllocPool* fVertexPool; |
| 523 | GrIndexBufferAllocPool* fIndexPool; |
| 524 | // counts number of uses of vertex/index pool in the geometry stack |
| 525 | int fVertexPoolUseCnt; |
| 526 | int fIndexPoolUseCnt; |
bsalomon@google.com | 6438695 | 2013-02-08 21:22:44 +0000 | [diff] [blame] | 527 | // these are mutable so they can be created on-demand |
bsalomon@google.com | 02ddc8b | 2013-01-28 15:35:28 +0000 | [diff] [blame] | 528 | mutable GrIndexBuffer* fQuadIndexBuffer; |
skia.committer@gmail.com | 66a4a4c | 2013-05-11 07:01:34 +0000 | [diff] [blame] | 529 | // Used to abandon/release all resources created by this GrGpu. TODO: Move this |
bsalomon@google.com | 76202b8 | 2013-05-10 19:08:22 +0000 | [diff] [blame] | 530 | // functionality to GrResourceCache. |
commit-bot@chromium.org | 089a780 | 2014-05-02 21:38:22 +0000 | [diff] [blame] | 531 | ObjectList fObjectList; |
bsalomon@google.com | 02ddc8b | 2013-01-28 15:35:28 +0000 | [diff] [blame] | 532 | |
bsalomon@google.com | 1c13c96 | 2011-02-14 16:51:21 +0000 | [diff] [blame] | 533 | typedef GrDrawTarget INHERITED; |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 534 | }; |
| 535 | |
| 536 | #endif |