TextureReader.cpp

Go to the documentation of this file.

#include <tdme/engine/fileio/textures/TextureReader.h>
 
#include <stdlib.h>
 
#include <string>
#include <vector>
 
#include <tdme/tdme.h>
#include <tdme/utilities/ByteBuffer.h>
 
#include <tdme/engine/fileio/textures/Texture.h>
#include <tdme/math/Matrix2D3x3.h>
#include <tdme/math/Vector2.h>
#include <tdme/os/filesystem/FileSystem.h>
#include <tdme/os/filesystem/FileSystemInterface.h>
#include <tdme/os/threading/Mutex.h>
#include <tdme/utilities/Console.h>
#include <tdme/utilities/Exception.h>
#include <tdme/utilities/StringTools.h>
 
#include <ext/libpng/png.h>
 
using std::string;
using std::to_string;
using std::vector;
 
using tdme::utilities::ByteBuffer;
using tdme::utilities::Console;
using tdme::utilities::Exception;
 
using tdme::engine::fileio::textures::Texture;
using tdme::engine::fileio::textures::TextureReader;
using tdme::math::Matrix2D3x3;
using tdme::math::Vector2;
using tdme::os::filesystem::FileSystem;
using tdme::os::filesystem::FileSystemInterface;
using tdme::os::threading::Mutex;
using tdme::utilities::StringTools;
 
vector<string> TextureReader::extensions = {"png"};
Mutex* TextureReader::textureCacheMutex = new Mutex("texturecache-mutex");
map<string, Texture*>* TextureReader::textureCache = new map<string, Texture*>();
 
const vector<string>& TextureReader::getTextureExtensions() {
    return extensions;
}
 
Texture* TextureReader::read(const string& pathName, const string& fileName, bool useCache, bool powerOfTwo, const string& idPrefix)
{
    Texture* texture = nullptr;
 
    // make canonical
    auto canonicalFilePath = FileSystem::getInstance()->getCanonicalPath(pathName, fileName);
    auto canonicalPathName = FileSystem::getInstance()->getPathName(canonicalFilePath);
    auto canonicalFileName = FileSystem::getInstance()->getFileName(canonicalFilePath);
 
    // do cache look up
    if (useCache == true) {
        textureCacheMutex->lock();
        auto textureCacheIt = textureCache->find(idPrefix + canonicalPathName + "/" + canonicalFileName);
        if (textureCacheIt != textureCache->end()) {
            texture = textureCacheIt->second;
        }
    }
 
    // have texture?
    if (texture == nullptr) {
        // nope try to load
        try {
            if (StringTools::endsWith(StringTools::toLowerCase(canonicalFileName), ".png") == true) {
 
                // create PNG input stream
                vector<uint8_t> data;
                FileSystem::getInstance()->getContent(pathName, fileName, data);
 
                texture = TextureReader::readPNG(canonicalFilePath, data, powerOfTwo, idPrefix);
                if (texture != nullptr && useCache == true) {
                    (*textureCache)[texture->getId()] = texture;
                }
            }
        } catch (Exception& exception) {
            Console::println("TextureReader::loadTexture(): Could not load texture: " + canonicalPathName + "/" + canonicalFileName + ": " + (exception.what()));
        }
    }
 
    // done
    if (texture != nullptr) texture->acquireReference();
 
    //
    if (useCache == true) textureCacheMutex->unlock();
 
    // done
    return texture;
}
 
