void OSystem_Wii::setCursorPalette(const byte *colors, uint start, uint num) {
if (!_texMouse.palette) {
printf("switching to palette based cursor\n");
if (!gfx_tex_init(&_texMouse, GFX_TF_PALETTE_RGB5A3, TLUT_MOUSE,
16, 16)) {
printf("could not init the mouse texture\n");
::abort();
}
gfx_tex_set_bilinear_filter(&_texMouse, _bilinearFilter);
}
if (_cursorPaletteDisabled) {
memcpy(_cursorPalette, _texMouse.palette, 256 * 2);
_cursorPaletteDisabled = false;
}
const byte *s = colors;
u16 *d = _texMouse.palette;
for (uint i = 0; i < num; ++i, s += 3)
d[start + i] = Graphics::ARGBToColor<Graphics::ColorMasks<3444> >(0xff, s[0], s[1], s[2]);
_cursorPaletteDirty = true;
}
void OSystem_Wii::initGfx() {
gfx_set_underscan(ConfMan.getInt("wii_video_default_underscan_x"),
ConfMan.getInt("wii_video_default_underscan_y"));
_overlayWidth = gfx_video_get_width();
_overlayHeight = gfx_video_get_height();
#ifndef GAMECUBE
if (CONF_GetAspectRatio() && _fullscreen)
_overlayHeight = 400;
#endif
_overlaySize = _overlayWidth * _overlayHeight * 2;
_overlayPixels = (OverlayColor *) memalign(32, _overlaySize);
memset(&_texMouse, 0, sizeof(gfx_tex_t));
memset(&_texOverlay, 0, sizeof(gfx_tex_t));
memset(&_texGame, 0, sizeof(gfx_tex_t));
_cursorPalette = (u16 *) malloc(256 * 2);
if (!_cursorPalette) {
printf("could not alloc palette buffer\n");
::abort();
}
memset(_cursorPalette, 0, 256 * 2);
if (!gfx_tex_init(&_texOverlay, GFX_TF_RGB5A3, 0,
_overlayWidth, _overlayHeight)) {
printf("could not init the overlay texture\n");
::abort();
}
gfx_coords(&_coordsOverlay, &_texOverlay, GFX_COORD_FULLSCREEN);
}
// TODO this is just my console test app, clean up this mess!
int main(int argc, char *argv[]) {
(void) argc;
(void) argv;
VIDEO_Init();
PAD_Init();
SYS_SetResetCallback(stmcb);
SYS_SetPowerCallback(stmcb);
gfx_video_init(NULL);
gfx_init();
gfx_con_init(NULL);
printf("startup\n");
gfx_tex_t tex;
memset(&tex, 0, sizeof(gfx_tex_t));
if (!gfx_tex_init(&tex, GFX_TF_RGB565, 0, 16, 16)) {
printf("failed to init tex!\n");
return 1;
}
memset(tex.pixels, 0xe070, 16 * 16 * 2);
gfx_tex_flush_texture(&tex);
gfx_screen_coords_t coords_bg;
gfx_coords(&coords_bg, &tex, GFX_COORD_FULLSCREEN);
srand(gettime());
u64 frame = 0;
u16 b;
bool pf = false;
u32 retries;
u8 fg = 7, bg = 0;
u32 i;
char buf[32];
while (!quit) {
b = 0;
if (PAD_ScanPads() & 1) {
b = PAD_ButtonsDown(0);
gfx_con_set_alpha(0xff - PAD_TriggerR(0), 0xff - PAD_TriggerL(0));
}
if (b & PAD_BUTTON_A)
quit = true;
if (b & PAD_BUTTON_B)
pf = !pf;
if (b & PAD_BUTTON_X)
printf(S_RED("Hello") " " S_BLUE("world") "!\n");
if (pf) {
for (i = 0; i < gfx_con_get_columns() * gfx_con_get_rows(); ++i) {
printf(CON_ESC "%u;1m" CON_ESC "%um%c", 30 + IRAND(8),
40 + IRAND(8), 0x20 + IRAND(16 * 9));
}
}
if (b & PAD_TRIGGER_Z) {
gfx_con_reset();
fg = 7;
bg = 0;
}
if (b & 15) {
if (b & PAD_BUTTON_LEFT) {
fg = (fg + 8 - 1) % 8;
gfx_con_set_foreground_color(fg, true);
}
if (b & PAD_BUTTON_RIGHT) {
fg = (fg + 1) % 8;
gfx_con_set_foreground_color(fg, true);
}
if (b & PAD_BUTTON_UP) {
bg = (bg + 8 - 1) % 8;
gfx_con_set_background_color(bg, false);
}
if (b & PAD_BUTTON_DOWN) {
bg = (bg + 1) % 8;
gfx_con_set_background_color(bg, false);
}
printf("new color selected: %u %u\n", fg, bg);
}
sprintf(buf, "frame: %llu", frame);
gfx_con_save_attr();
gfx_con_set_pos(1, gfx_con_get_columns() - strlen(buf) + 1);
printf(CON_COLRESET "%s", buf);
gfx_con_restore_attr();
retries = 0;
while (!gfx_frame_start()) {
retries++;
if (retries > 1000) {
printf("gx hates you\n");
gfx_frame_abort();
return -1;
}
usleep(50);
}
gfx_draw_tex(&tex, &coords_bg);
gfx_con_draw();
gfx_frame_end();
frame++;
}
printf("shutdown\n");
gfx_tex_deinit(&tex);
gfx_con_deinit();
gfx_deinit();
gfx_video_deinit();
return 0;
}
void OSystem_Wii::setMouseCursor(const byte *buf, uint w, uint h, int hotspotX,
int hotspotY, uint32 keycolor,
int cursorTargetScale,
const Graphics::PixelFormat *format) {
gfx_tex_format_t tex_format = GFX_TF_PALETTE_RGB5A3;
uint tw, th;
bool tmpBuf = false;
uint32 oldKeycolor = _mouseKeyColor;
#ifdef USE_RGB_COLOR
if (!format)
_pfCursor = Graphics::PixelFormat::createFormatCLUT8();
else
_pfCursor = *format;
if (_pfCursor.bytesPerPixel > 1) {
tex_format = GFX_TF_RGB5A3;
_mouseKeyColor = keycolor & 0xffff;
tw = ROUNDUP(w, 4);
th = ROUNDUP(h, 4);
if (_pfCursor != _pfRGB3444)
tmpBuf = true;
} else {
#endif
_mouseKeyColor = keycolor & 0xff;
tw = ROUNDUP(w, 8);
th = ROUNDUP(h, 4);
#ifdef USE_RGB_COLOR
}
#endif
if (!gfx_tex_init(&_texMouse, tex_format, TLUT_MOUSE, tw, th)) {
printf("could not init the mouse texture\n");
::abort();
}
gfx_tex_set_bilinear_filter(&_texMouse, _bilinearFilter);
if ((tw != w) || (th != h))
tmpBuf = true;
if (!tmpBuf) {
gfx_tex_convert(&_texMouse, buf);
} else {
u8 bpp = _texMouse.bpp >> 3;
byte *tmp = (byte *) malloc(tw * th * bpp);
if (!tmp) {
printf("could not alloc temp cursor buffer\n");
::abort();
}
if (bpp > 1)
memset(tmp, 0, tw * th * bpp);
else
memset(tmp, _mouseKeyColor, tw * th);
#ifdef USE_RGB_COLOR
if (bpp > 1) {
if (!Graphics::crossBlit(tmp, buf,
tw * _pfRGB3444.bytesPerPixel,
w * _pfCursor.bytesPerPixel,
tw, th, _pfRGB3444, _pfCursor)) {
printf("crossBlit failed (cursor)\n");
::abort();
}
// nasty, shouldn't the frontend set the alpha channel?
u16 *s = (u16 *) buf;
u16 *d = (u16 *) tmp;
for (u16 y = 0; y < h; ++y) {
for (u16 x = 0; x < w; ++x) {
if (*s++ != _mouseKeyColor)
*d++ |= 7 << 12;
else
d++;
}
d += tw - w;
}
} else {
#endif
byte *dst = tmp;
do {
memcpy(dst, buf, w * bpp);
buf += w * bpp;
dst += tw * bpp;
} while (--h);
#ifdef USE_RGB_COLOR
}
#endif
gfx_tex_convert(&_texMouse, tmp);
free(tmp);
}
_mouseHotspotX = hotspotX;
_mouseHotspotY = hotspotY;
_cursorScale = cursorTargetScale;
if ((_texMouse.palette) && (oldKeycolor != _mouseKeyColor))
_cursorPaletteDirty = true;
}
void OSystem_Wii::initSize(uint width, uint height,
const Graphics::PixelFormat *format) {
bool update = false;
gfx_tex_format_t tex_format;
#ifdef USE_RGB_COLOR
Graphics::PixelFormat newFormat;
if (format)
newFormat = *format;
else
newFormat = Graphics::PixelFormat::createFormatCLUT8();
if (newFormat.bytesPerPixel > 2)
newFormat = Graphics::PixelFormat::createFormatCLUT8();
if (_pfGame != newFormat) {
_pfGame = newFormat;
update = true;
}
#endif
uint newWidth, newHeight;
if (_pfGame.bytesPerPixel > 1) {
newWidth = ROUNDUP(width, 4);
newHeight = ROUNDUP(height, 4);
} else {
newWidth = ROUNDUP(width, 8);
newHeight = ROUNDUP(height, 4);
}
if (_gameWidth != newWidth || _gameHeight != newHeight) {
assert((newWidth <= 640) && (newHeight <= 480));
if (width != newWidth || height != newHeight)
printf("extending texture for compability: %ux%u -> %ux%u\n",
width, height, newWidth, newHeight);
_gameWidth = newWidth;
_gameHeight = newHeight;
update = true;
}
if (_gameRunning) {
switchVideoMode(_configGraphicsMode);
if (_arCorrection && (_gameWidth == 320) && (_gameHeight == 200))
gfx_set_ar(320.0 / 240.0);
else
gfx_set_ar(f32(_gameWidth) / f32(_gameHeight));
}
if (update) {
free(_gamePixels);
tex_format = GFX_TF_PALETTE_RGB565;
#ifdef USE_RGB_COLOR
if (_pfGame.bytesPerPixel > 1) {
tex_format = GFX_TF_RGB565;
_pfGameTexture = _pfRGB565;
}
printf("initSize %u*%u*%u (%u%u%u -> %u%u%u match: %d)\n",
_gameWidth, _gameHeight, _pfGame.bytesPerPixel * 8,
8 - _pfGame.rLoss, 8 - _pfGame.gLoss, 8 - _pfGame.bLoss,
8 - _pfGameTexture.rLoss, 8 - _pfGameTexture.gLoss,
8 - _pfGameTexture.bLoss, _pfGame == _pfGameTexture);
_gamePixels = (u8 *) memalign(32, _gameWidth * _gameHeight *
_pfGame.bytesPerPixel);
memset(_gamePixels, 0, _gameWidth * _gameHeight *
_pfGame.bytesPerPixel);
#else
printf("initSize %u*%u\n", _gameWidth, _gameHeight);
_gamePixels = (u8 *) memalign(32, _gameWidth * _gameHeight);
memset(_gamePixels, 0, _gameWidth * _gameHeight);
#endif
if (!gfx_tex_init(&_texGame, tex_format, TLUT_GAME,
_gameWidth, _gameHeight)) {
printf("could not init the game texture\n");
::abort();
}
gfx_tex_set_bilinear_filter(&_texGame, _bilinearFilter);
gfx_coords(&_coordsGame, &_texGame, GFX_COORD_FULLSCREEN);
updateScreenResolution();
}
}
