sprite.h

説明を見る。

/*---------------------------------------------------------------------------------

        sprite.h -- definitions for DS sprites

        Copyright (C) 2007
                Liran Nuna      (LiraNuna)
                Dave Murphy (WinterMute)

        This software is provided 'as-is', without any express or implied
        warranty.  In no event will the authors be held liable for any
        damages arising from the use of this software.

        Permission is granted to anyone to use this software for any
        purpose, including commercial applications, and to alter it and
        redistribute it freely, subject to the following restrictions:

        1.      The origin of this software must not be misrepresented; you
        must not claim that you wrote the original software. If you use
        this software in a product, an acknowledgment in the product
        documentation would be appreciated but is not required.

        2.      Altered source versions must be plainly marked as such, and
        must not be misrepresented as being the original software.

        3.      This notice may not be removed or altered from any source
        distribution.

---------------------------------------------------------------------------------*/
#ifndef _libnds_sprite_h_
#define _libnds_sprite_h_

#ifndef ARM9
#error Sprites are only available on the ARM9
#endif

#include "nds/ndstypes.h"
#include "nds/arm9/video.h"
#include "nds/memory.h"
#include "nds/system.h"

// Sprite control defines

// Attribute 0 consists of 8 bits of Y plus the following flags:
#define ATTR0_NORMAL                    (0<<8)
#define ATTR0_ROTSCALE                  (1<<8)
#define ATTR0_DISABLED                  (2<<8)
#define ATTR0_ROTSCALE_DOUBLE   (3<<8)

#define ATTR0_TYPE_NORMAL               (0<<10)
#define ATTR0_TYPE_BLENDED              (1<<10)
#define ATTR0_TYPE_WINDOWED             (2<<10)
#define ATTR0_BMP                               (3<<10)

#define ATTR0_MOSAIC                    (1<<12)

#define ATTR0_COLOR_16          (0<<13) //16 color in tile mode...16 bit in bitmap mode
#define ATTR0_COLOR_256         (1<<13)

#define ATTR0_SQUARE            (0<<14)
#define ATTR0_WIDE                      (1<<14)
#define ATTR0_TALL                      (2<<14)

#define OBJ_Y(m)                        ((m)&0x00ff)

// Atribute 1 consists of 9 bits of X plus the following flags:
#define ATTR1_ROTDATA(n)      ((n)<<9)  // note: overlaps with flip flags
#define ATTR1_FLIP_X          (1<<12)
#define ATTR1_FLIP_Y          (1<<13)
#define ATTR1_SIZE_8          (0<<14)
#define ATTR1_SIZE_16         (1<<14)
#define ATTR1_SIZE_32         (2<<14)
#define ATTR1_SIZE_64         (3<<14)

#define OBJ_X(m)                        ((m)&0x01ff)

// Atribute 2 consists of the following:
#define ATTR2_PRIORITY(n)     ((n)<<10)
#define ATTR2_PALETTE(n)      ((n)<<12)
#define ATTR2_ALPHA(n)            ((n)<<12)

typedef enum
{
        OBJMODE_NORMAL,         
        OBJMODE_BLENDED,        
        OBJMODE_WINDOWED,       
        OBJMODE_BITMAP,         
} ObjBlendMode;
 
typedef enum {
        OBJSHAPE_SQUARE,        
        OBJSHAPE_WIDE,          
        OBJSHAPE_TALL,          
        OBJSHAPE_FORBIDDEN,     
} ObjShape;
 
typedef enum {
        OBJSIZE_8,              
        OBJSIZE_16,             
        OBJSIZE_32,             
        OBJSIZE_64,             
} ObjSize;

typedef enum {
        OBJCOLOR_16,            
        OBJCOLOR_256,           
} ObjColMode;

typedef enum {
        OBJPRIORITY_0,          
        OBJPRIORITY_1,          
        OBJPRIORITY_2,          
        OBJPRIORITY_3,          
} ObjPriority;

