sprite_eng_legacy.h

Go to the documentation of this file.

 
#if     LEGACY_SPRITE_ENGINE
 
#ifndef _SPRITE_ENG_LEGACY_H_
#define _SPRITE_ENG_LEGACY_H_
 
#include "vdp_tile.h"
#include "vdp_spr.h"
#include "pal.h"
#include "pool.h"
 
 
#define COLLISION_TYPE_NONE     0
#define COLLISION_TYPE_BOX      1
#define COLLISION_TYPE_CIRCLE   2
 
#define SPR_FLAG_INSERT_HEAD                    0x4000
#define SPR_FLAG_DISABLE_DELAYED_FRAME_UPDATE   0x2000
#define SPR_FLAG_AUTO_VRAM_ALLOC                0x1000
#define SPR_FLAG_AUTO_SPRITE_ALLOC              0x0800
#define SPR_FLAG_AUTO_TILE_UPLOAD               0x0400
#define SPR_FLAG_AUTO_VISIBILITY                0x0200
#define SPR_FLAG_FAST_AUTO_VISIBILITY           0x0100
 
#define SPR_FLAG_MASK                           (SPR_FLAG_INSERT_HEAD | SPR_FLAG_DISABLE_DELAYED_FRAME_UPDATE | SPR_FLAG_AUTO_VRAM_ALLOC | SPR_FLAG_AUTO_SPRITE_ALLOC | SPR_FLAG_AUTO_TILE_UPLOAD | SPR_FLAG_AUTO_VISIBILITY | SPR_FLAG_FAST_AUTO_VISIBILITY)
 
#define SPR_MIN_DEPTH       (-0x8000)
#define SPR_MAX_DEPTH       0x7FFF
 
typedef enum
{
    VISIBLE,        
    HIDDEN,         
    AUTO_FAST,      
    AUTO_SLOW,      
} SpriteVisibility;
 
typedef struct
{
    s8 x;
    s8 y;
    u8 w;
    u8 h;
} BoxCollision;
 
typedef struct
{
    s8 x;
    s8 y;
    u16 ray;
} CircleCollision;
 
typedef struct _collision
{
    u8 typeHit;
    u8 typeAttack;
    union
    {
        BoxCollision box;
        CircleCollision circle;
    } hit;
    union
    {
        BoxCollision box;
        CircleCollision circle;
    } attack;
} Collision;
 
typedef struct
{
    u8 offsetY;          // respect VDP sprite field order, may help
    u8 offsetYFlip;
    u8 size;
    u8 offsetX;
    u8 offsetXFlip;
    u8 numTile;
}  FrameVDPSprite;
 
typedef struct
{
    u8 numSprite;
    u8 timer;
    TileSet* tileset;                   // TODO: have a tileset per VDP sprite --> probably not a good idea performance wise
    Collision* collision;               // Require many DMA queue operations and fast DMA flush as well, also bring extra computing in calculating delayed update
    FrameVDPSprite frameVDPSprites[];
} AnimationFrame;
 
typedef struct
{
    u8 numFrame;
    u8 loop;
    AnimationFrame** frames;
} Animation;
 
typedef struct
{
    u16 w;
    u16 h;
    Palette* palette;
    u16 numAnimation;
    Animation** animations;
    u16 maxNumTile;
    u16 maxNumSprite;
} SpriteDefinition;
 
typedef struct Sprite
{
    u16 status;
    u16 visibility;
    const SpriteDefinition* definition;
    void (*onFrameChange)(struct Sprite* sprite);
    Animation* animation;
    AnimationFrame* frame;
    s16 animInd;
    s16 frameInd;
    u16 timer;
    s16 x;
    s16 y;
    s16 depth;
    u16 attribut;
    u16 VDPSpriteIndex;
    VDPSprite* lastVDPSprite;
    u16 lastNumSprite;
    s16 spriteToHide;
    u32 data;
    struct Sprite* prev;
    struct Sprite* next;
} Sprite;
 
typedef void FrameChangeCallback(Sprite* sprite);
 
extern Pool* spritesPool;
extern Sprite* firstSprite;
extern Sprite* lastSprite;
extern u16 spriteVramSize;
 
 
void SPR_init(void);
void SPR_initEx(u16 vramSize);
void SPR_end(void);
bool SPR_isInitialized(void);
 
void SPR_reset(void);
 
Sprite* SPR_addSpriteEx(const SpriteDefinition* spriteDef, s16 x, s16 y, u16 attribut, u16 spriteIndex, u16 flag);
Sprite* SPR_addSprite(const SpriteDefinition* spriteDef, s16 x, s16 y, u16 attribut);
Sprite* SPR_addSpriteExSafe(const SpriteDefinition* spriteDef, s16 x, s16 y, u16 attribut, u16 spriteIndex, u16 flag);
Sprite* SPR_addSpriteSafe(const SpriteDefinition* spriteDef, s16 x, s16 y, u16 attribut);
 
void SPR_releaseSprite(Sprite* sprite);
u16 SPR_getNumActiveSprite(void);
void SPR_defragVRAM(void);
u16** SPR_loadAllFrames(const SpriteDefinition* sprDef, u16 index, u16* totalNumTile);
 
bool SPR_setDefinition(Sprite* sprite, const SpriteDefinition* spriteDef);
s16 SPR_getPositionX(Sprite* sprite);
s16 SPR_getPositionY(Sprite* sprite);
void SPR_setPosition(Sprite* sprite, s16 x, s16 y);
void SPR_setHFlip(Sprite* sprite, bool value);
void SPR_setVFlip(Sprite* sprite, bool value);
void SPR_setPalette(Sprite* sprite, u16 value);
void SPR_setPriority(Sprite* sprite, bool value);
#define SPR_setPriorityAttribut(sprite, value)      _Pragma("GCC error \"This method is deprecated, use SPR_setPriority(..) instead.\"")
void SPR_setDepth(Sprite* sprite, s16 value);
void SPR_setZ(Sprite* sprite, s16 value);
void SPR_setAlwaysOnTop(Sprite* sprite);
void SPR_setAnimAndFrame(Sprite* sprite, s16 anim, s16 frame);
void SPR_setAnim(Sprite* sprite, s16 anim);
void SPR_setFrame(Sprite* sprite, s16 frame);
void SPR_nextFrame(Sprite* sprite);
 
bool SPR_setVRAMTileIndex(Sprite* sprite, s16 value);
bool SPR_setSpriteTableIndex(Sprite* sprite, s16 value);
void SPR_setAutoTileUpload(Sprite* sprite, bool value);
void SPR_setDelayedFrameUpdate(Sprite* sprite, bool value);
void SPR_setFrameChangeCallback(Sprite* sprite, FrameChangeCallback* callback);
 
SpriteVisibility SPR_getVisibility(Sprite* sprite);
bool SPR_isVisible(Sprite* sprite, bool recompute);
 
void SPR_setVisibility(Sprite* sprite, SpriteVisibility value);
#define SPR_setAlwaysVisible(sprite, value)     _Pragma("GCC error \"This method is deprecated, use SPR_setVisibility(..) instead.\"")
#define SPR_setNeverVisible(sprite, value)      _Pragma("GCC error \"This method is deprecated, use SPR_setVisibility(..) instead.\"")
#define SPR_computeVisibility(sprite)           _Pragma("GCC error \"This method is deprecated, use SPR_isVisible(sprite, TRUE) instead.\"")
 
void SPR_clear(void);
void SPR_update(void);
 
void SPR_logProfil(void);
void SPR_logSprites(void);
 
 
#endif // _SPRITE_ENG_LEGACY_H_
 
#endif