jmSprites.h

#ifndef JUGIMAP_SPRITES_H
#define JUGIMAP_SPRITES_H
 
#include "jmCommon.h"
#include "jmColor.h"
#include "jmGlobal.h"
 
 
 
namespace jugimap {
 
 
class JugiMapBinaryLoader;
class GraphicItem;
class Layer;
class SpriteLayer;
class SourceSprite;
class ComposedSprite;
class StandardSprite;
class Collider;
struct AnimatedProperties;
 
//class TextLayer;
class Font;
 
struct SourceSpriteReplacements;
 
 
 
class Sprite
{
public:
    friend class JugiMapBinaryLoader;
    friend class ComposedSprite;
    friend class SpriteLayer;
    friend class ComposedSprite;
 
    enum Property
    {
        NONE =      0,
        POSITION =  1 << 0,
        FLIP =      1 << 1,
        SCALE =     1 << 2,
        ROTATION =  1 << 3,
        HANDLE =    1 << 4,
 
        ALPHA =     1 << 5,
        BLEND =     1 << 6,
        OVERLAY_COLOR = 1 << 7,
        COLOR =     1 << 8,
 
        TEXTURE =     1 << 10,
        TEXT_STRING = 1 << 11,
 
        VISIBILITY =  1 << 13,
 
        ID =        1 << 15,
        TAG =       1 << 16,
        DATA =      1 << 17,
        LINK =      1 << 18,
 
        TRANSFORMATION = POSITION | FLIP | SCALE |  ROTATION | HANDLE,
        APPEARANCE = ALPHA | BLEND | OVERLAY_COLOR | COLOR,
        ALL = TRANSFORMATION | APPEARANCE | TEXTURE | TEXT_STRING | VISIBILITY |  ID | TAG | DATA | LINK
    };
 
 
    Sprite(){}
    Sprite(const Sprite &s) = delete;
    Sprite& operator=(const Sprite &s) = delete;
 
 
    Sprite* MakePassiveCopy();
 
 
    Sprite* MakeActiveCopy();
 
 
 
 
    virtual void CopyProperties(Sprite *_sprite, int copyFlags);
 
 
    //------ MANAGE ENGINE OBJECTS
 
 
    virtual void InitEngineObjects(){}
 
 
    virtual void UpdateEngineObjects(){}
 
 
    virtual void DrawEngineSprite(){}
 
 
    virtual bool IsEngineSpriteInitialized() {return false;}
 
 
    //------
 
 
    virtual void SetVisible(bool _visible);
 
 
    bool IsVisible(){ return visible; }
 
 
    //------        
 
    void SetDisabledEngineSpriteUpdate(bool _engineSpriteUsedDirectly){ engineSpriteUsedDirectly = _engineSpriteUsedDirectly; }
 
 
    bool IsEngineSpriteUsedDirectly(){ return engineSpriteUsedDirectly; }
 
 
 
    virtual void UpdateBoundingBox() {boundingBox = Rectf(position, position);}
 
 
    Rectf GetBoundingBox(){ return boundingBox;}
 
 
    virtual void CaptureForLerpDrawing(){}
 
 
    //---- LINK OBJECTS
 
 
    SpriteLayer* GetLayer() {return layer;}
 
 
    SourceSprite* GetSourceSprite() {return sourceSprite;}
 
 
    ComposedSprite* GetParentComposedSprite() {return parentComposedSprite;}
 
 
    SpriteKind GetKind();
 
 
    //------
    void SetId(int _id){ id = _id; }
 
 
    int GetId(){ return id;}
 
 
    void SetName(const std::string& _nameID){ name = _nameID; }
 
 
    std::string GetName(){ return name;}
 
 
 
    void SetTag(int _tag){ tag = _tag; }
 
 
    int GetTag(){ return tag;}
 
 
    //------
 
    void SetCustomObject(CustomObject* _customObject){ customObject = _customObject; }
 
 
    CustomObject* GetCustomObject(){ return customObject; }
 
 
    //------
 
 
    std::vector<jugimap::Parameter> &GetParameters(){return parameters;}
 
 
    int GetDataFlags() {return dataFlags;}
 
 
    // TRANSFORM PROPERTIES
    //-------------------------------------------------------------------------------
 
