jmLayers.h

#ifndef JUGIMAP_LAYERS_H
#define JUGIMAP_LAYERS_H
 
#include "jmCommon.h"
#include "jmColor.h"
#include "jmGlobal.h"
 
 
namespace jugimap {
 
 
class Map;
class Sprite;
class StandardSprite;
class SourceSprite;
class TextSprite;
class Font;
class ComposedSprite;
class JugiMapBinaryLoader;
class VectorShape;
 
 
 
 
class Layer
{
public:
    friend class JugiMapBinaryLoader;
    friend class ComposedSprite;
    friend class Map;
 
 
    Layer(){}
 
    Layer(const Layer &l) = delete;
    Layer& operator=(const Layer &l) = delete;
 
 
 
    virtual void InitLayerParameters();
 
 
    virtual void InitEngineObjects() {}
 
 
    virtual void UpdateEngineObjects() {}
 
 
    virtual void DrawEngineObjects() {}
 
 
    Map* GetMap() {return map;}
 
 
    ComposedSprite* GetParentComposedSprite() {return parentComposedSprite;}
 
 
    bool IsMapLayer(){ return (parentComposedSprite==nullptr); }
 
 
    LayerKind GetKind() {return kind;}
 
 
    std::string GetName() {return name;}
 
 
    std::vector<jugimap::Parameter>& GetParameters() {return parameters;}
 
 
    int GetZOrder() {return zOrder;}
 
 
    virtual void UpdateBoundingBox(){}
 
 
    Rectf GetBoundingBox(){ return boundingBox;}
 
 
    LayerType GetLayerType(){ return layerType;}
 
 
    //AlignX GetAlignX() {return alignX;}
 
 
    //AlignY GetAlignY() {return alignY;}
 
    StretchingVariant GetStretchingVariant(){ return stretchingVariant;}
 
 
    Vec2i GetAlignPosition(){ return alignPosition; }
 
 
    Vec2f GetAlignOffset(){ return alignOffset; }
 
 
    Vec2f GetLayersPlaneSize(){return layersPlaneSize;}
 
 
    //ParallaxLayerMode GetParallaxLayerMode(){ return parallaxLayerMode;}
 
 
 
 
 
    Vec2f GetParallaxFactor() {return parallaxFactor;}
 
 
    Vec2f GetParallaxOffset(){return parallaxOffset;}
 
 
    //ScreenLayerMode GetScreenLayerMode(){ return screenLayerMode;}
 
 
    //-------
 
    void _SetName(const std::string &_name){ name = _name; }
 
 
    void _SetKind(LayerKind _kind){ kind = _kind; }
 
 
    void _SetLayerType(LayerType _layerType){ layerType = _layerType; }
 
 
    void _SetParallaxFactor(Vec2f _parallaxFactor){ parallaxFactor = _parallaxFactor; }
 
 
    void _SetAlignPosition(Vec2i _alignPosition){ alignPosition = _alignPosition; }
 
 
    void _SetAlignOffset(Vec2f _alignOffset){ alignOffset = _alignOffset; }
 
 
    void _SetAttachToLayer(std::string _attachToLayer){ attachToLayer = _attachToLayer; }
 
 
    void _SetStretchingVariant(StretchingVariant _stretchingVariant){ stretchingVariant = _stretchingVariant;}
 
 
    void _SetZOrder(int _zOrder){ zOrder = _zOrder; }
 
 
protected:
 
    virtual ~Layer(){}
 
    bool UpdateParallaxOffset();
 
    //---
    Rectf boundingBox;
 
private:
 
    Map *map = nullptr;                               // LINK to map
    ComposedSprite *parentComposedSprite = nullptr;   // LINK to parent composed sprite (or nullptr if parent is map).
 
    LayerKind kind = LayerKind::NOT_DEFINED;
    std::string name = "Layer";
    std::vector<jugimap::Parameter> parameters;            // Custom parameters from JugiMap editor.
 
    //---
    int zOrder = 0;                                      // Drawing order of layer sprites (used by some engines)
 
 
 
    //---- properties of layers of the parallax maps
    //ParallaxLayerMode parallaxLayerMode = ParallaxLayerMode::STANDARD;
    LayerType layerType = LayerType::WORLD;
    Vec2i alignPosition;
    Vec2f alignOffset;
    Vec2f parallaxFactor;
    Vec2i tilingCount;
    Vec2i tilingSpacing;
    Vec2i tilingSpacingDelta;
    Vec2i tilingCountAutoSpread;                                                    //boolean Flag
    StretchingVariant stretchingVariant = StretchingVariant::XY_TO_WORLD_SIZE;
 
