1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
/*
* Copyright 2010 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkGr_DEFINED
#define SkGr_DEFINED
#include <stddef.h>
// Gr headers
#include "GrTypes.h"
#include "GrContext.h"
#include "GrFontScaler.h"
#include "GrClipIterator.h"
#include "GrPath.h"
// skia headers
#include "SkBitmap.h"
#include "SkPath.h"
#include "SkPoint.h"
#include "SkRegion.h"
#include "SkShader.h"
#include "SkClipStack.h"
#if (GR_DEBUG && defined(SK_RELEASE)) || (GR_RELEASE && defined(SK_DEBUG))
// #error "inconsistent GR_DEBUG and SK_DEBUG"
#endif
////////////////////////////////////////////////////////////////////////////////
// Sk to Gr Type conversions
GR_STATIC_ASSERT((int)GrSamplerState::kClamp_WrapMode == (int)SkShader::kClamp_TileMode);
GR_STATIC_ASSERT((int)GrSamplerState::kRepeat_WrapMode ==(
int)SkShader::kRepeat_TileMode);
GR_STATIC_ASSERT((int)GrSamplerState::kMirror_WrapMode ==
(int)SkShader::kMirror_TileMode);
#define sk_tile_mode_to_grwrap(X) ((GrSamplerState::WrapMode)(X))
GR_STATIC_ASSERT((int)kZero_BlendCoeff == (int)SkXfermode::kZero_Coeff);
GR_STATIC_ASSERT((int)kOne_BlendCoeff == (int)SkXfermode::kOne_Coeff);
GR_STATIC_ASSERT((int)kSC_BlendCoeff == (int)SkXfermode::kSC_Coeff);
GR_STATIC_ASSERT((int)kISC_BlendCoeff == (int)SkXfermode::kISC_Coeff);
GR_STATIC_ASSERT((int)kDC_BlendCoeff == (int)SkXfermode::kDC_Coeff);
GR_STATIC_ASSERT((int)kIDC_BlendCoeff == (int)SkXfermode::kIDC_Coeff);
GR_STATIC_ASSERT((int)kSA_BlendCoeff == (int)SkXfermode::kSA_Coeff);
GR_STATIC_ASSERT((int)kISA_BlendCoeff == (int)SkXfermode::kISA_Coeff);
GR_STATIC_ASSERT((int)kDA_BlendCoeff == (int)SkXfermode::kDA_Coeff);
GR_STATIC_ASSERT((int)kIDA_BlendCoeff == (int)SkXfermode::kIDA_Coeff);
#define sk_blend_to_grblend(X) ((GrBlendCoeff)(X))
GR_STATIC_ASSERT((int)SkPath::kMove_Verb == (int)kMove_PathCmd);
GR_STATIC_ASSERT((int)SkPath::kLine_Verb == (int)kLine_PathCmd);
GR_STATIC_ASSERT((int)SkPath::kQuad_Verb == (int)kQuadratic_PathCmd);
GR_STATIC_ASSERT((int)SkPath::kCubic_Verb == (int)kCubic_PathCmd);
GR_STATIC_ASSERT((int)SkPath::kClose_Verb == (int)kClose_PathCmd);
GR_STATIC_ASSERT((int)SkPath::kDone_Verb == (int)kEnd_PathCmd);
#define sk_path_verb_to_gr_path_command(X) ((GrPathCmd)(X))
///////////////////////////////////////////////////////////////////////////////
#include "SkColorPriv.h"
class SkGr {
public:
/**
* Convert the SkBitmap::Config to the corresponding PixelConfig, or
* kUnknown_PixelConfig if the conversion cannot be done.
*/
static GrPixelConfig BitmapConfig2PixelConfig(SkBitmap::Config,
bool isOpaque);
static GrPixelConfig Bitmap2PixelConfig(const SkBitmap& bm) {
return BitmapConfig2PixelConfig(bm.config(), bm.isOpaque());
}
static GrColor SkColor2GrColor(SkColor c) {
SkPMColor pm = SkPreMultiplyColor(c);
unsigned r = SkGetPackedR32(pm);
unsigned g = SkGetPackedG32(pm);
unsigned b = SkGetPackedB32(pm);
unsigned a = SkGetPackedA32(pm);
return GrColorPackRGBA(r, g, b, a);
}
};
////////////////////////////////////////////////////////////////////////////////
// Classes
class SkGrClipIterator : public GrClipIterator {
public:
SkGrClipIterator() { fClipStack = NULL; fCurr = NULL; }
SkGrClipIterator(const SkClipStack& clipStack) { this->reset(clipStack); }
void reset(const SkClipStack& clipStack);
// overrides
virtual bool isDone() const { return NULL == fCurr; }
virtual void next() { fCurr = fIter.next(); }
virtual void rewind() { this->reset(*fClipStack); }
virtual GrClipType getType() const;
virtual GrSetOp getOp() const;
virtual void getRect(GrRect* rect) const {
if (!fCurr->fRect) {
rect->setEmpty();
} else {
*rect = *fCurr->fRect;
}
}
virtual const GrPath* getPath() {
return fCurr->fPath;
}
virtual GrPathFill getPathFill() const;
private:
const SkClipStack* fClipStack;
SkClipStack::B2FIter fIter;
// SkClipStack's auto advances on each get
// so we store the current pos here.
const SkClipStack::B2FIter::Clip* fCurr;
};
class SkGrRegionIterator : public GrClipIterator {
public:
SkGrRegionIterator() {}
SkGrRegionIterator(const SkRegion& region) { this->reset(region); }
void reset(const SkRegion& region) {
fRegion = ®ion;
fIter.reset(region);
}
// overrides
virtual bool isDone() const { return fIter.done(); }
virtual void next() { fIter.next(); }
virtual void rewind() { this->reset(*fRegion); }
virtual GrClipType getType() const { return kRect_ClipType; }
virtual GrSetOp getOp() const { return kUnion_SetOp; }
virtual void getRect(GrRect* rect) const {
const SkIRect& r = fIter.rect();
rect->fLeft = GrIntToScalar(r.fLeft);
rect->fTop = GrIntToScalar(r.fTop);
rect->fRight = GrIntToScalar(r.fRight);
rect->fBottom = GrIntToScalar(r.fBottom);
}
virtual const GrPath* getPath() {
SkASSERT(0);
return NULL;
}
virtual GrPathFill getPathFill() const {
SkASSERT(0);
return kWinding_PathFill;
}
private:
const SkRegion* fRegion;
SkRegion::Iterator fIter;
};
class SkGlyphCache;
class SkGrFontScaler : public GrFontScaler {
public:
explicit SkGrFontScaler(SkGlyphCache* strike);
virtual ~SkGrFontScaler();
// overrides
virtual const GrKey* getKey();
virtual GrMaskFormat getMaskFormat();
virtual bool getPackedGlyphBounds(GrGlyph::PackedID, GrIRect* bounds);
virtual bool getPackedGlyphImage(GrGlyph::PackedID, int width, int height,
int rowBytes, void* image);
virtual bool getGlyphPath(uint16_t glyphID, GrPath*);
private:
SkGlyphCache* fStrike;
GrKey* fKey;
// DECLARE_INSTANCE_COUNTER(SkGrFontScaler);
};
////////////////////////////////////////////////////////////////////////////////
// Helper functions
static const GrContext::TextureKey gUNCACHED_KEY = ~0;
GrContext::TextureCacheEntry sk_gr_create_bitmap_texture(GrContext* ctx,
GrContext::TextureKey key,
const GrSamplerState* sampler,
const SkBitmap& bitmap);
#endif
|
