atlasloader.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2019 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE is free software; you can redistribute it and/or                 *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

// Standard C++ library includes

// 3rd party library includes
#include <tinyxml.h>

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "model/model.h"
#include "model/structures/layer.h"
#include "vfs/fife_boost_filesystem.h"
#include "vfs/vfs.h"
#include "vfs/raw/rawdata.h"
#include "util/base/exception.h"
#include "util/log/logger.h"
#include "util/resource/resource.h"
#include "util/resource/resourcemanager.h"
#include "video/animationmanager.h" 
#include "view/visual.h"

#include "atlasloader.h"

namespace FIFE {
    static Logger _log(LM_NATIVE_LOADERS);


    size_t Atlas::getImageCount() const {
        return m_subimages.size();
    }

    ImagePtr& Atlas::getPackedImage() {
        return m_image;
    }

    ImagePtr Atlas::getImage(const std::string& id) {
        SubimageMap::iterator iter = m_subimages.find(id);
        if(iter == m_subimages.end())
            return ImagePtr();
        return iter->second.image;
    }

    ImagePtr Atlas::getImage(uint32_t index) {
        if(index > getImageCount())
            return ImagePtr();

        SubimageMap::iterator iter = m_subimages.begin();
        for(uint32_t i = 0; i < index; ++i, ++iter);
        return iter->second.image;
    }

    bool Atlas::addImage(const std::string& imagename, const AtlasData& data) {
        return m_subimages.insert(std::pair<std::string, AtlasData>(imagename, data)).second;
    }

    void Atlas::setPackedImage(const ImagePtr& image) {
        m_image = image;
    }

    const std::string& Atlas::getName() const {
        return m_name;
    }

    AtlasLoader::AtlasLoader(Model* model, VFS* vfs, ImageManager* imageManager, AnimationManager* animationManager)
    : m_model(model), m_vfs(vfs), m_imageManager(imageManager), m_animationManager(animationManager) {
    }

    AtlasLoader::~AtlasLoader() {
    }

    bool AtlasLoader::isLoadable(const std::string& filename) {
        bfs::path atlasPath(filename);
        std::string atlasFilename = atlasPath.string();
        TiXmlDocument atlasFile;

        try {
            RawData* data = m_vfs->open(atlasFilename);

            if (data) {
                if (data->getDataLength() != 0) {
                    atlasFile.Parse(data->readString(data->getDataLength()).c_str());

                    if (atlasFile.Error()) {
                        return false;
                    }
                } else {
                    return false;
                }

                // done with data delete resource
                delete data;
                data = 0;
            }
        } catch (NotFound&) {
            return false;
        }

        // if we get here then loading the file went well
        TiXmlElement* root = atlasFile.RootElement();

        if (root && root->ValueStr() == "assets") {
            if (root->FirstChildElement("atlas")) {
                return true;
            }
        }

        return false;
    }

    AtlasPtr AtlasLoader::load(const std::string& filename) {
        bfs::path atlasPath(filename);
        bfs::path atlasPathDirectory;
        std::string atlasFilename = atlasPath.string();

        if (HasParentPath(atlasPath)) {
            // save the directory where the atlas file is located
            atlasPathDirectory = GetParentPath(atlasPath);
        }

        TiXmlDocument doc;
        AtlasPtr atlas;

        try {
            RawData* data = m_vfs->open(atlasFilename);

            if (data) {
                if (data->getDataLength() != 0) {
                    doc.Parse(data->readString(data->getDataLength()).c_str());

                    if (doc.Error()) {
                        return atlas;
                    }

                    // done with data delete resource
                    delete data;
                    data = 0;
                }
            }
        }
        catch (NotFound& e) {
            FL_ERR(_log, e.what());

            // TODO - should we abort here
            //        or rethrow the exception
            //        or just keep going

            return atlas;
        }

        // if we get here then everything loaded properly
        // so we can just parse out the contents
        TiXmlElement* root = doc.RootElement();

        if (root && root->ValueStr() == "assets") {
            atlas = loadAtlas(filename, root->FirstChildElement("atlas"));
        }

        return atlas;
    }

    std::vector<AtlasPtr> AtlasLoader::loadMultiple(const std::string& filename) {
        bfs::path atlasPath(filename);
        bfs::path atlasPathDirectory;
        std::string atlasFilename = atlasPath.string();

        if (HasParentPath(atlasPath)) {
            // save the directory where the atlas file is located
            atlasPathDirectory = GetParentPath(atlasPath);
        }

        TiXmlDocument doc;
        std::vector<AtlasPtr> atlasVector;

        try {
            RawData* data = m_vfs->open(atlasFilename);

            if (data) {
                if (data->getDataLength() != 0) {
                    doc.Parse(data->readString(data->getDataLength()).c_str());

                    if (doc.Error()) {
                        return atlasVector;
                    }

                    // done with data delete resource
                    delete data;
                    data = 0;
                }
            }
        }
        catch (NotFound& e) {
            FL_ERR(_log, e.what());

            // TODO - should we abort here
            //        or rethrow the exception
            //        or just keep going

            return atlasVector;
        }

        // if we get here then everything loaded properly
        // so we can just parse out the contents
        TiXmlElement* root = doc.RootElement();

        if (root && root->ValueStr() == "assets") {
            for (TiXmlElement* atlasElem = root->FirstChildElement("atlas"); atlasElem; atlasElem = atlasElem->NextSiblingElement("atlas")) {
                AtlasPtr atlas = loadAtlas(filename, atlasElem);
                if (atlas) {
                    atlasVector.push_back(atlas);
                }
            }
        }

        return atlasVector;
    }