    void SetPosition(Vec2f _position);
 
 
    Vec2f GetPosition(bool _includeAnimatedProperties = true);
 
 
    Vec2f GetGlobalPosition(bool _includeAnimatedProperties = true);
 
 
    //------
 
 
    void SetScale(Vec2f _scale);
 
 
    Vec2f GetScale(bool _includeAnimatedProperties = true);
 
 
    Vec2f GetGlobalScale(bool _includeAnimatedProperties = true);
 
 
    //------
 
 
    void SetRotation(float _rotation);
 
 
    float GetRotation(bool _includeAnimatedProperties = true);
 
 
    float GetGlobalRotation(bool _includeAnimatedProperties = true);
 
 
    //------
 
 
    void SetFlip(Vec2i _flip);
 
 
    Vec2i GetFlip(bool _includeAnimatedProperties = true);
 
 
    Vec2i GetGlobalFlip(bool _includeAnimatedProperties = true);
 
 
    //------
 
    virtual void SetHandle(Vec2f _handle);
 
 
    Vec2f GetHandle() {return handle;}
 
 
    // APPEARANCE PROPERTIES
    //-------------------------------------------------------------------------------
 
    void SetAlpha(float _alpha);
 
 
    //float GetAlpha(){return alpha;}
 
 
    float GetAlpha(bool _includeAnimatedProperties = true);
 
 
    //------
 
    void SetOwnBlend(Blend _blend);
 
 
    Blend GetOwnBlend(){return ownBlend;}
 
 
    //------
 
    void SetColorOverlayActive(bool _colorOverlayActive);
 
 
    bool IsOverlayColorActive();
 
 
 
    void SetColorOverlayRGBA(ColorRGBA _colorOverlayRGBA);
 
 
    ColorRGBA GetOverlayColorRGBA(bool _includeAnimatedProperties = true);
 
 
    void SetColorOverlayBlend(ColorOverlayBlend _colorOverlayBlend);
 
 
    ColorOverlayBlend GetOverlayColorBlend(bool _includeAnimatedProperties = true);
 
 
    //------ ANIMATED PROPERTIES
 
 
    AnimatedProperties* GetAnimatedProperties(){ return ap; }
 
 
    virtual void CreateAnimatedPropertiesIfNone();
 
 
    virtual void ResetAnimatedProperties();
 
 
    virtual void AppendAnimatedProperties(AnimatedProperties& _ap);
 
 
 
    //------ COLLIDER
 
 
    virtual bool HasCollider() { return false; }
 
 
    virtual bool PointInside(Vec2f _pos){ return false; }
 
 
    virtual bool Overlaps(Sprite *_sprite){  return false; }
 
 
    virtual bool RaycastHit(Vec2f _rayStart, Vec2f _rayEnd, Vec2f &_hitPos){  return false; }
 
 
 
    //-------- CHANGE FLAGS
 
 
    void SetChangeFlags(int _changeFlags);
 
 
    void AppendToChangeFlags(int _changeFlags);
 
 
    int GetChangeFlags() {return changeFlags;}
 
 
    //--------
 
 
    void _SetSourceSprite(SourceSprite *_sourceSprite){ sourceSprite = _sourceSprite; }
 
 
    void _SetLayer(SpriteLayer *_spriteLayer){ layer = _spriteLayer; }
 
 
 
    SourceSpriteReplacements* GetSourceSpriteReplacements(){ return ssr;}
 
    SourceSprite* GetOriginalSourceSprite();
 
 
protected:
 
    void SetBoundingBox(const Rectf &_boundingBox) { boundingBox = _boundingBox;}
 
 
    virtual ~Sprite();
 
 
private:
    SpriteLayer *layer = nullptr;                           // LINK pointer to a layer where the sprite is stored.
    SourceSprite * sourceSprite= nullptr;                   // LINK pointer to the belonging SourceSprite.
    ComposedSprite * parentComposedSprite = nullptr;        // LINK pointer to parent composed sprite if sprite is child of a composed sprite.
 
