jmSourceGraphics.h

#ifndef JUGIMAP_SOURCE_GRAPHICS_H
#define JUGIMAP_SOURCE_GRAPHICS_H
 
 
#include "jmCommon.h"
#include "jmGlobal.h"
 
 
 
namespace jugimap {
 
 
class VectorShape;
class GraphicFile;
class SourceSprite;
class FrameAnimation;
class TimelineAnimation;
class StandardSprite;
class ComposedSprite;
class SkeletonSprite;
class SourceGraphics;
class SpriteLayer;
class VectorLayer;
class Administrator;
class JugiMapBinaryLoader;
class ObjectFactory;
 
 
 
class GraphicItem
{
public:
    friend class JugiMapBinaryLoader;
    friend class ObjectFactory;
    friend class Administrator;
    friend class GraphicFile;
    friend class SourceSprite;
    friend class GraphicFile;
    friend class StandardSprite;
    friend class SkeletonSprite;
 
 
 
    virtual void Init();
 
 
    GraphicFile* GetFile() {return graphicFile;}
 
 
    std::string GetName() {return name;}
 
 
    Vec2i GetPos() {return rect.min;}
 
 
    int GetWidth() {return rect.GetWidth();}
 
 
    int GetHeight() {return rect.GetHeight();}
 
 
    Vec2i GetSize() {return rect.GetSize();}
 
 
    Vec2f GetHandle() {return handle;}
 
 
    float GetSpineScale() {return spineScale;}
 
 
    std::vector<VectorShape*>& GetSpriteShapes() {return spriteShapes;}
 
 
    std::vector<VectorShape*>& GetExtraShapes() {return extraShapes;}
 
 
    std::string GetLabel(){ return label; }
 
 
    int GetFontStyleId(){ return fontStyleId; }
 
    int GetColorStyleId(){ return colorStyleId; }
 
 
    TextHandleVariant GetTextHandleVariant(){ return textHandleVariant; }
 
 
protected:
 
    GraphicItem(){}
 
    GraphicItem(const GraphicItem &gi) = delete;
    GraphicItem & operator=(const GraphicItem &gi) = delete;
 
    virtual ~GraphicItem();
 
 
private:
    GraphicFile *graphicFile = nullptr;             //LINK pointer to parent file.
    std::string name;
 
    // (sub)image rectangle
    Recti rect;
 
    float spineScale = 1.0;
    Vec2f handle;
    std::vector<VectorShape*>spriteShapes;          // OWNED
    std::vector<VectorShape*>extraShapes;           // OWNED
 
    // text label
    std::string label;
    int fontStyleId = 0;
    int colorStyleId = 0;
    TextHandleVariant textHandleVariant = TextHandleVariant::CENTER;
 
};
 
 
//=======================================================================================
 
class GraphicFile
{
public:
    friend class ObjectFactory;
    friend class JugiMapBinaryLoader;
    friend class Administrator;
    friend class GraphicItem;
    friend class StandardSprite;
    friend class SkeletonSprite;
    friend class SourceGraphics;
 
    static std::string pathPrefix;          
 
 
 
 
    virtual void Init(){}
 
 
    FileKind GetKind() {return kind;}
 
 
    std::string GetRelativeFilePath() {return pathPrefix + relativeFilePath;}
 
 
    Vec2i GetSize() {return size;}
 
 
    std::vector<GraphicItem*>& GetItems() {return items;}
 
 
    std::string GetSpineAtlasRelativeFilePath() {return pathPrefix + spineAtlasRelativeFilePath;}
 
 
protected:
 
    GraphicFile(){}
    GraphicFile(const GraphicFile &gf) = delete;
    GraphicFile & operator=(const GraphicFile &gf) = delete;
 
