*/
public class Atlas {
/**
- * This flag indicates whether the packing algorithm will attempt
- * to rotate entries to make them fit better in the atlas.
+ * WARNING: These flag values are part of the on-disk configuration information,
+ * do not change their values.
*/
- public static final int FLAG_ALLOW_ROTATIONS = 0x1;
+
+ /** DELETED: FLAG_ROTATION = 0x01 */
+
/**
* This flag indicates whether the packing algorithm should leave
* an empty 1 pixel wide border around each bitmap. This border can
/**
* Represents a bitmap packed in the atlas. Each entry has a location in
- * pixels in the atlas and a rotation flag. If the entry was rotated, the
- * bitmap must be rotated by 90 degrees (in either direction as long as
- * the origin remains the same) before being rendered into the atlas.
+ * pixels in the atlas and a rotation flag.
*/
public static class Entry {
/**
* Location, in pixels, of the bitmap on the Y axis in the atlas.
*/
public int y;
-
- /**
- * If true, the bitmap must be rotated 90 degrees in the atlas.
- */
- public boolean rotated;
}
private final Policy mPolicy;
private final SplitDecision mSplitDecision;
- private final boolean mAllowRotation;
private final int mPadding;
/**
}
SlicePolicy(int width, int height, int flags, SplitDecision splitDecision) {
- mAllowRotation = (flags & FLAG_ALLOW_ROTATIONS) != 0;
mPadding = (flags & FLAG_ADD_PADDING) != 0 ? 1 : 0;
// The entire atlas is empty at first, minus padding
*
* @return True if the rectangle was packed in the atlas, false otherwise
*/
- @SuppressWarnings("SuspiciousNameCombination")
private boolean insert(Cell cell, Cell prev, int width, int height, Entry entry) {
- boolean rotated = false;
-
- // If the rectangle doesn't fit we'll try to rotate it
- // if possible before giving up
if (cell.width < width || cell.height < height) {
- if (mAllowRotation) {
- if (cell.width < height || cell.height < width) {
- return false;
- }
-
- // Rotate the rectangle
- int temp = width;
- width = height;
- height = temp;
- rotated = true;
- } else {
- return false;
- }
+ return false;
}
// Remaining free space after packing the rectangle
// Return the location and rotation of the packed rectangle
entry.x = cell.x;
entry.y = cell.y;
- entry.rotated = rotated;
return true;
}
Texture* const mDelegate;
}; // struct DelegateTexture
-/**
- * TODO: This method does not take the rotation flag into account
- */
void AssetAtlas::createEntries(Caches& caches, int64_t* map, int count) {
const float width = float(mTexture->width);
const float height = float(mTexture->height);
// pointers on 64 bit architectures.
const int x = static_cast<int>(map[i++]);
const int y = static_cast<int>(map[i++]);
- bool rotated = map[i++] > 0;
// Bitmaps should never be null, we're just extra paranoid
if (!pixelRef) continue;
texture->width = pixelRef->info().width();
texture->height = pixelRef->info().height();
- Entry* entry = new Entry(pixelRef, x, y, rotated, texture, mapper, *this);
+ Entry* entry = new Entry(pixelRef, texture, mapper, *this);
texture->uvMapper = &entry->uvMapper;
mEntries.add(entry->pixelRef, entry);
class AssetAtlas {
public:
/**
- * Entry representing the position and rotation of a
- * bitmap inside the atlas.
+ * Entry representing the texture and uvMapper of a PixelRef in the
+ * atlas
*/
class Entry {
public:
SkPixelRef* pixelRef;
/**
- * Location of the bitmap inside the atlas, in pixels.
- */
- int x;
- int y;
-
- /**
- * If set, the bitmap is rotated 90 degrees (clockwise)
- * inside the atlas.
- */
- bool rotated;
-
- /**
* Atlas this entry belongs to.
*/
const AssetAtlas& atlas;
- Entry(SkPixelRef* pixelRef, int x, int y, bool rotated,
- Texture* texture, const UvMapper& mapper, const AssetAtlas& atlas)
+ Entry(SkPixelRef* pixelRef, Texture* texture, const UvMapper& mapper,
+ const AssetAtlas& atlas)
: texture(texture)
, uvMapper(mapper)
, pixelRef(pixelRef)
- , x(x)
- , y(y)
- , rotated(rotated)
, atlas(atlas) {
}
* Initializes the atlas with the specified buffer and
* map. The buffer is a gralloc'd texture that will be
* used as an EGLImage. The map is a list of SkBitmap*
- * and their (x, y) positions as well as their rotation
- * flags.
+ * and their (x, y) positions
*
* This method returns immediately if the atlas is already
* initialized. To re-initialize the atlas, you must
// long0: SkBitmap*, the native bitmap object
// long1: x position
// long2: y position
- // long3: rotated, 1 if the bitmap must be rotated, 0 otherwise
private long[] mAtlasMap;
/**
/**
* Renders a list of bitmaps into the atlas. The position of each bitmap
* was decided by the packing algorithm and will be honored by this
- * method. If need be this method will also rotate bitmaps.
+ * method.
*
* @param buffer The buffer to render the atlas entries into
* @param atlas The atlas to pack the bitmaps into
canvas.save();
canvas.translate(entry.x, entry.y);
- if (entry.rotated) {
- canvas.translate(bitmap.getHeight(), 0.0f);
- canvas.rotate(90.0f);
- }
canvas.drawBitmap(bitmap, 0.0f, 0.0f, null);
canvas.restore();
atlasMap[mapIndex++] = bitmap.refSkPixelRef();
atlasMap[mapIndex++] = entry.x;
atlasMap[mapIndex++] = entry.y;
- atlasMap[mapIndex++] = entry.rotated ? 1 : 0;
}
}
OSDN Git Service
