spine-runtimes/spine-cpp/spine-cpp/include/spine/Atlas.h

/******************************************************************************
 * Spine Runtimes Software License v2.5
 *
 * Copyright (c) 2013-2016, Esoteric Software
 * All rights reserved.
 *
 * You are granted a perpetual, non-exclusive, non-sublicensable, and
 * non-transferable license to use, install, execute, and perform the Spine
 * Runtimes software and derivative works solely for personal or internal
 * use. Without the written permission of Esoteric Software (see Section 2 of
 * the Spine Software License Agreement), you may not (a) modify, translate,
 * adapt, or develop new applications using the Spine Runtimes or otherwise
 * create derivative works or improvements of the Spine Runtimes or (b) remove,
 * delete, alter, or obscure any trademarks or any copyright, trademark, patent,
 * or other intellectual property or proprietary rights notices on or in the
 * Software, including any copy thereof. Redistributions in binary or source
 * form must include this license and terms.
 *
 * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS INTERRUPTION, OR LOSS OF
 * USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

#ifndef Spine_Atlas_h
#define Spine_Atlas_h

#include <spine/Vector.h>
#include <spine/Extension.h>

#include <string>

namespace Spine
{
    enum Format
    {
        Format_Alpha,
        Format_Intensity,
        Format_LuminanceAlpha,
        Format_RGB565,
        Format_RGBA4444,
        Format_RGB888,
        Format_RGBA8888
    };
    
    enum TextureFilter
    {
        TextureFilter_Nearest,
        TextureFilter_Linear,
        TextureFilter_MipMap,
        TextureFilter_MipMapNearestNearest,
        TextureFilter_MipMapLinearNearest,
        TextureFilter_MipMapNearestLinear,
        TextureFilter_MipMapLinearLinear
    };
    
    enum TextureWrap
    {
        TextureWrap_MirroredRepeat,
        TextureWrap_ClampToEdge,
        TextureWrap_Repeat
    };
    
    class AtlasPage
    {
    public:
        std::string name;
        Format format;
        TextureFilter minFilter;
        TextureFilter magFilter;
        TextureWrap uWrap;
        TextureWrap vWrap;
        void* rendererObject;
        int width, height;
        
        AtlasPage(std::string inName) : name(inName) {}
    };
    
    class AtlasRegion
    {
    public:
        AtlasPage* page;
        std::string name;
        int x, y, width, height;
        float u, v, u2, v2;
        float offsetX, offsetY;
        int originalWidth, originalHeight;
        int index;
        bool rotate;
        Vector<int> splits;
        Vector<int> pads;
    };
    
    class TextureLoader
    {
    public:
        virtual void load(AtlasPage page, std::string path) = 0;
        virtual void unload(void* texture) = 0;
    };
    
    class Atlas
    {
    public:
        Atlas(const char* path, TextureLoader& textureLoader);
        
        Atlas(const char* data, int length, const char* dir, TextureLoader& textureLoader);
        
        ~Atlas();
        
        void flipV();
        
        /// Returns the first region found with the specified name. This method uses std::string comparison to find the region, so the result
        /// should be cached rather than calling this method multiple times.
        /// @return The region, or NULL.
        AtlasRegion* findRegion(std::string name);
        
        void dispose();
        
    private:
        Vector<AtlasPage*> _pages;
        Vector<AtlasRegion*> _regions;
        TextureLoader& _textureLoader;
        
        void load(const char* begin, int length, const char* dir);
        
        class Str
        {
        public:
            const char* begin;
            const char* end;
        };
        
        static void trim(Str* str);
        
        /// Tokenize string without modification. Returns 0 on failure
        static int readLine(const char** begin, const char* end, Str* str);
        
        /// Moves str->begin past the first occurence of c. Returns 0 on failure
        static int beginPast(Str* str, char c);
        
        /// Returns 0 on failure
        static int readValue(const char** begin, const char* end, Str* str);
        
        /// Returns the number of tuple values read (1, 2, 4, or 0 for failure)
        static int readTuple(const char** begin, const char* end, Str tuple[]);
        
        static char* mallocString(Str* str);
        
        static int indexOf(const char** array, int count, Str* str);
        
        static int equals(Str* str, const char* other);
        
        static int toInt(Str* str);
        
        static Atlas* abortAtlas(Atlas* atlas);
    };
}

#endif /* Spine_Atlas_h */