background.h

説明を見る。

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

        background.h -- definitions for DS backgrounds

        Copyright (C) 2007
                Dave Murphy (WinterMute)
                Jason Rogers (Dovoto) 

        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_background_h_
#define _libnds_background_h_

#include <nds/ndstypes.h>
#include <nds/arm9/video.h>
#include <nds/arm9/sassert.h>
#include <nds/memory.h>
#include <nds/dma.h>




typedef struct bg_scroll {
        u16 x;
        u16 y;
} bg_scroll;

typedef struct bg_transform {
    s16 xdx; 
    s16 ydx; 
    s16 xdy; 
    s16 ydy; 
    s32 dx;  
    s32 dy;  
} bg_transform;

typedef struct bg_attribute {
    u16 control[4];
    bg_scroll scroll[4];
    bg_transform bg2_rotation;
    bg_transform bg3_rotation;
} bg_attribute;

#define MAP_BASE_SHIFT 8

#define TILE_BASE_SHIFT 2 

#define BG_TILE_BASE(base) ((base) << TILE_BASE_SHIFT)

#define BG_MAP_BASE(base)  ((base) << MAP_BASE_SHIFT)

#define BG_BMP_BASE(base)  ((base) << MAP_BASE_SHIFT)

#define BG_PRIORITY(n) (n)

#define TILE_PALETTE(n) ((n)<<12)

#define TILE_FLIP_H BIT(10)

#define TILE_FLIP_V BIT(11)

typedef enum
{
   BG_32x32    =  (0 << 14), 
   BG_64x32    =  (1 << 14), 
   BG_32x64    =  (2 << 14), 
   BG_64x64    =  (3 << 14), 
   BG_RS_16x16   =  (0 << 14),  
   BG_RS_32x32   =  (1 << 14),  
   BG_RS_64x64   =  (2 << 14),  
   BG_RS_128x128 =  (3 << 14),  
   BG_BMP8_128x128  = ((0 << 14) | BIT(7)), 
   BG_BMP8_256x256  = ((1 << 14) | BIT(7)),
   BG_BMP8_512x256  = ((2 << 14) | BIT(7)),
   BG_BMP8_512x512  = ((3 << 14) | BIT(7)),
   BG_BMP8_1024x512 = BIT(14),
   BG_BMP8_512x1024 = 0,
   BG_BMP16_128x128  = ((0 << 14) | BIT(7) | BIT(2)),
   BG_BMP16_256x256  = ((1 << 14) | BIT(7) | BIT(2)),
   BG_BMP16_512x256  = ((2 << 14) | BIT(7) | BIT(2)),
   BG_BMP16_512x512  = ((3 << 14) | BIT(7) | BIT(2)),
   BG_MOSAIC_ON   = (BIT(6)),
   BG_MOSAIC_OFF  = (0),
   BG_PRIORITY_0  = (0),
   BG_PRIORITY_1  = (1),
   BG_PRIORITY_2  = (2),
   BG_PRIORITY_3  = (3),
   BG_WRAP_OFF    = (0),
   BG_WRAP_ON     = (1 << 13),
   BG_PALETTE_SLOT0 = 0, 
   BG_PALETTE_SLOT1 = 0, 
   BG_PALETTE_SLOT2 = BIT(13), 
   BG_PALETTE_SLOT3 = BIT(13), 
   BG_COLOR_256 =       0x80,
   BG_COLOR_16          =       0x00
}BackgroundControl;


#define BACKGROUND           (*((bg_attribute *)0x04000008))

#define BG_OFFSET ((bg_scroll *)(0x04000010))

#define BG_MAP_RAM(base)                ((u16*)(((base)*0x800) + 0x06000000))

#define BG_TILE_RAM(base)               ((u16*)(((base)*0x4000) + 0x06000000))

#define BG_BMP_RAM(base)                ((u16*)(((base)*0x4000) + 0x06000000))

#define CHAR_BASE_BLOCK(n)                      (((n)*0x4000)+ 0x06000000)