typedef union SpriteEntry {
        struct {
 
                struct {
                        u16 y                                           :8;     
                        union {
                                struct {
                                        u8                                              :1;
                                        bool isHidden                   :1;     
                                        u8                                              :6;
                                };
                                struct {
                                        bool isRotateScale              :1;     
                                        bool isSizeDouble                       :1;     
                                        ObjBlendMode blendMode          :2;     
                                        bool isMosaic                   :1;     
                                        ObjColMode colorMode            :1;     
                                        ObjShape shape          :2;     
                                };
                        };
                };
 
                union {
                        struct {
                                u16 x                                   :9;     
                                u8                                                      :7;
                        };
                        struct {
                                u8                                                      :8;
                                union {
                                        struct {
                                                u8                                      :4;
                                                bool hFlip                      :1; 
                                                bool vFlip                      :1; 
                                                u8                                      :2;
                                        };
                                        struct {
                                                u8                                      :1;
                                                u8 rotationIndex                :5; 
                                                ObjSize size    :2; 
                                        };
                                };
                        };
                };
 
                struct {
                        u16 gfxIndex                                            :10;
                        ObjPriority priority            :2;     
                                u8 palette                                              :4;     
                };
 
                u16 attribute3;                                                 
        };
 
        struct {
                uint16 attribute[3];
                uint16 filler;
        };
 
} SpriteEntry, * pSpriteEntry;

typedef struct SpriteRotation {
  uint16 filler1[3]; 
  int16 hdx;             
  uint16 filler2[3];  
  int16 hdy;              
  uint16 filler3[3];  
  int16 vdx;              
  uint16 filler4[3];  
  int16 vdy;                    
} SpriteRotation, * pSpriteRotation;

#define SPRITE_COUNT 128
#define MATRIX_COUNT 32


typedef union OAMTable {
        SpriteEntry oamBuffer[SPRITE_COUNT];
        SpriteRotation matrixBuffer[MATRIX_COUNT];
} OAMTable;
 
typedef enum {
   SpriteSize_8x8   = (OBJSIZE_8 << 14) | (OBJSHAPE_SQUARE << 12) | (8*8>>5), 
   SpriteSize_16x16 = (OBJSIZE_16 << 14) | (OBJSHAPE_SQUARE << 12) | (16*16>>5), 
   SpriteSize_32x32 = (OBJSIZE_32 << 14) | (OBJSHAPE_SQUARE << 12) | (32*32>>5), 
   SpriteSize_64x64 = (OBJSIZE_64 << 14) | (OBJSHAPE_SQUARE << 12) | (64*64>>5), 
   SpriteSize_16x8  = (OBJSIZE_8 << 14)  | (OBJSHAPE_WIDE << 12) | (16*8>>5),
   SpriteSize_32x8  = (OBJSIZE_16 << 14) | (OBJSHAPE_WIDE << 12) | (32*8>>5),
   SpriteSize_32x16 = (OBJSIZE_32 << 14) | (OBJSHAPE_WIDE << 12) | (32*16>>5),
   SpriteSize_64x32 = (OBJSIZE_64 << 14) | (OBJSHAPE_WIDE << 12) | (64*32>>5),
   SpriteSize_8x16  = (OBJSIZE_8 << 14)  | (OBJSHAPE_TALL << 12) | (8*16>>5),
   SpriteSize_8x32  = (OBJSIZE_16 << 14) | (OBJSHAPE_TALL << 12) | (8*32>>5),
   SpriteSize_16x32 = (OBJSIZE_32 << 14) | (OBJSHAPE_TALL << 12) | (16*32>>5),
   SpriteSize_32x64 = (OBJSIZE_64 << 14) | (OBJSHAPE_TALL << 12) | (32*64>>5)
}SpriteSize;

#define SPRITE_SIZE_SHAPE(size) (((size) >> 12) & 0x3)
#define SPRITE_SIZE_SIZE(size)  (((size) >> 14) & 0x3)
#define SPRITE_SIZE_PIXELS(size) (((size) & 0xFFF) << 5)