Texture* TextureReader::read2(const string& texturePathName, const string& textureFileName, const string& transparencyTexturePathName, const string& transparencyTextureFileName, bool useCache, bool powerOfTwo, const string& idPrefix) {
    // make canonical
    auto canonicalFile = FileSystem::getInstance()->getCanonicalPath(texturePathName, textureFileName);
    auto canonicalPathName = FileSystem::getInstance()->getPathName(canonicalFile);
    auto canonicalFileName = FileSystem::getInstance()->getFileName(canonicalFile);
    auto cacheId = idPrefix + canonicalPathName + "/" + canonicalFileName + "/transparency";
 
    // do cache look up
    if (useCache == true) {
        textureCacheMutex->lock();
        auto textureCacheIt = textureCache->find(cacheId);
        if (textureCacheIt != textureCache->end()) {
            auto texture = textureCacheIt->second;
            texture->acquireReference();
            textureCacheMutex->unlock();
            return texture;
        }
    }
 
    // load diffuse texture
    auto texture = TextureReader::read(texturePathName, textureFileName, false, powerOfTwo, idPrefix);
    if (texture == nullptr) {
        if (useCache == true) textureCacheMutex->unlock();
        return nullptr;
    }
    // additional transparency texture
    auto transparencyTexture = TextureReader::read(transparencyTexturePathName, transparencyTextureFileName, false, powerOfTwo, idPrefix);
    // do we have one?
    if (transparencyTexture == nullptr) {
        Console::println("TextureReader::read(): transparency texture: failed: " + texturePathName + "/" + textureFileName + ";" + transparencyTexturePathName + "/" + transparencyTextureFileName);
        if (useCache == true) {
            (*textureCache)[cacheId] = texture;
            textureCacheMutex->unlock();
        }
        return texture;
    }
    // same dimensions and supported pixel depth?
    if (texture->getTextureWidth() != transparencyTexture->getTextureWidth() || texture->getTextureHeight() != transparencyTexture->getTextureHeight()) {
        Console::println("TextureReader::read(): texture does not match transparency texture dimension: " + texturePathName + "/" + textureFileName + ";" + transparencyTexturePathName + "/" + transparencyTextureFileName);
        if (useCache == true) {
            (*textureCache)[cacheId] = texture;
            textureCacheMutex->unlock();
        }
        return texture;
    }
    // yep, combine diffuse map + diffuse transparency map
    auto textureWidth = texture->getTextureWidth();
    auto textureHeight = texture->getTextureHeight();
    ByteBuffer* textureByteBuffer = new ByteBuffer(textureWidth * textureHeight * 4);
    auto textureWithTransparency = new Texture(
        idPrefix + texture->getId() + "/transparency",
        32,
        texture->getWidth(),
        texture->getHeight(),
        texture->getTextureWidth(),
        texture->getTextureHeight(),
        textureByteBuffer
    );
    auto diffuseTextureBytesPerPixel = texture->getDepth() / 8;
    auto transparencyTextureBytesPerPixel = transparencyTexture->getDepth() / 8;
    for (auto y = 0; y < textureHeight; y++) {
        for (auto x = 0; x < textureWidth; x++) {
            auto transparencyTextureRed = transparencyTexture->getTextureData()->get((y * textureWidth * transparencyTextureBytesPerPixel) + (x * transparencyTextureBytesPerPixel) + 0);
            auto transparencyTextureGreen = transparencyTexture->getTextureData()->get((y * textureWidth * transparencyTextureBytesPerPixel) + (x * transparencyTextureBytesPerPixel) + 1);
            auto transparencyTextureBlue = transparencyTexture->getTextureData()->get((y * textureWidth * transparencyTextureBytesPerPixel) + (x * transparencyTextureBytesPerPixel) + 2);
            textureByteBuffer->put(texture->getTextureData()->get((y * textureWidth * diffuseTextureBytesPerPixel) + (x * diffuseTextureBytesPerPixel) + 0));
            textureByteBuffer->put(texture->getTextureData()->get((y * textureWidth * diffuseTextureBytesPerPixel) + (x * diffuseTextureBytesPerPixel) + 1));
            textureByteBuffer->put(texture->getTextureData()->get((y * textureWidth * diffuseTextureBytesPerPixel) + (x * diffuseTextureBytesPerPixel) + 2));
            textureByteBuffer->put((uint8_t)((transparencyTextureRed + transparencyTextureGreen + transparencyTextureBlue) * 0.3333f));
        }
    }
    textureWithTransparency->acquireReference();
    if (useCache == true) {
        (*textureCache)[cacheId] = textureWithTransparency;
        textureCacheMutex->unlock();
    }
    texture->releaseReference();
    transparencyTexture->releaseReference();
    return textureWithTransparency;
}
 