    AtlasPtr AtlasLoader::loadAtlas(const std::string& filename, TiXmlElement* atlasElem) {
        AtlasPtr atlas;
        if (!atlasElem) {
            return atlas;
        }

        const std::string* atlasSource = atlasElem->Attribute(std::string("source"));
        if (atlasSource) {
            const std::string* atlasId = atlasElem->Attribute(std::string("id"));

            bfs::path atlasPath(filename);
            bfs::path atlasPathDirectory;
            if (HasParentPath(atlasPath)) {
                // save the directory where the atlas file is located
                atlasPathDirectory = GetParentPath(atlasPath);
            }

            // Atlas itself doesn't have appended id
            bfs::path atlasImagePath = atlasPathDirectory / *atlasSource;
            atlas.reset(new Atlas(atlasImagePath.string()));

            // End-user could create the same atlas for the second time.
            // Since we don't hold any data for Atlases like ImageManager we need to recreate
            // atlas parameters (to return proper AtlasPtr) but don't reload pixel data (they are held by ImageManager).
            if (!m_imageManager->exists(atlas->getName())) {
                atlas->setPackedImage(m_imageManager->create(atlas->getName()));
            } else {
                atlas->setPackedImage(m_imageManager->getPtr(atlas->getName()));
            }
            // Create subimages with given id and individual position and size
            if (atlasElem->FirstChildElement("subimage")) {
                for (TiXmlElement* imageElem = atlasElem->FirstChildElement("subimage");
                    imageElem != 0; imageElem = imageElem->NextSiblingElement("subimage")) {

                    const std::string* subimageId = imageElem->Attribute(std::string("id"));
                    if (subimageId) {
                        Rect region;
                        imageElem->QueryValueAttribute("xpos", &region.x);
                        imageElem->QueryValueAttribute("ypos", &region.y);
                        imageElem->QueryValueAttribute("width", &region.w);
                        imageElem->QueryValueAttribute("height", &region.h);

                        std::string finalname;
                        // atlas id is optional here
                        if (atlasId) {
                            finalname = *atlasId + ":" + *subimageId;
                        } else {
                            finalname = *subimageId;
                        }
                        ImagePtr subImage;

                        if (!m_imageManager->exists(finalname)) {
                            subImage = m_imageManager->create(finalname);
                        } else {
                            subImage = m_imageManager->getPtr(finalname);
                        }
                        subImage->useSharedImage(atlas->getPackedImage(), region);

                        AtlasData atlasData = {region, subImage};
                        atlas->addImage(finalname, atlasData);
                    }
                }
            } else {
                // Create subimages with automatic id and same size
                int frame = 0;
                int atlasWidth = 0;
                int atlasHeight = 0;
                int subimageWidth = 0;
                int subimageHeight = 0;
                atlasElem->QueryValueAttribute("atlas_width", &atlasWidth);
                atlasElem->QueryValueAttribute("atlas_height", &atlasHeight);
                atlasElem->QueryValueAttribute("subimage_width", &subimageWidth);
                atlasElem->QueryValueAttribute("subimage_height", &subimageHeight);
                // file extension of the atlas is also used as subimage extension
                std::string extension = bfs::extension(*atlasSource);
                // we need an atlas id
                if (!atlasId) {
                    atlasId = atlasSource;
                }
                
                if (atlasWidth != 0 && atlasHeight != 0 && subimageWidth != 0 && subimageHeight != 0) {
                    int x_rows = atlasWidth / subimageWidth;
                    int y_rows = atlasHeight / subimageHeight;
                    Rect region(0, 0, subimageWidth, subimageHeight);
                    for (int y = 0; y < y_rows; ++y) {
                        region.y = y * subimageHeight;
                        for (int x = 0; x < x_rows; ++x) {
                            region.x = x * subimageWidth;

                            static char tmp[64];
                            snprintf(tmp, 64, "%04d", frame);
                            std::ostringstream finalname;
                            finalname << *atlasId << ":" << std::string(tmp) << extension;

                            ImagePtr subImage;
                            if (!m_imageManager->exists(finalname.str())) {
                                subImage = m_imageManager->create(finalname.str());
                            } else {
                                subImage = m_imageManager->getPtr(finalname.str());
                            }
                            subImage->useSharedImage(atlas->getPackedImage(), region);

                            AtlasData atlasData = {region, subImage};
                            atlas->addImage(finalname.str(), atlasData);

                            ++frame;
                        }
                    }
                }
            }
        }

        return atlas;
    }

    AtlasLoader* createDefaultAtlasLoader(Model* model, VFS* vfs, ImageManager* imageManager, AnimationManager* animationManager) {
        return new AtlasLoader(model, vfs, imageManager, animationManager);
    }
}