// override from SkRasterizer
virtual bool onRasterize(const SkPath& path, const SkMatrix& matrix,
const SkIRect* clipBounds,
- SkMask* mask, SkMask::CreateMode mode) const;
+ SkMask* mask, SkMask::CreateMode mode) const SK_OVERRIDE;
private:
const SkDeque* const fLayers;
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
// override from SkXfermode
- virtual SkPMColor xferColor(SkPMColor src, SkPMColor dst) const;
+ virtual SkPMColor xferColor(SkPMColor src, SkPMColor dst) const SK_OVERRIDE;
private:
SkColor fOpColor;
virtual ~GrPorterDuffXferProcessor();
- virtual const char* name() const { return "Porter Duff"; }
+ virtual const char* name() const SK_OVERRIDE { return "Porter Duff"; }
void getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const SK_OVERRIDE;
};
protected:
- virtual SkCanvas* canvasForDrawIter();
+ virtual SkCanvas* canvasForDrawIter() SK_OVERRIDE;
SkDeferredDevice* getDeferredDevice() const;
private:
this->initClassID<ColorMatrixEffect>();
}
- virtual bool onIsEqual(const GrFragmentProcessor& s) const {
+ virtual bool onIsEqual(const GrFragmentProcessor& s) const SK_OVERRIDE {
const ColorMatrixEffect& cme = s.cast<ColorMatrixEffect>();
return cme.fMatrix == fMatrix;
}
return fDirection;
};
SkPoint3 lightColor(const SkPoint3&) const { return color(); }
- virtual LightType type() const { return kDistant_LightType; }
+ virtual LightType type() const SK_OVERRIDE { return kDistant_LightType; }
const SkPoint3& direction() const { return fDirection; }
virtual GrGLLight* createGLLight() const SK_OVERRIDE {
#if SK_SUPPORT_GPU
SkDistantLight(const SkPoint3& direction, const SkPoint3& color)
: INHERITED(color), fDirection(direction) {
}
- virtual SkLight* transform(const SkMatrix& matrix) const {
+ virtual SkLight* transform(const SkMatrix& matrix) const SK_OVERRIDE {
return new SkDistantLight(direction(), color());
}
virtual void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE {
return direction;
};
SkPoint3 lightColor(const SkPoint3&) const { return color(); }
- virtual LightType type() const { return kPoint_LightType; }
+ virtual LightType type() const SK_OVERRIDE { return kPoint_LightType; }
const SkPoint3& location() const { return fLocation; }
virtual GrGLLight* createGLLight() const SK_OVERRIDE {
#if SK_SUPPORT_GPU
return INHERITED::isEqual(other) &&
fLocation == o.fLocation;
}
- virtual SkLight* transform(const SkMatrix& matrix) const {
+ virtual SkLight* transform(const SkMatrix& matrix) const SK_OVERRIDE {
SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY);
matrix.mapPoints(&location2, 1);
// Use X scale and Y scale on Z and average the result
fConeScale = SkScalarInvert(antiAliasThreshold);
}
- virtual SkLight* transform(const SkMatrix& matrix) const {
+ virtual SkLight* transform(const SkMatrix& matrix) const SK_OVERRIDE {
SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY);
matrix.mapPoints(&location2, 1);
// Use X scale and Y scale on Z and average the result
#endif
}
virtual bool requiresFragmentPosition() const SK_OVERRIDE { return true; }
- virtual LightType type() const { return kSpot_LightType; }
+ virtual LightType type() const SK_OVERRIDE { return kSpot_LightType; }
const SkPoint3& location() const { return fLocation; }
const SkPoint3& target() const { return fTarget; }
SkScalar specularExponent() const { return fSpecularExponent; }
virtual ~GrLinearGradient() { }
- virtual const char* name() const { return "Linear Gradient"; }
+ virtual const char* name() const SK_OVERRIDE { return "Linear Gradient"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
GrProcessorKeyBuilder* b) const SK_OVERRIDE {
virtual BitmapType asABitmap(SkBitmap* bitmap,
SkMatrix* matrix,
- TileMode* xy) const;
+ TileMode* xy) const SK_OVERRIDE;
virtual SkShader::GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
virtual bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix*, GrColor*,
GrFragmentProcessor**) const SK_OVERRIDE;
GrClipMaskManager fClipMaskManager;
private:
- GrClipMaskManager* clipMaskManager() { return &fClipMaskManager; }
+ GrClipMaskManager* clipMaskManager() SK_OVERRIDE { return &fClipMaskManager; }
virtual bool setupClip(const SkRect* devBounds,
GrDrawState::AutoRestoreEffects* are,
, fHasVertexCoverage(false)
, fHasLocalCoords(false) {}
- virtual const char* name() const = 0;
-
/**
* Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this geometry
* processor's GL backend implementation.
virtual void initBatchTracker(GrBatchTracker*, const InitBT&) const {}
GrColor color() const { return fColor; }
- uint8_t coverage() const { return fCoverage; }
+ uint8_t coverage() const SK_OVERRIDE { return fCoverage; }
// TODO this is a total hack until the gp can own whether or not it uses uniform
// color / coverage
~GrInOrderDrawBuffer() SK_OVERRIDE;
// tracking for draws
- DrawToken getCurrentDrawToken() { return DrawToken(this, fDrawID); }
+ DrawToken getCurrentDrawToken() SK_OVERRIDE { return DrawToken(this, fDrawID); }
void clearStencilClip(const SkIRect& rect,
bool insideClip,
// Records any trace markers for a command after adding it to the buffer.
void recordTraceMarkersIfNecessary();
- virtual bool isIssued(uint32_t drawID) { return drawID != fDrawID; }
+ virtual bool isIssued(uint32_t drawID) SK_OVERRIDE { return drawID != fDrawID; }
// TODO: Use a single allocator for commands and records
enum {
const SkPaint& paint,
SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE;
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
- int x, int y, const SkPaint& paint);
+ int x, int y, const SkPaint& paint) SK_OVERRIDE;
virtual void drawText(const SkDraw&, const void* text, size_t len,
SkScalar x, SkScalar y, const SkPaint&) SK_OVERRIDE;
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
- virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const {
+ virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
// If the texture was opaque we could know that the output color if we knew the sum of the
// kernel values.
inout->mulByUnknownFourComponents();
this->addTextureAccess(&fVAccess);
}
- virtual bool onIsEqual(const GrFragmentProcessor& sBase) const {
+ virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
const YUVtoRGBEffect& s = sBase.cast<YUVtoRGBEffect>();
return fColorSpace == s.getColorSpace();
}
GrGLuint basePathID() const { return fBasePathID; }
protected:
- virtual void onInitPath(int index, const SkPath&) const;
+ virtual void onInitPath(int index, const SkPath&) const SK_OVERRIDE;
virtual void onRelease() SK_OVERRIDE;
virtual void onAbandon() SK_OVERRIDE;
GrGLuint textureFBOID() const { return fTexFBOID; }
// override of GrRenderTarget
- virtual GrBackendObject getRenderTargetHandle() const { return this->renderFBOID(); }
- virtual GrBackendObject getRenderTargetResolvedHandle() const { return this->textureFBOID(); }
- virtual ResolveType getResolveType() const {
+ virtual GrBackendObject getRenderTargetHandle() const SK_OVERRIDE { return this->renderFBOID(); }
+ virtual GrBackendObject getRenderTargetResolvedHandle() const SK_OVERRIDE { return this->textureFBOID(); }
+ virtual ResolveType getResolveType() const SK_OVERRIDE {
if (!this->isMultisampled() ||
fRTFBOID == fTexFBOID) {
// catches FBO 0 and non MSAA case
public:
GrGLLegacyNvprProgramBuilder(GrGpuGL*, const GrOptDrawState&);
- virtual GrGLProgram* createProgram(GrGLuint programID);
+ virtual GrGLProgram* createProgram(GrGLuint programID) SK_OVERRIDE;
private:
int addTexCoordSets(int count);
typedef GrTAllocator<SeparableVaryingInfo> SeparableVaryingInfoArray;
- virtual GrGLProgram* createProgram(GrGLuint programID);
+ virtual GrGLProgram* createProgram(GrGLuint programID) SK_OVERRIDE;
private:
virtual void emitTransforms(const GrPendingFragmentStage&,
}
#endif
- virtual Format getFormat() const {
+ virtual Format getFormat() const SK_OVERRIDE {
return kJPEG_Format;
}
* to preserve semantics if blitAntiH doesn't get called in too many
* weird ways...
*/
- virtual int requestRowsPreserved() const { return BlockDim; }
+ virtual int requestRowsPreserved() const SK_OVERRIDE { return BlockDim; }
private:
static const int kPixelsPerBlock = BlockDim * BlockDim;