void TextureReader::readPNGDataFromMemory(png_structp png_ptr, png_bytep outBytes, png_size_t outBytesToRead) {
    png_voidp io_ptr = png_get_io_ptr(png_ptr);
    if (io_ptr == nullptr) return;
 
    PNGInputStream* pngInputStream = static_cast<PNGInputStream*>(io_ptr);
    pngInputStream->readBytes((int8_t*)outBytes, outBytesToRead);
}
 
Texture* TextureReader::readPNG(const string& textureId, const vector<uint8_t>& data, bool powerOfTwo, const string& idPrefix) {
    // see: http://devcry.heiho.net/html/2015/20150517-libpng.html
 
    // create PNG input stream
    PNGInputStream pngInputStream(&data);
 
    // check that the PNG signature is in the file header
    unsigned char sig[8];
    pngInputStream.readBytes((int8_t*)sig, sizeof(sig));
    if (png_sig_cmp(sig, 0, 8)) {
        return nullptr;
    }
 
    // create two data structures: 'png_struct' and 'png_info'
    png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
    if (png == nullptr) {
        return nullptr;
    }
    png_infop info = png_create_info_struct(png);
    if (info == nullptr) {
        png_destroy_read_struct(&png, nullptr, nullptr);
        return nullptr;
    }
 
    // set up custom read function
    png_set_read_fn(png, &pngInputStream, TextureReader::readPNGDataFromMemory);
 
    // set libpng error handling mechanism
    if (setjmp(png_jmpbuf(png))) {
        png_destroy_read_struct(&png, &info, nullptr);
        return nullptr;
    }
 
    // tell libpng we already read the signature
    png_set_sig_bytes(png, sizeof(sig));
 
    // get image information
    png_read_info(png, info);
 
    // dimensions
    auto width = png_get_image_width(png, info);
    auto height = png_get_image_height(png, info);
 
    // set one byte per channel
    if (png_get_bit_depth(png, info) < 8) png_set_packing(png);
    if (png_get_bit_depth(png, info) == 16) png_set_strip_16(png);
 
    // determine bytes per pixel
    auto bytesPerPixel = -1;
    switch(png_get_color_type(png, info)) {
        case PNG_COLOR_TYPE_GRAY:
            {
                bytesPerPixel = 3;
                png_set_gray_to_rgb(png);
                break;
            }
        case PNG_COLOR_TYPE_GRAY_ALPHA:
            {
                bytesPerPixel = 4;
                png_set_gray_to_rgb(png);
                break;
            }
        case PNG_COLOR_TYPE_PALETTE:
            {
                // if transparency, convert it to alpha
                // does not seem to work though
                bool alpha = false;
                if (png_get_valid(png, info, PNG_INFO_tRNS)) {
                    alpha = true;
                    png_set_tRNS_to_alpha(png);
                }
                bytesPerPixel = alpha?4:3;
                png_set_expand(png);
                break;
            }
        case PNG_COLOR_TYPE_RGB:
            {
                bytesPerPixel = 3;
                break;
            }
        case PNG_COLOR_TYPE_RGBA:
            {
                bytesPerPixel = 4;
                break;
            }
        default:
            {
                png_destroy_read_struct(&png, &info, nullptr);
                return nullptr;
            }
    }
 
    // ... what ever :DDD
    png_set_interlace_handling(png);
    png_read_update_info(png, info);
 
    // allocate pixel buffer
    ByteBuffer* pixelByteBuffer = ByteBuffer::allocate(width * height * bytesPerPixel);
 
    // setup array with row pointers into pixel buffer
    png_bytep* rows = new png_bytep[height];
    uint8_t* p = (uint8_t*)pixelByteBuffer->getBuffer();
    for(auto i = 0; i < height; i++) {
        rows[i] = p;
        p += width * bytesPerPixel;
    }
 
    // read all rows (data goes into 'pixels' buffer)
    // Note that any decoding errors will jump to the
    // setjmp point and eventually return nullptr
    png_read_image(png, rows);
    png_read_end(png, nullptr);
 
    //
    delete [] rows;
 
    // done
    png_destroy_read_struct(&png, &info, nullptr);
 
    // make width, height a power of 2
    auto textureWidth = width;
    auto textureHeight = height;
    if (powerOfTwo == true) {
        textureWidth = 1;
        while (textureWidth < width) textureWidth*= 2;
        textureHeight = 1;
        while (textureHeight < height) textureHeight*= 2;
        if (textureWidth != width || textureHeight != height) {
            Console::println("TextureReader::loadPNG(): " + idPrefix + textureId + ": scaling to fit power of 2: " + to_string(width) + "x" + to_string(height) + " --> " + to_string(textureWidth) + "x" + to_string(textureHeight));
            ByteBuffer* pixelByteBufferScaled = ByteBuffer::allocate(textureWidth * textureHeight * bytesPerPixel);
            auto textureYIncrement = (float)textureHeight / (float)height;
            auto textureYPixelRest = 0.0f;
            auto textureY = 0;
            for (auto y = 0; y < height; y++) {
                for (auto i = 0; i < (int)textureYIncrement + (int)textureYPixelRest; i++) {
                    scaleTextureLine(pixelByteBuffer, pixelByteBufferScaled, width, textureWidth, bytesPerPixel, y);
                    textureY++;
                }
                textureYPixelRest-= (int)textureYPixelRest;
                textureYPixelRest+= textureYIncrement - (int)textureYIncrement;
 
            }
            while (textureY < textureHeight) {
                scaleTextureLine(pixelByteBuffer, pixelByteBufferScaled, width, textureWidth, bytesPerPixel, height - 1);
                textureY++;
            }
            delete pixelByteBuffer;
            pixelByteBuffer = pixelByteBufferScaled;
        }
    }
 
    // thats it
    auto texture = new Texture(
        idPrefix + textureId,
        bytesPerPixel * 8,
        width,
        height,
        textureWidth,
        textureHeight,
        pixelByteBuffer
    );
    texture->acquireReference();
    return texture;
}
 