    virtual ~GraphicFile();
 
private:
    FileKind kind = FileKind::NOT_DEFINED;
    std::string relativeFilePath;
    Vec2i size;
    std::vector<GraphicItem*>items;                 // OWNED objects
    std::string spineAtlasRelativeFilePath;
 
};
 
 
//=======================================================================================
 
 
 
 
 
class SourceSprite
{
public:
    friend class ObjectFactory;
    friend class JugiMapBinaryLoader;
    friend class Administrator;
    friend class JMSprite;
    friend class StandardSprite;
    friend class ComposedSprite;
    friend class SkeletonSprite;
    friend class SourceGraphics;
 
 
    enum Status{
        HAS_IMAGES_OF_DIFFERENT_SIZE = 1,                       
        HAS_IMAGES_WITH_SPRITE_SHAPES = 2,                      
        HAS_IMAGES_WITH_DIFFERENT_SPRITE_SHAPES = 4,         
        HAS_MULTIPLE_SPRITE_SHAPES_IN_IMAGE = 8                 
    };
 
 
    void Init();
 
 
    SpriteKind GetKind() {return kind;}
 
 
    std::string GetName() {return name;}
 
 
    std::vector<Parameter>& GetConstantParameters(){return constantParameters;}
 
 
    std::vector<GraphicItem*>& GetGraphicItems(){return graphicItems;}
 
 
    std::vector<FrameAnimation*>& GetFrameAnimations(){return frameAnimations;}
 
 
    std::vector<TimelineAnimation*>& GetTimelineAnimations(){return timelineAnimations;}
 
 
    int GetStatusFlags() {return statusFlags;}
 
 
    ComposedSprite* GetSourceComposedSprite(){return sourceComposedSprite;}
 
 
private:
    SpriteKind kind = SpriteKind::NOT_DEFINED;
    std::string name;
    std::vector<Parameter> constantParameters;
    std::vector<GraphicItem*>graphicItems;                     // LINKs
    std::vector<FrameAnimation*>frameAnimations;               // OWNED
    std::vector<TimelineAnimation*>timelineAnimations;          // OWNED
 
    std::vector<Parameter> parametersTMP;
 
    int statusFlags = 0;
    bool initialized = false;
 
    ComposedSprite * sourceComposedSprite = nullptr;          // OWNED
 
 
    SourceSprite(){}
    SourceSprite(SpriteKind _kind) : kind(_kind){}
 
    SourceSprite(const SourceSprite &ss) = delete;
    SourceSprite & operator=(const SourceSprite &ss) = delete;
 
    ~SourceSprite();
 
};
 
 
 
 
 
struct SourceSpriteReplacement
{
    SourceSprite * sourceSprite = nullptr;      // LINK
    std::string childSpriteName;
 
 
    SourceSpriteReplacement(SourceSprite * _sourceSprite, const std::string &_childSpriteName) :
        sourceSprite(_sourceSprite),
        childSpriteName(_childSpriteName)
    {}
};
 
 
 
struct SourceSpriteReplacements
{
 
    std::vector<SourceSpriteReplacement>replacements;
    SourceSprite * originalSourceSprite = nullptr;      // LINK
 
    SourceSpriteReplacements(SourceSprite * _sourceSprite, const std::string &_childSpriteName, SourceSprite * _originalSourceSprite)
        :originalSourceSprite(_originalSourceSprite)
    {
        replacements.push_back(SourceSpriteReplacement(_sourceSprite, _childSpriteName));
    }
 
    SourceSprite * FindSourceSpriteForChild(const std::string &_childSpriteName);
 
 
};
 
 
//=======================================================================================
 
class SourceGraphics
{
public:
    friend class JugiMapBinaryLoader;
 
    static SourceSprite* dummyTextSourceSprite;
 
    SourceGraphics(){}
 
 
    ~SourceGraphics();
 
 
    void DeleteContent();
 
 
    std::vector<GraphicFile*>& GetFiles(){return files;}
 
 
    std::vector<SourceSprite*>& GetSourceSprites(){return sourceSprites;}
 
 
    static void DeleteGlobalData();
 
 
 
private:
    std::vector<GraphicFile*>files;               //OWNED
    std::vector<SourceSprite*>sourceSprites;      //OWNED
 
};
 
 
/*
*/
 
}
 
 
 
 
 
 
#endif