typedef enum{
   SpriteMapping_1D_32 = DISPLAY_SPR_1D | DISPLAY_SPR_1D_SIZE_32 | (0 << 28) | 0, 
   SpriteMapping_1D_64 = DISPLAY_SPR_1D | DISPLAY_SPR_1D_SIZE_64 | (1 << 28) | 1,
   SpriteMapping_1D_128 = DISPLAY_SPR_1D | DISPLAY_SPR_1D_SIZE_128 | (2 << 28) | 2,
   SpriteMapping_1D_256 = DISPLAY_SPR_1D | DISPLAY_SPR_1D_SIZE_256 | (3 << 28) | 3,
   SpriteMapping_2D = DISPLAY_SPR_2D | (4 << 28),
   SpriteMapping_Bmp_1D_128 = DISPLAY_SPR_1D | DISPLAY_SPR_1D_SIZE_128 | DISPLAY_SPR_1D_BMP |DISPLAY_SPR_1D_BMP_SIZE_128 | (5 << 28) | 2,
   SpriteMapping_Bmp_1D_256 = DISPLAY_SPR_1D | DISPLAY_SPR_1D_SIZE_256 | DISPLAY_SPR_1D_BMP |DISPLAY_SPR_1D_BMP_SIZE_256 | (6 << 28) | 3,
   SpriteMapping_Bmp_2D_128 = DISPLAY_SPR_2D | DISPLAY_SPR_2D_BMP_128 | (7 << 28) | 2,
   SpriteMapping_Bmp_2D_256 = DISPLAY_SPR_2D | DISPLAY_SPR_2D_BMP_256 | (8 << 28) | 3
}SpriteMapping;

typedef enum{
   SpriteColorFormat_16Color = OBJCOLOR_16,
   SpriteColorFormat_256Color = OBJCOLOR_256,
   SpriteColorFormat_Bmp = OBJMODE_BITMAP
}SpriteColorFormat;


typedef struct AllocHeader
{
   u16 nextFree;
   u16 size;
}AllocHeader;

typedef struct OamState
{
        int gfxOffsetStep; 
        s16 firstFree;
        AllocHeader *allocBuffer; 
        s16 allocBufferSize; 
        union
   {
       SpriteEntry *oamMemory; 
           SpriteRotation *oamRotationMemory; 
   };
   SpriteMapping spriteMapping;

}OamState;

#ifdef __cplusplus
extern "C" {
#endif

extern OamState oamMain;
extern OamState oamSub;

void oamInit(OamState* oam, SpriteMapping mapping, bool extPalette);

void oamDisable(OamState* oam );
void oamEnable(OamState* oam );

u16* oamGetGfxPtr(OamState* oam, int gfxOffsetIndex);

u16* oamAllocateGfx(OamState *oam, SpriteSize size, SpriteColorFormat colorFormat);

void oamFreeGfx(OamState *oam, const void* gfxOffset);

static inline
void oamSetMosaic(unsigned int dx, unsigned int dy) {
        sassert(dx < 16 && dy < 16, "Mosaic range is 0 to 15");
        
        mosaicShadow = ( mosaicShadow & 0x00ff) | (dx << 8)| (dy << 12);
        REG_MOSAIC = mosaicShadow;
}

static inline
void oamSetMosaicSub(unsigned int dx, unsigned int dy){
        sassert(dx < 16 && dy < 16, "Mosaic range is 0 to 15");
        
        mosaicShadowSub = ( mosaicShadowSub & 0x00ff) | (dx << 8)| (dy << 12);
        REG_MOSAIC_SUB = mosaicShadowSub;
}

void oamSet(OamState* oam, int id,  int x, int y, int priority, int palette_alpha, SpriteSize size, SpriteColorFormat format, const void* gfxOffset, int affineIndex, bool sizeDouble, bool hide, bool hflip, bool vflip, bool mosaic);

void oamClear(OamState *oam, int start, int count);

void oamUpdate(OamState* oam);

void oamRotateScale(OamState* oam, int rotId, int angle, int sx, int sy);

static inline
void oamAffineTransformation(OamState* oam, int rotId, int hdx, int hdy, int vdx, int vdy) {
        sassert(rotId >= 0 && rotId < 32, "oamAffineTransformation() rotId is out of bounds, must be 0-31");

        oam->oamRotationMemory[rotId].hdx = hdx >>12;
        oam->oamRotationMemory[rotId].hdy = hdy >>12;
        oam->oamRotationMemory[rotId].vdx = vdx >>12;
        oam->oamRotationMemory[rotId].vdy = vdy >>12;
}

int oamCountFragments(OamState *oam);

void oamAllocReset(OamState *oam);

unsigned int oamGfxPtrToOffset(OamState *oam, const void* offset);


#ifdef __cplusplus
}
#endif

#endif // _libnds_sprite_h_

---