void TextureReader::scaleTextureLine(ByteBuffer* pixelByteBuffer, ByteBuffer* pixelByteBufferScaled, int width, int textureWidth, int bytesPerPixel, int y) {
    auto textureXIncrement = (float)textureWidth / (float)width;
    auto textureXPixelRest = 0.0f;
    auto textureX = 0;
    for (auto x = 0; x < width; x++) {
        for (auto i = 0; i < (int)textureXIncrement + (int)textureXPixelRest; i++) {
            for (auto bytePerPixel = 0; bytePerPixel < bytesPerPixel; bytePerPixel++) {
                pixelByteBufferScaled->put(pixelByteBuffer->get((y * width * bytesPerPixel) + (x * bytesPerPixel) + bytePerPixel));
            }
            textureX++;
        }
        textureXPixelRest-= (int)textureXPixelRest;
        textureXPixelRest+= textureXIncrement - (int)textureXIncrement;
    }
    {
        auto x = width - 1;
        while (textureX < textureWidth) {
            for (auto bytePerPixel = 0; bytePerPixel < bytesPerPixel; bytePerPixel++) {
                pixelByteBufferScaled->put(pixelByteBuffer->get((y * width * bytesPerPixel) + (x * bytesPerPixel) + bytePerPixel));
            }
            textureX++;
        }
    }
}
 
void TextureReader::removeFromCache(Texture* texture) {
    textureCacheMutex->lock();
    auto textureCacheIt = textureCache->find(texture->getId());
    if (textureCacheIt != textureCache->end()) textureCache->erase(textureCacheIt);
    textureCacheMutex->unlock();
}
 