#define SCREEN_BASE_BLOCK(n)            (((n)*0x800) + 0x06000000)

#define BGCTRL                  ( (vu16*)0x4000008)

#define REG_BG0CNT              (*(vu16*)0x4000008)

#define REG_BG1CNT              (*(vu16*)0x400000A)

#define REG_BG2CNT              (*(vu16*)0x400000C)

#define REG_BG3CNT              (*(vu16*)0x400000E)


#define REG_BGOFFSETS   ( (vu16*)0x4000010)

#define REG_BG0HOFS             (*(vu16*)0x4000010)

#define REG_BG0VOFS             (*(vu16*)0x4000012)

#define REG_BG1HOFS             (*(vu16*)0x4000014)

#define REG_BG1VOFS             (*(vu16*)0x4000016)

#define REG_BG2HOFS             (*(vu16*)0x4000018)

#define REG_BG2VOFS             (*(vu16*)0x400001A)

#define REG_BG3HOFS             (*(vu16*)0x400001C)

#define REG_BG3VOFS             (*(vu16*)0x400001E)

#define REG_BG2PA               (*(vs16*)0x4000020)

#define REG_BG2PB               (*(vs16*)0x4000022)

#define REG_BG2PC               (*(vs16*)0x4000024)

#define REG_BG2PD               (*(vs16*)0x4000026)

#define REG_BG2X                (*(vs32*)0x4000028)

#define REG_BG2Y                (*(vs32*)0x400002C)

#define REG_BG3PA               (*(vs16*)0x4000030)

#define REG_BG3PB               (*(vs16*)0x4000032)

#define REG_BG3PC               (*(vs16*)0x4000034)

#define REG_BG3PD               (*(vs16*)0x4000036)

#define REG_BG3X                (*(vs32*)0x4000038)

#define REG_BG3Y                (*(vs32*)0x400003C)

#define BACKGROUND_SUB       (*((bg_attribute *)0x04001008))

#define BG_OFFSET_SUB ((bg_scroll *)(0x04001010))

#define BG_MAP_RAM_SUB(base)    ((u16*)(((base)*0x800) + 0x06200000))

#define BG_TILE_RAM_SUB(base)   ((u16*)(((base)*0x4000) + 0x06200000))

#define BG_BMP_RAM_SUB(base)    ((u16*)(((base)*0x4000) + 0x06200000))

#define SCREEN_BASE_BLOCK_SUB(n)        (((n)*0x800) + 0x06200000)

#define CHAR_BASE_BLOCK_SUB(n)          (((n)*0x4000)+ 0x06200000)

#define BGCTRL_SUB                              ( (vu16*)0x4001008)

#define REG_BG0CNT_SUB          (*(vu16*)0x4001008)

#define REG_BG1CNT_SUB          (*(vu16*)0x400100A)

#define REG_BG2CNT_SUB          (*(vu16*)0x400100C)

#define REG_BG3CNT_SUB          (*(vu16*)0x400100E)

#define REG_BGOFFSETS_SUB       ( (vu16*)0x4001010)

#define REG_BG0HOFS_SUB         (*(vu16*)0x4001010)

#define REG_BG0VOFS_SUB         (*(vu16*)0x4001012)

#define REG_BG1HOFS_SUB         (*(vu16*)0x4001014)

#define REG_BG1VOFS_SUB         (*(vu16*)0x4001016)

#define REG_BG2HOFS_SUB         (*(vu16*)0x4001018)

#define REG_BG2VOFS_SUB         (*(vu16*)0x400101A)

#define REG_BG3HOFS_SUB         (*(vu16*)0x400101C)

#define REG_BG3VOFS_SUB         (*(vu16*)0x400101E)

#define REG_BG2PA_SUB           (*(vs16*)0x4001020)

#define REG_BG2PB_SUB           (*(vs16*)0x4001022)

#define REG_BG2PC_SUB           (*(vs16*)0x4001024)

