jmGlobal.h

#ifndef JUGIMAP_GLOBAL_H
#define JUGIMAP_GLOBAL_H
 
#include <chrono>
#include "jmCommon.h"
 
 
 
namespace jugimap {
 
 
 
 
enum class FileKind
{
    SINGLE_IMAGE,                   
    TILE_SHEET_IMAGE,               
    SPRITE_SHEET_IMAGE,             
    SPINE_FILE,                     
    SPRITER_FILE,                   
    SPRITE_TEXT_CONTAINER,          
    NOT_DEFINED                     
};
 
 
enum class SpriteKind
{
    STANDARD,                       
    COMPOSED,                       
    TEXT,                           
    SPINE,                          
    SPRITER,                        
    NOT_DEFINED                     
};
 
 
enum class MapType
{
    WORLD,                  
    PARALLAX,               
    SCREEN,                 
};
 
 
enum class LayerKind
{
    SPRITE,                     
    VECTOR,                     
    DRAWING,                    
    //TEXT,                       ///< %Text layer - TextLayer object.
    CUSTOM,                     
    NOT_DEFINED                 
};
 
 
 
enum class LayerType
{
    WORLD,
    PARALLAX,
    PARALLAX_STRETCHING_SINGLE_SPRITE,
    SCREEN,
    SCREEN_STRETCHING_SINGLE_SPRITE
};
 
 
 
enum class StretchingVariant
{
    XY_TO_WORLD_SIZE,
    XY_TO_VIEWPORT_SIZE
};
 
 
enum class AlignX
{
    LEFT,                               
    MIDDLE,                             
    RIGHT                               
};
 
enum class AlignY
{
    TOP,                                
    MIDDLE,                             
    BOTTOM                              
};
 
 
enum class Blend
{
    SOLID,                              
    ALPHA,                              
    MULTIPLY,                           
    ADDITIVE,                           
    NOT_DEFINED                         
};
 
 
enum class ColorOverlayBlend
{
    SIMPLE_MULTIPLY,                    
    NORMAL,                             
    MULTIPLY,                           
    LINEAR_DODGE,                       
    COLOR,                              
    NOT_DEFINED                         
};
 
 
enum class FontKind
{
    TRUE_TYPE,                          
    BITMAP_FONT__FNT,
    NOT_DEFINED                         
};
 
 
enum class ShapeKind
{
    POLYLINE,                   
    BEZIER_POLYCURVE,           
    ELLIPSE,                    
    SINGLE_POINT,               
    NOT_DEFINED                 
};
 
 
 
enum class AnimationKind
{
    FRAME_ANIMATION = 0,        
    TIMELINE_ANIMATION = 1,     
    NOT_DEFINED = -1
};
 
 
//==================================================================================
 
 
enum class AnimationTrackKind
{
    TRANSLATION,                
    SCALING,                    
    ROTATION,                   
    ALPHA_CHANGE,               
    OVERLAY_COLOR_CHANGE,       
    PATH_MOVEMENT,              
    FRAME_CHANGE,               
    FRAME_ANIMATION,            
    TIMELINE_ANIMATION,         
    FLIP_HIDE,                  
    META,                       
    NOT_DEFINED                 
 
};
 
 
 
 
enum class AnimationPlayerState
{
    IDLE,                       
    PLAYING,                    
    STALLED,                    
    PAUSED,                     
    WAITING_TO_START,           
    WAITING_TO_REPEAT           
};
 
 
 
struct AnimationPlayerFlags
{
 
    static const int NONE = 0;                          
 
    // Play
    static const int DISCARD_ANIMATION_QUEUE = 1;       
    static const int SKIP_SUBPLAYER_UPDATING = 2;       
 
 
 
    // Return flags
    static const int PLAYER_STARTED = 1;                
    static const int PLAYER_UPDATED = 2;                
    static const int PLAYER_STOPPED = 4;                
    static const int ANIMATION_INSTANCE_UPDATED = 8;    
    static const int ANIMATED_PROPERTIES_CHANGED = 16;  
    static const int META_KEY_CHANGED = 32;             
 
};
 
 
 
enum class GuiWidgetKind
{
    NOT_DEFINED,
    BUTTON,                 
    SLIDER,                 
    BAR,                    
    TEXT_FIELD,             
    TEXT_INPUT              
};
 
 
 
enum class TextHandleVariant
{
    CENTER          = 0,
    LEFT_TOP        = 1,
    TOP             = 2,
    RIGHT_TOP       = 3,
    RIGHT           = 4,
    RIGHT_BOTTOM    = 5,
    BOTTOM          = 6,
    LEFT_BOTTOM     = 7,
    LEFT            = 8
};
 
 
TextHandleVariant GetTextHandleVariantFromInt(int _id);
 
 
Vec2f GetRelativeHandleFromTextHandleVariant(TextHandleVariant _thv);
 
 
enum class Engine
{
    NOT_DEFINED,
    AGK,
    SFML,
    Cocos2Dx,
    nCine,
};
 
 
 
class Settings
{
public:
 
 
    void SetEngine(Engine _engine){ engine = _engine; }
    Engine GetEngine(){ return engine; }
 
 
 