    //---
    int id = 0;
    std::string name;
    int tag = 0;
    CustomObject* customObject = nullptr;
 
    //---
    bool visible = true;
    bool engineSpriteUsedDirectly = false;
 
 
    //--- TRANSFORMATION PROPERTIES
    Vec2f position;
    //Vec2f animationFrameOffset;
    Vec2f scale = Vec2f(1.0, 1.0);
    float rotation = 0.0;
    Vec2i flip;
    Vec2f handle;
 
    Rectf boundingBox;
 
 
    //--- APPEARANCE PROPERTIES
    float alpha = 1.0;                                      // in scale [0 - 1.0]
    Blend ownBlend = Blend::NOT_DEFINED;
    bool colorOverlayActive = false;
    ColorRGBA colorOverlayRGBA = 0;
    ColorOverlayBlend colorOverlayBlend = ColorOverlayBlend::NORMAL;
 
 
    //---
    AnimatedProperties* ap = nullptr;
 
 
    //--- DATA
    std::vector<Parameter> parameters;
    int dataFlags = 0;
 
 
    SourceSpriteReplacements* ssr = nullptr;
    SourceSpriteReplacements* ssrChildren = nullptr;
 
    //----
    int changeFlags = 0;
 
};
 
 
//=======================================================================================
 
 
class ComposedSprite : public Sprite
{
public:
    friend class JugiMapBinaryLoader;
    friend class Sprite;
    friend class StandardSprite;
    friend class SkeletonSprite;
 
    ComposedSprite(){}
 
 
    virtual void InitEngineObjects() override;
    virtual void UpdateEngineObjects() override;
    virtual void DrawEngineSprite() override;
    virtual void SetVisible(bool _visible) override;
    virtual bool HasCollider() override;
    virtual bool PointInside(Vec2f _pos) override;
    virtual bool Overlaps(Sprite *_sprite) override;
    virtual bool RaycastHit(Vec2f _rayStart, Vec2f _rayEnd, Vec2f &_hitPos) override;
    virtual void UpdateBoundingBox() override;
    virtual void CaptureForLerpDrawing() override;
    virtual void ResetAnimatedProperties() override;
 
 
    Vec2f ConvertToWorldPos(const Vec2f &_pos)
    {
        return cTransform.Transform(_pos);
    }
 
    Vec2f ConvertToWorldScale(const Vec2f &_scale)
    {
        return Vec2f(cScale * _scale.x, cScale * _scale.y);
    }
 
    float ConvertToWorldRotation(float _rotation)
    {
        return (cFlip.y + cFlip.x == 1)?  cRotation - _rotation : cRotation + _rotation;    // one (and only one) flip changes direction of rotation !
    }
 
    Vec2i ConvertToWorldFlip(const Vec2i &_flip)
    {
        return Vec2i((_flip.x==1)? 1 - cFlip.x : cFlip.x , (_flip.y==1)? 1 - cFlip.y : cFlip.y);
    }
 
 
    Vec2f GetLocalPositionFromInMapPosition(const Vec2f &_pos) { return cTransform.Invert().Transform(_pos); }
 
 
    std::vector<Layer*> & GetLayers()  {return layers; }
 
 
    void SetChildrenSpritesChanged(bool _childrenSpritesChanged);
 
 
 
    //----
    AffineMat3f GetCTransform(){ return cTransform; }
    Vec2i GetCFlip(){ return cFlip; }
    float GetCScale(){ return cScale; }
    float GetCRotation(){ return cRotation; }
 
 
protected:
 
    virtual ~ComposedSprite() override;
 
 
private:
    std::vector<Layer*>layers;                         // OWNED
 
    // cumulative tranform properties
    AffineMat3f cTransform;
    Vec2i cFlip;
    float cScale = 1.0;
    float cRotation = 0.0;
 
    // misc - for construction purposes
    Vec2i tileSize;
    Vec2i nTiles;
    Vec2i size;
 
    bool childrenSpritesChanged = false;
 
 
 
 
 