#define REG_BG2PD_SUB           (*(vs16*)0x4001026)

#define REG_BG2X_SUB            (*(vs32*)0x4001028)

#define REG_BG2Y_SUB            (*(vs32*)0x400102C)

#define REG_BG3PA_SUB           (*(vs16*)0x4001030)

#define REG_BG3PB_SUB           (*(vs16*)0x4001032)

#define REG_BG3PC_SUB           (*(vs16*)0x4001034)

#define REG_BG3PD_SUB           (*(vs16*)0x4001036)

#define REG_BG3X_SUB            (*(vs32*)0x4001038)

#define REG_BG3Y_SUB            (*(vs32*)0x400103C)

//background state      
typedef struct BgState
{
        int angle;
        s32 centerX;
        s32 centerY;
        s32 scaleX;
        s32 scaleY;
        s32 scrollX;
        s32 scrollY;
        int size;
        int type;
        bool dirty;
        
}BgState;


//id -> register look up tables
extern vuint16* bgControl[8];
extern bg_scroll* bgScrollTable[8];
extern bg_transform* bgTransform[8];
extern BgState bgState[8];

typedef enum
{
        BgType_Text8bpp, 
        BgType_Text4bpp, 
        BgType_Rotation, 
        BgType_ExRotation, 
        BgType_Bmp8, 
        BgType_Bmp16 
}BgType;


typedef enum
{
        BgSize_R_128x128 =   (0 << 14), 
        BgSize_R_256x256 =   (1 << 14), 
        BgSize_R_512x512 =   (2 << 14), 
        BgSize_R_1024x1024 = (3 << 14), 
        BgSize_T_256x256 = (0 << 14) | (1 << 16), 
        BgSize_T_512x256 = (1 << 14) | (1 << 16), 
        BgSize_T_256x512 = (2 << 14) | (1 << 16), 
        BgSize_T_512x512 = (3 << 14) | (1 << 16), 
        BgSize_ER_128x128 = (0 << 14) | (2 << 16), 
        BgSize_ER_256x256 = (1 << 14) | (2 << 16), 
        BgSize_ER_512x512 = (2 << 14) | (2 << 16), 
        BgSize_ER_1024x1024 = (3 << 14) | (2 << 16),
        BgSize_B8_128x128 =  ((0 << 14) | BIT(7) | (3 << 16)),  
        BgSize_B8_256x256 =  ((1 << 14) | BIT(7) | (3 << 16)),  
        BgSize_B8_512x256 =  ((2 << 14) | BIT(7) | (3 << 16)),  
        BgSize_B8_512x512 =  ((3 << 14) | BIT(7) | (3 << 16)),  
        BgSize_B8_1024x512 = (1 << 14) | (3 << 16),                     
        BgSize_B8_512x1024 = (0) | (3 << 16),                                   
        BgSize_B16_128x128 = ((0 << 14) | BIT(7) | BIT(2) | (4 << 16)),  
        BgSize_B16_256x256 = ((1 << 14) | BIT(7) | BIT(2) | (4 << 16)),  
        BgSize_B16_512x256 = ((2 << 14) | BIT(7) | BIT(2) | (4 << 16)),  
        BgSize_B16_512x512 = ((3 << 14) | BIT(7) | BIT(2) | (4 << 16)),  
}BgSize;


