blob: c9e280c3cbc8b7478c8d9c25e24b326086df42b8 [file] [log] [blame]
reed@google.comac10a2d2010-12-22 21:39:39 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * 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.comac10a2d2010-12-22 21:39:39 +00006 */
7
jvanverth39edf762014-12-22 11:44:19 -08008#ifndef GrGLGpu_DEFINED
9#define GrGLGpu_DEFINED
reed@google.comac10a2d2010-12-22 21:39:39 +000010
robertphillips@google.com6177e692013-02-28 20:16:25 +000011#include "GrGLContext.h"
bsalomon@google.com81c3f8d2011-08-03 15:18:33 +000012#include "GrGLIRect.h"
commit-bot@chromium.orga0b40282013-09-18 13:00:55 +000013#include "GrGLIndexBuffer.h"
kkinnunenccdaa042014-08-20 01:36:23 -070014#include "GrGLPathRendering.h"
bsalomon@google.com5739d2c2012-05-31 15:07:19 +000015#include "GrGLProgram.h"
bsalomon37dd3312014-11-03 08:47:23 -080016#include "GrGLRenderTarget.h"
bsalomon@google.com81c3f8d2011-08-03 15:18:33 +000017#include "GrGLStencilBuffer.h"
18#include "GrGLTexture.h"
bsalomon@google.com6918d482013-03-07 19:09:11 +000019#include "GrGLVertexArray.h"
bsalomon@google.com81c3f8d2011-08-03 15:18:33 +000020#include "GrGLVertexBuffer.h"
commit-bot@chromium.orga0b40282013-09-18 13:00:55 +000021#include "GrGpu.h"
egdaniel8dd688b2015-01-22 10:16:09 -080022#include "GrPipelineBuilder.h"
egdaniel080e6732014-12-22 07:35:52 -080023#include "GrXferProcessor.h"
commit-bot@chromium.orga0b40282013-09-18 13:00:55 +000024#include "SkTypes.h"
reed@google.comac10a2d2010-12-22 21:39:39 +000025
egdaniel8dd688b2015-01-22 10:16:09 -080026class GrPipeline;
27
commit-bot@chromium.org174db772013-03-21 12:46:01 +000028#ifdef SK_DEVELOPER
jvanverth@google.com94878772013-03-12 16:00:54 +000029#define PROGRAM_CACHE_STATS
30#endif
31
bsalomon861e1032014-12-16 07:33:49 -080032class GrGLGpu : public GrGpu {
reed@google.comac10a2d2010-12-22 21:39:39 +000033public:
bsalomon861e1032014-12-16 07:33:49 -080034 GrGLGpu(const GrGLContext& ctx, GrContext* context);
bsalomond95263c2014-12-16 13:05:12 -080035 ~GrGLGpu() SK_OVERRIDE;
reed@google.comac10a2d2010-12-22 21:39:39 +000036
bsalomond95263c2014-12-16 13:05:12 -080037 void contextAbandoned() SK_OVERRIDE;
bsalomonc8dc1f72014-08-21 13:02:13 -070038
commit-bot@chromium.orgc9424b82013-10-30 20:03:16 +000039 const GrGLContext& glContext() const { return fGLContext; }
40
robertphillips@google.com6177e692013-02-28 20:16:25 +000041 const GrGLInterface* glInterface() const { return fGLContext.interface(); }
commit-bot@chromium.orgb1854a82014-01-16 18:39:04 +000042 const GrGLContextInfo& ctxInfo() const { return fGLContext; }
43 GrGLStandard glStandard() const { return fGLContext.standard(); }
44 GrGLVersion glVersion() const { return fGLContext.version(); }
45 GrGLSLGeneration glslGeneration() const { return fGLContext.glslGeneration(); }
46 const GrGLCaps& glCaps() const { return *fGLContext.caps(); }
bsalomon@google.com0b77d682011-08-19 13:28:54 +000047
kkinnunenccdaa042014-08-20 01:36:23 -070048 GrGLPathRendering* glPathRendering() {
cdaltonc7103a12014-08-11 14:05:05 -070049 SkASSERT(glCaps().pathRenderingSupport());
kkinnunenccdaa042014-08-20 01:36:23 -070050 return static_cast<GrGLPathRendering*>(pathRendering());
cdaltonc7103a12014-08-11 14:05:05 -070051 }
52
bsalomond95263c2014-12-16 13:05:12 -080053 void discard(GrRenderTarget*) SK_OVERRIDE;
commit-bot@chromium.org28361fa2014-03-28 16:08:05 +000054
commit-bot@chromium.org0a6fe712014-04-23 19:26:26 +000055 // Used by GrGLProgram and GrGLPathTexGenProgramEffects to configure OpenGL
56 // state.
bsalomon@google.com34cccde2013-01-04 18:34:30 +000057 void bindTexture(int unitIdx, const GrTextureParams& params, GrGLTexture* texture);
kkinnunenccdaa042014-08-20 01:36:23 -070058
bsalomon@google.com56d11e02011-11-30 19:59:08 +000059 // GrGpu overrides
bsalomond95263c2014-12-16 13:05:12 -080060 GrPixelConfig preferredReadPixelsConfig(GrPixelConfig readConfig,
61 GrPixelConfig surfaceConfig) const SK_OVERRIDE;
62 GrPixelConfig preferredWritePixelsConfig(GrPixelConfig writeConfig,
63 GrPixelConfig surfaceConfig) const SK_OVERRIDE;
64 bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const SK_OVERRIDE;
65 bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
66 int left, int top,
67 int width, int height,
68 GrPixelConfig config,
69 size_t rowBytes) const SK_OVERRIDE;
70 bool fullReadPixelsIsFasterThanPartial() const SK_OVERRIDE;
bsalomon@google.com75f9f252012-01-31 13:35:56 +000071
bsalomond95263c2014-12-16 13:05:12 -080072 bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) SK_OVERRIDE;
bsalomon@google.comeb851172013-04-15 13:51:00 +000073
bsalomon@google.com6918d482013-03-07 19:09:11 +000074 // These functions should be used to bind GL objects. They track the GL state and skip redundant
skia.committer@gmail.com754a3eb2013-03-08 07:01:25 +000075 // bindings. Making the equivalent glBind calls directly will confuse the state tracking.
bsalomon@google.com6918d482013-03-07 19:09:11 +000076 void bindVertexArray(GrGLuint id) {
77 fHWGeometryState.setVertexArrayID(this, id);
78 }
79 void bindIndexBufferAndDefaultVertexArray(GrGLuint id) {
80 fHWGeometryState.setIndexBufferIDOnDefaultVertexArray(this, id);
81 }
82 void bindVertexBuffer(GrGLuint id) {
83 fHWGeometryState.setVertexBufferID(this, id);
84 }
85
86 // These callbacks update state tracking when GL objects are deleted. They are called from
87 // GrGLResource onRelease functions.
88 void notifyVertexArrayDelete(GrGLuint id) {
89 fHWGeometryState.notifyVertexArrayDelete(id);
90 }
91 void notifyVertexBufferDelete(GrGLuint id) {
92 fHWGeometryState.notifyVertexBufferDelete(id);
93 }
94 void notifyIndexBufferDelete(GrGLuint id) {
95 fHWGeometryState.notifyIndexBufferDelete(id);
96 }
bsalomon@google.com880b8fc2013-02-19 20:17:28 +000097
bsalomonf90a02b2014-11-26 12:28:00 -080098 bool copySurface(GrSurface* dst,
99 GrSurface* src,
100 const SkIRect& srcRect,
101 const SkIPoint& dstPoint) SK_OVERRIDE;
joshualitta7024152014-11-03 14:16:35 -0800102
bsalomonf90a02b2014-11-26 12:28:00 -0800103 bool canCopySurface(const GrSurface* dst,
104 const GrSurface* src,
105 const SkIRect& srcRect,
106 const SkIPoint& dstPoint) SK_OVERRIDE;
joshualitta7024152014-11-03 14:16:35 -0800107
joshualitt873ad0e2015-01-20 09:08:51 -0800108 void buildProgramDesc(GrProgramDesc*,
109 const GrPrimitiveProcessor&,
egdaniel8dd688b2015-01-22 10:16:09 -0800110 const GrPipeline&,
joshualitt873ad0e2015-01-20 09:08:51 -0800111 const GrBatchTracker&) const SK_OVERRIDE;
joshualitt79f8fae2014-10-28 17:59:26 -0700112
bsalomon@google.com02ddc8b2013-01-28 15:35:28 +0000113private:
bsalomon@google.com1c13c962011-02-14 16:51:21 +0000114 // GrGpu overrides
bsalomond95263c2014-12-16 13:05:12 -0800115 void onResetContext(uint32_t resetBits) SK_OVERRIDE;
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000116
bsalomon5236cf42015-01-14 10:42:08 -0800117 GrTexture* onCreateTexture(const GrSurfaceDesc& desc, bool budgeted, const void* srcData,
bsalomond95263c2014-12-16 13:05:12 -0800118 size_t rowBytes) SK_OVERRIDE;
bsalomon5236cf42015-01-14 10:42:08 -0800119 GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, bool budgeted,
bsalomond95263c2014-12-16 13:05:12 -0800120 const void* srcData) SK_OVERRIDE;
121 GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) SK_OVERRIDE;
122 GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) SK_OVERRIDE;
123 GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) SK_OVERRIDE;
124 GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) SK_OVERRIDE;
bsalomon02a44a42015-02-19 09:09:00 -0800125 bool createStencilBufferForRenderTarget(GrRenderTarget* rt, int width, int height) SK_OVERRIDE;
bsalomond95263c2014-12-16 13:05:12 -0800126 bool attachStencilBufferToRenderTarget(GrStencilBuffer* sb, GrRenderTarget* rt) SK_OVERRIDE;
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000127
bsalomond95263c2014-12-16 13:05:12 -0800128 void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color,
129 bool canIgnoreRect) SK_OVERRIDE;
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000130
bsalomond95263c2014-12-16 13:05:12 -0800131 void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) SK_OVERRIDE;
joshualitt6db519c2014-10-29 08:48:18 -0700132
bsalomond95263c2014-12-16 13:05:12 -0800133 bool onReadPixels(GrRenderTarget* target,
134 int left, int top,
135 int width, int height,
136 GrPixelConfig,
137 void* buffer,
138 size_t rowBytes) SK_OVERRIDE;
139
140 bool onWriteTexturePixels(GrTexture* texture,
141 int left, int top, int width, int height,
142 GrPixelConfig config, const void* buffer,
senorblanco@chromium.org3cb406b2013-02-05 19:50:46 +0000143 size_t rowBytes) SK_OVERRIDE;
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000144
bsalomond95263c2014-12-16 13:05:12 -0800145 void onResolveRenderTarget(GrRenderTarget* target) SK_OVERRIDE;
bsalomon@google.com6f379512011-11-16 20:36:03 +0000146
joshualitt873ad0e2015-01-20 09:08:51 -0800147 void onDraw(const DrawArgs&, const GrDrawTarget::DrawInfo&) SK_OVERRIDE;
bsalomon3e791242014-12-17 13:43:13 -0800148 void onStencilPath(const GrPath*, const StencilPathState&) SK_OVERRIDE;
joshualitt873ad0e2015-01-20 09:08:51 -0800149 void onDrawPath(const DrawArgs&, const GrPath*, const GrStencilSettings&) SK_OVERRIDE;
150 void onDrawPaths(const DrawArgs&,
bsalomond95263c2014-12-16 13:05:12 -0800151 const GrPathRange*,
152 const void* indices,
153 GrDrawTarget::PathIndexType,
154 const float transformValues[],
155 GrDrawTarget::PathTransformType,
156 int count,
157 const GrStencilSettings&) SK_OVERRIDE;
bsalomon@google.com75f9f252012-01-31 13:35:56 +0000158
bsalomond95263c2014-12-16 13:05:12 -0800159 void clearStencil(GrRenderTarget*) SK_OVERRIDE;
bsalomon@google.com5739d2c2012-05-31 15:07:19 +0000160
robertphillips754f4e92014-09-18 13:52:08 -0700161 // GrDrawTarget overrides
bsalomond95263c2014-12-16 13:05:12 -0800162 void didAddGpuTraceMarker() SK_OVERRIDE;
163 void didRemoveGpuTraceMarker() SK_OVERRIDE;
commit-bot@chromium.orga3baf3b2014-02-21 18:45:30 +0000164
bsalomon@google.com1c13c962011-02-14 16:51:21 +0000165 // binds texture unit in GL
bsalomon@google.com8531c1c2011-01-13 19:52:45 +0000166 void setTextureUnit(int unitIdx);
reed@google.comac10a2d2010-12-22 21:39:39 +0000167
egdaniel8dd688b2015-01-22 10:16:09 -0800168 // Flushes state from GrPipeline to GL. Returns false if the state couldn't be set.
cdaltond0a840d2015-03-16 17:19:58 -0700169 bool flushGLState(const DrawArgs&);
bsalomond95263c2014-12-16 13:05:12 -0800170
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000171 // Sets up vertex attribute pointers and strides. On return indexOffsetInBytes gives the offset
172 // an into the index buffer. It does not account for drawInfo.startIndex() but rather the start
173 // index is relative to the returned offset.
joshualitt873ad0e2015-01-20 09:08:51 -0800174 void setupGeometry(const GrPrimitiveProcessor&,
joshualittd53a8272014-11-10 16:03:14 -0800175 const GrDrawTarget::DrawInfo& info,
176 size_t* indexOffsetInBytes);
bsalomon@google.com7acdb8e2011-02-11 14:07:02 +0000177
bsalomon@google.com86c1f712011-10-12 14:54:26 +0000178 // Subclasses should call this to flush the blend state.
egdaniel080e6732014-12-22 07:35:52 -0800179 void flushBlend(const GrXferProcessor::BlendInfo& blendInfo);
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000180
commit-bot@chromium.orgb1854a82014-01-16 18:39:04 +0000181 bool hasExtension(const char* ext) const { return fGLContext.hasExtension(ext); }
bsalomon@google.com96399942012-02-13 14:39:16 +0000182
bsalomon@google.com271cffc2011-05-20 14:13:56 +0000183 static bool BlendCoeffReferencesConstant(GrBlendCoeff coeff);
bsalomon@google.com080773c2011-03-15 19:09:25 +0000184
commit-bot@chromium.orga0b40282013-09-18 13:00:55 +0000185 class ProgramCache : public ::SkNoncopyable {
bsalomon@google.comc1d2a582012-06-01 15:08:19 +0000186 public:
bsalomon861e1032014-12-16 07:33:49 -0800187 ProgramCache(GrGLGpu* gpu);
jvanverth@google.com94878772013-03-12 16:00:54 +0000188 ~ProgramCache();
bsalomon@google.com5739d2c2012-05-31 15:07:19 +0000189
bsalomon@google.comc1d2a582012-06-01 15:08:19 +0000190 void abandon();
joshualitt873ad0e2015-01-20 09:08:51 -0800191 GrGLProgram* getProgram(const DrawArgs&);
bsalomon@google.com2db3ded2013-05-22 14:34:04 +0000192
bsalomon@google.comc1d2a582012-06-01 15:08:19 +0000193 private:
194 enum {
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000195 // We may actually have kMaxEntries+1 shaders in the GL context because we create a new
196 // shader before evicting from the cache.
commit-bot@chromium.orgb5564222014-03-28 15:52:18 +0000197 kMaxEntries = 128,
bsalomon@google.com2db3ded2013-05-22 14:34:04 +0000198 kHashBits = 6,
bsalomon@google.comc1d2a582012-06-01 15:08:19 +0000199 };
200
bsalomon@google.com2db3ded2013-05-22 14:34:04 +0000201 struct Entry;
bsalomon@google.comc1d2a582012-06-01 15:08:19 +0000202
bsalomon@google.com2db3ded2013-05-22 14:34:04 +0000203 struct ProgDescLess;
bsalomon@google.comc1d2a582012-06-01 15:08:19 +0000204
bsalomon@google.com2db3ded2013-05-22 14:34:04 +0000205 // binary search for entry matching desc. returns index into fEntries that matches desc or ~
206 // of the index of where it should be inserted.
joshualitt79f8fae2014-10-28 17:59:26 -0700207 int search(const GrProgramDesc& desc) const;
bsalomon@google.comc1d2a582012-06-01 15:08:19 +0000208
bsalomon@google.com2db3ded2013-05-22 14:34:04 +0000209 // sorted array of all the entries
210 Entry* fEntries[kMaxEntries];
211 // hash table based on lowest kHashBits bits of the program key. Used to avoid binary
212 // searching fEntries.
213 Entry* fHashTable[1 << kHashBits];
bsalomon@google.comc1d2a582012-06-01 15:08:19 +0000214
bsalomon@google.comc1d2a582012-06-01 15:08:19 +0000215 int fCount;
216 unsigned int fCurrLRUStamp;
bsalomon861e1032014-12-16 07:33:49 -0800217 GrGLGpu* fGpu;
jvanverth@google.com94878772013-03-12 16:00:54 +0000218#ifdef PROGRAM_CACHE_STATS
219 int fTotalRequests;
220 int fCacheMisses;
bsalomon@google.com2db3ded2013-05-22 14:34:04 +0000221 int fHashMisses; // cache hit but hash table missed
jvanverth@google.com94878772013-03-12 16:00:54 +0000222#endif
bsalomon@google.comc1d2a582012-06-01 15:08:19 +0000223 };
bsalomon@google.com5739d2c2012-05-31 15:07:19 +0000224
bsalomon3e791242014-12-17 13:43:13 -0800225 void flushDither(bool dither);
egdaniel080e6732014-12-22 07:35:52 -0800226 void flushColorWrite(bool writeColor);
egdaniel8dd688b2015-01-22 10:16:09 -0800227 void flushDrawFace(GrPipelineBuilder::DrawFace face);
bsalomon@google.comc96cb3a2012-06-04 19:31:00 +0000228
bsalomon@google.coma3201942012-06-21 19:58:20 +0000229 // flushes the scissor. see the note on flushBoundTextureAndParams about
230 // flushing the scissor after that function is called.
bsalomon3e791242014-12-17 13:43:13 -0800231 void flushScissor(const GrScissorState&,
joshualitt77b13072014-10-27 14:51:01 -0700232 const GrGLIRect& rtViewport,
233 GrSurfaceOrigin rtOrigin);
234
235 // disables the scissor
236 void disableScissor();
bsalomon@google.coma3201942012-06-21 19:58:20 +0000237
bsalomon@google.com18c9c192011-09-22 21:01:31 +0000238 void initFSAASupport();
bsalomon@google.com6aa25c32011-04-27 19:55:29 +0000239
bsalomon@google.com2c17fcd2011-07-06 17:47:02 +0000240 // determines valid stencil formats
bsalomon@google.com18c9c192011-09-22 21:01:31 +0000241 void initStencilFormats();
bsalomon@google.com2c17fcd2011-07-06 17:47:02 +0000242
commit-bot@chromium.orga15f7e52013-06-05 23:29:25 +0000243 // sets a texture unit to use for texture operations other than binding a texture to a program.
244 // ensures that such operations don't negatively interact with tracking bound textures.
245 void setScratchTextureUnit();
reed@google.comac10a2d2010-12-22 21:39:39 +0000246
egdanield803f272015-03-18 13:01:52 -0700247 // bounds is region that may be modified and therefore has to be resolved.
248 // NULL means whole target. Can be an empty rect.
249 void flushRenderTarget(GrGLRenderTarget*, const SkIRect* bounds);
bsalomonb0bd4f62014-09-03 07:19:50 -0700250
bsalomon3e791242014-12-17 13:43:13 -0800251 void flushStencil(const GrStencilSettings&);
cdaltond0a840d2015-03-16 17:19:58 -0700252 void flushHWAAState(GrRenderTarget* rt, bool useHWAA);
bsalomon@google.com0650e812011-04-08 18:07:53 +0000253
bsalomon@google.com280e99f2012-01-05 16:17:38 +0000254 bool configToGLFormats(GrPixelConfig config,
255 bool getSizedInternal,
256 GrGLenum* internalFormat,
257 GrGLenum* externalFormat,
258 GrGLenum* externalType);
bsalomon@google.com6f379512011-11-16 20:36:03 +0000259 // helper for onCreateTexture and writeTexturePixels
bsalomonb15b4c12014-10-29 12:41:57 -0700260 bool uploadTexData(const GrSurfaceDesc& desc,
bsalomon@google.com1e0e6072011-11-28 18:49:37 +0000261 bool isNewTexture,
bsalomon@google.com6f379512011-11-16 20:36:03 +0000262 int left, int top, int width, int height,
263 GrPixelConfig dataConfig,
264 const void* data,
265 size_t rowBytes);
bsalomon@google.com0650e812011-04-08 18:07:53 +0000266
krajcevski145d48c2014-06-11 16:07:50 -0700267 // helper for onCreateCompressedTexture. If width and height are
268 // set to -1, then this function will use desc.fWidth and desc.fHeight
269 // for the size of the data. The isNewTexture flag should be set to true
270 // whenever a new texture needs to be created. Otherwise, we assume that
271 // the texture is already in GPU memory and that it's going to be updated
272 // with new data.
bsalomonb15b4c12014-10-29 12:41:57 -0700273 bool uploadCompressedTexData(const GrSurfaceDesc& desc,
krajcevski145d48c2014-06-11 16:07:50 -0700274 const void* data,
275 bool isNewTexture = true,
276 int left = 0, int top = 0,
277 int width = -1, int height = -1);
krajcevski9c0e6292014-06-02 07:38:14 -0700278
bsalomon5236cf42015-01-14 10:42:08 -0800279 bool createRenderTargetObjects(const GrSurfaceDesc&, bool budgeted, GrGLuint texID,
280 GrGLRenderTarget::IDDesc*);
bsalomon@google.com81c3f8d2011-08-03 15:18:33 +0000281
egdanield803f272015-03-18 13:01:52 -0700282 enum TempFBOTarget {
283 kSrc_TempFBOTarget,
284 kDst_TempFBOTarget
285 };
egdaniel0f5f9672015-02-03 11:10:51 -0800286
egdanield803f272015-03-18 13:01:52 -0700287 GrGLuint bindSurfaceAsFBO(GrSurface* surface, GrGLenum fboTarget, GrGLIRect* viewport,
288 TempFBOTarget tempFBOTarget);
egdaniel0f5f9672015-02-03 11:10:51 -0800289
egdanield803f272015-03-18 13:01:52 -0700290 void unbindTextureFromFBO(GrGLenum fboTarget);
robertphillips754f4e92014-09-18 13:52:08 -0700291
robertphillips@google.com6177e692013-02-28 20:16:25 +0000292 GrGLContext fGLContext;
bsalomon@google.com2c17fcd2011-07-06 17:47:02 +0000293
bsalomon@google.com5739d2c2012-05-31 15:07:19 +0000294 // GL program-related state
295 ProgramCache* fProgramCache;
bsalomon@google.com9ba4fa62012-07-16 17:36:28 +0000296 SkAutoTUnref<GrGLProgram> fCurrentProgram;
bsalomon@google.com49209392012-06-05 15:13:46 +0000297
298 ///////////////////////////////////////////////////////////////////////////
299 ///@name Caching of GL State
300 ///@{
301 int fHWActiveTextureUnitIdx;
bsalomon@google.com5739d2c2012-05-31 15:07:19 +0000302 GrGLuint fHWProgramID;
bsalomon@google.com91207482013-02-12 21:45:24 +0000303
bsalomon@google.com49209392012-06-05 15:13:46 +0000304 enum TriState {
305 kNo_TriState,
306 kYes_TriState,
307 kUnknown_TriState
308 };
309
egdanield803f272015-03-18 13:01:52 -0700310 GrGLuint fTempSrcFBOID;
311 GrGLuint fTempDstFBOID;
312
313 GrGLuint fStencilClearFBOID;
bsalomondd3143b2015-02-23 09:27:45 -0800314
bsalomon@google.coma3201942012-06-21 19:58:20 +0000315 // last scissor / viewport scissor state seen by the GL.
316 struct {
317 TriState fEnabled;
318 GrGLIRect fRect;
319 void invalidate() {
320 fEnabled = kUnknown_TriState;
321 fRect.invalidate();
322 }
323 } fHWScissorSettings;
324
325 GrGLIRect fHWViewport;
326
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000327 /**
328 * Tracks bound vertex and index buffers and vertex attrib array state.
329 */
330 class HWGeometryState {
331 public:
bsalomon@google.com6918d482013-03-07 19:09:11 +0000332 HWGeometryState() { fVBOVertexArray = NULL; this->invalidate(); }
skia.committer@gmail.com754a3eb2013-03-08 07:01:25 +0000333
bsalomon@google.com6918d482013-03-07 19:09:11 +0000334 ~HWGeometryState() { SkSafeUnref(fVBOVertexArray); }
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000335
bsalomon@google.com6918d482013-03-07 19:09:11 +0000336 void invalidate() {
337 fBoundVertexArrayIDIsValid = false;
338 fBoundVertexBufferIDIsValid = false;
339 fDefaultVertexArrayBoundIndexBufferID = false;
340 fDefaultVertexArrayBoundIndexBufferIDIsValid = false;
341 fDefaultVertexArrayAttribState.invalidate();
bsalomon49f085d2014-09-05 13:34:00 -0700342 if (fVBOVertexArray) {
commit-bot@chromium.orgce6da4d2013-09-09 14:55:37 +0000343 fVBOVertexArray->invalidateCachedState();
344 }
bsalomon@google.com6918d482013-03-07 19:09:11 +0000345 }
346
347 void notifyVertexArrayDelete(GrGLuint id) {
348 if (fBoundVertexArrayIDIsValid && fBoundVertexArrayID == id) {
349 // Does implicit bind to 0
350 fBoundVertexArrayID = 0;
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000351 }
352 }
353
bsalomon861e1032014-12-16 07:33:49 -0800354 void setVertexArrayID(GrGLGpu* gpu, GrGLuint arrayID) {
bsalomon@google.com6918d482013-03-07 19:09:11 +0000355 if (!gpu->glCaps().vertexArrayObjectSupport()) {
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000356 SkASSERT(0 == arrayID);
bsalomon@google.com6918d482013-03-07 19:09:11 +0000357 return;
358 }
359 if (!fBoundVertexArrayIDIsValid || arrayID != fBoundVertexArrayID) {
360 GR_GL_CALL(gpu->glInterface(), BindVertexArray(arrayID));
361 fBoundVertexArrayIDIsValid = true;
362 fBoundVertexArrayID = arrayID;
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000363 }
364 }
365
bsalomon@google.come49ad452013-02-20 19:33:20 +0000366 void notifyVertexBufferDelete(GrGLuint id) {
bsalomon@google.com6918d482013-03-07 19:09:11 +0000367 if (fBoundVertexBufferIDIsValid && id == fBoundVertexBufferID) {
368 fBoundVertexBufferID = 0;
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000369 }
bsalomon49f085d2014-09-05 13:34:00 -0700370 if (fVBOVertexArray) {
bsalomon@google.com6918d482013-03-07 19:09:11 +0000371 fVBOVertexArray->notifyVertexBufferDelete(id);
372 }
373 fDefaultVertexArrayAttribState.notifyVertexBufferDelete(id);
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000374 }
375
bsalomon@google.come49ad452013-02-20 19:33:20 +0000376 void notifyIndexBufferDelete(GrGLuint id) {
bsalomon@google.com6918d482013-03-07 19:09:11 +0000377 if (fDefaultVertexArrayBoundIndexBufferIDIsValid &&
378 id == fDefaultVertexArrayBoundIndexBufferID) {
379 fDefaultVertexArrayBoundIndexBufferID = 0;
380 }
bsalomon49f085d2014-09-05 13:34:00 -0700381 if (fVBOVertexArray) {
bsalomon@google.com6918d482013-03-07 19:09:11 +0000382 fVBOVertexArray->notifyIndexBufferDelete(id);
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000383 }
384 }
385
bsalomon861e1032014-12-16 07:33:49 -0800386 void setVertexBufferID(GrGLGpu* gpu, GrGLuint id) {
bsalomon@google.com6918d482013-03-07 19:09:11 +0000387 if (!fBoundVertexBufferIDIsValid || id != fBoundVertexBufferID) {
388 GR_GL_CALL(gpu->glInterface(), BindBuffer(GR_GL_ARRAY_BUFFER, id));
389 fBoundVertexBufferIDIsValid = true;
390 fBoundVertexBufferID = id;
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000391 }
392 }
393
bsalomon@google.com6918d482013-03-07 19:09:11 +0000394 /**
395 * Binds the default vertex array and binds the index buffer. This is used when binding
396 * an index buffer in order to update it.
397 */
bsalomon861e1032014-12-16 07:33:49 -0800398 void setIndexBufferIDOnDefaultVertexArray(GrGLGpu* gpu, GrGLuint id) {
bsalomon@google.com6918d482013-03-07 19:09:11 +0000399 this->setVertexArrayID(gpu, 0);
400 if (!fDefaultVertexArrayBoundIndexBufferIDIsValid ||
401 id != fDefaultVertexArrayBoundIndexBufferID) {
402 GR_GL_CALL(gpu->glInterface(), BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, id));
403 fDefaultVertexArrayBoundIndexBufferIDIsValid = true;
404 fDefaultVertexArrayBoundIndexBufferID = id;
405 }
406 }
407
408 /**
409 * Binds the vertex array object that should be used to render from the vertex buffer.
410 * The vertex array is bound and its attrib array state object is returned. The vertex
411 * buffer is bound. The index buffer (if non-NULL) is bound to the vertex array. The
skia.committer@gmail.com754a3eb2013-03-08 07:01:25 +0000412 * returned GrGLAttribArrayState should be used to set vertex attribute arrays.
bsalomon@google.com6918d482013-03-07 19:09:11 +0000413 */
bsalomon861e1032014-12-16 07:33:49 -0800414 GrGLAttribArrayState* bindArrayAndBuffersToDraw(GrGLGpu* gpu,
bsalomon@google.com6918d482013-03-07 19:09:11 +0000415 const GrGLVertexBuffer* vbuffer,
416 const GrGLIndexBuffer* ibuffer);
417
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000418 private:
bsalomon@google.com6918d482013-03-07 19:09:11 +0000419 GrGLuint fBoundVertexArrayID;
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000420 GrGLuint fBoundVertexBufferID;
bsalomon@google.com6918d482013-03-07 19:09:11 +0000421 bool fBoundVertexArrayIDIsValid;
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000422 bool fBoundVertexBufferIDIsValid;
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000423
bsalomon@google.com6918d482013-03-07 19:09:11 +0000424 GrGLuint fDefaultVertexArrayBoundIndexBufferID;
425 bool fDefaultVertexArrayBoundIndexBufferIDIsValid;
426 // We return a non-const pointer to this from bindArrayAndBuffersToDraw when vertex array 0
jvanverth39edf762014-12-22 11:44:19 -0800427 // is bound. However, this class is internal to GrGLGpu and this object never leaks out of
428 // GrGLGpu.
bsalomon@google.com6918d482013-03-07 19:09:11 +0000429 GrGLAttribArrayState fDefaultVertexArrayAttribState;
bsalomon@google.com880b8fc2013-02-19 20:17:28 +0000430
bsalomon@google.com6918d482013-03-07 19:09:11 +0000431 // This is used when we're using a core profile and the vertices are in a VBO.
432 GrGLVertexArray* fVBOVertexArray;
bsalomon@google.com49209392012-06-05 15:13:46 +0000433 } fHWGeometryState;
bsalomon@google.com5782d712011-01-21 21:03:59 +0000434
bsalomon@google.coma4d8fc22012-05-21 13:21:46 +0000435 struct {
436 GrBlendCoeff fSrcCoeff;
437 GrBlendCoeff fDstCoeff;
438 GrColor fConstColor;
439 bool fConstColorValid;
440 TriState fEnabled;
441
442 void invalidate() {
bsalomon@google.com47059542012-06-06 20:51:20 +0000443 fSrcCoeff = kInvalid_GrBlendCoeff;
444 fDstCoeff = kInvalid_GrBlendCoeff;
bsalomon@google.coma4d8fc22012-05-21 13:21:46 +0000445 fConstColorValid = false;
446 fEnabled = kUnknown_TriState;
447 }
448 } fHWBlendState;
449
egdanielb414f252014-07-29 13:15:47 -0700450 TriState fMSAAEnabled;
bsalomon@google.comded4f4b2012-06-28 18:48:06 +0000451
bsalomon@google.com6a51dcb2013-02-13 16:03:51 +0000452 GrStencilSettings fHWStencilSettings;
453 TriState fHWStencilTestEnabled;
kkinnunenccdaa042014-08-20 01:36:23 -0700454
bsalomon@google.com6a51dcb2013-02-13 16:03:51 +0000455
egdaniel8dd688b2015-01-22 10:16:09 -0800456 GrPipelineBuilder::DrawFace fHWDrawFace;
bsalomon@google.com6a51dcb2013-02-13 16:03:51 +0000457 TriState fHWWriteToColor;
458 TriState fHWDitherEnabled;
egdanield803f272015-03-18 13:01:52 -0700459 uint32_t fHWBoundRenderTargetUniqueID;
bsalomon1c63bf62014-07-22 13:09:46 -0700460 SkTArray<uint32_t, true> fHWBoundTextureUniqueIDs;
commit-bot@chromium.org6b30e452013-10-04 20:02:53 +0000461
bsalomon@google.com49209392012-06-05 15:13:46 +0000462 ///@}
bsalomon@google.com978c8c62012-05-21 14:45:49 +0000463
bsalomon@google.comfe676522011-06-17 18:12:21 +0000464 // we record what stencil format worked last time to hopefully exit early
465 // from our loop that tries stencil formats and calls check fb status.
466 int fLastSuccessfulStencilFmtIdx;
467
reed@google.comac10a2d2010-12-22 21:39:39 +0000468 typedef GrGpu INHERITED;
kkinnunenccdaa042014-08-20 01:36:23 -0700469 friend class GrGLPathRendering; // For accessing setTextureUnit.
reed@google.comac10a2d2010-12-22 21:39:39 +0000470};
471
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000472#endif