Texture* TextureReader::rotate(Texture* texture, float rotation) {
    auto textureWidth = texture->getTextureWidth();
    auto textureHeight = texture->getTextureHeight();
    auto textureBytesPerPixel = texture->getDepth() / 8;
    auto textureWidthRotated = -1;
    auto textureHeightRotated = -1;
    {
        auto rotationsMatrix = Matrix2D3x3::rotateAroundPoint(Vector2(textureWidth / 2.0f, textureHeight / 2.0f), rotation);
        Vector2 leftTop(0.0f, 0.0f);
        Vector2 rightTop(textureWidth, 0.0f);
        Vector2 leftBottom(0.0f, textureHeight);
        Vector2 rightBottom(textureWidth, textureHeight);
        auto leftTopRotated = rotationsMatrix.multiply(leftTop);
        auto rightTopRotated = rotationsMatrix.multiply(rightTop);
        auto leftBottomRotated = rotationsMatrix.multiply(leftBottom);
        auto rightBottomRotated = rotationsMatrix.multiply(rightBottom);
        auto textureWidthTransformedMin = Math::min(leftTopRotated.getX(),
                Math::min(rightTopRotated.getX(),
                        Math::min(leftBottomRotated.getX(),
                                rightBottomRotated.getX())));
        auto textureWidthTransformedMax = Math::max(leftTopRotated.getX(),
                Math::max(rightTopRotated.getX(),
                        Math::max(leftBottomRotated.getX(),
                                rightBottomRotated.getX())));
        auto textureHeightTransformedMin = Math::min(leftTopRotated.getY(),
                Math::min(rightTopRotated.getY(),
                        Math::min(leftBottomRotated.getY(),
                                rightBottomRotated.getY())));
        auto textureHeightTransformedMax = Math::max(leftTopRotated.getY(),
                Math::max(rightTopRotated.getY(),
                        Math::max(leftBottomRotated.getY(),
                                rightBottomRotated.getY())));
        textureWidthRotated = static_cast<int>(textureWidthTransformedMax
                - textureWidthTransformedMin);
        textureHeightRotated = static_cast<int>(textureHeightTransformedMax
                - textureHeightTransformedMin);
    }
    auto rotatedTextureByteBuffer = new ByteBuffer(textureWidthRotated * textureHeightRotated * 4);
    auto rotatedTexture = new Texture(
        texture->getId() + ":r=" + to_string(rotation),
        32,
        textureWidthRotated,
        textureHeightRotated,
        textureWidthRotated,
        textureHeightRotated,
        rotatedTextureByteBuffer
    );
    rotatedTexture->acquireReference();
    auto rotationsMatrix = Matrix2D3x3::rotateAroundPoint(Vector2(textureWidth / 2.0f, textureHeight / 2.0f), rotation);
    for (auto y = 0; y < textureHeightRotated; y++) {
        for (auto x = 0; x < textureWidthRotated; x++) {
            auto originalTexturePoint = rotationsMatrix.multiply(
                Vector2(
                    x - (textureWidthRotated - textureWidth) / 2.0f,
                    y - (textureHeightRotated - textureHeight) / 2.0f
                )
            );
            auto red = 0;
            auto green = 0;
            auto blue = 0;
            auto alpha = 0;
            auto originalX = static_cast<int>(originalTexturePoint.getX());
            auto originalY = static_cast<int>(originalTexturePoint.getY());
            if (originalX >= 0 && originalX < textureWidth && originalY >= 0 && originalY < textureHeight) {
                red = texture->getTextureData()->get((originalY * textureWidth * textureBytesPerPixel) + (originalX * textureBytesPerPixel) + 0);
                green = texture->getTextureData()->get((originalY * textureWidth * textureBytesPerPixel) + (originalX * textureBytesPerPixel) + 1);
                blue = texture->getTextureData()->get((originalY * textureWidth * textureBytesPerPixel) + (originalX * textureBytesPerPixel) + 2);
                alpha = textureBytesPerPixel == 4?texture->getTextureData()->get((originalY * textureWidth * textureBytesPerPixel) + (originalX * textureBytesPerPixel) + 3):-1;
            }
            rotatedTextureByteBuffer->put(red);
            rotatedTextureByteBuffer->put(green);
            rotatedTextureByteBuffer->put(blue);
            rotatedTextureByteBuffer->put(alpha);
        }
    }
    // TODO: should be improved
    auto filteredTextureByteBuffer = new ByteBuffer(textureWidthRotated * textureHeightRotated * 4);
    auto filteredTexture = new Texture(
        texture->getId() + ":r=" + to_string(rotation) + ":bf",
        32,
        textureWidthRotated,
        textureHeightRotated,
        textureWidthRotated,
        textureHeightRotated,
        filteredTextureByteBuffer
    );
    filteredTexture->acquireReference();
    for (auto y = 0; y < textureHeightRotated; y++) {
        for (auto x = 0; x < textureWidthRotated; x++) {
            auto samples = 0;
            auto red = 0;
            auto green = 0;
            auto blue = 0;
            auto alpha = 0;
            for (auto _y = -1; _y <= 1; _y++)
            for (auto _x = -1; _x <= 1; _x++)
            if ((Math::abs(_x) == 1 && Math::abs(_y) == 1) == false &&
                (x + _x >= 0 && x + _x < textureWidthRotated && y + _y >= 0 && y + _y < textureHeightRotated)) {
                auto pixelOffset = (y + _y) * textureWidthRotated * 4 + (x + _x) * 4;
                red+= rotatedTexture->getTextureData()->get(pixelOffset + 0);
                green+= rotatedTexture->getTextureData()->get(pixelOffset + 1);
                blue+= rotatedTexture->getTextureData()->get(pixelOffset + 2);
                alpha+= rotatedTexture->getTextureData()->get(pixelOffset + 3);
                samples++;
            }
            filteredTextureByteBuffer->put(red / samples);
            filteredTextureByteBuffer->put(green / samples);
            filteredTextureByteBuffer->put(blue / samples);
            filteredTextureByteBuffer->put(alpha / samples);
        }
    }
    rotatedTexture->releaseReference();
    return filteredTexture;
}
 