    void UpdateTransform();
    //static void CopyLayers(ComposedSprite *csSource, ComposedSprite *csDest, JugiMapBinaryLoader *loader=nullptr);
    static void CopyLayers(ComposedSprite *csSource, ComposedSprite *csDest, int &zOrder);
};
 
 
//=======================================================================================
 
 
class StandardSprite  : public Sprite
{
public:
    friend class JugiMapBinaryLoader;
 
 
    enum PhysicsMode{
        NO_PHYSICS=0,       
        STATIC=1,           
        DYNAMIC=2,          
        KINEMATIC=3         
    };
 
 
    StandardSprite(){}
 
 
    void UpdateBoundingBox() override;
    virtual bool HasCollider() override;
    virtual bool PointInside(Vec2f _pos) override;
    virtual bool Overlaps(Sprite *_sprite) override;
    virtual bool RaycastHit(Vec2f _rayStart, Vec2f _rayEnd, Vec2f &_hitPos) override;
 
 
    GraphicItem * GetActiveImage() {return activeImage;}
 
 
    virtual void SetActiveImage(GraphicItem *_image);
 
 
    int GetActiveImageFrameIndex();
 
 
    void SetActiveImageByFrameIndex(int _frameIndex);
 
 
   // bool GetPreserveShapesOnNullActiveImage(){ return preserveShapesOnNullActiveImage;}
 
 
    void SetCollider(Collider *_collider){ collider = _collider; }
 
 
    Collider * GetCollider(){ return collider; }
 
 
    virtual PhysicsMode GetPhysicsMode(){ return physicsMode; }
 
 
    virtual void SetPhysicsMode(PhysicsMode _physicsMode){ physicsMode = _physicsMode;}
 
 
    virtual void AppendAnimatedProperties(AnimatedProperties& _ap) override;
 
 
 
protected:
 
    virtual ~StandardSprite();
 
    void SetColliderShapes();
    void UpdateColliderAndBoundingBox();
 
 
private:
    GraphicItem *activeImage = nullptr;                       // LINK to currently active (displayed) image from the source sprite 'graphicItems' list.
    Collider *collider = nullptr;
    bool preserveShapesOnNullActiveImage = true;
    PhysicsMode physicsMode = PhysicsMode::NO_PHYSICS;
 
 
 
 
};
 
 
 
class TextSprite : public Sprite
{
public:
 
 
    TextSprite(){};
 
 
    virtual void InitEngineObjects() override;
    virtual void CopyProperties(Sprite *_sprite, int copyFlags) override;
    virtual void UpdateBoundingBox() override;
    virtual bool PointInside(Vec2f _pos) override;
 
    //------
 
    Font* GetFont(){ return font; }
 
 
    void SetTextString(const std::string &_textString);
 
 
    std::string GetTextString(){ return textString; }
 
 
    void SetColor(ColorRGBA _color);
 
 
    ColorRGBA GetColor(){ return color; }
 
 
    float GetHeight();
 
 
    float GetWidth();
 
 
    Vec2f GetSize();
 
 
    Vec2f GetRelativeHandle(){ return relHandle; }
 
 
    //void SetClickable(bool _clickable) { clickable = _clickable; }
 
    //bool IsClickable(){ return clickable; }
 
    //virtual void ObtainSize() {}
 
 
    void _SetSize(Vec2f _size);
    void _SetFont(Font *_font){ font = _font; }
    /*
    */
    void _SetRelativeHandle(Vec2f _relHandle){ relHandle = _relHandle; }
 
 
 
protected:
 
 
private:
    std::string textString;
    Font* font = nullptr;                       // LINK pointer
    ColorRGBA color{255,255,255,255};
    Vec2f size;
 
    Vec2f relHandle{0.5, 0.5};
 
    //bool clickable = false;
 
 
    void AdjustRelativeHandleToRoundedSize();
 
};
 
 
 
 
//=======================================================================================
 
class SkeletonSprite : public Sprite
{
public:
    friend class JugiMapBinaryLoader;
 
    SkeletonSprite(){}
 
    virtual ~SkeletonSprite() override {}
 
    virtual void InitEngineObjects() override;
 
};
 
 
 
}
 
 
 
 
#endif  // JUGIMAP_SPRITES_H