38e0c32852
Also mostly consolidates texture creation Change-Id: Ifea01303afda531dcec99b8fe2a0f64cf2f24420
131 lines
4.5 KiB
C++
131 lines
4.5 KiB
C++
/*
|
|
* Copyright (C) 2013 The Android Open Source Project
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include "AssetAtlas.h"
|
|
#include "Caches.h"
|
|
#include "Image.h"
|
|
|
|
#include <GLES2/gl2ext.h>
|
|
|
|
namespace android {
|
|
namespace uirenderer {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Lifecycle
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void AssetAtlas::init(sp<GraphicBuffer> buffer, int64_t* map, int count) {
|
|
if (mImage) {
|
|
return;
|
|
}
|
|
|
|
ATRACE_NAME("AssetAtlas::init");
|
|
|
|
mImage = new Image(buffer);
|
|
if (mImage->getTexture()) {
|
|
if (!mTexture) {
|
|
Caches& caches = Caches::getInstance();
|
|
mTexture = new Texture(caches);
|
|
mTexture->wrap(mImage->getTexture(),
|
|
buffer->getWidth(), buffer->getHeight(), GL_RGBA);
|
|
createEntries(caches, map, count);
|
|
}
|
|
} else {
|
|
ALOGW("Could not create atlas image");
|
|
terminate();
|
|
}
|
|
}
|
|
|
|
void AssetAtlas::terminate() {
|
|
delete mImage;
|
|
mImage = nullptr;
|
|
delete mTexture;
|
|
mTexture = nullptr;
|
|
mEntries.clear();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Entries
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
AssetAtlas::Entry* AssetAtlas::getEntry(const SkPixelRef* pixelRef) const {
|
|
auto result = mEntries.find(pixelRef);
|
|
return result != mEntries.end() ? result->second.get() : nullptr;
|
|
}
|
|
|
|
Texture* AssetAtlas::getEntryTexture(const SkPixelRef* pixelRef) const {
|
|
auto result = mEntries.find(pixelRef);
|
|
return result != mEntries.end() ? result->second->texture : nullptr;
|
|
}
|
|
|
|
/**
|
|
* Delegates changes to wrapping and filtering to the base atlas texture
|
|
* instead of applying the changes to the virtual textures.
|
|
*/
|
|
struct DelegateTexture: public Texture {
|
|
DelegateTexture(Caches& caches, Texture* delegate)
|
|
: Texture(caches), mDelegate(delegate) { }
|
|
|
|
virtual void setWrapST(GLenum wrapS, GLenum wrapT, bool bindTexture = false,
|
|
bool force = false, GLenum renderTarget = GL_TEXTURE_2D) override {
|
|
mDelegate->setWrapST(wrapS, wrapT, bindTexture, force, renderTarget);
|
|
}
|
|
|
|
virtual void setFilterMinMag(GLenum min, GLenum mag, bool bindTexture = false,
|
|
bool force = false, GLenum renderTarget = GL_TEXTURE_2D) override {
|
|
mDelegate->setFilterMinMag(min, mag, bindTexture, force, renderTarget);
|
|
}
|
|
|
|
private:
|
|
Texture* const mDelegate;
|
|
}; // struct DelegateTexture
|
|
|
|
void AssetAtlas::createEntries(Caches& caches, int64_t* map, int count) {
|
|
const float width = float(mTexture->width());
|
|
const float height = float(mTexture->height());
|
|
|
|
for (int i = 0; i < count; ) {
|
|
SkPixelRef* pixelRef = reinterpret_cast<SkPixelRef*>(map[i++]);
|
|
// NOTE: We're converting from 64 bit signed values to 32 bit
|
|
// signed values. This is guaranteed to be safe because the "x"
|
|
// and "y" coordinate values are guaranteed to be representable
|
|
// with 32 bits. The array is 64 bits wide so that it can carry
|
|
// pointers on 64 bit architectures.
|
|
const int x = static_cast<int>(map[i++]);
|
|
const int y = static_cast<int>(map[i++]);
|
|
|
|
// Bitmaps should never be null, we're just extra paranoid
|
|
if (!pixelRef) continue;
|
|
|
|
const UvMapper mapper(
|
|
x / width, (x + pixelRef->info().width()) / width,
|
|
y / height, (y + pixelRef->info().height()) / height);
|
|
|
|
Texture* texture = new DelegateTexture(caches, mTexture);
|
|
texture->blend = !SkAlphaTypeIsOpaque(pixelRef->info().alphaType());
|
|
texture->wrap(mTexture->id(), pixelRef->info().width(),
|
|
pixelRef->info().height(), mTexture->format());
|
|
|
|
std::unique_ptr<Entry> entry(new Entry(pixelRef, texture, mapper, *this));
|
|
texture->uvMapper = &entry->uvMapper;
|
|
|
|
mEntries.emplace(entry->pixelRef, std::move(entry));
|
|
}
|
|
}
|
|
|
|
}; // namespace uirenderer
|
|
}; // namespace android
|