#ifdef __cplusplus
extern "C" {
#endif

//internally used for debug assertions
bool bgIsText(int id);
int bgInit_call(int layer, BgType type, BgSize size, int mapBase, int tileBase);
int bgInitSub_call(int layer, BgType type, BgSize size, int mapBase, int tileBase);

void bgUpdate(void);

static inline
void bgSetRotate(int id, int angle)
{
   bgState[id].angle = angle;

   bgState[id].dirty = true;
}



static inline 
void bgRotate(int id, int angle)
{
        sassert(!bgIsText(id), "Cannot Rotate a Text Background");
        
        bgSetRotate(id, angle + bgState[id].angle);
}

static inline 
void bgSet(int id, int angle, s32 sx, s32 sy, s32 scrollX, s32 scrollY, s32 rotCenterX, s32 rotCenterY)
{
    bgState[id].scaleX = sx;
        bgState[id].scaleY = sy;

    bgState[id].scrollX = scrollX;
        bgState[id].scrollY = scrollY;
   
        bgState[id].centerX = rotCenterX;
        bgState[id].centerY = rotCenterY;

        bgState[id].angle = angle;

        bgState[id].dirty = true;
}

static inline 
void bgSetRotateScale(int id, int angle, s32 sx, s32 sy)
{
        bgState[id].scaleX = sx;
        bgState[id].scaleY = sy;
        bgState[id].angle = angle;

        bgState[id].dirty = true;
}

static inline 
void bgSetScale(int id, s32 sx, s32 sy)
{
        sassert(!bgIsText(id), "Cannot Scale a Text Background");
        
        bgState[id].scaleX = sx;
        bgState[id].scaleY = sy;        

        bgState[id].dirty = true;
}

static inline 
int bgInit(int layer, BgType type, BgSize size, int mapBase, int tileBase)
{
    sassert(layer >= 0 && layer <= 3, "Only layers 0 - 3 are supported");
    sassert(tileBase >= 0 && tileBase <= 15, "Background tile base is out of range");
    sassert(mapBase >=0 && mapBase <= 31, "Background Map Base is out of range");
        sassert(layer != 0 || !video3DEnabled(), "Background 0 is currently being used for 3D display");
    sassert(layer > 1 || type == BgType_Text8bpp || type == BgType_Text4bpp, "Incorrect background type for mode");
    //sassert((size != BgSize_B8_512x1024 && size != BgSize_B8_1024x512) || videoGetMode() == 6, "Incorrect background type for mode"); 
        sassert(tileBase == 0 || type < BgType_Bmp8, "Tile base is unused for bitmaps.  Can be offset using mapBase * 16KB");
        sassert((mapBase == 0 || type != BgType_Bmp8) || (size != BgSize_B8_512x1024 && size != BgSize_B8_1024x512), "Large Bitmaps cannot be offset");

        return bgInit_call(layer, type, size, mapBase, tileBase);
}

static inline 
int bgInitSub(int layer, BgType type, BgSize size, int mapBase, int tileBase)
{
    sassert(layer >= 0 && layer <= 3, "Only layers 0 - 3 are supported");
    sassert(tileBase >= 0 && tileBase <= 15, "Background tile base is out of range");
    sassert(mapBase >=0 && mapBase <= 31, "Background Map Base is out of range");
    sassert(layer > 1 || type == BgType_Text8bpp|| type == BgType_Text4bpp , "Incorrect background type for mode");
        sassert(tileBase == 0 || type < BgType_Bmp8, "Tile base is unused for bitmaps.  Can be offset using mapBase * 16KB");
        sassert((size != BgSize_B8_512x1024 && size != BgSize_B8_1024x512), "Sub Display has no large Bitmaps");

        return bgInitSub_call(layer, type, size, mapBase, tileBase);
}

static inline 
vuint16* bgSetControlBits(int id, u16 bits)
{
        *bgControl[id] |= bits; 
        return bgControl[id];
}

static inline 
void  bgClearControlBits(int id, u16 bits)
{
        *bgControl[id] &= ~bits;
}

static inline

void bgWrapOn(int id)
{
   bgSetControlBits(id, BIT(13));
}

static inline

void bgWrapOff(int id)
{
   bgClearControlBits(id, BIT(13));
}
static inline 
void bgSetPriority(int id, unsigned int priority)
{
        sassert(priority < 4, "Priority must be less than 4");
        
        *bgControl[id] &= ~ 3;
        *bgControl[id] |= priority;
        
}

static inline 
void bgSetMapBase(int id, unsigned int base)
{
        sassert(base <= 31, "Map base cannot exceed 31");

        *bgControl[id] &= ~ (31 << MAP_BASE_SHIFT);
        *bgControl[id] |= base << MAP_BASE_SHIFT;
}

static inline 
void bgSetTileBase(int id, unsigned int base)
{
        sassert(base <= 15, "Tile base cannot exceed 15");

        *bgControl[id] &= ~ (15 << TILE_BASE_SHIFT);
        *bgControl[id] |= base << TILE_BASE_SHIFT;
}


static inline 
void bgSetScrollf(int id, s32 x, s32 y)
{
        
        bgState[id].scrollX = x;
        bgState[id].scrollY = y;
        
        bgState[id].dirty = true;
}

static inline 
void bgSetScroll(int id, int x, int y)
{
                bgSetScrollf(id, x << 8, y << 8);
}


static inline 
void bgMosaicEnable(int id)
{
        *bgControl[id] |= BIT(6);
}

static inline 
void bgMosaicDisable(int id)
{
        *bgControl[id] &= ~BIT(6);
}

static inline 
void bgSetMosaic(unsigned int dx, unsigned int dy) {
        sassert(dx < 16 && dy < 16, "Mosaic range is 0 to 15");
        
        mosaicShadow = ( mosaicShadow & 0xff00) | (dx | (dy << 4));
        REG_MOSAIC = mosaicShadow;

}

static inline
void bgSetMosaicSub(unsigned int dx, unsigned int dy) {
        sassert(dx < 16 && dy < 16, "Mosaic range is 0 to 15");

        mosaicShadowSub = ( mosaicShadowSub & 0xff00) | (dx | (dy << 4));
        REG_MOSAIC_SUB = mosaicShadowSub;

}

static inline 
int bgGetPriority(int id)
{
        return *bgControl[id] & 3;
}

static inline 
int bgGetMapBase(int id)
{
        return (*bgControl[id] >> MAP_BASE_SHIFT) & 31;
}

static inline 
int bgGetTileBase(int id)
{
        return (*bgControl[id] >> TILE_BASE_SHIFT) & 31;
}

static inline 
u16* bgGetMapPtr(int id) 
{
        return (id < 4) ? ((u16*)BG_MAP_RAM(bgGetMapBase(id))) : ((u16*)BG_MAP_RAM_SUB(bgGetMapBase(id)));
}

static inline 
u16* bgGetGfxPtr(int id) 
{
        if(bgState[id].type < BgType_Bmp8)
                return (id < 4) ? (u16*)(BG_TILE_RAM(bgGetTileBase(id))) : ((u16*)BG_TILE_RAM_SUB(bgGetTileBase(id)));
        else
                return (id < 4) ? (u16*)(BG_GFX + 0x2000 * (bgGetMapBase(id))) : (u16*)(BG_GFX_SUB + 0x2000 * (bgGetMapBase(id)));
}


static inline 
void bgScrollf(int id, s32 dx, s32 dy)
{       
        bgSetScrollf(id, bgState[id].scrollX + dx, bgState[id].scrollY + dy);
}

static inline 
void bgScroll(int id, int dx, int dy)
{       
        bgScrollf(id, dx << 8, dy << 8);
}

static inline 
void bgShow(int id)
{
        if(id < 4)
                videoBgEnable(id);
        else
                videoBgEnableSub(id & 3);
}

static inline 
void bgHide(int id)
{
        if(id < 4)
                videoBgDisable(id);
        else
                videoBgDisableSub(id & 3);
}

static inline 
void bgSetCenterf(int id, s32 x, s32 y)
{
        sassert(!bgIsText(id), "Text Backgrounds have no Center of Rotation");
                 
        bgState[id].centerX = x;
        bgState[id].centerY = y;

        bgState[id].dirty = true;
}

static inline 
void bgSetCenter(int id, int x, int y)
{
        bgSetCenterf(id, x << 8, y << 8);
}

#ifdef __cplusplus
}
#endif

#endif

---