'<(skia_include_path)/gpu/GrKey.h',
'<(skia_include_path)/gpu/GrPaint.h',
'<(skia_include_path)/gpu/GrPathRendererChain.h',
- '<(skia_include_path)/gpu/GrPoint.h',
'<(skia_include_path)/gpu/GrRect.h',
'<(skia_include_path)/gpu/GrRenderTarget.h',
'<(skia_include_path)/gpu/GrSurface.h',
'gpu/GrRenderTarget.h',
'gpu/GrSurface.h',
'gpu/GrTypesPriv.h',
- 'gpu/GrPoint.h',
'config/sk_stdint.h',
'config/SkUserConfig.h',
'pipe/SkGPipe.h',
#include "SkMath.h"
#include "SkScalar.h"
+/** \struct SkIPoint16
+
+ SkIPoint holds two 16 bit integer coordinates
+*/
+struct SkIPoint16 {
+ int16_t fX, fY;
+
+ static SkIPoint16 Make(int x, int y) {
+ SkIPoint16 pt;
+ pt.set(x, y);
+ return pt;
+ }
+
+ int16_t x() const { return fX; }
+ int16_t y() const { return fY; }
+
+ void set(int x, int y) {
+ fX = SkToS16(x);
+ fY = SkToS16(y);
+ }
+};
+
/** \struct SkIPoint
SkIPoint holds two 32 bit integer coordinates
#include "GrColor.h"
#include "GrPaint.h"
#include "GrPathRendererChain.h"
-#include "GrPoint.h"
#include "GrRenderTarget.h"
#include "GrTexture.h"
#include "SkMatrix.h"
SkPath* fPath;
PackedID fPackedID;
GrIRect16 fBounds;
- GrIPoint16 fAtlasLocation;
+ SkIPoint16 fAtlasLocation;
void init(GrGlyph::PackedID packed, const SkIRect& bounds) {
fPlot = NULL;
+++ /dev/null
-
-/*
- * 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 GrPoint_DEFINED
-#define GrPoint_DEFINED
-
-#include "GrTypes.h"
-#include "SkScalar.h"
-#include "SkPoint.h"
-
-struct GrIPoint16 {
- int16_t fX, fY;
-
- static GrIPoint16 Make(intptr_t x, intptr_t y) {
- GrIPoint16 pt;
- pt.set(x, y);
- return pt;
- }
-
- int16_t x() const { return fX; }
- int16_t y() const { return fY; }
-
- void set(intptr_t x, intptr_t y) {
- fX = SkToS16(x);
- fY = SkToS16(y);
- }
-};
-
-#endif
GrNextPow2(random.nextRangeU(kMinRectSize, kMaxRectSize)),
GrNextPow2(random.nextRangeU(kMinRectSize, kMaxRectSize)));
*fRects[2].append() = SkISize::Make(128, 128);
- *fRectLocations.append() = GrIPoint16::Make(0, 0);
+ *fRectLocations.append() = SkIPoint16::Make(0, 0);
}
fCurRects = &fRects[0];
int fCurRandRect;
SkTDArray<SkISize> fRects[3];
SkTDArray<SkISize>* fCurRects;
- SkTDArray<GrIPoint16> fRectLocations;
+ SkTDArray<SkIPoint16> fRectLocations;
GrRectanizer* fRectanizers[2];
GrRectanizer* fCurRectanizer;
fBatchUploads = batchUploads;
}
-static inline void adjust_for_offset(GrIPoint16* loc, const GrIPoint16& offset) {
+static inline void adjust_for_offset(SkIPoint16* loc, const SkIPoint16& offset) {
loc->fX += offset.fX;
loc->fY += offset.fY;
}
bool GrPlot::addSubImage(int width, int height, const void* image,
- GrIPoint16* loc) {
+ SkIPoint16* loc) {
float percentFull = fRects->percentFull();
if (!fRects->addRect(width, height, loc)) {
return false;
GrPlot* GrAtlasMgr::addToAtlas(GrAtlas* atlas,
int width, int height, const void* image,
- GrIPoint16* loc) {
+ SkIPoint16* loc) {
// iterate through entire plot list for this atlas, see if we can find a hole
// last one was most recently added and probably most empty
for (int i = atlas->fPlots.count()-1; i >= 0; --i) {
#define GrAtlas_DEFINED
-#include "GrPoint.h"
+#include "SkPoint.h"
#include "GrTexture.h"
#include "GrDrawTarget.h"
GrTexture* texture() const { return fTexture; }
- bool addSubImage(int width, int height, const void*, GrIPoint16*);
+ bool addSubImage(int width, int height, const void*, SkIPoint16*);
GrDrawTarget::DrawToken drawToken() const { return fDrawToken; }
void setDrawToken(GrDrawTarget::DrawToken draw) { fDrawToken = draw; }
GrTexture* fTexture;
GrRectanizer* fRects;
GrAtlasMgr* fAtlasMgr;
- GrIPoint16 fOffset; // the offset of the plot in the backing texture
+ SkIPoint16 fOffset; // the offset of the plot in the backing texture
size_t fBytesPerPixel;
SkIRect fDirtyRect;
bool fDirty;
// add subimage of width, height dimensions to atlas
// returns the containing GrPlot and location relative to the backing texture
- GrPlot* addToAtlas(GrAtlas*, int width, int height, const void*, GrIPoint16*);
+ GrPlot* addToAtlas(GrAtlas*, int width, int height, const void*, SkIPoint16*);
// remove reference to this plot
bool removePlot(GrAtlas* atlas, const GrPlot* plot);
#include "GrColor.h"
#include "GrEffectStage.h"
#include "GrPaint.h"
-#include "GrPoint.h"
#include "GrRenderTarget.h"
#include "GrStencil.h"
#include "GrTemplates.h"
#include "GrGpu.h"
#include "GrIndexBuffer.h"
#include "GrPath.h"
-#include "GrPoint.h"
#include "GrRenderTarget.h"
#include "GrTemplates.h"
#include "GrTexture.h"
#include "GrPathUtils.h"
-#include "GrPoint.h"
+#include "GrTypes.h"
#include "SkGeometry.h"
SkScalar GrPathUtils::scaleToleranceToSrc(SkScalar devTol,
#ifndef GrPathUtils_DEFINED
#define GrPathUtils_DEFINED
-#include "GrPoint.h"
#include "SkRect.h"
#include "SkPath.h"
#include "SkTArray.h"
#define GrPlotMgr_DEFINED
#include "GrTypes.h"
-#include "GrPoint.h"
#include "SkTypes.h"
class GrPlotMgr : SkNoncopyable {
sk_bzero(fBusy, fDim.fX * fDim.fY);
}
- bool newPlot(GrIPoint16* loc) {
+ bool newPlot(SkIPoint16* loc) {
char* busy = fBusy;
for (int y = 0; y < fDim.fY; y++) {
for (int x = 0; x < fDim.fX; x++) {
};
char fStorage[STORAGE];
char* fBusy;
- GrIPoint16 fDim;
+ SkIPoint16 fDim;
};
#endif
#ifndef GrRectanizer_DEFINED
#define GrRectanizer_DEFINED
-#include "GrPoint.h"
+#include "GrTypes.h"
+
+struct SkIPoint16;
class GrRectanizer {
public:
// Attempt to add a rect. Return true on success; false on failure. If
// successful the position in the atlas is returned in 'loc'.
- virtual bool addRect(int width, int height, GrIPoint16* loc) = 0;
+ virtual bool addRect(int width, int height, SkIPoint16* loc) = 0;
virtual float percentFull() const = 0;
/**
#include "GrRectanizer_pow2.h"
-bool GrRectanizerPow2::addRect(int width, int height, GrIPoint16* loc) {
+bool GrRectanizerPow2::addRect(int width, int height, SkIPoint16* loc) {
if ((unsigned)width > (unsigned)this->width() ||
(unsigned)height > (unsigned)this->height()) {
return false;
#define GrRectanizer_pow2_DEFINED
#include "GrRectanizer.h"
+#include "SkPoint.h"
// This Rectanizer quantizes the incoming rects to powers of 2. Each power
// of two can have, at most, one active row/shelf. Once a row/shelf for
sk_bzero(fRows, sizeof(fRows));
}
- virtual bool addRect(int w, int h, GrIPoint16* loc) SK_OVERRIDE;
+ virtual bool addRect(int w, int h, SkIPoint16* loc) SK_OVERRIDE;
virtual float percentFull() const SK_OVERRIDE {
return fAreaSoFar / ((float)this->width() * this->height());
static const int kMaxExponent = 16;
struct Row {
- GrIPoint16 fLoc;
+ SkIPoint16 fLoc;
// fRowHeight is actually known by this struct's position in fRows
// but it is used to signal if there exists an open row of this height
int fRowHeight;
*/
#include "GrRectanizer_skyline.h"
+#include "SkPoint.h"
-bool GrRectanizerSkyline::addRect(int width, int height, GrIPoint16* loc) {
+bool GrRectanizerSkyline::addRect(int width, int height, SkIPoint16* loc) {
if ((unsigned)width > (unsigned)this->width() ||
(unsigned)height > (unsigned)this->height()) {
return false;
seg->fWidth = this->width();
}
- virtual bool addRect(int w, int h, GrIPoint16* loc) SK_OVERRIDE;
+ virtual bool addRect(int w, int h, SkIPoint16* loc) SK_OVERRIDE;
virtual float percentFull() const SK_OVERRIDE{
return fAreaSoFar / ((float)this->width() * this->height());
#ifndef GrTextContext_DEFINED
#define GrTextContext_DEFINED
-#include "GrPoint.h"
#include "GrGlyph.h"
#include "GrPaint.h"
#include "SkDeviceProperties.h"
#include "GrAllocPool.h"
#include "GrFontScaler.h"
#include "GrTHashTable.h"
-#include "GrPoint.h"
#include "GrGlyph.h"
#include "GrDrawTarget.h"
#include "GrAtlas.h"
REPORTER_ASSERT(reporter, kWidth == rectanizer->width());
REPORTER_ASSERT(reporter, kHeight == rectanizer->height());
- GrIPoint16 loc;
+ SkIPoint16 loc;
REPORTER_ASSERT(reporter, rectanizer->addRect(50, 50, &loc));
REPORTER_ASSERT(reporter, rectanizer->percentFull() > 0.0f);
const SkTDArray<SkISize>& rects) {
int i;
for (i = 0; i < rects.count(); ++i) {
- GrIPoint16 loc;
+ SkIPoint16 loc;
if (!rectanizer->addRect(rects[i].fWidth, rects[i].fHeight, &loc)) {
break;
}