| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright 2014 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. | |
| 6 */ | |
| 7 | |
| 8 #ifndef GrRODrawState_DEFINED | |
| 9 #define GrRODrawState_DEFINED | |
| 10 | |
| 11 #include "GrProcessorStage.h" | |
| 12 #include "GrRenderTarget.h" | |
| 13 #include "GrStencil.h" | |
| 14 #include "SkMatrix.h" | |
| 15 | |
| 16 class GrDrawState; | |
| 17 class GrDrawTargetCaps; | |
| 18 class GrPaint; | |
| 19 class GrTexture; | |
| 20 | |
| 21 /** | |
| 22 * Read-only base class for GrDrawState. This class contains all the necessary d
ata to represent a | |
| 23 * canonical DrawState. All methods in the class are const, thus once created th
e data in the class | |
| 24 * cannot be changed. | |
| 25 */ | |
| 26 class GrRODrawState : public SkRefCnt { | |
| 27 public: | |
| 28 SK_DECLARE_INST_COUNT(GrRODrawState) | |
| 29 | |
| 30 GrRODrawState() {} | |
| 31 | |
| 32 GrRODrawState& operator= (const GrRODrawState& that); | |
| 33 | |
| 34 /////////////////////////////////////////////////////////////////////////// | |
| 35 /// @name Vertex Attributes | |
| 36 //// | |
| 37 | |
| 38 enum { | |
| 39 kMaxVertexAttribCnt = kLast_GrVertexAttribBinding + 4, | |
| 40 }; | |
| 41 | |
| 42 const GrVertexAttrib* getVertexAttribs() const { return fVAPtr; } | |
| 43 int getVertexAttribCount() const { return fVACount; } | |
| 44 | |
| 45 size_t getVertexStride() const { return fVAStride; } | |
| 46 | |
| 47 /** | |
| 48 * Getters for index into getVertexAttribs() for particular bindings. -1 is
returned if the | |
| 49 * binding does not appear in the current attribs. These bindings should app
ear only once in | |
| 50 * the attrib array. | |
| 51 */ | |
| 52 | |
| 53 int positionAttributeIndex() const { | |
| 54 return fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding
]; | |
| 55 } | |
| 56 int localCoordAttributeIndex() const { | |
| 57 return fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBindi
ng]; | |
| 58 } | |
| 59 int colorVertexAttributeIndex() const { | |
| 60 return fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding]; | |
| 61 } | |
| 62 int coverageVertexAttributeIndex() const { | |
| 63 return fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding
]; | |
| 64 } | |
| 65 | |
| 66 bool hasLocalCoordAttribute() const { | |
| 67 return -1 != fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttri
bBinding]; | |
| 68 } | |
| 69 bool hasColorVertexAttribute() const { | |
| 70 return -1 != fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBind
ing]; | |
| 71 } | |
| 72 bool hasCoverageVertexAttribute() const { | |
| 73 return -1 != fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribB
inding]; | |
| 74 } | |
| 75 | |
| 76 const int* getFixedFunctionVertexAttribIndices() const { | |
| 77 return fFixedFunctionVertexAttribIndices; | |
| 78 } | |
| 79 | |
| 80 bool validateVertexAttribs() const; | |
| 81 | |
| 82 /// @} | |
| 83 | |
| 84 /** | |
| 85 * Determines whether the output coverage is guaranteed to be one for all pi
xels hit by a draw. | |
| 86 */ | |
| 87 bool hasSolidCoverage() const; | |
| 88 | |
| 89 /// @} | |
| 90 | |
| 91 /////////////////////////////////////////////////////////////////////////// | |
| 92 /// @name Color | |
| 93 //// | |
| 94 | |
| 95 GrColor getColor() const { return fColor; } | |
| 96 | |
| 97 /// @} | |
| 98 | |
| 99 /////////////////////////////////////////////////////////////////////////// | |
| 100 /// @name Coverage | |
| 101 //// | |
| 102 | |
| 103 uint8_t getCoverage() const { return fCoverage; } | |
| 104 | |
| 105 GrColor getCoverageColor() const { | |
| 106 return GrColorPackRGBA(fCoverage, fCoverage, fCoverage, fCoverage); | |
| 107 } | |
| 108 | |
| 109 /// @} | |
| 110 | |
| 111 /////////////////////////////////////////////////////////////////////////// | |
| 112 /// @name Effect Stages | |
| 113 /// Each stage hosts a GrProcessor. The effect produces an output color or c
overage in the | |
| 114 /// fragment shader. Its inputs are the output from the previous stage as we
ll as some variables | |
| 115 /// available to it in the fragment and vertex shader (e.g. the vertex posit
ion, the dst color, | |
| 116 /// the fragment position, local coordinates). | |
| 117 /// | |
| 118 /// The stages are divided into two sets, color-computing and coverage-compu
ting. The final | |
| 119 /// color stage produces the final pixel color. The coverage-computing stage
s function exactly | |
| 120 /// as the color-computing but the output of the final coverage stage is tre
ated as a fractional | |
| 121 /// pixel coverage rather than as input to the src/dst color blend step. | |
| 122 /// | |
| 123 /// The input color to the first color-stage is either the constant color or
interpolated | |
| 124 /// per-vertex colors. The input to the first coverage stage is either a con
stant coverage | |
| 125 /// (usually full-coverage) or interpolated per-vertex coverage. | |
| 126 /// | |
| 127 /// See the documentation of kCoverageDrawing_StateBit for information about
disabling the | |
| 128 /// the color / coverage distinction. | |
| 129 //// | |
| 130 | |
| 131 int numColorStages() const { return fColorStages.count(); } | |
| 132 int numCoverageStages() const { return fCoverageStages.count(); } | |
| 133 int numTotalStages() const { | |
| 134 return this->numColorStages() + this->numCoverageStages() + | |
| 135 (this->hasGeometryProcessor() ? 1 : 0); | |
| 136 } | |
| 137 | |
| 138 bool hasGeometryProcessor() const { return SkToBool(fGeometryProcessor.get()
); } | |
| 139 const GrGeometryStage* getGeometryProcessor() const { return fGeometryProces
sor.get(); } | |
| 140 const GrFragmentStage& getColorStage(int stageIdx) const { return fColorStag
es[stageIdx]; } | |
| 141 const GrFragmentStage& getCoverageStage(int stageIdx) const { return fCovera
geStages[stageIdx]; } | |
| 142 | |
| 143 /** | |
| 144 * Checks whether any of the effects will read the dst pixel color. | |
| 145 */ | |
| 146 bool willEffectReadDstColor() const; | |
| 147 | |
| 148 /// @} | |
| 149 | |
| 150 /////////////////////////////////////////////////////////////////////////// | |
| 151 /// @name Blending | |
| 152 //// | |
| 153 | |
| 154 GrBlendCoeff getSrcBlendCoeff() const { return fSrcBlend; } | |
| 155 GrBlendCoeff getDstBlendCoeff() const { return fDstBlend; } | |
| 156 | |
| 157 void getDstBlendCoeff(GrBlendCoeff* srcBlendCoeff, | |
| 158 GrBlendCoeff* dstBlendCoeff) const { | |
| 159 *srcBlendCoeff = fSrcBlend; | |
| 160 *dstBlendCoeff = fDstBlend; | |
| 161 } | |
| 162 | |
| 163 /** | |
| 164 * Retrieves the last value set by setBlendConstant() | |
| 165 * @return the blending constant value | |
| 166 */ | |
| 167 GrColor getBlendConstant() const { return fBlendConstant; } | |
| 168 | |
| 169 /** | |
| 170 * Determines whether multiplying the computed per-pixel color by the pixel'
s fractional | |
| 171 * coverage before the blend will give the correct final destination color.
In general it | |
| 172 * will not as coverage is applied after blending. | |
| 173 */ | |
| 174 bool canTweakAlphaForCoverage() const; | |
| 175 | |
| 176 /// @} | |
| 177 | |
| 178 /////////////////////////////////////////////////////////////////////////// | |
| 179 /// @name View Matrix | |
| 180 //// | |
| 181 | |
| 182 /** | |
| 183 * Retrieves the current view matrix | |
| 184 * @return the current view matrix. | |
| 185 */ | |
| 186 const SkMatrix& getViewMatrix() const { return fViewMatrix; } | |
| 187 | |
| 188 /** | |
| 189 * Retrieves the inverse of the current view matrix. | |
| 190 * | |
| 191 * If the current view matrix is invertible, return true, and if matrix | |
| 192 * is non-null, copy the inverse into it. If the current view matrix is | |
| 193 * non-invertible, return false and ignore the matrix parameter. | |
| 194 * | |
| 195 * @param matrix if not null, will receive a copy of the current inverse. | |
| 196 */ | |
| 197 bool getViewInverse(SkMatrix* matrix) const { | |
| 198 // TODO: determine whether we really need to leave matrix unmodified | |
| 199 // at call sites when inversion fails. | |
| 200 SkMatrix inverse; | |
| 201 if (fViewMatrix.invert(&inverse)) { | |
| 202 if (matrix) { | |
| 203 *matrix = inverse; | |
| 204 } | |
| 205 return true; | |
| 206 } | |
| 207 return false; | |
| 208 } | |
| 209 | |
| 210 /// @} | |
| 211 | |
| 212 /////////////////////////////////////////////////////////////////////////// | |
| 213 /// @name Render Target | |
| 214 //// | |
| 215 | |
| 216 /** | |
| 217 * Retrieves the currently set render-target. | |
| 218 * | |
| 219 * @return The currently set render target. | |
| 220 */ | |
| 221 GrRenderTarget* getRenderTarget() const { | |
| 222 return static_cast<GrRenderTarget*>(fRenderTarget.getResource()); | |
| 223 } | |
| 224 | |
| 225 /// @} | |
| 226 | |
| 227 /////////////////////////////////////////////////////////////////////////// | |
| 228 /// @name Stencil | |
| 229 //// | |
| 230 | |
| 231 const GrStencilSettings& getStencil() const { return fStencilSettings; } | |
| 232 | |
| 233 /// @} | |
| 234 | |
| 235 /////////////////////////////////////////////////////////////////////////// | |
| 236 /// @name State Flags | |
| 237 //// | |
| 238 | |
| 239 /** | |
| 240 * Flags that affect rendering. Controlled using enable/disableState(). All | |
| 241 * default to disabled. | |
| 242 */ | |
| 243 enum StateBits { | |
| 244 /** | |
| 245 * Perform dithering. TODO: Re-evaluate whether we need this bit | |
| 246 */ | |
| 247 kDither_StateBit = 0x01, | |
| 248 /** | |
| 249 * Perform HW anti-aliasing. This means either HW FSAA, if supported by
the render target, | |
| 250 * or smooth-line rendering if a line primitive is drawn and line smooth
ing is supported by | |
| 251 * the 3D API. | |
| 252 */ | |
| 253 kHWAntialias_StateBit = 0x02, | |
| 254 /** | |
| 255 * Draws will respect the clip, otherwise the clip is ignored. | |
| 256 */ | |
| 257 kClip_StateBit = 0x04, | |
| 258 /** | |
| 259 * Disables writing to the color buffer. Useful when performing stencil | |
| 260 * operations. | |
| 261 */ | |
| 262 kNoColorWrites_StateBit = 0x08, | |
| 263 | |
| 264 /** | |
| 265 * Usually coverage is applied after color blending. The color is blende
d using the coeffs | |
| 266 * specified by setBlendFunc(). The blended color is then combined with
dst using coeffs | |
| 267 * of src_coverage, 1-src_coverage. Sometimes we are explicitly drawing
a coverage mask. In | |
| 268 * this case there is no distinction between coverage and color and the
caller needs direct | |
| 269 * control over the blend coeffs. When set, there will be a single blend
step controlled by | |
| 270 * setBlendFunc() which will use coverage*color as the src color. | |
| 271 */ | |
| 272 kCoverageDrawing_StateBit = 0x10, | |
| 273 | |
| 274 // Users of the class may add additional bits to the vector | |
| 275 kDummyStateBit, | |
| 276 kLastPublicStateBit = kDummyStateBit-1, | |
| 277 }; | |
| 278 | |
| 279 uint32_t getFlagBits() const { return fFlagBits; } | |
| 280 | |
| 281 bool isStateFlagEnabled(uint32_t stateBit) const { return 0 != (stateBit & f
FlagBits); } | |
| 282 | |
| 283 bool isDitherState() const { return 0 != (fFlagBits & kDither_StateBit); } | |
| 284 bool isHWAntialiasState() const { return 0 != (fFlagBits & kHWAntialias_Stat
eBit); } | |
| 285 bool isClipState() const { return 0 != (fFlagBits & kClip_StateBit); } | |
| 286 bool isColorWriteDisabled() const { return 0 != (fFlagBits & kNoColorWrites_
StateBit); } | |
| 287 bool isCoverageDrawing() const { return 0 != (fFlagBits & kCoverageDrawing_S
tateBit); } | |
| 288 | |
| 289 /// @} | |
| 290 | |
| 291 /////////////////////////////////////////////////////////////////////////// | |
| 292 /// @name Face Culling | |
| 293 //// | |
| 294 | |
| 295 enum DrawFace { | |
| 296 kInvalid_DrawFace = -1, | |
| 297 | |
| 298 kBoth_DrawFace, | |
| 299 kCCW_DrawFace, | |
| 300 kCW_DrawFace, | |
| 301 }; | |
| 302 | |
| 303 /** | |
| 304 * Gets whether the target is drawing clockwise, counterclockwise, | |
| 305 * or both faces. | |
| 306 * @return the current draw face(s). | |
| 307 */ | |
| 308 DrawFace getDrawFace() const { return fDrawFace; } | |
| 309 | |
| 310 /// @} | |
| 311 | |
| 312 /////////////////////////////////////////////////////////////////////////// | |
| 313 /// @name Hints | |
| 314 /// Hints that when provided can enable optimizations. | |
| 315 //// | |
| 316 | |
| 317 enum Hints { kVertexColorsAreOpaque_Hint = 0x1, }; | |
| 318 | |
| 319 bool vertexColorsAreOpaque() const { return kVertexColorsAreOpaque_Hint & fH
ints; } | |
| 320 | |
| 321 /// @} | |
| 322 | |
| 323 /////////////////////////////////////////////////////////////////////////// | |
| 324 | |
| 325 /** Return type for CombineIfPossible. */ | |
| 326 enum CombinedState { | |
| 327 /** The GrDrawStates cannot be combined. */ | |
| 328 kIncompatible_CombinedState, | |
| 329 /** Either draw state can be used in place of the other. */ | |
| 330 kAOrB_CombinedState, | |
| 331 /** Use the first draw state. */ | |
| 332 kA_CombinedState, | |
| 333 /** Use the second draw state. */ | |
| 334 kB_CombinedState, | |
| 335 }; | |
| 336 | |
| 337 protected: | |
| 338 /** | |
| 339 * Converts refs on GrGpuResources owned directly or indirectly by this GrRO
DrawState into | |
| 340 * pending reads and writes. This should be called when a GrDrawState is rec
orded into | |
| 341 * a GrDrawTarget for later execution. Subclasses of GrRODrawState may add s
etters. However, | |
| 342 * once this call has been made the GrRODrawState is immutable. It is also n
o longer copyable. | |
| 343 * In the future this conversion will automatically happen when converting a
GrDrawState into | |
| 344 * an optimized draw state. | |
| 345 */ | |
| 346 void convertToPendingExec(); | |
| 347 | |
| 348 friend class GrDrawTarget; | |
| 349 | |
| 350 explicit GrRODrawState(const GrRODrawState& drawState); | |
| 351 | |
| 352 bool isEqual(const GrRODrawState& that) const; | |
| 353 | |
| 354 /** | |
| 355 * Optimizations for blending / coverage to that can be applied based on the
current state. | |
| 356 */ | |
| 357 enum BlendOptFlags { | |
| 358 /** | |
| 359 * No optimization | |
| 360 */ | |
| 361 kNone_BlendOpt = 0, | |
| 362 /** | |
| 363 * Don't draw at all | |
| 364 */ | |
| 365 kSkipDraw_BlendOptFlag = 0x1, | |
| 366 /** | |
| 367 * The coverage value does not have to be computed separately from alpha
, the the output | |
| 368 * color can be the modulation of the two. | |
| 369 */ | |
| 370 kCoverageAsAlpha_BlendOptFlag = 0x2, | |
| 371 /** | |
| 372 * Instead of emitting a src color, emit coverage in the alpha channel a
nd r,g,b are | |
| 373 * "don't cares". | |
| 374 */ | |
| 375 kEmitCoverage_BlendOptFlag = 0x4, | |
| 376 /** | |
| 377 * Emit transparent black instead of the src color, no need to compute c
overage. | |
| 378 */ | |
| 379 kEmitTransBlack_BlendOptFlag = 0x8, | |
| 380 }; | |
| 381 GR_DECL_BITFIELD_OPS_FRIENDS(BlendOptFlags); | |
| 382 | |
| 383 /** | |
| 384 * Determines what optimizations can be applied based on the blend. The coef
ficients may have | |
| 385 * to be tweaked in order for the optimization to work. srcCoeff and dstCoef
f are optional | |
| 386 * params that receive the tweaked coefficients. Normally the function looks
at the current | |
| 387 * state to see if coverage is enabled. By setting forceCoverage the caller
can speculatively | |
| 388 * determine the blend optimizations that would be used if there was partial
pixel coverage. | |
| 389 * | |
| 390 * Subclasses of GrDrawTarget that actually draw (as opposed to those that j
ust buffer for | |
| 391 * playback) must call this function and respect the flags that replace the
output color. | |
| 392 * | |
| 393 * If the cached BlendOptFlags does not have the invalidate bit set, then ge
tBlendOpts will | |
| 394 * simply returned the cached flags and coefficients. Otherwise it will calc
ulate the values. | |
| 395 */ | |
| 396 BlendOptFlags getBlendOpts(bool forceCoverage = false, | |
| 397 GrBlendCoeff* srcCoeff = NULL, | |
| 398 GrBlendCoeff* dstCoeff = NULL) const; | |
| 399 | |
| 400 typedef GrTGpuResourceRef<GrRenderTarget> ProgramRenderTarget; | |
| 401 // These fields are roughly sorted by decreasing likelihood of being differe
nt in op== | |
| 402 ProgramRenderTarget fRenderTarget; | |
| 403 GrColor fColor; | |
| 404 SkMatrix fViewMatrix; | |
| 405 GrColor fBlendConstant; | |
| 406 uint32_t fFlagBits; | |
| 407 const GrVertexAttrib* fVAPtr; | |
| 408 int fVACount; | |
| 409 size_t fVAStride; | |
| 410 GrStencilSettings fStencilSettings; | |
| 411 uint8_t fCoverage; | |
| 412 DrawFace fDrawFace; | |
| 413 GrBlendCoeff fSrcBlend; | |
| 414 GrBlendCoeff fDstBlend; | |
| 415 | |
| 416 typedef SkSTArray<4, GrFragmentStage> FragmentStageArray; | |
| 417 SkAutoTDelete<GrGeometryStage> fGeometryProcessor; | |
| 418 FragmentStageArray fColorStages; | |
| 419 FragmentStageArray fCoverageStages; | |
| 420 | |
| 421 uint32_t fHints; | |
| 422 | |
| 423 // This is simply a different representation of info in fVertexAttribs and t
hus does | |
| 424 // not need to be compared in op==. | |
| 425 int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt
]; | |
| 426 | |
| 427 private: | |
| 428 /** | |
| 429 * Determines whether src alpha is guaranteed to be one for all src pixels | |
| 430 */ | |
| 431 bool srcAlphaWillBeOne() const; | |
| 432 | |
| 433 typedef SkRefCnt INHERITED; | |
| 434 }; | |
| 435 | |
| 436 GR_MAKE_BITFIELD_OPS(GrRODrawState::BlendOptFlags); | |
| 437 | |
| 438 #endif | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 597323002:
Split GrDrawState and GrOptDrawState into separate classes and remove base class. (Closed)
Base URL: https://skia.googlesource.com/skia.git@master