Texture* TextureReader::scale(Texture* texture, int width, int height) {
    auto textureWidth = texture->getTextureWidth();
    auto textureHeight = texture->getTextureHeight();
    auto textureBytesPerPixel = texture->getDepth() / 8;
    auto textureWidthScaled = width;
    auto textureHeightScaled = height;
    auto scaledTextureByteBuffer = new ByteBuffer(textureWidthScaled * textureHeightScaled * 4);
    auto scaledTexture = new Texture(
        texture->getId() + ":s=" + to_string(textureWidthScaled) + "x" + to_string(textureHeightScaled),
        32,
        textureWidthScaled,
        textureHeightScaled,
        textureWidthScaled,
        textureHeightScaled,
        scaledTextureByteBuffer
    );
    scaledTexture->acquireReference();
    auto scaleX = static_cast<float>(textureWidth) / static_cast<float>(textureWidthScaled);
    auto scaleY = static_cast<float>(textureHeight) / static_cast<float>(textureHeightScaled);
    for (auto y = 0; y < textureHeightScaled; y++) {
        for (auto x = 0; x < textureWidthScaled; x++) {
            auto originalTexturePoint = Vector2(static_cast<float>(x) * scaleX, static_cast<float>(y) * scaleY);
            auto red = 0;
            auto green = 0;
            auto blue = 0;
            auto alpha = 0;
            auto originalX = static_cast<int>(originalTexturePoint.getX());
            auto originalY = static_cast<int>(originalTexturePoint.getY());
            if (originalX >= 0 && originalX < textureWidth && originalY >= 0 && originalY < textureHeight) {
                red = texture->getTextureData()->get((originalY * textureWidth * textureBytesPerPixel) + (originalX * textureBytesPerPixel) + 0);
                green = texture->getTextureData()->get((originalY * textureWidth * textureBytesPerPixel) + (originalX * textureBytesPerPixel) + 1);
                blue = texture->getTextureData()->get((originalY * textureWidth * textureBytesPerPixel) + (originalX * textureBytesPerPixel) + 2);
                alpha = textureBytesPerPixel == 4?texture->getTextureData()->get((originalY * textureWidth * textureBytesPerPixel) + (originalX * textureBytesPerPixel) + 3):-1;
            }
            scaledTextureByteBuffer->put(red);
            scaledTextureByteBuffer->put(green);
            scaledTextureByteBuffer->put(blue);
            scaledTextureByteBuffer->put(alpha);
        }
    }
    // no bilinear filtering if texture got smaller
    if (textureWidthScaled < textureWidth) return scaledTexture;
    // otherwise do bilinear filtering
    // TODO: should be improved
    auto filteredTextureByteBuffer = new ByteBuffer(textureWidthScaled * textureHeightScaled * 4);
    auto filteredTexture = new Texture(
        texture->getId() + ":s=" + to_string(textureWidthScaled) + "x" + to_string(textureHeightScaled) + ":bf",
        32,
        textureWidthScaled,
        textureHeightScaled,
        textureWidthScaled,
        textureHeightScaled,
        filteredTextureByteBuffer
    );
    filteredTexture->acquireReference();
    for (auto y = 0; y < filteredTexture->getTextureHeight(); y++) {
        for (auto x = 0; x < filteredTexture->getTextureWidth(); x++) {
            auto samples = 0;
            auto red = 0;
            auto green = 0;
            auto blue = 0;
            auto alpha = 0;
            for (auto _y = -1; _y <= 1; _y++)
            for (auto _x = -1; _x <= 1; _x++)
            if ((Math::abs(_x) == 1 && Math::abs(_y) == 1) == false &&
                (x + _x >= 0 && x + _x < textureWidthScaled && y + _y >= 0 && y + _y < textureHeightScaled)) {
                auto pixelOffset = (y + _y) * textureWidthScaled * 4 + (x + _x) * 4;
                red+= scaledTexture->getTextureData()->get(pixelOffset + 0);
                green+= scaledTexture->getTextureData()->get(pixelOffset + 1);
                blue+= scaledTexture->getTextureData()->get(pixelOffset + 2);
                alpha+= scaledTexture->getTextureData()->get(pixelOffset + 3);
                samples++;
            }
            filteredTextureByteBuffer->put(red / samples);
            filteredTextureByteBuffer->put(green / samples);
            filteredTextureByteBuffer->put(blue / samples);
            filteredTextureByteBuffer->put(alpha / samples);
        }
    }
    scaledTexture->releaseReference();
    return filteredTexture;
}
 