    void SetScreenSize(Vec2i _screenSize){ screenSize = _screenSize; }
 
 
    Vec2i GetScreenSize(){ return screenSize; }
 
    //---------------
 
    void SetYCoordinateUp(bool _yCoordinateUp){ yCoordinateUp = _yCoordinateUp;}
 
 
    bool IsYCoordinateUp(){ return yCoordinateUp; }
 
    //---------------
 
    void EnableSpriteColliders(bool _spriteCollidersEnabled){ spriteCollidersEnabled = _spriteCollidersEnabled; }
 
 
    bool SpriteCollidersEnabled(){ return spriteCollidersEnabled; }
 
    //---------------
 
    void EnableEnginePhysics(bool _enginePhysicsEnabled){ enginePhysicsEnabled = _enginePhysicsEnabled; }
 
 
    bool EnginePhysicsEnabled(){ return enginePhysicsEnabled; }
 
    //---------------
 
 
    //void EnableLerpDrawing(bool _lerpDrawingEnabled){ lerpDrawingEnabled = _lerpDrawingEnabled; }
 
 
    //bool LerpDrawingEnabled(){ return lerpDrawingEnabled; }
 
    //---------------
 
    //void SetLerpDrawingFactor(float _lerpDrawingFactor){ lerpDrawingFactor = _lerpDrawingFactor; }
 
 
    //float GetLerpDrawingFactor(){ return lerpDrawingFactor; }
 
 
 
    //---------------
 
    void SetErrorMessage(const std::string &_errorMessage){ errorMessage = _errorMessage; }
 
 
    std::string &GetErrorMessage(){ return errorMessage; }
 
 
 
    //---------------
    void SetZOrderStep(int _zOrderStep){ zOrderStep = _zOrderStep; }
 
    int GetZOrderStep(){ return zOrderStep; }
 
 
 
    //---------------
    void SetMapZOrderStart(int _mapZOrderStart){ mapZOrderStart = _mapZOrderStart; }
 
    int GetMapZOrderStart(){ return mapZOrderStart; }
 
 
    //---------------
    void SetMapZOrderStep(int _mapZOrderStep){ mapZOrderStep = _mapZOrderStep; }
 
    int GetMapZOrderStep(){ return mapZOrderStep; }
 
 
    void SetAppTerminated(bool _appTerminated){ appTerminated = _appTerminated;}
 
 
    bool IsAppTerminated(){ return appTerminated; }
 
 
    //---------------
    int GetRotationSignForYdir(){ return (yCoordinateUp)? 1 : -1; }
 
 
private:
 
    Engine engine = Engine::NOT_DEFINED;
 
    Vec2i screenSize;
    bool yCoordinateUp;
    bool spriteCollidersEnabled = true;
    //bool lerpDrawingEnabled = false;
    bool enginePhysicsEnabled = true;
    std::string errorMessage;
    //float lerpDrawingFactor = 1.0;
    int zOrderStep = 10;
    int mapZOrderStart = 10000;
    int mapZOrderStep = 1000;
 
    bool appTerminated = false;
 
};
 
 
extern Settings settings;
 
 
class Time
{
public:
 
 
    double UpdatePassedTimeMS()
    {
        if(started==false){
            initTimePoint = std::chrono::high_resolution_clock::now();
            started = true;
        }
        passedMicroseconds = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - initTimePoint).count();
        return passedMicroseconds/1000.0;
    }
 
 
    void AddSuspendedTimeMS(int _suspendedTimeMS)
    {
        suspendedTimeMS += _suspendedTimeMS;
    }
 
 
 
    int GetPassedNetTimeMS(){ return passedMicroseconds/1000.0 - suspendedTimeMS; }
 
 
 
    void SetLogicTimeMS(float _logicTimeStepMS){ logicTimeStepMS = _logicTimeStepMS; }
 
 
    float GetLogicTimeMS(){ return logicTimeStepMS; }
 
 
 
 
private:
    std::chrono::high_resolution_clock::time_point initTimePoint;
    unsigned long long passedMicroseconds = 0;
 
    int suspendedTimeMS = 0;
    bool started = false;
    float logicTimeStepMS;
 
};
 
extern Time time;
 
 
 
 
void DeleteGlobalObjects();
 
 
 
 
 
 
}
 
#endif