    Vec2f parallaxOffset;
 
    //---- properties of layers of the screen maps
    //ScreenLayerMode screenLayerMode = ScreenLayerMode::STANDARD;
 
    //---- properties of layers of the parallax and screen maps
    //AlignX alignX = AlignX::MIDDLE;
    //AlignY alignY = AlignY::MIDDLE;
 
 
    //bool alignOffsetX_obtainFromMap = false;
    //bool alignOffsetY_obtainFromMap = false;
    Vec2i alignOffset_obtainFromMap;                                                //boolean Flag
 
    std::string attachToLayer;
    Vec2f layersPlaneSize;
 
 
 
 
 
};
 
 
 
//==================================================================================================
 
 
class SpriteLayer : public Layer
{
public:
    friend class JugiMapBinaryLoader;
    friend class ComposedSprite;
    friend class Map;
 
 
    SpriteLayer();
 
 
    //----
    virtual void InitEngineObjects() override;
    virtual void InitLayerParameters() override;
    virtual void UpdateEngineObjects() override;
    virtual void DrawEngineObjects()override;
 
 
    std::vector<Sprite*>& GetSprites() {return sprites;}
 
 
    virtual void UpdateBoundingBox() override;
 
 
    void SetAlpha(float _alpha);
 
 
    float GetAlpha();
 
 
    void SetBlend(Blend _blend);
 
 
    Blend GetBlend() {return blend;}
 
 
    void AddSprite(Sprite* _sprite);
 
 
    StandardSprite * AddStandardSprite(SourceSprite *_sourceSprite, Vec2f _position);
 
    TextSprite * AddTextSprite(const std::string &_textString, Font* _font, ColorRGBA _color, Vec2f _position, TextHandleVariant _textHandle);
 
 
    virtual void RemoveAndDeleteSprite(Sprite* _sprite);
 
 
    void CaptureForLerpDrawing();
 
 
    int FindLastZOrder();
 
    //-------
 
 
    void SetSpritesChanged(bool _spritesChanged){ spritesChanged = _spritesChanged;}
 
 
    bool IsSpritesChanged(){ return spritesChanged;}
 
 
    void SetSpritesChangeFlag(int _spritesChangeFlag)
    {
        spritesChangeFlag = _spritesChangeFlag;
        if(spritesChangeFlag!=0){
            spritesChanged = true;
        }
    }
 
 
    void AppendToSpritesChangeFlag(int _spritesChangeFlag)
    {
        spritesChangeFlag |= _spritesChangeFlag;
        if(spritesChangeFlag!=0){
            spritesChanged = true;
        }
    }
 
    int GetSpritesChangeFlag(){ return spritesChangeFlag; }
 
 
    //-------
 
 
    bool IsEditorTileLayer(){ return editorTileLayer;}
 
 
protected:
 
    virtual ~SpriteLayer() override;
 
 
private:
 
 
    float alpha = 1.0;                                  // Transparency for sprites: 0 - 1.0
    Blend blend = Blend::ALPHA;                         // Blending mode for sprites: SOLID, ALPHA, ADDITIVE
 
    //---
    std::vector<Sprite*>sprites;                        // OWNED sprites.
    bool editorTileLayer = false;
    bool spritesChanged = false;
    int spritesChangeFlag = 0;
 
 
 
 
    void UpdateSingleSpriteStretch(Vec2i _designSize, bool _stretchX, bool _stretchY);
    bool UpdateStretchingSingleSpriteLayer();
 
};
 
 
//==================================================================================================
 
 
class VectorLayer : public Layer
{
public:
    friend class JugiMapBinaryLoader;
    friend class ComposedSprite;
    friend class Map;
 
 
    VectorLayer();
 
 
    virtual void InitLayerParameters() override;
    virtual void UpdateEngineObjects() override;
 
    virtual void UpdateBoundingBox() override;
 
 
    std::vector<VectorShape*>& GetVectorShapes() {return vectorShapes;}
 
 
    void AddVectorShape(VectorShape* _vs){vectorShapes.push_back(_vs);}
 
 
protected:
 
    virtual ~VectorLayer() override;
 
 
private:
 
    std::vector<VectorShape*>vectorShapes;             //OWNED
 
};
 
 
 
}
 
 
#endif