Texture* TextureReader::smooth(Texture* texture) {
    // TODO: should be improved
    auto filteredTextureByteBuffer = new ByteBuffer(texture->getTextureWidth() * texture->getTextureHeight() * 4);
    auto filteredTexture = new Texture(
        texture->getId() + ":smooth",
        32,
        texture->getTextureWidth(),
        texture->getTextureHeight(),
        texture->getTextureWidth(),
        texture->getTextureHeight(),
        filteredTextureByteBuffer
    );
    filteredTexture->acquireReference();
    for (auto y = 0; y < filteredTexture->getTextureHeight(); y++) {
        for (auto x = 0; x < filteredTexture->getTextureWidth(); x++) {
            auto samples = 0;
            auto red = 0;
            auto green = 0;
            auto blue = 0;
            auto alpha = 0;
            for (auto _y = -1; _y <= 1; _y++)
            for (auto _x = -1; _x <= 1; _x++)
            if ((Math::abs(_x) == 1 && Math::abs(_y) == 1) == false &&
                (x + _x >= 0 && x + _x < texture->getTextureWidth() && y + _y >= 0 && y + _y < texture->getTextureHeight())) {
                auto pixelOffset = (y + _y) * texture->getTextureWidth() * 4 + (x + _x) * 4;
                red+= texture->getTextureData()->get(pixelOffset + 0);
                green+= texture->getTextureData()->get(pixelOffset + 1);
                blue+= texture->getTextureData()->get(pixelOffset + 2);
                alpha+= texture->getTextureData()->get(pixelOffset + 3);
                samples++;
            }
            filteredTextureByteBuffer->put(red / samples);
            filteredTextureByteBuffer->put(green / samples);
            filteredTextureByteBuffer->put(blue / samples);
            filteredTextureByteBuffer->put(alpha / samples);
        }
    }
    return filteredTexture;
}