mirror of https://github.com/axmolengine/axmol.git
211 lines
8.3 KiB
C
211 lines
8.3 KiB
C
/*
|
|
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 GrStencil_DEFINED
|
|
#define GrStencil_DEFINED
|
|
|
|
#include "GrTypes.h"
|
|
/**
|
|
* Gr uses the stencil buffer to implement complex clipping inside the
|
|
* GrDrawTarget class. The GrDrawTarget makes a subset of the stencil buffer
|
|
* bits available for other uses by external code (clients). Client code can
|
|
* modify these bits. GrDrawTarget will ignore ref, mask, and writemask bits
|
|
* provided by clients that overlap the bits used to implement clipping. The
|
|
* client can use the getUsableStencilBits() function to find out how many
|
|
* client accessible stencil bits are available.
|
|
*
|
|
* When code outside the GrDrawTarget class uses the stencil buffer the contract
|
|
* is as follows:
|
|
*
|
|
* > Normal stencil funcs allow the GrGpu client to modify the client bits of
|
|
* the stencil buffer outside of the clip.
|
|
* > Special functions allow a test against the clip. These are more limited
|
|
* than the general stencil functions.
|
|
* > Client can assume all client bits are zero initially.
|
|
* > Client must ensure that after all its passes are finished it has only
|
|
* written to the color buffer in the region inside the clip. Furthermore, it
|
|
* must zero all client bits that were modifed (both inside and outside the
|
|
* clip).
|
|
*/
|
|
|
|
/**
|
|
* Determines which pixels pass / fail the stencil test.
|
|
* Stencil test passes if (ref & mask) FUNC (stencil & mask) is true
|
|
*/
|
|
enum GrStencilFunc {
|
|
kAlways_StencilFunc = 0,
|
|
kNever_StencilFunc,
|
|
kGreater_StencilFunc,
|
|
kGEqual_StencilFunc,
|
|
kLess_StencilFunc,
|
|
kLEqual_StencilFunc,
|
|
kEqual_StencilFunc,
|
|
kNotEqual_StencilFunc,
|
|
|
|
// Gr stores the current clip in the
|
|
// stencil buffer in the high bits that
|
|
// are not directly accessible modifiable
|
|
// via the GrDrawTarget interface. The below
|
|
// stencil funcs test against the current
|
|
// clip in addition to the GrDrawTarget
|
|
// client's stencil bits.
|
|
|
|
// pass if inside the clip
|
|
kAlwaysIfInClip_StencilFunc,
|
|
kEqualIfInClip_StencilFunc,
|
|
kLessIfInClip_StencilFunc,
|
|
kLEqualIfInClip_StencilFunc,
|
|
kNonZeroIfInClip_StencilFunc, // this one forces the ref to be 0
|
|
|
|
// counts
|
|
kStencilFuncCount,
|
|
kClipStencilFuncCount = kNonZeroIfInClip_StencilFunc -
|
|
kAlwaysIfInClip_StencilFunc + 1,
|
|
kBasicStencilFuncCount = kStencilFuncCount - kClipStencilFuncCount
|
|
};
|
|
|
|
/**
|
|
* Operations to perform based on whether stencil test passed failed.
|
|
*/
|
|
enum GrStencilOp {
|
|
kKeep_StencilOp = 0, // preserve existing stencil value
|
|
kReplace_StencilOp, // replace with reference value from stencl test
|
|
kIncWrap_StencilOp, // increment and wrap at max
|
|
kIncClamp_StencilOp, // increment and clamp at max
|
|
kDecWrap_StencilOp, // decrement and wrap at 0
|
|
kDecClamp_StencilOp, // decrement and clamp at 0
|
|
kZero_StencilOp, // zero stencil bits
|
|
kInvert_StencilOp, // invert stencil bits
|
|
|
|
kStencilOpCount
|
|
};
|
|
|
|
/**
|
|
* Struct representing stencil state.
|
|
*/
|
|
struct GrStencilSettings {
|
|
GrStencilOp fFrontPassOp; // op to perform when front faces pass
|
|
GrStencilOp fBackPassOp; // op to perform when back faces pass
|
|
GrStencilOp fFrontFailOp; // op to perform when front faces fail
|
|
GrStencilOp fBackFailOp; // op to perform when back faces fail
|
|
GrStencilFunc fFrontFunc; // test function for front faces
|
|
GrStencilFunc fBackFunc; // test function for back faces
|
|
unsigned int fFrontFuncMask; // mask for front face test
|
|
unsigned int fBackFuncMask; // mask for back face test
|
|
unsigned int fFrontFuncRef; // reference value for front face test
|
|
unsigned int fBackFuncRef; // reference value for back face test
|
|
unsigned int fFrontWriteMask; // stencil write mask for front faces
|
|
unsigned int fBackWriteMask; // stencil write mask for back faces
|
|
|
|
bool operator == (const GrStencilSettings& s) const {
|
|
// make sure this is tightly packed.
|
|
GR_STATIC_ASSERT(0 == sizeof(GrStencilOp)%4);
|
|
GR_STATIC_ASSERT(0 == sizeof(GrStencilFunc)%4);
|
|
GR_STATIC_ASSERT(sizeof(GrStencilSettings) ==
|
|
4*sizeof(GrStencilOp) +
|
|
2*sizeof(GrStencilFunc) +
|
|
6*sizeof(unsigned int));
|
|
return 0 == memcmp(this, &s, sizeof(GrStencilSettings));
|
|
}
|
|
|
|
bool operator != (const GrStencilSettings& s) const {
|
|
return !(*this == s);
|
|
}
|
|
|
|
GrStencilSettings& operator =(const GrStencilSettings& s) {
|
|
memcpy(this, &s, sizeof(GrStencilSettings));
|
|
return *this;
|
|
}
|
|
|
|
void setSame(GrStencilOp passOp,
|
|
GrStencilOp failOp,
|
|
GrStencilFunc func,
|
|
unsigned int funcMask,
|
|
unsigned int funcRef,
|
|
unsigned int writeMask) {
|
|
fFrontPassOp = passOp;
|
|
fBackPassOp = passOp;
|
|
fFrontFailOp = failOp;
|
|
fBackFailOp = failOp;
|
|
fFrontFunc = func;
|
|
fBackFunc = func;
|
|
fFrontFuncMask = funcMask;
|
|
fBackFuncMask = funcMask;
|
|
fFrontFuncRef = funcRef;
|
|
fBackFuncRef = funcRef;
|
|
fFrontWriteMask = writeMask;
|
|
fBackWriteMask = writeMask;
|
|
}
|
|
|
|
// canonical value for disabled stenciling
|
|
static const GrStencilSettings gDisabled;
|
|
void setDisabled() {
|
|
*this = gDisabled;
|
|
}
|
|
bool isDisabled() const {
|
|
return kKeep_StencilOp == fFrontPassOp &&
|
|
kKeep_StencilOp == fBackPassOp &&
|
|
kKeep_StencilOp == fFrontFailOp &&
|
|
kKeep_StencilOp == fBackFailOp &&
|
|
kAlways_StencilFunc == fFrontFunc &&
|
|
kAlways_StencilFunc == fBackFunc;
|
|
}
|
|
void invalidate() {
|
|
// just write an illegal value to the first member
|
|
fFrontPassOp = (GrStencilOp)-1;
|
|
}
|
|
|
|
private:
|
|
friend class GrGpu;
|
|
|
|
enum {
|
|
kMaxStencilClipPasses = 2 // maximum number of passes to add a clip
|
|
// element to the stencil buffer.
|
|
};
|
|
|
|
/**
|
|
* Given a thing to draw into the stencil clip, a fill type, and a set op
|
|
* this function determines:
|
|
* 1. Whether the thing can be draw directly to the stencil clip or
|
|
* needs to be drawn to the client portion of the stencil first.
|
|
* 2. How many passes are needed.
|
|
* 3. What those passes are.
|
|
* 4. The fill rule that should actually be used to render (will
|
|
* always be non-inverted).
|
|
*
|
|
* @param op the set op to combine this element with the
|
|
* existing clip
|
|
* @param stencilClipMask mask with just the stencil bit used for clipping
|
|
* enabled.
|
|
* @param invertedFill is this path inverted
|
|
* @param numPasses out: the number of passes needed to add the
|
|
* element to the clip.
|
|
* @param settings out: the stencil settings to use for each pass
|
|
*
|
|
* @return true if the clip element's geometry can be drawn directly to the
|
|
* stencil clip bit. Will only be true if canBeDirect is true.
|
|
* numPasses will be 1 if return value is true.
|
|
*/
|
|
static bool GetClipPasses(GrSetOp op,
|
|
bool canBeDirect,
|
|
unsigned int stencilClipMask,
|
|
bool invertedFill,
|
|
int* numPasses,
|
|
GrStencilSettings settings[kMaxStencilClipPasses]);
|
|
};
|
|
|
|
#endif
|