fries/GRRLIB
1
0
Fork 0
mirror of https://github.com/GRRLIB/GRRLIB.git synced 2024-12-23 02:39:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

lib-conversion moved to trunk, version is now 4.1.0

Browse source
This commit is contained in:
csBlueChip 2009-08-13 17:47:30 +00:00
parent 68a63bf966
commit ee128f47bc
49 changed files with 11249 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
GRRLIB/GRRLIB/-README-.txt Normal file
View file

@ -0,0 +1,18 @@
*** Temporary fix ***
After the release of libogc v1.7.1a, Vector was renamed to guVector
"to avoid collisions" [svn 3650]
...also Quaternion was renamed to guQuaternion - but GRRLIB does not use these!
The main codebase of GRRLIB has been updated to reflect this change.
But until the new libogc is officially released,
if you are using a version of libogc later than v1.7.1a/svn3649,
you will need to add:
-DNOGUFIX
to the compiler flags in your makefile
When the libogc changes are officially released,
this *temporary fix* should be removed [see grrlib.h, line 50ish]
The requirement for -DNOGUFIX will be deprecated,
but its lingering presence will not be a hinderance
Thanks to Nicksasa for reporting this problem :)

133
GRRLIB/GRRLIB/GRRLIB_addon/GRRLIB_addon.c Normal file
View file

@ -0,0 +1,133 @@
/*===========================================
GRRLIB (GX version) 4.0.0 addon
Code : NoNameNo
Additional Code : Crayon & Xane
GX hints : RedShade
===========================================*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <stdarg.h>
#include <string.h>
#include "../lib/libpng/pngu/pngu.h"
#include "GRRLIB.h"
#include <fat.h>
#include "GRRLIB_addon/GRRLIBfont.h"
#include "GRRLIB_addon/GRRLIBbutton.h"
extern u32 fb;
extern void *xfb[2];
extern GXRModeObj *rmode;
GRRLIB_texImg *tex_GRRLIBfont;
GRRLIB_texImg *tex_GRRLIBbutton;
/**
* Initalize all addon requirement
*/
void GRRLIB_addon_Init(){
tex_GRRLIBfont = GRRLIB_LoadTexture(GRRLIBfont);
GRRLIB_InitTileSet(tex_GRRLIBfont, 16, 19, 32);
tex_GRRLIBbutton = GRRLIB_LoadTexture(GRRLIBbutton);
GRRLIB_InitTileSet(tex_GRRLIBbutton, 4, 24, 0);
}
/**
* Free all addon requirement
*/
void GRRLIB_addon_Exit(){
GRRLIB_FreeTexture(tex_GRRLIBfont);
GRRLIB_FreeTexture(tex_GRRLIBbutton);
}
/**
* Load a texture from a file.
* @param filename The JPEG or PNG filename to load.
* @return A GRRLIB_texImg structure filled with image informations.
*/
GRRLIB_texImg *GRRLIB_LoadTextureFromFile(const char *filename) {
fatInitDefault();
FILE *fd = fopen(filename, "rb");
fseek(fd, 0, SEEK_END);
long lsize = ftell(fd);
rewind(fd);
unsigned char *buffer = (unsigned char*) malloc (sizeof(unsigned char)*lsize);
fread (buffer, 1, lsize, fd);
GRRLIB_texImg *tex = GRRLIB_LoadTexture(buffer);
free(buffer);
fclose(fd);
return tex;
}
/**
* Make a PNG screenshot on the SD card.
* libfat is required to use the function.
* @param File name of the file to write.
* @return true if every thing worked, false otherwise.
*/
bool GRRLIB_ScrShot(const char* File) {
int ErrorCode = -1;
IMGCTX pngContext;
if(fatInitDefault() && (pngContext = PNGU_SelectImageFromDevice(File))) {
ErrorCode = PNGU_EncodeFromYCbYCr(pngContext, rmode->fbWidth, rmode->efbHeight, xfb[fb], 0);
PNGU_ReleaseImageContext(pngContext);
}
return !ErrorCode;
}
/**
* Easy Button Maker.
* @param indice Index number of your button.
* @param x top-left corner X position of the button.
* @param y top-left corner Y position of the button.
* @param col color of your button.
* @param wpadx your X wpad posistion.
* @param wpady your Y wpad posistion.
* @param WPADDown your wpad button Down Status.
* @param WPADHeld your wpad button Held Status.
* @param but The wpad button you want to check.
* @param resdown You will find here the downed button index number.
* @param resheld You will find here the helded button index number.
* @param toto Text on the button.
*/
void GRRLIB_addon_Button(int indice, int x,int y,u32 col, int wpadx, int wpady, u32 WPADDown, u32 WPADHeld, int but, int *resdown, int *resheld, char toto[]){
int butwidth=strlen(toto)*16+8;
Vector bg[]={{x+4,y,0},{x+4+strlen(toto)*16,y,0},{x+4+strlen(toto)*16,y+24,0},{x+4,y+24,0}};
if((toto[0]=='^') && ((toto[1]=='U') || (toto[1]=='D') || (toto[1]=='L') || (toto[1]=='R'))){
butwidth=1*16+8;
bg[1].x=x+4+1*16;
bg[2].x=x+4+1*16;
}
GRRLIB_DrawTile(x,y, tex_GRRLIBbutton , 0, 1, 1, col,0 );
GRRLIB_DrawTileQuad(bg, tex_GRRLIBbutton, col,1 );
GRRLIB_DrawTile(bg[1].x,y, tex_GRRLIBbutton , 0, 1, 1, col,2);
if(GRRLIB_PtInRect(x, y, butwidth, 24, wpadx, wpady)) {
if((toto[0]=='^') && (toto[1]=='U')) GRRLIB_Printf(x+4, y+2, tex_GRRLIBfont, 0xFFFFFFFF, 1, "%c", 0xa1);
else if((toto[0]=='^') && (toto[1]=='D')) GRRLIB_Printf(x+4, y+2, tex_GRRLIBfont, 0xFFFFFFFF, 1, "%c", 0xa2);
else if((toto[0]=='^') && (toto[1]=='L')) GRRLIB_Printf(x+4, y+2, tex_GRRLIBfont, 0xFFFFFFFF, 1, "%c", 0xa3);
else if((toto[0]=='^') && (toto[1]=='R')) GRRLIB_Printf(x+4, y+2, tex_GRRLIBfont, 0xFFFFFFFF, 1, "%c", 0xa4);
else GRRLIB_Printf(x+4, y+2, tex_GRRLIBfont, 0xFFFFFFFF, 1, toto);
if(WPADDown & but) {
*resdown=indice;
}
if(WPADHeld & but) {
*resheld=indice;
}
}
else{
if((toto[0]=='^') && (toto[1]=='U')) GRRLIB_Printf(x+4, y+2, tex_GRRLIBfont, 0xFFFFFF77, 1, "%c", 0xa1);
else if((toto[0]=='^') && (toto[1]=='D')) GRRLIB_Printf(x+4, y+2, tex_GRRLIBfont, 0xFFFFFF77, 1, "%c", 0xa2);
else if((toto[0]=='^') && (toto[1]=='L')) GRRLIB_Printf(x+4, y+2, tex_GRRLIBfont, 0xFFFFFF77, 1, "%c", 0xa3);
else if((toto[0]=='^') && (toto[1]=='R')) GRRLIB_Printf(x+4, y+2, tex_GRRLIBfont, 0xFFFFFF77, 1, "%c", 0xa4);
else GRRLIB_Printf(x+4, y+2, tex_GRRLIBfont, 0xFFFFFF77, 1, toto);
}
}

33
GRRLIB/GRRLIB/GRRLIB_addon/GRRLIB_addon.h Normal file
View file

@ -0,0 +1,33 @@
/*===========================================
GRRLIB (GX version) 4.0.0 addon
Code : NoNameNo
Additional Code : Crayon & Xane
GX hints : RedShade
===========================================*/
#ifndef __GRRLIB_ADDON__
#define __GRRLIB_ADDON__
/**
* @file GRRLIBaddon.h
* GRRLIB library.
*/
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
void GRRLIB_addon_Init();
void GRRLIB_addon_Exit();
GRRLIB_texImg *GRRLIB_LoadTextureFromFile(const char *filename);
bool GRRLIB_ScrShot(const char*);
void GRRLIB_addon_Button(int indice, int x,int y,u32 col, int wpadx, int wpady, u32 WPADDown, u32 WPADHeld, int but, int *resdown, int *resheld, char toto[]);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif

32
GRRLIB/GRRLIB/GRRLIB_addon/GRRLIBbutton.c Normal file
View file

@ -0,0 +1,32 @@
/*
This file was autogenerated by raw2c.
Visit http://www.devkitpro.org
*/
const unsigned char GRRLIBbutton[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xce, 0x32, 0x1c,
0x6a, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52, 0x47, 0x42, 0x00, 0xae, 0xce, 0x1c, 0xe9, 0x00, 0x00,
0x00, 0x06, 0x62, 0x4b, 0x47, 0x44, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xa0, 0xbd, 0xa7, 0x93,
0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13,
0x01, 0x00, 0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, 0x45, 0x07, 0xd9, 0x03,
0x13, 0x02, 0x17, 0x23, 0x58, 0x89, 0x44, 0x6c, 0x00, 0x00, 0x00, 0xf9, 0x49, 0x44, 0x41, 0x54,
0x38, 0xcb, 0xed, 0x93, 0xcd, 0x8d, 0xc5, 0x20, 0x0c, 0x84, 0x07, 0x30, 0x01, 0x29, 0x8d, 0xa4,
0xac, 0x94, 0x96, 0x0a, 0x52, 0x4f, 0x0a, 0x48, 0x0b, 0xf9, 0x01, 0x0c, 0xde, 0x43, 0x44, 0xf4,
0x0e, 0x79, 0x64, 0xf7, 0xbe, 0x96, 0x10, 0x17, 0x7f, 0xf2, 0x8c, 0x19, 0x14, 0x00, 0x2c, 0xcb,
0x22, 0x22, 0x02, 0x11, 0xc1, 0x53, 0x29, 0xa5, 0xa0, 0x94, 0xc2, 0x30, 0x0c, 0x4a, 0xcd, 0xf3,
0x2c, 0x31, 0x46, 0xe4, 0x9c, 0x91, 0x73, 0x7e, 0x04, 0x8c, 0x31, 0x30, 0xc6, 0xa0, 0xeb, 0x3a,
0xd0, 0xbe, 0xef, 0x08, 0x21, 0x80, 0x99, 0x9b, 0x00, 0x11, 0x81, 0x99, 0x41, 0xc7, 0x71, 0xe0,
0x3c, 0x4f, 0xa4, 0x94, 0x9a, 0x80, 0xb5, 0x16, 0xa5, 0x14, 0x50, 0x8c, 0x11, 0x21, 0x84, 0x57,
0xa0, 0x94, 0x02, 0xad, 0xf5, 0x05, 0xc4, 0x18, 0x5f, 0x01, 0x11, 0xb9, 0xa4, 0xa5, 0x94, 0x50,
0x0f, 0x33, 0x3f, 0x02, 0x44, 0x74, 0xdf, 0x14, 0x42, 0x40, 0x9d, 0xf2, 0x0d, 0xc8, 0x39, 0x43,
0x44, 0x2e, 0x49, 0xcc, 0x8c, 0xea, 0xa3, 0x94, 0xf2, 0x15, 0xb8, 0x27, 0x7c, 0xca, 0x69, 0x79,
0xd0, 0x5a, 0x23, 0xa5, 0x74, 0x01, 0xcc, 0xfc, 0xea, 0xe1, 0x06, 0x6a, 0x73, 0x6b, 0x4b, 0x55,
0xbf, 0xb5, 0x16, 0xb4, 0xae, 0x2b, 0xb6, 0x6d, 0xc3, 0x79, 0x9e, 0xcd, 0x09, 0xde, 0x7b, 0xf4,
0x7d, 0x0f, 0x8d, 0x3f, 0xd6, 0x3f, 0xf0, 0x2b, 0xa0, 0xfe, 0xd7, 0xb7, 0xaa, 0x7d, 0x54, 0x73,
0x52, 0x23, 0xdc, 0x8a, 0x86, 0x31, 0x06, 0xe4, 0x9c, 0xbb, 0x5f, 0xd8, 0x5a, 0xfb, 0x2c, 0x43,
0x6b, 0x78, 0xef, 0xe1, 0x9c, 0x83, 0x02, 0x80, 0x71, 0x1c, 0x25, 0x84, 0xd0, 0x4c, 0xab, 0x73,
0x0e, 0xd3, 0x34, 0xa9, 0x1f, 0x23, 0x30, 0xc3, 0x86, 0xb8, 0x36, 0x6a, 0xe5, 0x00, 0x00, 0x00,
0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
};
const int GRRLIBbutton_size = sizeof(GRRLIBbutton);

14
GRRLIB/GRRLIB/GRRLIB_addon/GRRLIBbutton.h Normal file
View file

@ -0,0 +1,14 @@
/*
This file was autogenerated by raw2c.
Visit http://www.devkitpro.org
*/
//---------------------------------------------------------------------------------
#ifndef _GRRLIBbutton_h_
#define _GRRLIBbutton_h_
//---------------------------------------------------------------------------------
extern const unsigned char GRRLIBbutton[];
extern const int GRRLIBbutton_size;
//---------------------------------------------------------------------------------
#endif //_GRRLIBbutton_h_
//---------------------------------------------------------------------------------

BIN
GRRLIB/GRRLIB/GRRLIB_addon/GRRLIBbutton.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 377 B

231
GRRLIB/GRRLIB/GRRLIB_addon/GRRLIBfont.c Normal file
View file

@ -0,0 +1,231 @@
/*
This file was autogenerated by raw2c.
Visit http://www.devkitpro.org
*/
const unsigned char GRRLIBfont[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x08, 0x06, 0x00, 0x00, 0x00, 0xf8, 0xea, 0xc8,
0x46, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52, 0x47, 0x42, 0x00, 0xae, 0xce, 0x1c, 0xe9, 0x00, 0x00,
0x00, 0x06, 0x62, 0x4b, 0x47, 0x44, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xa0, 0xbd, 0xa7, 0x93,
0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13,
0x01, 0x00, 0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, 0x45, 0x07, 0xd9, 0x03,
0x13, 0x04, 0x1a, 0x0a, 0xab, 0x18, 0xde, 0xff, 0x00, 0x00, 0x0d, 0x67, 0x49, 0x44, 0x41, 0x54,
0x78, 0xda, 0xed, 0x9d, 0xdb, 0x8e, 0xe4, 0xaa, 0x0e, 0x40, 0xbb, 0xba, 0xf3, 0xff, 0x5f, 0x9c,
0x52, 0xce, 0x53, 0xb6, 0x18, 0x0e, 0x10, 0x03, 0x36, 0x18, 0xb2, 0x96, 0x34, 0xd2, 0xa8, 0x3a,
0xdc, 0x6d, 0xc0, 0xe6, 0xf6, 0xf9, 0x31, 0xe0, 0x3c, 0xcf, 0x2b, 0xfe, 0xed, 0x38, 0x8e, 0x4f,
0x4b, 0x98, 0x96, 0xb8, 0xb4, 0xf2, 0x1f, 0xa6, 0x5f, 0x4a, 0xf3, 0xba, 0xae, 0xff, 0xf2, 0xf8,
0xf9, 0x7c, 0x8a, 0x79, 0xbb, 0xae, 0xeb, 0xfa, 0x7e, 0xbf, 0xff, 0x94, 0xe3, 0x0e, 0x7f, 0xff,
0x1e, 0xf3, 0xf7, 0xf7, 0x27, 0x8a, 0xbb, 0xa7, 0xfe, 0x53, 0xe5, 0x49, 0xe5, 0xa7, 0xa5, 0x1d,
0x6b, 0xf3, 0x0f, 0x76, 0xb4, 0xc8, 0x5f, 0x4b, 0x5b, 0xa6, 0xe2, 0xcc, 0xc9, 0x4e, 0x6f, 0xfa,
0x3d, 0xe1, 0x9f, 0x74, 0xa5, 0xe5, 0xef, 0x52, 0xb4, 0xea, 0x7f, 0xf5, 0xf0, 0xf0, 0xaf, 0x5e,
0xd6, 0xd6, 0xd3, 0xca, 0xed, 0x5f, 0xab, 0x3f, 0xde, 0xd2, 0xef, 0xd5, 0xff, 0xd9, 0xfd, 0x87,
0x74, 0xae, 0x50, 0x33, 0xa7, 0xb0, 0x98, 0xb3, 0xf5, 0xce, 0x0f, 0xad, 0xe6, 0x97, 0x16, 0xe9,
0xff, 0xfd, 0xfd, 0xfd, 0x9f, 0xde, 0x97, 0xd2, 0x79, 0xb3, 0xfe, 0x8d, 0x4e, 0x5f, 0x5b, 0xfe,
0xe2, 0x7e, 0x3f, 0xd5, 0xfe, 0xa5, 0x6f, 0xb4, 0xd3, 0x97, 0xd6, 0xef, 0x9d, 0x7e, 0x6f, 0x78,
0x8d, 0xfe, 0xaf, 0x66, 0x2e, 0x96, 0x0b, 0x93, 0xd2, 0x39, 0x8d, 0x3e, 0xaa, 0xd7, 0x0e, 0xb3,
0x9e, 0x27, 0x1d, 0x5e, 0x27, 0x44, 0xb7, 0x20, 0x49, 0x7f, 0x8f, 0x1b, 0x20, 0x37, 0x49, 0x4f,
0x35, 0x40, 0xae, 0x03, 0x09, 0xc3, 0x85, 0x82, 0x12, 0x0a, 0x78, 0xac, 0x00, 0xa5, 0x46, 0x4b,
0x29, 0x72, 0xea, 0xb7, 0x3b, 0x8f, 0x77, 0x9a, 0xf7, 0xdf, 0x5b, 0x05, 0xa2, 0x54, 0x67, 0x92,
0x3c, 0xf6, 0xd2, 0x9b, 0x7f, 0xb0, 0x31, 0x32, 0x5a, 0xda, 0x5b, 0xd2, 0x96, 0x35, 0x71, 0xf6,
0xa6, 0x6f, 0x91, 0xff, 0xd9, 0x6d, 0x32, 0xb2, 0xfc, 0x6f, 0xaf, 0x7f, 0x2f, 0xc4, 0x75, 0xf9,
0xfd, 0x7e, 0x7f, 0xfe, 0xfe, 0xfe, 0x1e, 0xeb, 0xe9, 0x6d, 0xed, 0xef, 0x2d, 0xfd, 0xd5, 0xfb,
0x8f, 0xb7, 0xea, 0x5b, 0xcd, 0x9c, 0xa8, 0xa5, 0x4d, 0x9e, 0x0c, 0xb8, 0x55, 0xdb, 0xff, 0xed,
0xfa, 0xbf, 0xab, 0x2e, 0xc4, 0xe3, 0x4e, 0xae, 0xde, 0x52, 0xba, 0xd3, 0x1b, 0xde, 0x03, 0xdf,
0xef, 0xd7, 0x95, 0x4c, 0xdc, 0x72, 0x6d, 0x9d, 0xa7, 0xc3, 0xab, 0x40, 0x8e, 0xea, 0xb4, 0x47,
0x75, 0x20, 0x39, 0x4f, 0x59, 0x4b, 0xda, 0xa3, 0x07, 0xba, 0x1a, 0xaf, 0x95, 0xd6, 0xea, 0x28,
0xd8, 0xca, 0x79, 0x49, 0x2e, 0xa4, 0x1e, 0x64, 0x4d, 0x39, 0xd5, 0x4c, 0xbf, 0x37, 0xfc, 0x48,
0x7d, 0xf1, 0x58, 0xfe, 0xd5, 0xeb, 0x7f, 0x84, 0xde, 0x58, 0x0c, 0xca, 0xad, 0x4e, 0x00, 0xe4,
0xc7, 0x7f, 0xf8, 0x95, 0xfa, 0x8f, 0xdd, 0xc7, 0x3e, 0xef, 0xf4, 0x4e, 0xfc, 0xd1, 0x3f, 0x79,
0xf8, 0xde, 0xdd, 0x2e, 0xda, 0x06, 0x78, 0xec, 0x44, 0x0a, 0x77, 0x17, 0xd7, 0xce, 0xe9, 0x25,
0x32, 0x94, 0x4b, 0xa3, 0x94, 0x7e, 0x38, 0xfe, 0xf5, 0x86, 0x97, 0xd4, 0x6b, 0x6e, 0x07, 0x81,
0x46, 0x5f, 0x1a, 0x3b, 0x2f, 0x34, 0xf5, 0xae, 0xb5, 0xcf, 0x8d, 0xe7, 0x00, 0x96, 0x4e, 0x80,
0x5f, 0xaf, 0xc6, 0x7f, 0x5c, 0xe0, 0xa7, 0x89, 0x57, 0x5c, 0xd9, 0xe7, 0x79, 0x5e, 0xf7, 0xbf,
0xda, 0x46, 0x39, 0x8e, 0xe3, 0x13, 0xff, 0xb3, 0x32, 0xbe, 0x6a, 0x0c, 0xf4, 0x5a, 0x63, 0xbe,
0x65, 0xb2, 0x6a, 0x39, 0x50, 0x4a, 0xe3, 0x3e, 0xcf, 0xf3, 0x0a, 0x3b, 0x8e, 0xeb, 0xba, 0x2e,
0x9c, 0x09, 0x36, 0xf2, 0x97, 0x6b, 0x93, 0x9c, 0xfe, 0x48, 0xda, 0xb2, 0x46, 0x5f, 0x5a, 0xe5,
0x2d, 0xec, 0x20, 0x2d, 0x65, 0x71, 0xc4, 0x64, 0x6f, 0x66, 0xf9, 0x3d, 0xd7, 0x7f, 0x49, 0xfe,
0xa4, 0xfd, 0x48, 0x4f, 0xf8, 0x91, 0xc6, 0x7f, 0x38, 0x31, 0x4a, 0xe9, 0x67, 0x6e, 0x22, 0xb5,
0x73, 0xfb, 0xaf, 0x90, 0xfe, 0xea, 0xfd, 0xc7, 0x1b, 0xd1, 0xd8, 0xee, 0x2b, 0x31, 0xe0, 0x47,
0x38, 0x1f, 0xde, 0xae, 0x7f, 0xab, 0xcb, 0x7f, 0x4a, 0x0e, 0xe3, 0xbc, 0xa5, 0xf2, 0xaa, 0x2d,
0xbf, 0xa5, 0x39, 0xa1, 0xc4, 0xf0, 0xee, 0x0d, 0x6f, 0x61, 0xfc, 0xb7, 0x96, 0x3d, 0x37, 0xd6,
0xce, 0x98, 0xab, 0x5b, 0xe7, 0xc9, 0xcd, 0x0e, 0x80, 0x9c, 0xd1, 0x60, 0x7d, 0xde, 0xbf, 0xb7,
0x03, 0x89, 0xbd, 0x5c, 0xb1, 0x62, 0xce, 0x98, 0x44, 0x5a, 0xd7, 0xd9, 0x88, 0x01, 0x3a, 0x14,
0xfa, 0xdc, 0xb6, 0x22, 0xf0, 0x69, 0xc4, 0x8c, 0x94, 0xd5, 0xd5, 0x65, 0x7d, 0x76, 0xff, 0x98,
0x5a, 0x7d, 0xa8, 0x1d, 0x34, 0xd1, 0x1b, 0xfd, 0x49, 0xa1, 0xc6, 0x4e, 0x80, 0x9e, 0xf6, 0xab,
0x39, 0x57, 0x3b, 0x6b, 0x8c, 0xa0, 0x9f, 0xa0, 0xfc, 0xbb, 0xf6, 0x5b, 0xde, 0xb6, 0x24, 0x23,
0xff, 0x63, 0xe6, 0xbc, 0xa9, 0x3e, 0xb8, 0x45, 0x7e, 0x43, 0x07, 0x54, 0xcf, 0x2e, 0x00, 0x89,
0xd3, 0xa2, 0x37, 0x7c, 0x8b, 0xf1, 0xaf, 0xa5, 0x17, 0x77, 0xde, 0x35, 0x77, 0x02, 0x68, 0xce,
0x39, 0xac, 0xf3, 0x74, 0xec, 0xa4, 0xe0, 0x2d, 0x77, 0x00, 0x48, 0x27, 0xc0, 0xa5, 0x0e, 0x44,
0x7a, 0x16, 0x3a, 0x25, 0xbc, 0xa9, 0x73, 0x4c, 0xf1, 0xaa, 0xd5, 0xdb, 0x2e, 0xce, 0x8a, 0xeb,
0xc4, 0xda, 0x63, 0x8f, 0x11, 0xc3, 0x44, 0x0e, 0xf6, 0x9b, 0xb4, 0xb5, 0x86, 0x6f, 0xd5, 0x1b,
0xcd, 0x4b, 0x80, 0xa4, 0x4e, 0x00, 0x8d, 0x8b, 0x35, 0x4b, 0x46, 0x08, 0xc0, 0xca, 0xe3, 0x5f,
0x28, 0xc7, 0x23, 0xc7, 0xbf, 0x7b, 0xc2, 0xde, 0xea, 0x5c, 0xf5, 0xae, 0x7b, 0xb3, 0xc7, 0xdf,
0x3b, 0xfd, 0x15, 0xea, 0x4a, 0xda, 0xd7, 0xc7, 0xf2, 0x93, 0x2b, 0x9b, 0x54, 0x7e, 0x6b, 0x17,
0xce, 0x52, 0x67, 0xf9, 0x6b, 0x56, 0xde, 0x7b, 0xc3, 0x8f, 0x36, 0xfe, 0xbd, 0x39, 0x01, 0x52,
0x65, 0x8d, 0xf3, 0xa4, 0x3e, 0xc7, 0x62, 0x98, 0xa8, 0x9b, 0xc8, 0xd5, 0xdc, 0x82, 0x2e, 0x11,
0xde, 0xd2, 0x20, 0xf1, 0x46, 0xc3, 0x37, 0xbe, 0xf8, 0xf0, 0xfe, 0xbf, 0xe4, 0x35, 0x06, 0xcf,
0x72, 0xa3, 0x65, 0xd4, 0xec, 0x68, 0xfc, 0x5b, 0xac, 0x36, 0xce, 0x3c, 0x32, 0xd2, 0xdb, 0x7f,
0x68, 0xf4, 0x3f, 0xb5, 0x83, 0x5f, 0xc9, 0x01, 0x59, 0xea, 0x97, 0x76, 0x98, 0x80, 0x69, 0xe9,
0x8d, 0xb6, 0x6e, 0x5b, 0x5c, 0x0c, 0x28, 0x2d, 0x4f, 0xfc, 0x52, 0x48, 0x8d, 0x3e, 0xf5, 0xea,
0x5e, 0x8d, 0xfc, 0xed, 0x38, 0x0e, 0x68, 0x8c, 0x23, 0x3d, 0x71, 0xac, 0x7e, 0xdc, 0x2e, 0x35,
0x87, 0x18, 0x29, 0x33, 0x29, 0xc3, 0xa7, 0xa5, 0x8f, 0x9c, 0xb5, 0x12, 0x39, 0xbb, 0xfd, 0x2d,
0xfb, 0x0f, 0xcf, 0xf3, 0xa0, 0x27, 0x39, 0xa9, 0x5d, 0xfd, 0x97, 0x8c, 0x07, 0x25, 0x27, 0x44,
0xee, 0x3b, 0x8b, 0xf0, 0xb3, 0x8c, 0x7f, 0x6f, 0x4e, 0x80, 0xb8, 0xac, 0x71, 0x9e, 0x70, 0x00,
0x18, 0x35, 0xbc, 0xd4, 0x00, 0x69, 0xb9, 0x05, 0xbd, 0x56, 0x78, 0xef, 0x06, 0x0f, 0x05, 0xb0,
0xf4, 0x5a, 0x00, 0xc0, 0xca, 0xc6, 0x7f, 0x4d, 0xe7, 0xb6, 0xfa, 0x2e, 0x06, 0x6f, 0xb7, 0x90,
0xb7, 0xac, 0x52, 0x3d, 0x0d, 0x8c, 0x5c, 0xf8, 0x67, 0xef, 0x04, 0xa8, 0x1e, 0xe8, 0x37, 0x1a,
0x2b, 0xd8, 0x1e, 0x0d, 0x2b, 0xc8, 0x4c, 0xcf, 0xa4, 0xdd, 0xab, 0x63, 0xd5, 0x43, 0x9f, 0x18,
0x3a, 0x73, 0x2c, 0xe6, 0xef, 0xb3, 0xed, 0x90, 0x92, 0xfc, 0xd4, 0xac, 0xfe, 0xb7, 0x8c, 0x17,
0xb9, 0x15, 0x67, 0x69, 0x1c, 0xbd, 0xe1, 0x67, 0x18, 0xff, 0x9e, 0x9c, 0x00, 0x71, 0x59, 0xad,
0x9d, 0x00, 0xdb, 0x38, 0x00, 0xa4, 0x97, 0xfd, 0x9d, 0xe7, 0x79, 0xc5, 0x93, 0x21, 0x49, 0xe3,
0xc6, 0xf1, 0xe5, 0x1a, 0xa3, 0x76, 0x12, 0x59, 0x5a, 0xa9, 0x09, 0x9d, 0x00, 0x6f, 0x19, 0xa8,
0xc3, 0xb7, 0x6d, 0x57, 0x3b, 0x02, 0xe0, 0x61, 0x92, 0xbd, 0xc3, 0xb6, 0x7f, 0x8d, 0x7a, 0xd4,
0xba, 0x91, 0x55, 0x2b, 0xaf, 0xab, 0xbf, 0x62, 0x90, 0x4b, 0xbf, 0x76, 0x02, 0xb6, 0xb3, 0xf1,
0x6f, 0xb1, 0x03, 0xa8, 0xe6, 0xf5, 0x0e, 0x0d, 0xc3, 0x63, 0xb4, 0xfc, 0x78, 0x94, 0xff, 0xd9,
0xfd, 0xd7, 0xec, 0xfe, 0x6f, 0x97, 0xfa, 0x8f, 0xfb, 0xa5, 0x91, 0x93, 0xf9, 0x7b, 0xfe, 0xd6,
0xe2, 0xac, 0x8b, 0xfb, 0xd4, 0xd1, 0xaf, 0x18, 0xcc, 0x9e, 0xc7, 0xc4, 0xe9, 0xc7, 0x73, 0xc1,
0x16, 0xa3, 0x78, 0x15, 0xf9, 0xcd, 0x19, 0x7a, 0x2d, 0x72, 0xd4, 0x62, 0x34, 0x96, 0xce, 0xa0,
0x3f, 0xe5, 0xe1, 0x69, 0x17, 0x80, 0x64, 0xd7, 0xf4, 0x2c, 0xe3, 0xdf, 0x83, 0x13, 0x20, 0x57,
0xd6, 0x30, 0x4f, 0x38, 0x00, 0x36, 0x9f, 0x44, 0xa6, 0x84, 0xf0, 0x6d, 0x97, 0xe0, 0xdd, 0xf5,
0x18, 0x3e, 0x95, 0xc8, 0x8a, 0xcf, 0x9e, 0xc6, 0xff, 0x5b, 0xcf, 0x19, 0x7b, 0xb9, 0x85, 0x5c,
0xe3, 0x16, 0xe5, 0x1d, 0x26, 0x60, 0x1a, 0x37, 0x2d, 0x6b, 0x4f, 0x9c, 0x5b, 0xf5, 0x59, 0x23,
0x1f, 0xf7, 0xd8, 0xe3, 0xb5, 0xdd, 0xb8, 0x9f, 0x00, 0x24, 0xf3, 0xa8, 0x58, 0x8f, 0x46, 0xcc,
0x25, 0x52, 0x17, 0x43, 0xb7, 0xe8, 0xd1, 0x6e, 0xc7, 0xab, 0x7a, 0xea, 0x33, 0x3c, 0xd6, 0xa1,
0x71, 0x21, 0xaa, 0xc7, 0x7a, 0xed, 0x35, 0xa0, 0x73, 0x65, 0x93, 0x94, 0x55, 0xba, 0xc8, 0x68,
0xa5, 0x3b, 0x1e, 0x8c, 0x7f, 0x0f, 0x4e, 0x80, 0xde, 0x23, 0x16, 0xb5, 0xfc, 0xee, 0xd2, 0x49,
0xc4, 0x93, 0x9e, 0xdc, 0x13, 0x7e, 0x29, 0xcf, 0x78, 0xfc, 0xcf, 0x6a, 0xb2, 0x76, 0x05, 0x48,
0x05, 0x21, 0x34, 0x82, 0xdf, 0x64, 0x1c, 0xdd, 0xab, 0xfe, 0xf7, 0xb3, 0x58, 0xa3, 0xcb, 0x5f,
0xd3, 0x56, 0x1e, 0xd2, 0xdf, 0xf9, 0xc2, 0x3f, 0x4b, 0xb8, 0x4c, 0x10, 0x72, 0x72, 0xe0, 0xe9,
0x39, 0xa0, 0x5a, 0x7d, 0xd6, 0xe8, 0xbf, 0xd0, 0x0d, 0xd8, 0x95, 0x11, 0xba, 0xdd, 0xa3, 0x3f,
0xa1, 0x9e, 0xe3, 0x04, 0xf0, 0x6f, 0xbc, 0x5b, 0xca, 0x4d, 0xeb, 0xea, 0x7f, 0x6d, 0xd8, 0xdc,
0x25, 0x74, 0x35, 0xf5, 0x5e, 0x32, 0x60, 0x57, 0x30, 0xfe, 0x73, 0xf6, 0x57, 0xe8, 0x04, 0x18,
0x6d, 0xfc, 0x4b, 0xff, 0xde, 0x64, 0x37, 0x33, 0xf1, 0xeb, 0x7f, 0x06, 0x4b, 0x6a, 0xfc, 0x87,
0xdf, 0xd4, 0x3c, 0xcf, 0xf1, 0x36, 0x4f, 0x70, 0xcb, 0x11, 0x0d, 0xcb, 0xc9, 0xf7, 0xe8, 0xdd,
0x07, 0xb5, 0xe9, 0xbf, 0xd9, 0xf8, 0x4f, 0x39, 0xec, 0x7a, 0x57, 0x40, 0x9f, 0x9c, 0x80, 0x2b,
0x5c, 0x48, 0xb9, 0x72, 0xfd, 0x6b, 0xd5, 0x73, 0x4d, 0xf8, 0x11, 0x4f, 0xef, 0x8d, 0x34, 0xfe,
0x7b, 0xfb, 0xaf, 0xdd, 0xfa, 0x0e, 0x4b, 0x39, 0x05, 0xdf, 0xed, 0x12, 0xaf, 0xc0, 0x8f, 0xd8,
0x51, 0x79, 0xf7, 0x27, 0xbd, 0x7a, 0xb4, 0xfa, 0xdc, 0x2f, 0x37, 0x96, 0x6a, 0xd5, 0xff, 0x6e,
0x7a, 0x9d, 0x5b, 0xe9, 0x6d, 0x91, 0x23, 0xe9, 0xaa, 0x71, 0xe9, 0xb9, 0xbe, 0xdc, 0xf3, 0x7e,
0x5a, 0xe3, 0x83, 0x47, 0xe3, 0xbf, 0x64, 0x7f, 0xed, 0xb6, 0x1b, 0xd9, 0xc4, 0x01, 0x30, 0x4b,
0x01, 0xb5, 0xde, 0xca, 0xae, 0xd9, 0x05, 0xa0, 0x75, 0xe1, 0x5f, 0xad, 0x12, 0x5b, 0x0d, 0x60,
0x96, 0x03, 0x0e, 0x2b, 0x4a, 0xfe, 0x8c, 0x85, 0x5c, 0x7b, 0x3f, 0xe9, 0x8c, 0x97, 0xb6, 0xec,
0x75, 0xe0, 0xf5, 0x9e, 0x61, 0x6f, 0xbd, 0x9c, 0xb3, 0xf7, 0x19, 0xa3, 0xde, 0xfa, 0xd7, 0x4a,
0x7f, 0x56, 0xfe, 0xa5, 0xed, 0x52, 0x93, 0x8e, 0x07, 0x27, 0xc0, 0x68, 0x67, 0x9e, 0xb4, 0xfd,
0x52, 0x4f, 0xd3, 0xce, 0xbe, 0x08, 0xcc, 0x83, 0xfe, 0xac, 0xde, 0xff, 0xbd, 0x3d, 0xff, 0x9e,
0x0d, 0x6c, 0x89, 0x01, 0xe7, 0xbd, 0xfe, 0x5a, 0x5e, 0x11, 0x91, 0x10, 0xde, 0x09, 0xb0, 0xa2,
0xfc, 0x48, 0x9f, 0xd4, 0xeb, 0x59, 0xfd, 0xaf, 0xc9, 0x63, 0xe9, 0x9e, 0x99, 0xda, 0xbb, 0x00,
0x5a, 0xdb, 0xd2, 0x93, 0xf1, 0xff, 0x16, 0x27, 0x80, 0x89, 0x03, 0x60, 0x25, 0xaf, 0x5c, 0xad,
0x01, 0x10, 0x0b, 0xa8, 0x85, 0xf0, 0x4a, 0x2f, 0x1c, 0x1c, 0x45, 0x98, 0x1f, 0x8d, 0xe7, 0x87,
0xbc, 0xb3, 0x92, 0xc7, 0x7d, 0x84, 0xfc, 0xcd, 0x94, 0xb7, 0x62, 0xe7, 0xa5, 0xf4, 0x8c, 0x55,
0xed, 0x93, 0x7c, 0xd6, 0x3a, 0xb0, 0xf3, 0x33, 0x4c, 0x55, 0x83, 0xd3, 0x84, 0x31, 0x63, 0xa6,
0x13, 0xc0, 0xcb, 0x4e, 0x9e, 0xb7, 0xcb, 0xdf, 0xa8, 0xf0, 0x56, 0xf2, 0xbd, 0xcb, 0x33, 0x7e,
0xb3, 0xc6, 0x78, 0xad, 0xf6, 0xd3, 0xd2, 0xdb, 0x5a, 0x23, 0x73, 0x05, 0xfd, 0xb5, 0xec, 0xd3,
0x56, 0xef, 0xbf, 0x52, 0x77, 0x48, 0xb4, 0xc4, 0x91, 0x8a, 0x2b, 0x35, 0xe6, 0xb4, 0x84, 0xd7,
0x1a, 0x0f, 0x73, 0xf7, 0x15, 0x68, 0x5d, 0xa8, 0x1b, 0xc7, 0xd3, 0xd2, 0xe7, 0xe6, 0x9c, 0x00,
0x3b, 0xf4, 0xbb, 0x5c, 0x02, 0x98, 0x50, 0xb0, 0x70, 0xeb, 0xa8, 0x74, 0x1b, 0xe9, 0xd3, 0x64,
0x2d, 0xa7, 0xd4, 0xbd, 0x0e, 0x88, 0xd9, 0x0e, 0x11, 0xe9, 0x00, 0x36, 0x63, 0x22, 0xbb, 0x6a,
0xbe, 0x5b, 0x06, 0x80, 0xde, 0x0b, 0x27, 0xbd, 0xc8, 0x9f, 0xb5, 0xbc, 0x6a, 0xe7, 0xbf, 0x37,
0xfd, 0xd1, 0xf9, 0xd7, 0x4e, 0xdf, 0xab, 0xfc, 0x84, 0xf7, 0x88, 0xac, 0xe0, 0x04, 0xd0, 0x34,
0xfe, 0x6b, 0xfa, 0x8f, 0xd5, 0xf4, 0xdf, 0x9b, 0xfe, 0xbc, 0xbd, 0xff, 0x7b, 0x5b, 0xff, 0x3d,
0xb3, 0x7e, 0x76, 0xaa, 0xbf, 0xd4, 0x6b, 0x5c, 0x6f, 0x1c, 0xff, 0x25, 0xdf, 0x8e, 0x74, 0x86,
0xe5, 0xd2, 0xb4, 0xde, 0x05, 0xb0, 0x82, 0x8d, 0xb8, 0xe3, 0x71, 0x6c, 0xce, 0xc0, 0x01, 0x00,
0x00, 0x18, 0x1a, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x70, 0x02, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe8, 0xc1, 0x2a, 0x06, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x22, 0xb4, 0x5e, 0x3e, 0x78, 0x1c, 0xc7, 0x47, 0x7c, 0x8b,
0xf6, 0xc8, 0x1b, 0x6b, 0x3d, 0xbe, 0x18, 0x30, 0x32, 0x9f, 0xa5, 0x4b, 0x45, 0xb4, 0xd3, 0x1c,
0xf5, 0x8e, 0x7a, 0x4b, 0x9c, 0x92, 0x78, 0x3c, 0xe7, 0x1f, 0xf6, 0xe9, 0x50, 0x69, 0xff, 0xb5,
0xc8, 0xf5, 0xa1, 0x2d, 0x37, 0x07, 0xd7, 0xb4, 0x7f, 0xea, 0xb9, 0xbc, 0x9f, 0x1f, 0xd9, 0x91,
0x81, 0x30, 0xcf, 0x71, 0xb8, 0xdc, 0x4b, 0x2c, 0x57, 0x39, 0xc2, 0x9f, 0x9f, 0x42, 0xb2, 0x9f,
0x52, 0xf8, 0xf0, 0xde, 0xb1, 0x4c, 0x1c, 0x9f, 0xa7, 0xf4, 0x1f, 0xd0, 0x08, 0x0f, 0x00, 0x00,
0x00, 0x0d, 0x4e, 0x80, 0xd4, 0x8f, 0xbb, 0xdd, 0x74, 0xb8, 0xda, 0xc4, 0x95, 0xba, 0x07, 0x00,
0x58, 0xbf, 0x0f, 0xbd, 0xf3, 0xf1, 0xf4, 0x82, 0x40, 0x9c, 0xe7, 0x5c, 0x38, 0xf1, 0xed, 0xcb,
0xb7, 0x01, 0xff, 0xe0, 0x04, 0x30, 0x6c, 0x04, 0x9d, 0x74, 0x67, 0xe5, 0x1f, 0x00, 0x00, 0xe0,
0x6d, 0x0e, 0x00, 0x9c, 0x00, 0xce, 0x1a, 0x69, 0xb1, 0xd5, 0x47, 0xad, 0xfc, 0xb2, 0xea, 0x0a,
0x00, 0x2b, 0xf5, 0x25, 0x77, 0x3a, 0x3d, 0x6f, 0x02, 0x1f, 0xc7, 0xf1, 0xdf, 0x33, 0x84, 0xdf,
0xef, 0xb7, 0x3e, 0xae, 0xf8, 0xd5, 0xb0, 0xd1, 0x46, 0xf4, 0x75, 0xe9, 0xc7, 0x87, 0x13, 0x00,
0x00, 0x00, 0xc0, 0xd6, 0x01, 0xd0, 0xf2, 0xe6, 0xa1, 0x74, 0x92, 0x22, 0xd9, 0x12, 0x59, 0x8a,
0x2b, 0x15, 0xbe, 0xf5, 0x1d, 0xd7, 0x7b, 0xb2, 0xd6, 0xfb, 0x0e, 0xac, 0xd6, 0x3b, 0xa0, 0xe7,
0x79, 0x26, 0x57, 0xae, 0xee, 0xfa, 0xc8, 0x4d, 0x62, 0x7b, 0xcb, 0xdf, 0x5b, 0xff, 0x92, 0xf0,
0x56, 0x47, 0x00, 0x66, 0xc4, 0xd5, 0x22, 0xf7, 0xb9, 0xfa, 0xeb, 0x0d, 0xdf, 0x2b, 0x7f, 0xa3,
0xd3, 0x2f, 0xd5, 0xbf, 0x34, 0x9e, 0xd6, 0x70, 0x12, 0xfd, 0x93, 0xb4, 0x73, 0x98, 0xbe, 0x54,
0xae, 0x4a, 0xdf, 0x95, 0x6e, 0x9a, 0x4f, 0x95, 0x2d, 0x7c, 0xdf, 0xbe, 0x37, 0xfd, 0x54, 0xda,
0xa9, 0xba, 0xc9, 0x7d, 0xa7, 0x51, 0xfe, 0x16, 0x63, 0x39, 0x97, 0xcf, 0x9e, 0x7e, 0xdc, 0x92,
0xa7, 0x3c, 0xc5, 0x7f, 0x8f, 0xdb, 0x5e, 0x7c, 0x94, 0x20, 0x67, 0x7c, 0x8f, 0x32, 0xa2, 0xb5,
0x8d, 0x7f, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x63, 0x1c, 0x00, 0xa2, 0x89, 0x46, 0xe7, 0x44, 0xe8,
0x69, 0x4b, 0xa4, 0x34, 0x7c, 0xef, 0x76, 0xcf, 0xd1, 0xe1, 0x7b, 0xcb, 0xaf, 0x9d, 0xff, 0xd1,
0xed, 0xe7, 0x05, 0xf1, 0x56, 0xda, 0xcd, 0xe4, 0xdf, 0x9b, 0xfe, 0xf5, 0xca, 0xf1, 0x6c, 0xfd,
0xd3, 0x94, 0xc7, 0x3b, 0x6f, 0xa1, 0xc1, 0x97, 0x32, 0xfe, 0xad, 0xd3, 0x8e, 0xeb, 0x26, 0xe7,
0xa0, 0x78, 0x9b, 0xee, 0x9a, 0x0e, 0xc4, 0x09, 0xa7, 0x49, 0xb5, 0x7c, 0x3e, 0x19, 0xdf, 0xd6,
0x46, 0xb4, 0x95, 0xf1, 0x8f, 0x13, 0x00, 0x00, 0x00, 0x60, 0x8c, 0x03, 0x40, 0x63, 0x02, 0x13,
0x52, 0xb3, 0xca, 0x23, 0x5d, 0x41, 0x6a, 0xcd, 0xcb, 0x8c, 0xf4, 0x25, 0xe1, 0x8f, 0xe3, 0xf8,
0x68, 0xac, 0x54, 0xcf, 0xca, 0x3f, 0xfc, 0x5b, 0x7f, 0xe7, 0x79, 0x5e, 0x2d, 0xab, 0x9c, 0xb3,
0xdb, 0xcf, 0x8b, 0xfc, 0xb4, 0xea, 0x71, 0x8f, 0xfe, 0xe5, 0xbe, 0xb5, 0xdc, 0x42, 0x1e, 0xae,
0xf6, 0xc6, 0xce, 0x8d, 0xdc, 0xf7, 0x96, 0x4e, 0x80, 0xd1, 0xc6, 0x77, 0xa9, 0x6e, 0xe3, 0x1d,
0x10, 0x2d, 0xe9, 0xcf, 0x70, 0x18, 0x0c, 0x3f, 0x42, 0x27, 0x35, 0xbe, 0xad, 0x8c, 0xe8, 0xeb,
0x1a, 0x57, 0x4e, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x1c, 0x00, 0xb5, 0xf4, 0x4e, 0x8e, 0xc2,
0x15, 0x2b, 0x0f, 0xf9, 0x18, 0x9d, 0xae, 0x76, 0x3c, 0xab, 0xa4, 0x2b, 0xa1, 0xf7, 0x08, 0xc3,
0x1b, 0xe4, 0xdf, 0x8b, 0xfe, 0x8d, 0x92, 0xa7, 0x15, 0xee, 0x93, 0x48, 0xed, 0x02, 0xb0, 0x5e,
0x79, 0x0f, 0x9d, 0x0f, 0x77, 0x7a, 0xf7, 0x2e, 0x80, 0xb8, 0x6d, 0xc2, 0xf4, 0x47, 0xe8, 0x4f,
0xc9, 0xf8, 0xcf, 0xa5, 0x9f, 0xd2, 0xfd, 0xda, 0xbc, 0x6a, 0xd4, 0x73, 0xea, 0x78, 0x44, 0xe8,
0x10, 0x9c, 0x6a, 0x7c, 0x6b, 0x1b, 0xd1, 0xa5, 0x63, 0x07, 0xe5, 0x4a, 0x6a, 0x73, 0x1c, 0xe0,
0x04, 0x00, 0x00, 0x00, 0x98, 0xef, 0x00, 0xe8, 0x3d, 0x43, 0x0f, 0x30, 0xda, 0xf0, 0x5e, 0xfd,
0x08, 0x03, 0xe4, 0x59, 0xc1, 0x01, 0x54, 0x32, 0xc4, 0x9f, 0xbe, 0xab, 0xa9, 0x07, 0x89, 0xc1,
0x99, 0x73, 0x02, 0x84, 0x0e, 0x88, 0x15, 0x8c, 0xff, 0x52, 0x5c, 0x35, 0x61, 0x66, 0x1e, 0x69,
0x69, 0x14, 0x9e, 0xb2, 0xf1, 0xbd, 0xf2, 0xb6, 0x7f, 0x9c, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x1c,
0x00, 0x3c, 0x5b, 0x57, 0x67, 0x80, 0xc0, 0x00, 0xa1, 0xe6, 0x08, 0xc3, 0x6b, 0xc8, 0x5d, 0x94,
0xf7, 0x64, 0xdc, 0x79, 0x75, 0x00, 0xc5, 0xbb, 0x00, 0x62, 0xc7, 0xc5, 0x48, 0x07, 0x44, 0xaa,
0x3e, 0xbd, 0x1b, 0xff, 0xb9, 0x63, 0x54, 0x5e, 0xfb, 0x25, 0x17, 0x48, 0xee, 0x0e, 0xc8, 0x39,
0x1d, 0x5a, 0x57, 0xf1, 0xfb, 0x05, 0x96, 0xce, 0x0f, 0x00, 0x00, 0x60, 0x96, 0x03, 0x00, 0x03,
0x0c, 0x56, 0x04, 0xa7, 0xd5, 0x5e, 0x4e, 0x80, 0xa7, 0x6f, 0x56, 0xe8, 0x7f, 0x9e, 0x76, 0x01,
0x58, 0x1a, 0xdf, 0xb9, 0xd7, 0x06, 0xe2, 0x23, 0x09, 0xd6, 0x8e, 0x13, 0xcd, 0x95, 0xff, 0x99,
0xba, 0xbe, 0x54, 0xff, 0x52, 0x6b, 0xc4, 0xc7, 0xcd, 0x90, 0x0b, 0x2f, 0x69, 0xae, 0xa7, 0x6f,
0x5a, 0xe3, 0x05, 0x00, 0x00, 0x00, 0x3b, 0x07, 0x00, 0x86, 0x54, 0xa2, 0x52, 0x79, 0xbf, 0x1e,
0xc0, 0x35, 0x9e, 0xfb, 0xad, 0x11, 0x67, 0xff, 0x25, 0xc6, 0xff, 0x68, 0x27, 0x80, 0x85, 0xf1,
0x0f, 0xca, 0x4e, 0x80, 0x5c, 0x33, 0x8c, 0xda, 0x09, 0x80, 0x18, 0x00, 0x00, 0x00, 0xcc, 0x77,
0x00, 0x00, 0x40, 0x46, 0xb9, 0x70, 0x04, 0x99, 0x33, 0xfa, 0xc6, 0x7e, 0x7b, 0xfb, 0x26, 0xbd,
0x0b, 0xc0, 0xca, 0x00, 0xce, 0x19, 0xff, 0xb9, 0x67, 0x00, 0xad, 0x9c, 0x00, 0x18, 0xff, 0x0b,
0x38, 0x01, 0x9e, 0x9a, 0xc1, 0xda, 0x09, 0x80, 0x18, 0x00, 0x00, 0x00, 0xa8, 0xf0, 0xdb, 0x1b,
0x41, 0xeb, 0xea, 0x54, 0xef, 0xaa, 0x56, 0xb8, 0x42, 0x35, 0x23, 0xff, 0x5a, 0xe1, 0x67, 0xd5,
0x3f, 0xec, 0x51, 0xa7, 0xab, 0xeb, 0x9f, 0xc7, 0xf2, 0xd7, 0xc4, 0x69, 0x55, 0x7e, 0x69, 0xfd,
0x6a, 0x94, 0xbf, 0x64, 0xfc, 0xdf, 0x06, 0x78, 0xe9, 0x7b, 0x6f, 0xc6, 0xbf, 0x47, 0xfd, 0x5d,
0xa6, 0x4f, 0x29, 0xad, 0xf0, 0xcf, 0x34, 0xd2, 0x31, 0xfe, 0x01, 0x00, 0x00, 0xd4, 0x30, 0xd9,
0x01, 0xd0, 0x7b, 0xde, 0x76, 0x54, 0xf8, 0xdc, 0x4a, 0xe1, 0xec, 0xf4, 0x67, 0xd7, 0x3f, 0xac,
0xcd, 0x2a, 0xfa, 0xe7, 0xb5, 0xfc, 0x4f, 0x71, 0x3e, 0xe9, 0x6d, 0x6f, 0xfa, 0xf1, 0x2e, 0x80,
0x5a, 0x23, 0x38, 0x4c, 0xff, 0x29, 0x2f, 0x35, 0xc6, 0x7c, 0xee, 0x82, 0x42, 0x8d, 0xf2, 0x87,
0xf1, 0x85, 0xff, 0x2f, 0xc5, 0x55, 0xd3, 0x7f, 0xde, 0xf1, 0x58, 0xef, 0x0e, 0xd9, 0xa2, 0xef,
0x8d, 0x57, 0xf2, 0x6b, 0x8d, 0x6f, 0xed, 0x9d, 0x00, 0x18, 0xff, 0x00, 0x00, 0x00, 0xbe, 0x1c,
0x00, 0xb5, 0xb7, 0x70, 0xf7, 0x3e, 0xc3, 0x15, 0x87, 0xaf, 0x4d, 0xbf, 0x37, 0xff, 0xda, 0xe1,
0x47, 0xd7, 0x3f, 0xec, 0x55, 0xa7, 0xab, 0xeb, 0x9f, 0xc7, 0xf2, 0xd7, 0xc4, 0xb9, 0x5b, 0xf9,
0x4b, 0xbf, 0xe7, 0x8e, 0x26, 0xf4, 0x96, 0x5f, 0xbb, 0xde, 0x3c, 0xe9, 0xaf, 0xd7, 0x67, 0x27,
0xc5, 0x46, 0x7c, 0x6b, 0xb6, 0xb5, 0x8a, 0x8b, 0xf1, 0x0f, 0x00, 0x00, 0xa0, 0x3f, 0xcc, 0x53,
0x05, 0xef, 0x20, 0x5e, 0x99, 0x4a, 0x6d, 0xf5, 0x25, 0xcf, 0xc8, 0xc5, 0xcf, 0x8f, 0xcd, 0x2a,
0xe9, 0x6e, 0x67, 0xf5, 0x01, 0x5d, 0x06, 0x00, 0x00, 0x00, 0x58, 0x11, 0x2e, 0x01, 0xdc, 0xd8,
0x90, 0xa3, 0x1c, 0x00, 0x80, 0xde, 0x02, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x80, 0x97, 0xb2, 0xe2,
0x96, 0xd4, 0x65, 0xb7, 0xd1, 0x02, 0x00, 0xba, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x0e, 0xa9, 0x5b,
0xa3, 0x6b, 0xc2, 0xde, 0x50, 0x93, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7d, 0xfc, 0x5a,
0x1b, 0xff, 0xb3, 0x0c, 0x78, 0xad, 0x74, 0x71, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x0e, 0x00, 0xa1, 0xd1, 0x3c, 0xda, 0x88, 0xd6, 0x4e, 0x0f, 0x27, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xe0, 0x00, 0x10, 0x1a, 0xcb, 0xa3, 0x8c, 0x68, 0xab, 0x74, 0x70, 0x02, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0xa1, 0x91, 0x6c, 0x6d, 0x44, 0xaf, 0x1e, 0x3f, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7b, 0x07, 0x80, 0xd4, 0x38, 0x5e, 0x7d, 0x85, 0x1e, 0x27,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xac, 0xc8, 0x67, 0x96, 0x51, 0xfc, 0xf9, 0x7c, 0x3e,
0xd2, 0x38, 0x6b, 0xbe, 0xad, 0xcd, 0x43, 0x4f, 0x58, 0xc4, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x56, 0xe1, 0xd0, 0x88, 0x24, 0x65, 0x0c, 0xd7, 0x18, 0xf0, 0x3d, 0xcc, 0x7c, 0x65, 0x00,
0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0xca, 0x01, 0x60, 0x6d, 0xc4, 0xa7, 0xfe,
0x7e, 0x1b, 0xdf, 0x3d, 0xab, 0xf8, 0x3d, 0x60, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
0x4a, 0x0c, 0x59, 0x99, 0x97, 0x18, 0xcb, 0x35, 0x46, 0xfc, 0xd3, 0x8e, 0x03, 0x4d, 0x23, 0xdd,
0x2a, 0x5e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x91, 0xfc, 0x7a, 0xc9, 0x88, 0xd4, 0xa8,
0xce, 0x7d, 0x37, 0xca, 0x28, 0xc7, 0xf8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00,
0xc6, 0xc6, 0x75, 0xef, 0xdf, 0x31, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x80,
0x73, 0x27, 0x40, 0xef, 0x0e, 0x01, 0x8c, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x01,
0xe0, 0xdc, 0x09, 0x50, 0x6b, 0x7c, 0x6b, 0x1b, 0xeb, 0x18, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x19, 0xae, 0x80, 0x9e, 0x38, 0xa8, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0,
0xc3, 0xff, 0x00, 0xe2, 0xe6, 0xa1, 0xf3, 0xf8, 0x5f, 0xec, 0xc5, 0x00, 0x00, 0x00, 0x00, 0x49,
0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
};
const int GRRLIBfont_size = sizeof(GRRLIBfont);

14
GRRLIB/GRRLIB/GRRLIB_addon/GRRLIBfont.h Normal file
View file

@ -0,0 +1,14 @@
/*
This file was autogenerated by raw2c.
Visit http://www.devkitpro.org
*/
//---------------------------------------------------------------------------------
#ifndef _GRRLIBfont_h_
#define _GRRLIBfont_h_
//---------------------------------------------------------------------------------
extern const unsigned char GRRLIBfont[];
extern const int GRRLIBfont_size;
//---------------------------------------------------------------------------------
#endif //_GRRLIBfont_h_
//---------------------------------------------------------------------------------

BIN
GRRLIB/GRRLIB/GRRLIB_addon/GRRLIBfont.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 3.5 KiB

114
GRRLIB/GRRLIB/GRRLIB_bmf.c Normal file
View file

@ -0,0 +1,114 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <malloc.h>
#include <string.h>
#include <grrlib.h>
/**
* Load a ByteMap font structure from a buffer.
* @param my_bmf The ByteMap font buffer to load.
* @return A GRRLIB_bytemapFont structure filled with BMF informations.
*/
GRRLIB_bytemapFont* GRRLIB_LoadBMF (const u8 my_bmf[] ) {
GRRLIB_bytemapFont *fontArray = (struct GRRLIB_bytemapFont *)malloc(sizeof(GRRLIB_bytemapFont));
int i, j = 1;
u8 lineheight, usedcolors, highestcolor, nbPalette;
short int sizeover, sizeunder, sizeinner, numcolpal;
u16 nbPixels;
if (fontArray != NULL && my_bmf[0]==0xE1 && my_bmf[1]==0xE6 && my_bmf[2]==0xD5 && my_bmf[3]==0x1A) {
fontArray->version = my_bmf[4];
lineheight = my_bmf[5];
sizeover = my_bmf[6];
sizeunder = my_bmf[7];
fontArray->tracking = my_bmf[8];
sizeinner = my_bmf[9];
usedcolors = my_bmf[10];
highestcolor = my_bmf[11];
nbPalette = my_bmf[16];
numcolpal = 3 * nbPalette;
fontArray->palette = (u32 *)calloc(nbPalette + 1, sizeof(u32));
for (i=0; i < numcolpal; i+=3) {
fontArray->palette[j++] = ((((my_bmf[i+17]<<2)+3)<<24) | (((my_bmf[i+18]<<2)+3)<<16) | (((my_bmf[i+19]<<2)+3)<<8) | 0xFF);
}
j = my_bmf[17 + numcolpal];
fontArray->name = (char *)calloc(j + 1, sizeof(char));
memcpy(fontArray->name, &my_bmf[18 + numcolpal], j);
j = 18 + numcolpal + j;
fontArray->nbChar = (my_bmf[j] | my_bmf[j+1]<<8);
fontArray->charDef = (GRRLIB_bytemapChar *)calloc(fontArray->nbChar, sizeof(GRRLIB_bytemapChar));
j++;
for (i=0; i < fontArray->nbChar; i++) {
fontArray->charDef[i].character = my_bmf[++j];
fontArray->charDef[i].width = my_bmf[++j];
fontArray->charDef[i].height = my_bmf[++j];
fontArray->charDef[i].relx = my_bmf[++j];
fontArray->charDef[i].rely = my_bmf[++j];
fontArray->charDef[i].kerning = my_bmf[++j];
nbPixels = fontArray->charDef[i].width * fontArray->charDef[i].height;
fontArray->charDef[i].data = (u8 *)malloc(nbPixels);
if (nbPixels && fontArray->charDef[i].data) {
memcpy(fontArray->charDef[i].data, &my_bmf[++j], nbPixels);
j += (nbPixels - 1);
}
}
}
return fontArray;
}
/**
* Free memory allocated by ByteMap fonts.
* @param bmf A GRRLIB_bytemapFont structure.
*/
void GRRLIB_FreeBMF (const GRRLIB_bytemapFont *bmf) {
unsigned int i;
for (i=0; i<bmf->nbChar; i++) {
free(bmf->charDef[i].data);
}
free(bmf->charDef);
free(bmf->palette);
free(bmf->name);
}
/**
* Initialize a tile set.
* @param tex The texture to initialize.
* @param tilew Width of the tile.
* @param tileh Height of the tile.
* @param tilestart Offset for starting position (Used in fonts).
*/
void GRRLIB_InitTileSet (GRRLIB_texImg *tex,
const uint tilew, const uint tileh,
const uint tilestart) {
tex->tilew = tilew;
tex->tileh = tileh;
if (tilew) // Avoid division by zero
tex->nbtilew = tex->w / tilew;
if (tileh) // Avoid division by zero
tex->nbtileh = tex->h / tileh;
tex->tilestart = tilestart;
tex->tiledtex = true;
GRRLIB_SetHandle( tex, 0, 0 );
}

214
GRRLIB/GRRLIB/GRRLIB_bmfx.c Normal file
View file

@ -0,0 +1,214 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <stdlib.h>
#include <grrlib.h>
/**
* Flip texture horizontal.
* @see GRRLIB_FlushTex
* @param texsrc The texture source.
* @param texdest The texture destination.
*/
void GRRLIB_BMFX_FlipH (const GRRLIB_texImg *texsrc, GRRLIB_texImg *texdest) {
unsigned int x, y, txtWidth = texsrc->w - 1;
for (y = 0; y < texsrc->h; y++) {
for (x = 0; x < texsrc->w; x++) {
GRRLIB_SetPixelTotexImg(txtWidth - x, y, texdest,
GRRLIB_GetPixelFromtexImg(x, y, texsrc));
}
}
}
/**
* Flip texture vertical.
* @see GRRLIB_FlushTex
* @param texsrc The texture source.
* @param texdest The texture destination.
*/
void GRRLIB_BMFX_FlipV (const GRRLIB_texImg *texsrc, GRRLIB_texImg *texdest) {
unsigned int x, y, texHeight = texsrc->h - 1;
for (y = 0; y < texsrc->h; y++) {
for (x = 0; x < texsrc->w; x++) {
GRRLIB_SetPixelTotexImg(x, texHeight - y, texdest,
GRRLIB_GetPixelFromtexImg(x, y, texsrc));
}
}
}
/**
* Change a texture to gray scale.
* @see GRRLIB_FlushTex
* @param texsrc The texture source.
* @param texdest The texture grayscaled destination.
*/
void GRRLIB_BMFX_Grayscale (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest) {
unsigned int x, y;
u8 gray;
u32 color;
for (y = 0; y < texsrc->h; y++) {
for (x = 0; x < texsrc->w; x++) {
color = GRRLIB_GetPixelFromtexImg(x, y, texsrc);
gray = (((color >> 24 & 0xFF)*77 + (color >> 16 & 0xFF)*150 + (color >> 8 & 0xFF)*28) / (255));
GRRLIB_SetPixelTotexImg(x, y, texdest,
((gray << 24) | (gray << 16) | (gray << 8) | (color & 0xFF)));
}
}
GRRLIB_SetHandle( texdest, 0, 0 );
}
/**
* Invert colors of the texture.
* @see GRRLIB_FlushTex
* @param texsrc The texture source.
* @param texdest The texture destination.
*/
void GRRLIB_BMFX_Invert (const GRRLIB_texImg *texsrc, GRRLIB_texImg *texdest) {
unsigned int x, y;
u32 color;
for (y = 0; y < texsrc->h; y++) {
for (x = 0; x < texsrc->w; x++) {
color = GRRLIB_GetPixelFromtexImg(x, y, texsrc);
GRRLIB_SetPixelTotexImg(x, y, texdest,
((0xFFFFFF - (color >> 8 & 0xFFFFFF)) << 8) | (color & 0xFF));
}
}
}
/**
* A texture effect (Blur).
* @see GRRLIB_FlushTex
* @param texsrc The texture source.
* @param texdest The texture destination.
* @param factor The blur factor.
*/
void GRRLIB_BMFX_Blur (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest, const u32 factor) {
int numba = (1+(factor<<1))*(1+(factor<<1));
u32 x, y;
s32 k, l;
int tmp = 0;
int newr, newg, newb, newa;
u32 colours[numba];
u32 thiscol;
for (x = 0; x < texsrc->w; x++) {
for (y = 0; y < texsrc->h; y++) {
newr = 0;
newg = 0;
newb = 0;
newa = 0;
tmp = 0;
thiscol = GRRLIB_GetPixelFromtexImg(x, y, texsrc);
for (k = x - factor; k <= x + factor; k++) {
for (l = y - factor; l <= y + factor; l++) {
if (k < 0) { colours[tmp] = thiscol; }
else if (k >= texsrc->w) { colours[tmp] = thiscol; }
else if (l < 0) { colours[tmp] = thiscol; }
else if (l >= texsrc->h) { colours[tmp] = thiscol; }
else { colours[tmp] = GRRLIB_GetPixelFromtexImg(k, l, texsrc); }
tmp++;
}
}
for (tmp = 0; tmp < numba; tmp++) {
newr += (colours[tmp] >> 24) & 0xFF;
newg += (colours[tmp] >> 16) & 0xFF;
newb += (colours[tmp] >> 8) & 0xFF;
newa += colours[tmp] & 0xFF;
}
newr /= numba;
newg /= numba;
newb /= numba;
newa /= numba;
GRRLIB_SetPixelTotexImg(x, y, texdest, (newr<<24) | (newg<<16) | (newb<<8) | newa);
}
}
}
/**
* A texture effect (Scatter).
* @see GRRLIB_FlushTex
* @param texsrc The texture source.
* @param texdest The texture destination.
* @param factor The factor level of the effect.
*/
void GRRLIB_BMFX_Scatter (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest, const u32 factor) {
unsigned int x, y;
u32 val1, val2;
u32 val3, val4;
int factorx2 = factor*2;
for (y = 0; y < texsrc->h; y++) {
for (x = 0; x < texsrc->w; x++) {
val1 = x + (int) (factorx2 * (rand() / (RAND_MAX + 1.0))) - factor;
val2 = y + (int) (factorx2 * (rand() / (RAND_MAX + 1.0))) - factor;
if ((val1 >= texsrc->w) || (val2 >= texsrc->h)) {
}
else {
val3 = GRRLIB_GetPixelFromtexImg(x, y, texsrc);
val4 = GRRLIB_GetPixelFromtexImg(val1, val2, texsrc);
GRRLIB_SetPixelTotexImg(x, y, texdest, val4);
GRRLIB_SetPixelTotexImg(val1, val2, texdest, val3);
}
}
}
}
/**
* A texture effect (Pixelate).
* @see GRRLIB_FlushTex
* @param texsrc The texture source.
* @param texdest The texture destination.
* @param factor The factor level of the effect.
*/
void GRRLIB_BMFX_Pixelate (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest, const u32 factor) {
unsigned int x, y;
unsigned int xx, yy;
u32 rgb;
for (x = 0; x < texsrc->w - 1 - factor; x += factor) {
for (y = 0; y < texsrc->h - 1 - factor; y +=factor) {
rgb = GRRLIB_GetPixelFromtexImg(x, y, texsrc);
for (xx = x; xx < x + factor; xx++) {
for (yy = y; yy < y + factor; yy++) {
GRRLIB_SetPixelTotexImg(xx, yy, texdest, rgb);
}
}
}
}
}

170
GRRLIB/GRRLIB/GRRLIB_core.c Normal file
View file

@ -0,0 +1,170 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <malloc.h>
#include <string.h>
#include <ogc/conf.h>
#define __GRRLIB_CORE__
#include <grrlib.h>
#define DEFAULT_FIFO_SIZE (256 * 1024) /**< GX fifo buffer size. */
GRRLIB_drawSettings GRRLIB_Settings;
Mtx GXmodelView2D;
static void *gp_fifo = NULL;
/**
* Initialize GRRLIB. Call this at the beginning your code.
* @see GRRLIB_Exit
*/
void GRRLIB_Init (void) {
f32 yscale;
u32 xfbHeight;
Mtx44 perspective;
VIDEO_Init();
rmode = VIDEO_GetPreferredMode(NULL);
if (rmode == NULL)
return;
// Video Mode Correction
switch (rmode->viTVMode) {
case VI_DEBUG_PAL: // PAL 50hz 576i
//rmode = &TVPal574IntDfScale;
rmode = &TVPal528IntDf; //BC
break;
}
// Widescreen patch by CashMan's Productions (http://www.CashMan-Productions.fr.nf)
if (CONF_GetAspectRatio() == CONF_ASPECT_16_9) {
rmode->viWidth = 678;
rmode->viXOrigin = (VI_MAX_WIDTH_NTSC - 678)/2;
}
VIDEO_Configure(rmode);
xfb[0] = (u32 *)MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
xfb[1] = (u32 *)MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
if (xfb[0] == NULL || xfb[1] == NULL)
return;
VIDEO_SetNextFramebuffer(xfb[fb]);
VIDEO_SetBlack(true);
VIDEO_Flush();
VIDEO_WaitVSync();
if (rmode->viTVMode & VI_NON_INTERLACE) {
VIDEO_WaitVSync();
}
gp_fifo = (u8 *) memalign(32, DEFAULT_FIFO_SIZE);
if (gp_fifo == NULL)
return;
memset(gp_fifo, 0, DEFAULT_FIFO_SIZE);
GX_Init(gp_fifo, DEFAULT_FIFO_SIZE);
// Clears the BG to color and clears the z-buffer
GX_SetCopyClear((GXColor){ 0, 0, 0, 0xff }, GX_MAX_Z24);
// Other GX setup
yscale = GX_GetYScaleFactor(rmode->efbHeight, rmode->xfbHeight);
xfbHeight = GX_SetDispCopyYScale(yscale);
GX_SetDispCopySrc(0, 0, rmode->fbWidth, rmode->efbHeight);
GX_SetDispCopyDst(rmode->fbWidth, xfbHeight);
GX_SetCopyFilter(rmode->aa, rmode->sample_pattern, GX_TRUE, rmode->vfilter);
GX_SetFieldMode(rmode->field_rendering, ((rmode->viHeight == 2 * rmode->xfbHeight) ? GX_ENABLE : GX_DISABLE));
if (rmode->aa) {
// Set 16 bit RGB565
GX_SetPixelFmt(GX_PF_RGB565_Z16, GX_ZC_LINEAR);
} else {
// Set 24 bit Z24
GX_SetPixelFmt(GX_PF_RGB8_Z24, GX_ZC_LINEAR);
}
GX_SetDispCopyGamma(GX_GM_1_0);
// Setup the vertex descriptor
// Tells the flipper to expect direct data
GX_ClearVtxDesc();
GX_InvVtxCache();
GX_InvalidateTexAll();
GX_SetVtxDesc(GX_VA_TEX0, GX_NONE);
GX_SetVtxDesc(GX_VA_POS, GX_DIRECT);
GX_SetVtxDesc(GX_VA_CLR0, GX_DIRECT);
GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
GX_SetZMode(GX_FALSE, GX_LEQUAL, GX_TRUE);
GX_SetNumChans(1);
GX_SetNumTexGens(1);
GX_SetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
GX_SetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
GX_SetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
guMtxIdentity(GXmodelView2D);
guMtxTransApply(GXmodelView2D, GXmodelView2D, 0.0F, 0.0F, -100.0F);
GX_LoadPosMtxImm(GXmodelView2D, GX_PNMTX0);
guOrtho(perspective, 0, rmode->efbHeight, 0, rmode->fbWidth, 0, 1000.0f);
GX_LoadProjectionMtx(perspective, GX_ORTHOGRAPHIC);
GX_SetViewport(0, 0, rmode->fbWidth, rmode->efbHeight, 0, 1);
GX_SetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
GX_SetAlphaUpdate(GX_TRUE);
GX_SetAlphaCompare(GX_GREATER, 0, GX_AOP_AND, GX_ALWAYS, 0);
GX_SetColorUpdate(GX_ENABLE);
GX_SetCullMode(GX_CULL_NONE);
GRRLIB_ClipReset();
VIDEO_SetBlack(false);
// Default settings
GRRLIB_Settings.antialias = true;
GRRLIB_Settings.blend = GRRLIB_BLEND_ALPHA;
}
/**
* Call this before exiting your application.
*/
void GRRLIB_Exit (void) {
// Allow write access to the full screen
GX_SetClipMode( GX_CLIP_DISABLE );
GX_SetScissor( 0, 0, rmode->fbWidth, rmode->efbHeight );
// We empty both frame buffers on our way out
// otherwise dead frames are sometimes seen when starting the next app
GRRLIB_FillScreen( 0x000000FF ); GRRLIB_Render();
GRRLIB_FillScreen( 0x000000FF ); GRRLIB_Render();
// Shut down the GX engine
GX_DrawDone();
GX_AbortFrame();
// Free up memory allocated for frame buffers & FIFOs
if (xfb[0] != NULL) { free(MEM_K1_TO_K0(xfb[0])); xfb[0] = NULL; }
if (xfb[1] != NULL) { free(MEM_K1_TO_K0(xfb[1])); xfb[0] = NULL; }
if (gp_fifo != NULL) { free(gp_fifo); gp_fifo = NULL; }
}

55
GRRLIB/GRRLIB/GRRLIB_fbAdvanced.c Normal file
View file

@ -0,0 +1,55 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <math.h>
#include <grrlib.h>
/**
* Draw a circle.
* @author Dark_Link
* @param x Specifies the x-coordinate of the circle.
* @param y Specifies the y-coordinate of the circle.
* @param radius The radius of the circle.
* @param color The color of the circle in RGBA format.
* @param filled Set to true to fill the circle.
*/
void GRRLIB_Circle (const f32 x, const f32 y, const f32 radius,
const u32 color, const u8 filled) {
guVector v[36];
u32 ncolor[36];
u32 a;
f32 ra;
f32 G_DTOR = M_DTOR * 10;
for (a = 0; a < 36; a++) {
ra = a * G_DTOR;
v[a].x = cos(ra) * radius + x;
v[a].y = sin(ra) * radius + y;
v[a].z = 0.0f;
ncolor[a] = color;
}
if (!filled) GRRLIB_GXEngine(v, ncolor, 36, GX_LINESTRIP ) ;
else GRRLIB_GXEngine(v, ncolor, 36, GX_TRIANGLEFAN) ;
}

107
GRRLIB/GRRLIB/GRRLIB_print.c Normal file
View file

@ -0,0 +1,107 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <malloc.h>
#include <stdarg.h>
#include <stdio.h>
#include <grrlib.h>
/**
* Print formatted output.
* @param xpos Specifies the x-coordinate of the upper-left corner of the text.
* @param ypos Specifies the y-coordinate of the upper-left corner of the text.
* @param tex The texture containing the character set.
* @param color Text color in RGBA format. The alpha channel is used to change the opacity of the text.
* @param zoom This is a factor by which the text size will be increase or decrease.
* @param text Text to draw.
* @param ... Optional arguments.
*/
void GRRLIB_Printf (const f32 xpos, const f32 ypos,
const GRRLIB_texImg *tex, const u32 color,
const f32 zoom, const char *text, ...) {
if (tex == NULL || tex->data == NULL) {
return;
}
int i, size;
char tmp[1024];
va_list argp;
va_start(argp, text);
size = vsprintf(tmp, text, argp);
va_end(argp);
for (i = 0; i < size; i++) {
u8 c = tmp[i]-tex->tilestart;
GRRLIB_DrawTile(xpos+i*tex->tilew*zoom, ypos, tex, 0, zoom, zoom, color, c);
}
}
/**
* Print formatted output.
* @param xpos Specifies the x-coordinate of the upper-left corner of the text.
* @param ypos Specifies the y-coordinate of the upper-left corner of the text.
* @param bmf The ByteMap font to use.
* @param zoom This is a factor by which the text size will be increase or decrease.
* @param text Text to draw.
* @param ... Optional arguments.
*/
void GRRLIB_PrintBMF (const f32 xpos, const f32 ypos,
const GRRLIB_bytemapFont *bmf,
const f32 zoom, const char *text, ...) {
uint i, j, x, y, n, size;
char tmp[1024];
f32 xoff = xpos;
va_list argp;
va_start(argp, text);
size = vsprintf(tmp, text, argp);
va_end(argp);
GRRLIB_texImg *tex_BMfont = GRRLIB_CreateEmptyTexture(rmode->fbWidth, rmode->xfbHeight);
for (i=0; i<size; i++) {
for (j=0; j<bmf->nbChar; j++) {
if (tmp[i] == bmf->charDef[j].character) {
n=0;
for (y=0; y<bmf->charDef[j].height; y++) {
for (x=0; x<bmf->charDef[j].width; x++) {
if (bmf->charDef[j].data[n]) {
GRRLIB_SetPixelTotexImg(xoff + x + bmf->charDef[j].relx, ypos + y + bmf->charDef[j].rely,
tex_BMfont, bmf->palette[bmf->charDef[j].data[n]]);
}
n++;
}
}
xoff += bmf->charDef[j].kerning + bmf->tracking;
break;
}
}
}
GRRLIB_FlushTex( tex_BMfont );
GRRLIB_DrawImg(0, 0, tex_BMfont, 0, 1, 1, 0xFFFFFFFF);
free(tex_BMfont->data);
free(tex_BMfont);
}

306
GRRLIB/GRRLIB/GRRLIB_render.c Normal file
View file

@ -0,0 +1,306 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <math.h>
#include <grrlib.h>
extern GRRLIB_drawSettings GRRLIB_Settings;
extern Mtx GXmodelView2D;
/**
* Draw a texture.
* @param xpos Specifies the x-coordinate of the upper-left corner.
* @param ypos Specifies the y-coordinate of the upper-left corner.
* @param tex The texture to draw.
* @param degrees Angle of rotation.
* @param scaleX Specifies the x-coordinate scale. -1 could be used for flipping the texture horizontally.
* @param scaleY Specifies the y-coordinate scale. -1 could be used for flipping the texture vertically.
* @param color Color in RGBA format.
*/
void GRRLIB_DrawImg (const f32 xpos, const f32 ypos, const GRRLIB_texImg *tex,
const f32 degrees, const f32 scaleX, const f32 scaleY,
const u32 color) {
if (tex == NULL || tex->data == NULL) {
return;
}
GXTexObj texObj;
u16 width, height;
Mtx m, m1, m2, mv;
GX_InitTexObj(&texObj, tex->data, tex->w, tex->h, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
if (GRRLIB_Settings.antialias == false) {
GX_InitTexObjLOD(&texObj, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
}
GX_LoadTexObj(&texObj, GX_TEXMAP0);
GX_SetTevOp(GX_TEVSTAGE0, GX_MODULATE);
GX_SetVtxDesc(GX_VA_TEX0, GX_DIRECT);
width = tex->w * 0.5;
height = tex->h * 0.5;
guMtxIdentity(m1);
guMtxScaleApply(m1, m1, scaleX, scaleY, 1.0);
guVector axis = (guVector) {0, 0, 1};
guMtxRotAxisDeg (m2, &axis, degrees);
guMtxConcat(m2, m1, m);
guMtxTransApply(m, m, xpos+width+tex->handlex-tex->offsetx+(scaleX*( -tex->handley*sin(-DegToRad(degrees)) - tex->handlex*cos(-DegToRad(degrees)) )), ypos+height+tex->handley-tex->offsety+(scaleX*( -tex->handley*cos(-DegToRad(degrees)) + tex->handlex*sin(-DegToRad(degrees)) )), 0);
guMtxConcat(GXmodelView2D, m, mv);
GX_LoadPosMtxImm(mv, GX_PNMTX0);
GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
GX_Position3f32(-width, -height, 0);
GX_Color1u32(color);
GX_TexCoord2f32(0, 0);
GX_Position3f32(width, -height, 0);
GX_Color1u32(color);
GX_TexCoord2f32(1, 0);
GX_Position3f32(width, height, 0);
GX_Color1u32(color);
GX_TexCoord2f32(1, 1);
GX_Position3f32(-width, height, 0);
GX_Color1u32(color);
GX_TexCoord2f32(0, 1);
GX_End();
GX_LoadPosMtxImm(GXmodelView2D, GX_PNMTX0);
GX_SetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
GX_SetVtxDesc(GX_VA_TEX0, GX_NONE);
}
/**
* Draw a textured quad.
* @param pos Vector array of the 4 points.
* @param tex The texture to draw.
* @param color Color in RGBA format.
*/
void GRRLIB_DrawImgQuad (const guVector pos[4], GRRLIB_texImg *tex,
const u32 color) {
if (tex == NULL || tex->data == NULL) {
return;
}
GXTexObj texObj;
Mtx m, m1, m2, mv;
GX_InitTexObj(&texObj, tex->data, tex->w, tex->h, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
if (GRRLIB_Settings.antialias == false) {
GX_InitTexObjLOD(&texObj, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
}
GX_LoadTexObj(&texObj, GX_TEXMAP0);
GX_SetTevOp(GX_TEVSTAGE0, GX_MODULATE);
GX_SetVtxDesc(GX_VA_TEX0, GX_DIRECT);
guMtxIdentity(m1);
guMtxScaleApply(m1, m1, 1, 1, 1.0);
guVector axis = (guVector) {0, 0, 1};
guMtxRotAxisDeg (m2, &axis, 0);
guMtxConcat(m2, m1, m);
guMtxConcat(GXmodelView2D, m, mv);
GX_LoadPosMtxImm(mv, GX_PNMTX0);
GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
GX_Position3f32(pos[0].x, pos[0].y, 0);
GX_Color1u32(color);
GX_TexCoord2f32(0, 0);
GX_Position3f32(pos[1].x, pos[1].y, 0);
GX_Color1u32(color);
GX_TexCoord2f32(1, 0);
GX_Position3f32(pos[2].x, pos[2].y, 0);
GX_Color1u32(color);
GX_TexCoord2f32(1, 1);
GX_Position3f32(pos[3].x, pos[3].y, 0);
GX_Color1u32(color);
GX_TexCoord2f32(0, 1);
GX_End();
GX_LoadPosMtxImm(GXmodelView2D, GX_PNMTX0);
GX_SetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
GX_SetVtxDesc(GX_VA_TEX0, GX_NONE);
}
/**
* Draw a tile.
* @param xpos Specifies the x-coordinate of the upper-left corner.
* @param ypos Specifies the y-coordinate of the upper-left corner.
* @param tex The texture containing the tile to draw.
* @param degrees Angle of rotation.
* @param scaleX Specifies the x-coordinate scale. -1 could be used for flipping the texture horizontally.
* @param scaleY Specifies the y-coordinate scale. -1 could be used for flipping the texture vertically.
* @param color Color in RGBA format.
* @param frame Specifies the frame to draw.
*/
void GRRLIB_DrawTile (const f32 xpos, const f32 ypos, const GRRLIB_texImg *tex,
const f32 degrees, const f32 scaleX, const f32 scaleY,
const u32 color, const int frame) {
if (tex == NULL || tex->data == NULL) {
return;
}
GXTexObj texObj;
f32 width, height;
Mtx m, m1, m2, mv;
// Frame Correction by spiffen
f32 FRAME_CORR = 0.001f;
f32 s1 = (((frame%tex->nbtilew))/(f32)tex->nbtilew)+(FRAME_CORR/tex->w);
f32 s2 = (((frame%tex->nbtilew)+1)/(f32)tex->nbtilew)-(FRAME_CORR/tex->w);
f32 t1 = (((int)(frame/tex->nbtilew))/(f32)tex->nbtileh)+(FRAME_CORR/tex->h);
f32 t2 = (((int)(frame/tex->nbtilew)+1)/(f32)tex->nbtileh)-(FRAME_CORR/tex->h);
GX_InitTexObj(&texObj, tex->data, tex->tilew*tex->nbtilew, tex->tileh*tex->nbtileh, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
if (GRRLIB_Settings.antialias == false) {
GX_InitTexObjLOD(&texObj, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
}
GX_LoadTexObj(&texObj, GX_TEXMAP0);
GX_SetTevOp(GX_TEVSTAGE0, GX_MODULATE);
GX_SetVtxDesc(GX_VA_TEX0, GX_DIRECT);
width = tex->tilew * 0.5f;
height = tex->tileh * 0.5f;
guMtxIdentity(m1);
guMtxScaleApply(m1, m1, scaleX, scaleY, 1.0f);
guVector axis = (guVector) {0, 0, 1};
guMtxRotAxisDeg(m2, &axis, degrees);
guMtxConcat(m2, m1, m);
guMtxTransApply(m, m, xpos+width+tex->handlex-tex->offsetx+(scaleX*( -tex->handley*sin(-DegToRad(degrees)) - tex->handlex*cos(-DegToRad(degrees)) )), ypos+height+tex->handley-tex->offsety+(scaleX*( -tex->handley*cos(-DegToRad(degrees)) + tex->handlex*sin(-DegToRad(degrees)) )), 0);
guMtxConcat(GXmodelView2D, m, mv);
GX_LoadPosMtxImm(mv, GX_PNMTX0);
GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
GX_Position3f32(-width, -height, 0);
GX_Color1u32(color);
GX_TexCoord2f32(s1, t1);
GX_Position3f32(width, -height, 0);
GX_Color1u32(color);
GX_TexCoord2f32(s2, t1);
GX_Position3f32(width, height, 0);
GX_Color1u32(color);
GX_TexCoord2f32(s2, t2);
GX_Position3f32(-width, height, 0);
GX_Color1u32(color);
GX_TexCoord2f32(s1, t2);
GX_End();
GX_LoadPosMtxImm(GXmodelView2D, GX_PNMTX0);
GX_SetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
GX_SetVtxDesc(GX_VA_TEX0, GX_NONE);
}
/**
* Draw a tile in a quad.
* @param pos Vector array of the 4 points.
* @param tex The texture to draw.
* @param color Color in RGBA format.
* @param frame Specifies the frame to draw.
*/
void GRRLIB_DrawTileQuad (const guVector pos[4], GRRLIB_texImg *tex,
const u32 color, const int frame) {
if (tex == NULL || tex->data == NULL) {
return;
}
GXTexObj texObj;
Mtx m, m1, m2, mv;
// Frame Correction by spiffen
f32 FRAME_CORR = 0.001f;
f32 s1 = (((frame%tex->nbtilew))/(f32)tex->nbtilew)+(FRAME_CORR/tex->w);
f32 s2 = (((frame%tex->nbtilew)+1)/(f32)tex->nbtilew)-(FRAME_CORR/tex->w);
f32 t1 = (((int)(frame/tex->nbtilew))/(f32)tex->nbtileh)+(FRAME_CORR/tex->h);
f32 t2 = (((int)(frame/tex->nbtilew)+1)/(f32)tex->nbtileh)-(FRAME_CORR/tex->h);
GX_InitTexObj(&texObj, tex->data, tex->tilew*tex->nbtilew, tex->tileh*tex->nbtileh, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
if (GRRLIB_Settings.antialias == false) {
GX_InitTexObjLOD(&texObj, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
}
GX_LoadTexObj(&texObj, GX_TEXMAP0);
GX_SetTevOp(GX_TEVSTAGE0, GX_MODULATE);
GX_SetVtxDesc(GX_VA_TEX0, GX_DIRECT);
guMtxIdentity(m1);
guMtxScaleApply(m1, m1, 1, 1, 1.0f);
guVector axis = (guVector) {0, 0, 1};
guMtxRotAxisDeg(m2, &axis, 0);
guMtxConcat(m2, m1, m);
guMtxConcat(GXmodelView2D, m, mv);
GX_LoadPosMtxImm(mv, GX_PNMTX0);
GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
GX_Position3f32(pos[0].x, pos[0].y, 0);
GX_Color1u32(color);
GX_TexCoord2f32(s1, t1);
GX_Position3f32(pos[1].x, pos[1].y, 0);
GX_Color1u32(color);
GX_TexCoord2f32(s2, t1);
GX_Position3f32(pos[2].x, pos[2].y, 0);
GX_Color1u32(color);
GX_TexCoord2f32(s2, t2);
GX_Position3f32(pos[3].x, pos[3].y, 0);
GX_Color1u32(color);
GX_TexCoord2f32(s1, t2);
GX_End();
GX_LoadPosMtxImm(GXmodelView2D, GX_PNMTX0);
GX_SetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
GX_SetVtxDesc(GX_VA_TEX0, GX_NONE);
}
/**
* Call this function after drawing.
*/
void GRRLIB_Render (void) {
GX_DrawDone();
GX_InvalidateTexAll();
fb ^= 1; // Flip framebuffer
GX_SetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
GX_SetColorUpdate(GX_TRUE);
GX_CopyDisp(xfb[fb], GX_TRUE);
VIDEO_SetNextFramebuffer(xfb[fb]);
VIDEO_Flush();
VIDEO_WaitVSync();
if (rmode->viTVMode &VI_NON_INTERLACE) VIDEO_WaitVSync() ;
}

37
GRRLIB/GRRLIB/GRRLIB_snapshot.c Normal file
View file

@ -0,0 +1,37 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <grrlib.h>
/**
* Make a snapshot of the screen in a texture.
* @param tex A pointer to a texture representing the screen or NULL if an error occurs.
*/
void GRRLIB_Screen2Texture (GRRLIB_texImg *tex) {
if(tex->data != NULL) {
GX_SetTexCopySrc(0, 0, rmode->fbWidth, rmode->efbHeight);
GX_SetTexCopyDst(rmode->fbWidth, rmode->efbHeight, GX_TF_RGBA8, GX_FALSE);
GX_CopyTex(tex->data, GX_FALSE);
GX_PixModeSync();
GRRLIB_FlushTex(tex);
}
}

239
GRRLIB/GRRLIB/GRRLIB_texEdit.c Normal file
View file

@ -0,0 +1,239 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <jpeglib.h>
#include <malloc.h>
#include <pngu.h>
#include <stdio.h>
#include <string.h>
#include <grrlib.h>
/**
* Convert a raw BMP (RGB, no alpha) to 4x4RGBA.
* @author DragonMinded
* @param src
* @param dst
* @param width
* @param height
*/
static
void RawTo4x4RGBA (const u8 *src, void *dst,
const uint width, const uint height) {
uint block;
uint i;
uint c;
uint ar;
uint gb;
u8 *p = (u8*)dst;
for (block = 0; block < height; block += 4) {
for (i = 0; i < width; i += 4) {
/* Alpha and Red */
for (c = 0; c < 4; ++c) {
for (ar = 0; ar < 4; ++ar) {
/* Alpha pixels */
*p++ = 255;
/* Red pixels */
*p++ = src[((i + ar) + ((block + c) * width)) * 3];
}
}
/* Green and Blue */
for (c = 0; c < 4; ++c) {
for (gb = 0; gb < 4; ++gb) {
/* Green pixels */
*p++ = src[(((i + gb) + ((block + c) * width)) * 3) + 1];
/* Blue pixels */
*p++ = src[(((i + gb) + ((block + c) * width)) * 3) + 2];
}
}
} /* i */
} /* block */
}
/**
* Load a texture from a buffer.
* @param my_img The JPEG or PNG buffer to load.
* @return A GRRLIB_texImg structure filled with image informations.
*/
GRRLIB_texImg* GRRLIB_LoadTexture (const u8 my_img[]) {
if (my_img[0]==0xFF && my_img[1]==0xD8 && my_img[2]==0xFF) {
return (GRRLIB_LoadTextureJPG(my_img));
}
else {
return (GRRLIB_LoadTexturePNG(my_img));
}
}
/**
* Load a texture from a buffer.
* @param my_png the PNG buffer to load.
* @return A GRRLIB_texImg structure filled with image informations.
*/
GRRLIB_texImg* GRRLIB_LoadTexturePNG (const u8 *my_png) {
PNGUPROP imgProp;
IMGCTX ctx;
GRRLIB_texImg *my_texture = (struct GRRLIB_texImg *)calloc(1, sizeof(GRRLIB_texImg));
if(my_texture != NULL) {
ctx = PNGU_SelectImageFromBuffer(my_png);
PNGU_GetImageProperties(ctx, &imgProp);
my_texture->data = memalign(32, imgProp.imgWidth * imgProp.imgHeight * 4);
if(my_texture->data != NULL) {
PNGU_DecodeTo4x4RGBA8(ctx, imgProp.imgWidth, imgProp.imgHeight, my_texture->data, 255);
PNGU_ReleaseImageContext(ctx);
my_texture->w = imgProp.imgWidth;
my_texture->h = imgProp.imgHeight;
GRRLIB_SetHandle( my_texture, 0, 0 );
GRRLIB_FlushTex( my_texture );
}
}
return my_texture;
}
/**
* Load a texture from a buffer.
* Take care to have the JPG finnish with 0xFF 0xD9!!
* @author DrTwox
* @param my_jpg The JPEG buffer to load.
* @return A GRRLIB_texImg structure filled with image informations.
*/
GRRLIB_texImg* GRRLIB_LoadTextureJPG (const u8 *my_jpg) {
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
GRRLIB_texImg *my_texture = (struct GRRLIB_texImg *)calloc(1, sizeof(GRRLIB_texImg));
int n = 0;
unsigned int i;
if(my_texture == NULL)
return NULL;
if ((my_jpg[0]==0xFF) && (my_jpg[1]==0xD8) && (my_jpg[2]==0xFF)) {
while(true) {
if ((my_jpg[n]==0xFF) && (my_jpg[n+1]==0xD9))
break;
n++;
}
n+=2;
}
jpeg_create_decompress(&cinfo);
cinfo.err = jpeg_std_error(&jerr);
cinfo.progress = NULL;
jpeg_memory_src(&cinfo, my_jpg, n);
jpeg_read_header(&cinfo, TRUE);
jpeg_start_decompress(&cinfo);
unsigned char *tempBuffer = (unsigned char*) malloc(cinfo.output_width * cinfo.output_height * cinfo.num_components);
JSAMPROW row_pointer[1];
row_pointer[0] = (unsigned char*) malloc(cinfo.output_width * cinfo.num_components);
size_t location = 0;
while (cinfo.output_scanline < cinfo.output_height) {
jpeg_read_scanlines(&cinfo, row_pointer, 1);
for (i = 0; i < cinfo.image_width * cinfo.num_components; i++) {
/* Put the decoded scanline into the tempBuffer */
tempBuffer[ location++ ] = row_pointer[0][i];
}
}
/* Create a buffer to hold the final texture */
my_texture->data = memalign(32, cinfo.output_width * cinfo.output_height * 4);
RawTo4x4RGBA(tempBuffer, my_texture->data, cinfo.output_width, cinfo.output_height);
/* Done - Do cleanup and release allocated memory */
jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
free(row_pointer[0]);
free(tempBuffer);
my_texture->w = cinfo.output_width;
my_texture->h = cinfo.output_height;
GRRLIB_SetHandle( my_texture, 0, 0 );
GRRLIB_FlushTex( my_texture );
return my_texture;
}
//==============================================================================
/**
* Compose a layer/sprite to a canvas/textured-image
* Currently only performs "a-over-b (normal) alpha compositing" (opacity)
* Ie. Light source is behind the eye, not behind the canvas!
* @author BlueChip
* @param xoff : The x-offset within the canvas (negative values allowed)
* @param yoff : The y-offset within the canvas (negative values allowed)
* @param layer : The layer/sprite to draw
* @param canvas : The canvas/textured-image on which to draw
* @param mode : Currently unused - will be composition mode
*/
//==============================================================================
void GRRLIB_Compose( int xoff, int yoff, GRRLIB_texImg* layer,
GRRLIB_texImg* canvas, GRRLIB_ComposeMode mode )
{
int x, y; // x & y on layer
int cnv_x, cnv_y; // x & y on canvas
float cnv_a, lyr_a, alpha; // Alpha of canvas & layer & result
u32 cnv_c, lyr_c; // Colour of pixel from canvas & layer
u32 new_r, new_g, new_b, new_a; // R, G, B & A values of result
// Loop through the layer, one pixel at a time
for (y = 0; y < layer->h; y++) {
cnv_y = y +yoff; // y coord of canvas pixel to be changed
if (cnv_y < 0) continue ; // not on the canvas yet
if (cnv_y >= canvas->h) break; // off the bottom of the canvas
for (x = 0; x < layer->w; x++) {
cnv_x = x +xoff; // x coord of canvas pixel to be changed
if (cnv_x < 0) continue ; // not on the canvas yet
if (cnv_x >= canvas->h) break; // off the right of the canvas
// Grab the working pixels from the canvas and layer
cnv_c = GRRLIB_GetPixelFromtexImg(cnv_x,cnv_y, canvas);
lyr_c = GRRLIB_GetPixelFromtexImg(x,y, layer);
// Calculate alpha value as 0.0 to 1.0 in 255th's
cnv_a = A(cnv_c) /255.0;
lyr_a = A(lyr_c) /255.0;
// Perform desired composition
switch (mode) {
default:
case GRRLIB_COMPOSE_NORMAL :
// Perform "a-over-b (normal) alpha compositing" (opacity)
// http://en.wikipedia.org/wiki/Alpha_compositing
new_a = (u32)( A(lyr_c) + (A(cnv_c) *(1.0 -lyr_a)) );
alpha = new_a /255.0;
new_r = ( (R(lyr_c) *lyr_a) + (R(cnv_c) *cnv_a *(1 -lyr_a)) ) /alpha;
new_g = ( (G(lyr_c) *lyr_a) + (G(cnv_c) *cnv_a *(1 -lyr_a)) ) /alpha;
new_b = ( (B(lyr_c) *lyr_a) + (B(cnv_c) *cnv_a *(1 -lyr_a)) ) /alpha;
break;
}
// Replace the old canvas pixel with the new one
GRRLIB_SetPixelTotexImg( cnv_x,cnv_y, canvas,
RGBA(new_r, new_g, new_b, new_a) );
}//for x
}// for y
GRRLIB_FlushTex(canvas);
}

242
GRRLIB/GRRLIB/grrlib.h Normal file
View file

@ -0,0 +1,242 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
Library : GRRLIB (GX inside)
Version : 4.1.0
Project Leader : NoNameNo
Documentation : Crayon
Lead Coder : NoNameNo,
Support Coders : BlueChip, DragonMinded, Xane
Advisors : RedShade
------------------------------------------------------------------------------*/
/**
* @file GRRLIB.h
* GRRLIB library.
*/
#ifndef __GRRLIB_H__
#define __GRRLIB_H__
#define __HAVE_GRRLIB__
//==============================================================================
// Includes
//==============================================================================
#include <gccore.h>
//==============================================================================
/*
*** Temporary fix ***
After the release of libogc v1.7.1a, Vector was renamed to guVector
"to avoid collisions" [svn 3650]
...also Quaternion was renamed to guQuaternion - but GRRLIB does not use these!
The main codebase of GRRLIB has been updated to reflect this change.
But until the new libogc is officially released,
if you are using a version of libogc later than v1.7.1a/svn3649,
you will need to add:
-DNOGUFIX
to the compiler flags in your makefile
When the libogc changes are officially released,
this *temporary fix* should be removed
The requirement for -DNOGUFIX will be deprecated,
but its lingering presence will not be a hinderance
Thanks to Nicksasa for reporting this problem :)
*/
//==============================================================================
#ifndef NOGUFIX
// If you are getting a compile error here, read the above comment!
typedef Vector guVector ;
typedef Quaternion guQuaternion ;
#endif
//==============================================================================
// C++ header
//==============================================================================
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
//==============================================================================
// Extra standard declarations
//==============================================================================
typedef unsigned int uint;
//==============================================================================
// Primitive colour macros
//==============================================================================
// Feel free to convert these to inline functions if it floats your boat
#define R(c) (((c) >>24) &0xFF) // Exract RED component of colour
#define G(c) (((c) >>16) &0xFF) // Exract GREEN component of colour
#define B(c) (((c) >> 8) &0xFF) // Exract BLUE component of colour
#define A(c) ( (c) &0xFF) // Exract ALPHA component of colour
// Build an RGB pixel from components
#define RGBA(r,g,b,a) ( (u32)( ( ((u32)(r)) <<24) | \
((((u32)(g)) &0xFF) <<16) | \
((((u32)(b)) &0xFF) << 8) | \
( ((u32)(a)) &0xFF ) ) )
//==============================================================================
// typedefs, enumerators & structs
//==============================================================================
/**
* Compositions Modes
* NORMAL : a-over-b alpha composition (normal)
* ...more to come
*/
typedef enum Composition_Modes {
GRRLIB_COMPOSE_NORMAL,
} GRRLIB_ComposeMode;
//------------------------------------------------------------------------------
/**
* GRRLIB Blending Modes
*/
typedef enum GRRLIB_blendMode {
GRRLIB_BLEND_ALPHA = 0, /**< Alpha Blending. */
GRRLIB_BLEND_ADD = 1, /**< Additive Blending. */
GRRLIB_BLEND_SCREEN = 2, /**< Alpha Light Blending. */
GRRLIB_BLEND_MULTI = 3, /**< Multiply Blending. */
GRRLIB_BLEND_INV = 4, /**< Invert Color Blending. */
} GRRLIB_blendMode;
// Blending mode aliases
#define GRRLIB_BLEND_NONE (GRRLIB_BLEND_ALPHA)
#define GRRLIB_BLEND_LIGHT (GRRLIB_BLEND_ADD)
#define GRRLIB_BLEND_SHADE (GRRLIB_BLEND_MULTI)
//------------------------------------------------------------------------------
/**
* Structure to hold the current drawing settings.
*/
typedef struct GRRLIB_drawSettings {
bool antialias; /**< true => AntiAlias enabled. */
int blend; /**< Blending Mode. */
} GRRLIB_drawSettings;
//------------------------------------------------------------------------------
/**
* Structure to hold the texture informations.
*/
typedef struct GRRLIB_texImg {
uint w; /**< Texture Width. */
uint h; /**< Texture Height. */
int handlex; /**< Texture Handle x. */
int handley; /**< Texture Handle y. */
int offsetx; /**< Texture Offset x. */
int offsety; /**< Texture Offset y. */
bool tiledtex; /**< true => Texture is tiled. */
uint tilew; /**< Width of one tile. */
uint tileh; /**< Height of one tile. */
uint nbtilew; /**< Number of tiles for the x axis. */
uint nbtileh; /**< Number of tiles for the y axis. */
uint tilestart; /**< Offset to tile starting position. */
void *data; /**< Pointer to the texture data. */
} GRRLIB_texImg;
//------------------------------------------------------------------------------
/**
* Structure to hold the bytemap character informations.
*/
typedef struct GRRLIB_bytemapChar {
u8 character; /**< Character identity. */
u8 width; /**< Character width. */
u8 height; /**< Character height. */
s8 relx; /**< Horizontal offset relative to cursor (-128 to 127). */
s8 rely; /**< Vertical offset relative to cursor (-128 to 127). */
u8 kerning; /**< Kerning (Horizontal cursor shift after drawing the character). */
u8 *data; /**< Character data (uncompressed, 8 bits per pixel). */
} GRRLIB_bytemapChar;
//------------------------------------------------------------------------------
/**
* Structure to hold the bytemap font informations.
*/
typedef
struct GRRLIB_bytemapFont {
//! the order of the fields here is changed
//! to encourage efficient structure packing in the compiler
char *name; /**< Font name. */
u32 *palette; /**< Font palette. */
u16 nbChar; /**< Number of characters in font. */
u8 version; /**< Version. */
s8 tracking; /**< Tracking (Add-space after each char) (-128 to 127). */
GRRLIB_bytemapChar *charDef; /**< Array of bitmap characters. */
}
GRRLIB_bytemapFont;
//==============================================================================
// Allow general access to screen and frame information
//==============================================================================
#if defined __GRRLIB_CORE__
# define GRR_EXTERN
# define GRR_INIT(v) = v
# define GRR_INITS(...) = { __VA_ARGS__ }
#else
# define GRR_EXTERN extern
# define GRR_INIT(v)
# define GRR_INITS(...)
#endif
GRR_EXTERN GXRModeObj *rmode;
GRR_EXTERN void *xfb[2] GRR_INITS(NULL, NULL) ;
GRR_EXTERN u32 fb GRR_INIT(0) ;
//==============================================================================
// procedure and function prototypes
// Inline function handling - http://www.greenend.org.uk/rjk/2003/03/inline.html
//==============================================================================
#include "grrlib/GRRLIB__lib.h"
#if defined __GRRLIB_CORE__
# define INLINE
#else
# if __GNUC__ && !__GNUC_STDC_INLINE__
# define INLINE extern inline
# else
# define INLINE inline
# endif
#endif
#include "grrlib/GRRLIB__inline.h"
//==============================================================================
// C++ footer
//==============================================================================
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif // __GRRLIB_H__
/**
* @mainpage GRRLIB Documentation
* @image html grrlib_logo.png
* Welcome to the GRRLIB documentation.
*/

136
GRRLIB/GRRLIB/grrlib/GRRLIB__inline.h Normal file
View file

@ -0,0 +1,136 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
/**
* @file GRRLIB_fnLibrary.h
* GRRLIB inline functions.
*/
#ifndef __GRRLIB_H__
# error Do not include GRRLIB_fnInline.h directly, include only GRRLIB.h
#endif
#ifndef __GRRLIB_FNINLINE_H__
#define __GRRLIB_FNINLINE_H__
//==============================================================================
// Prototypes for inlined functions
//==============================================================================
//------------------------------------------------------------------------------
// GRRLIB_cExtn.h - C extensions (helper functions)
INLINE u8 GRRLIB_ClampVar8 (f32 Value) ;
//------------------------------------------------------------------------------
// GRRLIB_clipping.h - Clipping control
INLINE void GRRLIB_ClipReset (void) ;
INLINE void GRRLIB_ClipDrawing (const int x, const int y,
const int width, const int height) ;
//------------------------------------------------------------------------------
// GRRLIB_collision.h - Collision detection
INLINE bool GRRLIB_PtInRect (const int hotx, const int hoty,
const int hotw, const int hoth,
const int wpadx, const int wpady) ;
INLINE bool GRRLIB_RectInRect (const int rect1x, const int rect1y,
const int rect1w, const int rect1h,
const int rect2x, const int rect2y,
const int rect2w, const int rect2h) ;
INLINE bool GRRLIB_RectOnRect (const int rect1x, const int rect1y,
const int rect1w, const int rect1h,
const int rect2x, const int rect2y,
const int rect2w, const int rect2h) ;
//------------------------------------------------------------------------------
// GRRLIB_fbComplex.h -
INLINE void GRRLIB_NPlot (const guVector v[], const u32 color[],
const long n) ;
INLINE void GRRLIB_NGone (const guVector v[], const u32 color[],
const long n) ;
INLINE void GRRLIB_NGoneFilled (const guVector v[], const u32 color[],
const long n) ;
//------------------------------------------------------------------------------
// GRRLIB_fbGX.h -
INLINE void GRRLIB_GXEngine (const guVector v[], const u32 color[],
const long n, const u8 fmt) ;
//------------------------------------------------------------------------------
// GRRLIB_fbSimple.h -
INLINE void GRRLIB_FillScreen (const u32 color) ;
INLINE void GRRLIB_Plot (const f32 x, const f32 y, const u32 color) ;
INLINE void GRRLIB_Line (const f32 x1, const f32 y1,
const f32 x2, const f32 y2, const u32 color) ;
INLINE void GRRLIB_Rectangle (const f32 x, const f32 y,
const f32 width, const f32 height,
const u32 color, const u8 filled) ;
//------------------------------------------------------------------------------
// GRRLIB_handle.h - Texture handle manipulation
INLINE void GRRLIB_SetHandle (GRRLIB_texImg *tex, const int x, const int y) ;
INLINE void GRRLIB_SetMidHandle (GRRLIB_texImg *tex, const bool enabled) ;
//------------------------------------------------------------------------------
// GRRLIB_pixel.h - Pixel manipulation
INLINE u32 GRRLIB_GetPixelFromtexImg (const int x, const int y,
const GRRLIB_texImg *tex) ;
INLINE void GRRLIB_SetPixelTotexImg (const int x, const int y,
GRRLIB_texImg *tex, const u32 color) ;
INLINE u32 GRRLIB_GetColor (const u8 r, const u8 g, const u8 b, const u8 a) ;
INLINE void GRRLIB_GetPixelFromFB (int x, int y,
u8 *R1, u8 *G1, u8 *B1,
u8 *R2, u8 *G2, u8 *B2) ;
//------------------------------------------------------------------------------
// GRRLIB_settings.h - Rendering functions
INLINE void GRRLIB_SetBlend (const int blendmode) ;
INLINE int GRRLIB_GetBlend (void) ;
INLINE void GRRLIB_SetAntiAliasing (const bool aa) ;
INLINE bool GRRLIB_GetAntiAliasing (void) ;
//------------------------------------------------------------------------------
// GRRLIB_texSetup.h - Create and setup textures
INLINE GRRLIB_texImg* GRRLIB_CreateEmptyTexture (const uint w, const uint h) ;
INLINE void GRRLIB_ClearTex (GRRLIB_texImg* tex) ;
INLINE void GRRLIB_FlushTex (GRRLIB_texImg *tex) ;
INLINE void GRRLIB_FreeTexture (GRRLIB_texImg *tex) ;
//==============================================================================
// Definitions of inlined functions
//==============================================================================
#include <grrlib/GRRLIB_cExtn.h> // C extensions (helper functions)
#include <grrlib/GRRLIB_clipping.h> // Clipping control
#include <grrlib/GRRLIB_collision.h> // Collision detection
#include <grrlib/GRRLIB_fbComplex.h> // Render to framebuffer: Complex primitives
#include <grrlib/GRRLIB_fbGX.h> // Render to framebuffer: Simple GX wrapper
#include <grrlib/GRRLIB_fbSimple.h> // Render to framebuffer: Simple primitives
#include <grrlib/GRRLIB_handle.h> // Texture handle manipulation
#include <grrlib/GRRLIB_pixel.h> // Pixel manipulation
#include <grrlib/GRRLIB_settings.h> // GRRLIB Settings
#include <grrlib/GRRLIB_texSetup.h> // Setup for textures
#endif // __GRRLIB_FNINLINE_H__

123
GRRLIB/GRRLIB/grrlib/GRRLIB__lib.h Normal file
View file

@ -0,0 +1,123 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
/**
* @file GRRLIB_fnLibrary.h
* GRRLIB library functions.
*/
#ifndef __GRRLIB_H__
# error Do not include GRRLIB_fnLib.h directly, include only GRRLIB.h
#endif
#ifndef __GRRLIB_FNLIB_H__
#define __GRRLIB_FNLIB_H__
//==============================================================================
// Prototypes for library contained functions
//==============================================================================
//------------------------------------------------------------------------------
// GRRLIB_bmf.c - BitMapFont functions
GRRLIB_bytemapFont* GRRLIB_LoadBMF (const u8 my_bmf[] ) ;
void GRRLIB_FreeBMF (const GRRLIB_bytemapFont *bmf) ;
void GRRLIB_InitTileSet (GRRLIB_texImg *tex,
const uint tilew, const uint tileh,
const uint tilestart) ;
//------------------------------------------------------------------------------
// GRRLIB_bmfx.c - Bitmap f/x
void GRRLIB_BMFX_FlipH (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest) ;
void GRRLIB_BMFX_FlipV (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest) ;
void GRRLIB_BMFX_Grayscale (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest) ;
void GRRLIB_BMFX_Invert (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest) ;
void GRRLIB_BMFX_Blur (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest, const u32 factor) ;
void GRRLIB_BMFX_Scatter (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest, const u32 factor) ;
void GRRLIB_BMFX_Pixelate (const GRRLIB_texImg *texsrc,
GRRLIB_texImg *texdest, const u32 factor) ;
//------------------------------------------------------------------------------
// GRRLIB_core.c - GRRLIB core functions
void GRRLIB_Init (void) ;
void GRRLIB_Exit (void) ;
//------------------------------------------------------------------------------
// GRRLIB_fbAdvanced.c - Render to framebuffer: Advanced primitives
void GRRLIB_Circle (const f32 x, const f32 y, const f32 radius,
const u32 color, const u8 filled) ;
//------------------------------------------------------------------------------
//! GRRLIB_print.c - Will someome please tell me what these are :)
void GRRLIB_Printf (const f32 xpos, const f32 ypos,
const GRRLIB_texImg *tex, const u32 color,
const f32 zoom, const char *text, ...) ;
void GRRLIB_PrintBMF (const f32 xpos, const f32 ypos,
const GRRLIB_bytemapFont *bmf,
const f32 zoom, const char *text, ...) ;
//------------------------------------------------------------------------------
// GRRLIB_render.c - Rendering functions
void GRRLIB_DrawImg (const f32 xpos, const f32 ypos, const GRRLIB_texImg *tex,
const f32 degrees, const f32 scaleX, const f32 scaleY,
const u32 color) ;
void GRRLIB_DrawImgQuad (const guVector pos[4], GRRLIB_texImg *tex,
const u32 color) ;
void GRRLIB_DrawTile (const f32 xpos, const f32 ypos, const GRRLIB_texImg *tex,
const f32 degrees, const f32 scaleX, const f32 scaleY,
const u32 color, const int frame) ;
void GRRLIB_DrawTileQuad (const guVector pos[4], GRRLIB_texImg *tex,
const u32 color, const int frame) ;
void GRRLIB_Render (void) ;
//------------------------------------------------------------------------------
// GRRLIB_snapshot.c - Create a texture containing a snapshot of the framebuffer
void GRRLIB_Screen2Texture (GRRLIB_texImg *tex) ;
//------------------------------------------------------------------------------
// GRRLIB_texEdit.c - Modifying the content of a texture
GRRLIB_texImg* GRRLIB_LoadTexture (const u8 *my_img) ;
GRRLIB_texImg* GRRLIB_LoadTexturePNG (const u8 *my_png) ;
GRRLIB_texImg* GRRLIB_LoadTextureJPG (const u8 *my_jpg) ;
void GRRLIB_Compose (int xoff, int yoff, GRRLIB_texImg* layer,
GRRLIB_texImg* canvas,
GRRLIB_ComposeMode mode) ;
#endif // __GRRLIB_FNLIB_H__

40
GRRLIB/GRRLIB/grrlib/GRRLIB_cExtn.h Normal file
View file

@ -0,0 +1,40 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <math.h>
/**
* A helper function for the YCbCr -> RGB conversion.
* Clamps the given value into a range of 0 - 255 and thus preventing an overflow.
* @param Value The value to clamp.
* @return Returns a clean, clamped unsigned char.
*/
INLINE
u8 GRRLIB_ClampVar8 (f32 Value) {
/* Using float to increase the precision.
This makes a full spectrum (0 - 255) possible. */
Value = roundf(Value);
if (Value < 0) Value = 0 ;
else if (Value > 255) Value = 255 ;
return (u8)Value;
}

44
GRRLIB/GRRLIB/grrlib/GRRLIB_clipping.h Normal file
View file

@ -0,0 +1,44 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
/**
* Reset the clipping to normal.
*/
INLINE
void GRRLIB_ClipReset (void) {
GX_SetClipMode( GX_CLIP_ENABLE );
GX_SetScissor( 0, 0, rmode->fbWidth, rmode->efbHeight );
}
/**
* Clip the drawing area to an rectangle.
* @param x The x-coordinate of the rectangle.
* @param y The y-coordinate of the rectangle.
* @param width The width of the rectangle.
* @param height The height of the rectangle.
*/
INLINE
void GRRLIB_ClipDrawing (const int x, const int y,
const int width, const int height) {
GX_SetClipMode( GX_CLIP_ENABLE );
GX_SetScissor( x, y, width, height );
}

84
GRRLIB/GRRLIB/grrlib/GRRLIB_collision.h Normal file
View file

@ -0,0 +1,84 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
/**
* Determine whether the specified point lies within the specified rectangle.
* @param hotx Specifies the x-coordinate of the upper-left corner of the rectangle.
* @param hoty Specifies the y-coordinate of the upper-left corner of the rectangle.
* @param hotw The width of the rectangle.
* @param hoth The height of the rectangle.
* @param wpadx Specifies the x-coordinate of the point.
* @param wpady Specifies the y-coordinate of the point.
* @return If the specified point lies within the rectangle, the return value is true otherwise it's false.
*/
INLINE
bool GRRLIB_PtInRect (const int hotx, const int hoty,
const int hotw, const int hoth,
const int wpadx, const int wpady) {
return( ((wpadx>=hotx) && (wpadx<=(hotx+hotw))) &&
((wpady>=hoty) && (wpady<=(hoty+hoth))) );
}
/**
* Determine whether a specified rectangle lies within another rectangle.
* @param rect1x Specifies the x-coordinate of the upper-left corner of the rectangle.
* @param rect1y Specifies the y-coordinate of the upper-left corner of the rectangle.
* @param rect1w Specifies the width of the rectangle.
* @param rect1h Specifies the height of the rectangle.
* @param rect2x Specifies the x-coordinate of the upper-left corner of the rectangle.
* @param rect2y Specifies the y-coordinate of the upper-left corner of the rectangle.
* @param rect2w Specifies the width of the rectangle.
* @param rect2h Specifies the height of the rectangle.
* @return If the specified rectangle lies within the other rectangle, the return value is true otherwise it's false.
*/
INLINE
bool GRRLIB_RectInRect (const int rect1x, const int rect1y,
const int rect1w, const int rect1h,
const int rect2x, const int rect2y,
const int rect2w, const int rect2h) {
return ( (rect1x >= rect2x) && (rect1y >= rect2y) &&
(rect1x+rect1w <= rect2x+rect2w) &&
(rect1y+rect1h <= rect2y+rect2h) );
}
/**
* Determine whether a part of a specified rectangle lies on another rectangle.
* @param rect1x Specifies the x-coordinate of the upper-left corner of the first rectangle.
* @param rect1y Specifies the y-coordinate of the upper-left corner of the first rectangle.
* @param rect1w Specifies the width of the first rectangle.
* @param rect1h Specifies the height of the first rectangle.
* @param rect2x Specifies the x-coordinate of the upper-left corner of the second rectangle.
* @param rect2y Specifies the y-coordinate of the upper-left corner of the second rectangle.
* @param rect2w Specifies the width of the second rectangle.
* @param rect2h Specifies the height of the second rectangle.
* @return If the specified rectangle lies on the other rectangle, the return value is true otherwise it's false.
*/
INLINE
bool GRRLIB_RectOnRect (const int rect1x, const int rect1y,
const int rect1w, const int rect1h,
const int rect2x, const int rect2y,
const int rect2w, const int rect2h) {
return GRRLIB_PtInRect(rect1x, rect1y, rect1w, rect1h, rect2x, rect2y) ||
GRRLIB_PtInRect(rect1x, rect1y, rect1w, rect1h, rect2x+rect2w, rect2y) ||
GRRLIB_PtInRect(rect1x, rect1y, rect1w, rect1h, rect2x+rect2w, rect2y+rect2h) ||
GRRLIB_PtInRect(rect1x, rect1y, rect1w, rect1h, rect2x, rect2y+rect2h) ;
}

54
GRRLIB/GRRLIB/grrlib/GRRLIB_fbComplex.h Normal file
View file

@ -0,0 +1,54 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
/**
* Draw an array of points.
* @param v Array containing the points.
* @param color The color of the points in RGBA format.
* @param n Number of points in the vector array.
*/
INLINE
void GRRLIB_NPlot (const guVector v[], const u32 color[], const long n) {
GRRLIB_GXEngine(v, color, n, GX_POINTS);
}
/**
* Draw a polygon.
* @param v The vector containing the coordinates of the polygon.
* @param color The color of the filled polygon in RGBA format.
* @param n Number of points in the vector.
*/
INLINE
void GRRLIB_NGone (const guVector v[], const u32 color[], const long n) {
GRRLIB_GXEngine(v, color, n, GX_LINESTRIP);
}
/**
* Draw a filled polygon.
* @param v The vector containing the coordinates of the polygon.
* @param color The color of the filled polygon in RGBA format.
* @param n Number of points in the vector.
*/
INLINE
void GRRLIB_NGoneFilled (const guVector v[], const u32 color[], const long n) {
GRRLIB_GXEngine(v, color, n, GX_TRIANGLEFAN);
}

37
GRRLIB/GRRLIB/grrlib/GRRLIB_fbGX.h Normal file
View file

@ -0,0 +1,37 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
/**
* Draws a vector.
*/
INLINE
void GRRLIB_GXEngine (const guVector v[], const u32 color[], const long n,
const u8 fmt) {
int i;
GX_Begin(fmt, GX_VTXFMT0, n);
for (i = 0; i < n; i++) {
GX_Position3f32(v[i].x, v[i].y, v[i].z);
GX_Color1u32(color[i]);
}
GX_End();
}

88
GRRLIB/GRRLIB/grrlib/GRRLIB_fbSimple.h Normal file
View file

@ -0,0 +1,88 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <math.h>
/**
* Clear screen with a specific color.
* @param color The color to use to fill the screen.
*/
INLINE
void GRRLIB_FillScreen (const u32 color) {
GRRLIB_Rectangle(-40, -40,
rmode->fbWidth +80, rmode->xfbHeight +80,
color, 1);
}
/**
* Draw a dot.
* @param x Specifies the x-coordinate of the dot.
* @param y Specifies the y-coordinate of the dot.
* @param color The color of the dot in RGBA format.
*/
INLINE
void GRRLIB_Plot (const f32 x, const f32 y, const u32 color) {
guVector v[] = {{x,y,0.0f}};
u32 ncolor[] = {color};
GRRLIB_NPlot(v, ncolor, 1);
}
/**
* Draw a line.
* @param x1 Starting point for line for the x coordinate.
* @param y1 Starting point for line for the y coordinate.
* @param x2 Ending point for line for the x coordinate.
* @param y2 Ending point for line for the x coordinate.
* @param color Line color in RGBA format.
*/
INLINE
void GRRLIB_Line (const f32 x1, const f32 y1,
const f32 x2, const f32 y2, const u32 color) {
guVector v[] = {{x1,y1,0.0f}, {x2,y2,0.0f}};
u32 ncolor[] = {color,color};
GRRLIB_NGone(v, ncolor, 2);
}
/**
* Draw a rectangle.
* @param x Specifies the x-coordinate of the upper-left corner of the rectangle.
* @param y Specifies the y-coordinate of the upper-left corner of the rectangle.
* @param width The width of the rectangle.
* @param height The height of the rectangle.
* @param color The color of the rectangle in RGBA format.
* @param filled Set to true to fill the rectangle.
*/
INLINE
void GRRLIB_Rectangle (const f32 x, const f32 y,
const f32 width, const f32 height,
const u32 color, const u8 filled) {
f32 x2 = x+width;
f32 y2 = y+height;
guVector v[] = { {x,y,0.0f}, {x2,y,0.0f}, {x2,y2,0.0f}, {x,y2,0.0f},
{x,y,0.0f} };
u32 ncolor[] = {color,color,color,color,color};
if (!filled) GRRLIB_NGone (v, ncolor, 5) ;
else GRRLIB_NGoneFilled(v, ncolor, 4) ;
}

61
GRRLIB/GRRLIB/grrlib/GRRLIB_handle.h Normal file
View file

@ -0,0 +1,61 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
/**
* Set a texture's X and Y handles. e.g. for rotation.
* @param tex The texture to set the handle on.
* @param x The x-coordinate of the handle.
* @param y The y-coordinate of the handle.
*/
INLINE
void GRRLIB_SetHandle (GRRLIB_texImg *tex, const int x, const int y) {
if (tex->tiledtex) {
tex->handlex = -(((int)tex->tilew)/2) + x;
tex->handley = -(((int)tex->tileh)/2) + y;
} else {
tex->handlex = -(((int)tex->w)/2) + x;
tex->handley = -(((int)tex->h)/2) + y;
}
}
/**
* Center a texture's handles. e.g. for rotation.
* @param tex The texture to center.
* @param enabled
*/
INLINE
void GRRLIB_SetMidHandle (GRRLIB_texImg *tex, const bool enabled) {
if (enabled) {
if (tex->tiledtex) {
tex->offsetx = (((int)tex->tilew)/2);
tex->offsety = (((int)tex->tileh)/2);
} else {
tex->offsetx = (((int)tex->w)/2);
tex->offsety = (((int)tex->h)/2);
}
GRRLIB_SetHandle(tex, tex->offsetx, tex->offsety);
} else {
GRRLIB_SetHandle(tex, 0, 0);
tex->offsetx = 0;
tex->offsety = 0;
}
}

118
GRRLIB/GRRLIB/grrlib/GRRLIB_pixel.h Normal file
View file

@ -0,0 +1,118 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
/**
* Return the color value of a pixel from a GRRLIB_texImg.
* @param x Specifies the x-coordinate of the pixel in the texture.
* @param y Specifies the y-coordinate of the pixel in the texture.
* @param tex The texture to get the color from.
* @return The color of a pixel in RGBA format.
*/
INLINE
u32 GRRLIB_GetPixelFromtexImg (const int x, const int y,
const GRRLIB_texImg *tex) {
u8 *truc = (u8*)tex->data;
u32 offset;
offset = (((y >> 2)<<4)*tex->w) + ((x >> 2)<<6) + ((((y&3) << 2) + (x&3) ) << 1); // Fuckin equation found by NoNameNo ;)
return ((*(truc+offset+1)<<24) | (*(truc+offset+32)<<16) | (*(truc+offset+33)<<8) | *(truc+offset));
}
/**
* Set the color value of a pixel to a GRRLIB_texImg.
* @see GRRLIB_FlushTex
* @param x Specifies the x-coordinate of the pixel in the texture.
* @param y Specifies the y-coordinate of the pixel in the texture.
* @param tex The texture to set the color to.
* @param color The color of the pixel in RGBA format.
*/
INLINE
void GRRLIB_SetPixelTotexImg (const int x, const int y,
GRRLIB_texImg *tex, const u32 color) {
u8 *truc = (u8*)tex->data;
u32 offset;
offset = (((y >> 2)<<4)*tex->w) + ((x >> 2)<<6) + ((((y&3) << 2) + (x&3) ) << 1); // Fuckin equation found by NoNameNo ;)
*(truc+offset) = color & 0xFF;
*(truc+offset+1) = (color>>24) & 0xFF;
*(truc+offset+32) = (color>>16) & 0xFF;
*(truc+offset+33) = (color>>8) & 0xFF;
}
/**
* Converts RGBA values to u32 color.
* @param r Amount of red (0 - 255).
* @param g Amount of green (0 - 255).
* @param b Amount of blue (0 - 255).
* @param a Amount of alpha (0 - 255).
* @return Returns the color in u32 format.
*/
INLINE
u32 GRRLIB_GetColor (const u8 r, const u8 g, const u8 b, const u8 a) {
return (r << 24) | (g << 16) | (b << 8) | a;
}
/**
* Reads a pixel directly from the FrontBuffer.
* Since the FB is stored in YCbCr,
* @param x The x-coordinate within the FB.
* @param y The y-coordinate within the FB.
* @param R1 A pointer to a variable receiving the first Red value.
* @param G1 A pointer to a variable receiving the first Green value.
* @param B1 A pointer to a variable receiving the first Blue value.
* @param R2 A pointer to a variable receiving the second Red value.
* @param G2 A pointer to a variable receiving the second Green value.
* @param B2 A pointer to a variable receiving the second Blue value.
*/
INLINE
void GRRLIB_GetPixelFromFB (int x, int y,
u8 *R1, u8 *G1, u8 *B1,
u8 *R2, u8 *G2, u8 *B2) {
u32 Buffer;
u8 *Colors;
// Position Correction
if (x > (rmode->fbWidth/2)) { x = (rmode->fbWidth/2); }
if (x < 0) { x = 0; }
if (y > rmode->efbHeight) { y = rmode->efbHeight; }
if (y < 0) { y = 0; }
// Preparing FB for reading
Buffer = ((u32 *)xfb[fb])[y*(rmode->fbWidth/2)+x];
Colors = (u8 *) &Buffer;
/** Color channel:
Colors[0] = Y1
Colors[1] = Cb
Colors[2] = Y2
Colors[3] = Cr */
*R1 = GRRLIB_ClampVar8( 1.164 * (Colors[0] - 16) + 1.596 * (Colors[3] - 128) );
*G1 = GRRLIB_ClampVar8( 1.164 * (Colors[0] - 16) - 0.813 * (Colors[3] - 128) - 0.392 * (Colors[1] - 128) );
*B1 = GRRLIB_ClampVar8( 1.164 * (Colors[0] - 16) + 2.017 * (Colors[1] - 128) );
*R2 = GRRLIB_ClampVar8( 1.164 * (Colors[2] - 16) + 1.596 * (Colors[3] - 128) );
*G2 = GRRLIB_ClampVar8( 1.164 * (Colors[2] - 16) - 0.813 * (Colors[3] - 128) - 0.392 * (Colors[1] - 128) );
*B2 = GRRLIB_ClampVar8( 1.164 * (Colors[2] - 16) + 2.017 * (Colors[1] - 128) );
}

80
GRRLIB/GRRLIB/grrlib/GRRLIB_settings.h Normal file
View file

@ -0,0 +1,80 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <math.h>
#include "GRRLIB.h"
extern GRRLIB_drawSettings GRRLIB_Settings;
/**
* Set a blending mode.
* @param blendmode The blending mode to use (Default: GRRLIB_BLEND_ALPHA).
*/
INLINE
void GRRLIB_SetBlend (const int blendmode) {
GRRLIB_Settings.blend = blendmode;
switch (GRRLIB_Settings.blend) {
case GRRLIB_BLEND_ALPHA:
GX_SetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
break;
case GRRLIB_BLEND_ADD:
GX_SetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_DSTALPHA, GX_LO_CLEAR);
break;
case GRRLIB_BLEND_SCREEN:
GX_SetBlendMode(GX_BM_BLEND, GX_BL_SRCCLR, GX_BL_DSTALPHA, GX_LO_CLEAR);
break;
case GRRLIB_BLEND_MULTI:
GX_SetBlendMode(GX_BM_SUBSTRACT, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
break;
case GRRLIB_BLEND_INV:
GX_SetBlendMode(GX_BM_BLEND, GX_BL_INVSRCCLR, GX_BL_INVSRCCLR, GX_LO_CLEAR);
break;
}
}
/**
* Get the current blending mode.
* @return The current blending mode.
*/
INLINE
int GRRLIB_GetBlend (void) {
return GRRLIB_Settings.blend;
}
/**
* Turn AntiAliasing on/off.
* @param aa Set to true to enable AntiAliasing (Default: Enabled).
*/
INLINE
void GRRLIB_SetAntiAliasing (const bool aa) {
GRRLIB_Settings.antialias = aa;
}
/**
* Get current AntiAliasing setting.
* @return True if AntiAliasing is enabled.
*/
INLINE
bool GRRLIB_GetAntiAliasing (void) {
return GRRLIB_Settings.antialias;
}

87
GRRLIB/GRRLIB/grrlib/GRRLIB_texSetup.h Normal file
View file

@ -0,0 +1,87 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
#include <malloc.h>
#include <pngu.h>
#include <stdio.h>
#include <string.h>
#include <jpeglib.h> // this bad header file must be included last :(
/**
* Create an empty texture.
* @param w Width of the new texture to create.
* @param h Height of the new texture to create.
* @return A GRRLIB_texImg structure newly created.
*/
INLINE
GRRLIB_texImg* GRRLIB_CreateEmptyTexture (const uint w, const uint h)
{
GRRLIB_texImg *my_texture = (struct GRRLIB_texImg *)calloc(1, sizeof(GRRLIB_texImg));
if(my_texture != NULL) {
my_texture->data = memalign(32, h * w * 4);
my_texture->w = w;
my_texture->h = h;
// Initialize the texture
memset(my_texture->data, '\0', (h * w) << 2);
GRRLIB_SetHandle(my_texture, 0, 0);
GRRLIB_FlushTex(my_texture);
}
return my_texture;
}
/**
* Write the contents of a texture in the data cache down to main memory.
* For performance the CPU holds a data cache where modifications are stored before they get written down to mainmemory.
* @param tex The texture to flush.
*/
INLINE
void GRRLIB_FlushTex (GRRLIB_texImg *tex) {
DCFlushRange(tex->data, tex->w * tex->h * 4);
}
/**
* Free memory allocated for texture.
* @param tex A GRRLIB_texImg structure.
*/
INLINE
void GRRLIB_FreeTexture (GRRLIB_texImg *tex) {
free(tex->data);
free(tex);
tex = NULL;
}
//==============================================================================
/**
* Clear a texture to transparent black
* @param tex : Texture to clear
*/
//==============================================================================
INLINE
void GRRLIB_ClearTex(GRRLIB_texImg* tex)
{
bzero(tex->data, (tex->h *tex->w) <<2);
GRRLIB_FlushTex(tex);
}

43
GRRLIB/GRRLIB/makefile Normal file
View file

@ -0,0 +1,43 @@
# Quick'n'dirty makefile [BC] v2
ifeq ($(strip $(DEVKITPPC)),)
$(error "Use export DEVKITPPC=<path to>devkitPPC and try again")
endif
ifeq ($(strip $(DEVKITPRO)),)
$(error "Use export DEVKITPRO=<path to>devkitPRO and try again")
endif
PWD := $(shell pwd)
CC := $(DEVKITPPC)/bin/powerpc-gekko-gcc
AR := $(DEVKITPPC)/bin/powerpc-gekko-ar
OGC := $(DEVKITPRO)/libogc
INCD := $(OGC)/include
LIBD := $(OGC)/lib/wii
MACHDEP := -DGEKKO -mrvl -mcpu=750 -meabi -mhard-float
CFLAGS := -O2 -Wall $(MACHDEP) -I$(PWD) -I$(INCD)
LIB := grrlib
SRC := $(wildcard *.c)
OBJ := $(patsubst %.c,%.o,$(SRC))
ARC := lib$(LIB).a
HDR := $(LIB).h
INL := $(wildcard $(LIB)/*.h)
all : $(OBJ)
$(AR) -r $(ARC) $(OBJ)
clean :
rm -f $(OBJ) $(ARC)
install :
mkdir -p $(LIBD) $(INCD) $(INCD)/grrlib
cp -f $(ARC) $(LIBD)/
cp -f $(HDR) $(INCD)/
cp -f $(INL) $(INCD)/grrlib
%.o : %.c
$(CC) $(CFLAGS) -c $< -o $@

43
GRRLIB/lib/install.bat Normal file
View file

@ -0,0 +1,43 @@
@echo off
Rem -- Quick'n'dirty library installation util [BC]
Rem -- JPEG library
echo.
echo ---------------------------------------------------------------------------
echo Installing JPEG Library...
echo.
cd jpeg
make install
cd ..
Rem -- PNG & PNGU libraries
echo.
echo ---------------------------------------------------------------------------
echo Installing PNG Library...
echo.
cd png
make install
cd ..
echo.
echo ---------------------------------------------------------------------------
echo Building PNGU Library...
echo.
cd pngu
make clean
make all
cd ..
echo.
echo ---------------------------------------------------------------------------
echo Installing PNGU Library...
echo.
cd pngu
make install
cd ..
Rem -- The End
echo.
echo Done
echo.

35
GRRLIB/lib/install.sh Normal file
View file

@ -0,0 +1,35 @@
#!/bin/bash
set -x
# Quick'n'dirty library installation util [BC]
# JPEG library
echo -e "\n--------------------------------------------------------------------"
echo -e "Installing JPEG Library...\n"
pushd jpeg
make install
popd
# PNG & PNGU libraries
echo -e "\n--------------------------------------------------------------------"
echo -e "Installing PNG Library...\n"
cd png
make install
cd ..
echo -e "\n--------------------------------------------------------------------"
echo -e "Building PNGU Library...\n"
cd pngu
make clean
make all
cd ..
echo -e "\n--------------------------------------------------------------------"
echo -e "Installing PNGU Library...\n"
cd pngu
make install
cd ..
# The End
echo -e "\nDone\n"

45
GRRLIB/lib/jpeg/include/jconfig.h Normal file
View file

@ -0,0 +1,45 @@
/* jconfig.h. Generated automatically by configure. */
/* jconfig.cfg --- source file edited by configure script */
/* see jconfig.doc for explanations */
#define HAVE_PROTOTYPES
#define HAVE_UNSIGNED_CHAR
#define HAVE_UNSIGNED_SHORT
#undef void
#undef const
#undef CHAR_IS_UNSIGNED
#define HAVE_STDDEF_H
#define HAVE_STDLIB_H
#undef NEED_BSD_STRINGS
#undef NEED_SYS_TYPES_H
#undef NEED_FAR_POINTERS
#undef NEED_SHORT_EXTERNAL_NAMES
/* Define this if you get warnings about undefined structures. */
#undef INCOMPLETE_TYPES_BROKEN
#ifdef JPEG_INTERNALS
#undef RIGHT_SHIFT_IS_UNSIGNED
#define INLINE __inline__
/* These are for configuring the JPEG memory manager. */
#undef DEFAULT_MAX_MEM
#undef NO_MKTEMP
#endif /* JPEG_INTERNALS */
#ifdef JPEG_CJPEG_DJPEG
#define BMP_SUPPORTED /* BMP image file format */
#define GIF_SUPPORTED /* GIF image file format */
#define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */
#undef RLE_SUPPORTED /* Utah RLE image file format */
#define TARGA_SUPPORTED /* Targa image file format */
#undef TWO_FILE_COMMANDLINE
#undef NEED_SIGNAL_CATCHER
#undef DONT_USE_B_MODE
/* Define this if you want percent-done progress reports from cjpeg/djpeg. */
#undef PROGRESS_REPORT
#endif /* JPEG_CJPEG_DJPEG */

368
GRRLIB/lib/jpeg/include/jmorecfg.h Normal file
View file

@ -0,0 +1,368 @@
/*
* jmorecfg.h
*
* Copyright (C) 1991-1997, Thomas G. Lane.
* This file is part of the Independent JPEG Group's software.
* For conditions of distribution and use, see the accompanying README file.
*
* This file contains additional configuration options that customize the
* JPEG software for special applications or support machine-dependent
* optimizations. Most users will not need to touch this file.
*/
/*
* Define BITS_IN_JSAMPLE as either
* 8 for 8-bit sample values (the usual setting)
* 12 for 12-bit sample values
* Only 8 and 12 are legal data precisions for lossy JPEG according to the
* JPEG standard, and the IJG code does not support anything else!
* We do not support run-time selection of data precision, sorry.
*/
#define BITS_IN_JSAMPLE 8 /* use 8 or 12 */
/*
* Maximum number of components (color channels) allowed in JPEG image.
* To meet the letter of the JPEG spec, set this to 255. However, darn
* few applications need more than 4 channels (maybe 5 for CMYK + alpha
* mask). We recommend 10 as a reasonable compromise; use 4 if you are
* really short on memory. (Each allowed component costs a hundred or so
* bytes of storage, whether actually used in an image or not.)
*/
#define MAX_COMPONENTS 10 /* maximum number of image components */
/*
* Basic data types.
* You may need to change these if you have a machine with unusual data
* type sizes; for example, "char" not 8 bits, "short" not 16 bits,
* or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits,
* but it had better be at least 16.
*/
/* Representation of a single sample (pixel element value).
* We frequently allocate large arrays of these, so it's important to keep
* them small. But if you have memory to burn and access to char or short
* arrays is very slow on your hardware, you might want to change these.
*/
#if BITS_IN_JSAMPLE == 8
/* JSAMPLE should be the smallest type that will hold the values 0..255.
* You can use a signed char by having GETJSAMPLE mask it with 0xFF.
*/
#ifdef HAVE_UNSIGNED_CHAR
typedef unsigned char JSAMPLE;
#define GETJSAMPLE(value) ((int) (value))
#else /* not HAVE_UNSIGNED_CHAR */
typedef char JSAMPLE;
#ifdef CHAR_IS_UNSIGNED
#define GETJSAMPLE(value) ((int) (value))
#else
#define GETJSAMPLE(value) ((int) (value) & 0xFF)
#endif /* CHAR_IS_UNSIGNED */
#endif /* HAVE_UNSIGNED_CHAR */
#define MAXJSAMPLE 255
#define CENTERJSAMPLE 128
#endif /* BITS_IN_JSAMPLE == 8 */
#if BITS_IN_JSAMPLE == 12
/* JSAMPLE should be the smallest type that will hold the values 0..4095.
* On nearly all machines "short" will do nicely.
*/
typedef short JSAMPLE;
#define GETJSAMPLE(value) ((int) (value))
#define MAXJSAMPLE 4095
#define CENTERJSAMPLE 2048
#endif /* BITS_IN_JSAMPLE == 12 */
/* Representation of a DCT frequency coefficient.
* This should be a signed value of at least 16 bits; "short" is usually OK.
* Again, we allocate large arrays of these, but you can change to int
* if you have memory to burn and "short" is really slow.
*/
typedef short JCOEF;
/* Compressed datastreams are represented as arrays of JOCTET.
* These must be EXACTLY 8 bits wide, at least once they are written to
* external storage. Note that when using the stdio data source/destination
* managers, this is also the data type passed to fread/fwrite.
*/
#ifdef HAVE_UNSIGNED_CHAR
typedef unsigned char JOCTET;
#define GETJOCTET(value) (value)
#else /* not HAVE_UNSIGNED_CHAR */
typedef char JOCTET;
#ifdef CHAR_IS_UNSIGNED
#define GETJOCTET(value) (value)
#else
#define GETJOCTET(value) ((value) & 0xFF)
#endif /* CHAR_IS_UNSIGNED */
#endif /* HAVE_UNSIGNED_CHAR */
/* These typedefs are used for various table entries and so forth.
* They must be at least as wide as specified; but making them too big
* won't cost a huge amount of memory, so we don't provide special
* extraction code like we did for JSAMPLE. (In other words, these
* typedefs live at a different point on the speed/space tradeoff curve.)
*/
/* UINT8 must hold at least the values 0..255. */
#ifdef HAVE_UNSIGNED_CHAR
typedef unsigned char UINT8;
#else /* not HAVE_UNSIGNED_CHAR */
#ifdef CHAR_IS_UNSIGNED
typedef char UINT8;
#else /* not CHAR_IS_UNSIGNED */
typedef short UINT8;
#endif /* CHAR_IS_UNSIGNED */
#endif /* HAVE_UNSIGNED_CHAR */
/* UINT16 must hold at least the values 0..65535. */
#ifdef HAVE_UNSIGNED_SHORT
typedef unsigned short UINT16;
#else /* not HAVE_UNSIGNED_SHORT */
typedef unsigned int UINT16;
#endif /* HAVE_UNSIGNED_SHORT */
/* INT16 must hold at least the values -32768..32767. */
#ifndef XMD_H /* X11/xmd.h correctly defines INT16 */
typedef short INT16;
#endif
/* INT32 must hold at least signed 32-bit values. */
#ifndef XMD_H /* X11/xmd.h correctly defines INT32 */
typedef long INT32;
#endif
/* Datatype used for image dimensions. The JPEG standard only supports
* images up to 64K*64K due to 16-bit fields in SOF markers. Therefore
* "unsigned int" is sufficient on all machines. However, if you need to
* handle larger images and you don't mind deviating from the spec, you
* can change this datatype.
*/
typedef unsigned int JDIMENSION;
#define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */
/* These macros are used in all function definitions and extern declarations.
* You could modify them if you need to change function linkage conventions;
* in particular, you'll need to do that to make the library a Windows DLL.
* Another application is to make all functions global for use with debuggers
* or code profilers that require it.
*/
/* a function called through method pointers: */
#define METHODDEF(type) static type
/* a function used only in its module: */
#define LOCAL(type) static type
/* a function referenced thru EXTERNs: */
#define GLOBAL(type) type
/* a reference to a GLOBAL function: */
#define EXTERN(type) extern type
/* This macro is used to declare a "method", that is, a function pointer.
* We want to supply prototype parameters if the compiler can cope.
* Note that the arglist parameter must be parenthesized!
* Again, you can customize this if you need special linkage keywords.
*/
#ifdef HAVE_PROTOTYPES
#define JMETHOD(type,methodname,arglist) type (*methodname) arglist
#else
#define JMETHOD(type,methodname,arglist) type (*methodname) ()
#endif
/* Here is the pseudo-keyword for declaring pointers that must be "far"
* on 80x86 machines. Most of the specialized coding for 80x86 is handled
* by just saying "FAR *" where such a pointer is needed. In a few places
* explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
*/
#ifdef NEED_FAR_POINTERS
#define FAR far
#else
#define FAR
#endif
/*
* On a few systems, type boolean and/or its values FALSE, TRUE may appear
* in standard header files. Or you may have conflicts with application-
* specific header files that you want to include together with these files.
* Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
*/
#ifndef HAVE_BOOLEAN
# ifndef boolean /* this works around the bug in gctypes.h */
typedef int boolean;
# endif
#define HAVE_BOOLEAN
#endif
#ifndef FALSE /* in case these macros already exist */
#define FALSE 0 /* values of boolean */
#endif
#ifndef TRUE
#define TRUE 1
#endif
/*
* The remaining options affect code selection within the JPEG library,
* but they don't need to be visible to most applications using the library.
* To minimize application namespace pollution, the symbols won't be
* defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
*/
#ifdef JPEG_INTERNALS
#define JPEG_INTERNAL_OPTIONS
#endif
#ifdef JPEG_INTERNAL_OPTIONS
/*
* These defines indicate whether to include various optional functions.
* Undefining some of these symbols will produce a smaller but less capable
* library. Note that you can leave certain source files out of the
* compilation/linking process if you've #undef'd the corresponding symbols.
* (You may HAVE to do that if your compiler doesn't like null source files.)
*/
/* Arithmetic coding is unsupported for legal reasons. Complaints to IBM. */
/* Capability options common to encoder and decoder: */
#define DCT_ISLOW_SUPPORTED /* slow but accurate integer algorithm */
#define DCT_IFAST_SUPPORTED /* faster, less accurate integer method */
#define DCT_FLOAT_SUPPORTED /* floating-point: accurate, fast on fast HW */
/* Encoder capability options: */
#undef C_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */
#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
#define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */
/* Note: if you selected 12-bit data precision, it is dangerous to turn off
* ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit
* precision, so jchuff.c normally uses entropy optimization to compute
* usable tables for higher precision. If you don't want to do optimization,
* you'll have to supply different default Huffman tables.
* The exact same statements apply for progressive JPEG: the default tables
* don't work for progressive mode. (This may get fixed, however.)
*/
#define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */
/* Decoder capability options: */
#undef D_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */
#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
#define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
#define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */
#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */
#define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */
#undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */
#define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */
#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */
#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */
/* more capability options later, no doubt */
/*
* Ordering of RGB data in scanlines passed to or from the application.
* If your application wants to deal with data in the order B,G,R, just
* change these macros. You can also deal with formats such as R,G,B,X
* (one extra byte per pixel) by changing RGB_PIXELSIZE. Note that changing
* the offsets will also change the order in which colormap data is organized.
* RESTRICTIONS:
* 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
* 2. These macros only affect RGB<=>YCbCr color conversion, so they are not
* useful if you are using JPEG color spaces other than YCbCr or grayscale.
* 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
* is not 3 (they don't understand about dummy color components!). So you
* can't use color quantization if you change that value.
*/
#define RGB_RED 0 /* Offset of Red in an RGB scanline element */
#define RGB_GREEN 1 /* Offset of Green */
#define RGB_BLUE 2 /* Offset of Blue */
#define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */
/* Definitions for speed-related optimizations. */
/* If your compiler supports inline functions, define INLINE
* as the inline keyword; otherwise define it as empty.
*/
#ifndef INLINE
#ifdef __GNUC__ /* for instance, GNU C knows about inline */
#define INLINE __inline__
#endif
#ifndef INLINE
#define INLINE /* default is to define it as empty */
#endif
#endif
/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
* two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER
* as short on such a machine. MULTIPLIER must be at least 16 bits wide.
*/
#ifndef MULTIPLIER
#define MULTIPLIER int /* type for fastest integer multiply */
#endif
/* FAST_FLOAT should be either float or double, whichever is done faster
* by your compiler. (Note that this type is only used in the floating point
* DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
* Typically, float is faster in ANSI C compilers, while double is faster in
* pre-ANSI compilers (because they insist on converting to double anyway).
* The code below therefore chooses float if we have ANSI-style prototypes.
*/
#ifndef FAST_FLOAT
#ifdef HAVE_PROTOTYPES
#define FAST_FLOAT float
#else
#define FAST_FLOAT double
#endif
#endif
#endif /* JPEG_INTERNAL_OPTIONS */

1100
GRRLIB/lib/jpeg/include/jpeglib.h Normal file
View file

File diff suppressed because it is too large Load diff

29
GRRLIB/lib/jpeg/include/jpgogc.h Normal file
View file

@ -0,0 +1,29 @@
/****************************************************************************
* libjpeg - 6b wrapper
*
* The version of libjpeg used in libOGC has been modified to include a memory
* source data manager (jmemsrc.c).
*
* softdev November 2006
****************************************************************************/
#ifndef __JPGLIB__
#define __JPGLIB__
#include <jpeglib.h>
typedef struct {
char *inbuffer;
char *outbuffer;
int inbufferlength;
int outbufferlength;
int width;
int height;
int num_colours;
int dct_method;
int dither_mode;
int greyscale;
} JPEGIMG;
int JPEG_Decompress(JPEGIMG * jpgimg);
#endif

27
GRRLIB/lib/jpeg/makefile Normal file
View file

@ -0,0 +1,27 @@
# Quick'n'dirty makefile [BC]
ifeq ($(strip $(DEVKITPPC)),)
$(error "Use export DEVKITPPC=<path to>devkitPPC and try again")
endif
ifeq ($(strip $(DEVKITPRO)),)
$(error "Use export DEVKITPRO=<path to>devkitPRO and try again")
endif
OGC := $(DEVKITPRO)/libogc
HDR := $(shell ls include/*.h)
ARC := $(shell ls lib/wii/*.a)
.PHONY : all install
all :
@echo -e "\nWe must track down the svn repo for the source"
@echo " and add it as an SVN Vendor Branch"
@echo " http://svnbook.red-bean.com/en/1.1/ch07s05.html"
@echo "...For now, all you get is precompiled libraries"
install :
mkdir -p $(OGC)/lib/wii/ $(OGC)/include/
cp -rf $(ARC) $(OGC)/lib/wii/
cp -rf $(HDR) $(OGC)/include/

3569
GRRLIB/lib/png/include/png.h Normal file
View file

File diff suppressed because it is too large Load diff

1481
GRRLIB/lib/png/include/pngconf.h Normal file
View file

File diff suppressed because it is too large Load diff

27
GRRLIB/lib/png/makefile Normal file
View file

@ -0,0 +1,27 @@
# Quick'n'dirty makefile [BC]
ifeq ($(strip $(DEVKITPPC)),)
$(error "Use export DEVKITPPC=<path to>devkitPPC and try again")
endif
ifeq ($(strip $(DEVKITPRO)),)
$(error "Use export DEVKITPRO=<path to>devkitPRO and try again")
endif
OGC := $(DEVKITPRO)/libogc
HDR := $(shell ls include/*.h)
ARC := $(shell ls lib/wii/*.a)
.PHONY : all install
all :
@echo -e "\nWe must track down the svn repo for the source"
@echo " and add it as an SVN Vendor Branch"
@echo " http://svnbook.red-bean.com/en/1.1/ch07s05.html"
@echo "...For now, all you get is precompiled libraries"
install :
mkdir -p $(OGC)/lib/wii/ $(OGC)/include/
cp -rf $(ARC) $(OGC)/lib/wii/
cp -rf $(HDR) $(OGC)/include/

39
GRRLIB/lib/pngu/makefile Normal file
View file

@ -0,0 +1,39 @@
# Quick'n'dirty makefile [BC] v2
ifeq ($(strip $(DEVKITPPC)),)
$(error "Use export DEVKITPPC=<path to>devkitPPC and try again")
endif
ifeq ($(strip $(DEVKITPRO)),)
$(error "Use export DEVKITPRO=<path to>devkitPRO and try again")
endif
CC := $(DEVKITPPC)/bin/powerpc-gekko-gcc
AR := $(DEVKITPPC)/bin/powerpc-gekko-ar
OGC := $(DEVKITPRO)/libogc
INCD := $(OGC)/include
LIBD := $(OGC)/lib/wii
MACHDEP := -DGEKKO -mrvl -mcpu=750 -meabi -mhard-float
CFLAGS := -O2 -Wall $(MACHDEP) -I $(INCD)
LIB := pngu
SRC := $(shell ls *.c)
OBJ := $(patsubst %.c,%.o,$(SRC))
ARC := lib$(LIB).a
HDR := $(LIB).h
all : $(OBJ)
$(AR) -r $(ARC) $(OBJ)
clean :
rm -f $(OBJ) $(ARC)
install :
mkdir -p $(LIBD) $(INCD)
cp -f $(ARC) $(LIBD)/
cp -f $(HDR) $(INCD)/
%.o : %.c
$(CC) $(CFLAGS) -c $< -o $@

1132
GRRLIB/lib/pngu/pngu.c Normal file
View file

File diff suppressed because it is too large Load diff

171
GRRLIB/lib/pngu/pngu.h Normal file
View file

@ -0,0 +1,171 @@
/********************************************************************************************
PNGU Version : 0.2a
Coder : frontier
More info : http://frontier-dev.net
********************************************************************************************/
#ifndef __PNGU__
#define __PNGU__
// Return codes
#define PNGU_OK 0
#define PNGU_ODD_WIDTH 1
#define PNGU_ODD_STRIDE 2
#define PNGU_INVALID_WIDTH_OR_HEIGHT 3
#define PNGU_FILE_IS_NOT_PNG 4
#define PNGU_UNSUPPORTED_COLOR_TYPE 5
#define PNGU_NO_FILE_SELECTED 6
#define PNGU_CANT_OPEN_FILE 7
#define PNGU_CANT_READ_FILE 8
#define PNGU_LIB_ERROR 9
// Color types
#define PNGU_COLOR_TYPE_GRAY 1
#define PNGU_COLOR_TYPE_GRAY_ALPHA 2
#define PNGU_COLOR_TYPE_PALETTE 3
#define PNGU_COLOR_TYPE_RGB 4
#define PNGU_COLOR_TYPE_RGB_ALPHA 5
#define PNGU_COLOR_TYPE_UNKNOWN 6
#ifdef __cplusplus
extern "C" {
#endif
// Types
typedef unsigned char PNGU_u8;
typedef unsigned short PNGU_u16;
typedef unsigned int PNGU_u32;
typedef unsigned long long PNGU_u64;
typedef struct
{
PNGU_u8 r;
PNGU_u8 g;
PNGU_u8 b;
} PNGUCOLOR;
typedef struct
{
PNGU_u32 imgWidth; // In pixels
PNGU_u32 imgHeight; // In pixels
PNGU_u32 imgBitDepth; // In bitx
PNGU_u32 imgColorType; // PNGU_COLOR_TYPE_*
PNGU_u32 validBckgrnd; // Non zero if there is a background color
PNGUCOLOR bckgrnd; // Backgroun color
PNGU_u32 numTrans; // Number of transparent colors
PNGUCOLOR *trans; // Transparent colors
} PNGUPROP;
// Image context, always initialize with SelectImageFrom* and free with ReleaseImageContext
struct _IMGCTX;
typedef struct _IMGCTX *IMGCTX;
/****************************************************************************
* Pixel conversion *
****************************************************************************/
// Macro to convert RGB8 values to RGB565
#define PNGU_RGB8_TO_RGB565(r,g,b) ( ((((PNGU_u16) r) & 0xF8U) << 8) | ((((PNGU_u16) g) & 0xFCU) << 3) | (((PNGU_u16) b) >> 3) )
// Macro to convert RGBA8 values to RGB5A3
#define PNGU_RGB8_TO_RGB5A3(r,g,b,a) (PNGU_u16) (((a & 0xE0U) == 0xE0U) ? \
(0x8000U | ((((PNGU_u16) r) & 0xF8U) << 7) | ((((PNGU_u16) g) & 0xF8U) << 2) | (((PNGU_u16) b) >> 3)) : \
(((((PNGU_u16) a) & 0xE0U) << 7) | ((((PNGU_u16) r) & 0xF0U) << 4) | (((PNGU_u16) g) & 0xF0U) | ((((PNGU_u16) b) & 0xF0U) >> 4)))
// Function to convert two RGB8 values to YCbYCr
PNGU_u32 PNGU_RGB8_TO_YCbYCr (PNGU_u8 r1, PNGU_u8 g1, PNGU_u8 b1, PNGU_u8 r2, PNGU_u8 g2, PNGU_u8 b2);
// Function to convert an YCbYCr to two RGB8 values.
void PNGU_YCbYCr_TO_RGB8 (PNGU_u32 ycbycr, PNGU_u8 *r1, PNGU_u8 *g1, PNGU_u8 *b1, PNGU_u8 *r2, PNGU_u8 *g2, PNGU_u8 *b2);
/****************************************************************************
* Image context handling *
****************************************************************************/
// Selects a PNG file, previosly loaded into a buffer, and creates an image context for subsequent procesing.
IMGCTX PNGU_SelectImageFromBuffer (const void *buffer);
// Selects a PNG file, from any devoptab device, and creates an image context for subsequent procesing.
IMGCTX PNGU_SelectImageFromDevice (const char *filename);
// Frees resources associated with an image context. Always call this function when you no longer need the IMGCTX.
void PNGU_ReleaseImageContext (IMGCTX ctx);
/****************************************************************************
* Miscelaneous *
****************************************************************************/
// Retrieves info from selected PNG file, including image dimensions, color format, background and transparency colors.
int PNGU_GetImageProperties (IMGCTX ctx, PNGUPROP *fileproperties);
/****************************************************************************
* Image conversion *
****************************************************************************/
// Expands selected image into an YCbYCr buffer. You need to specify context, image dimensions,
// destination address and stride in pixels (stride = buffer width - image width).
int PNGU_DecodeToYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
// Macro for decoding an image inside a buffer at given coordinates.
#define PNGU_DECODE_TO_COORDS_YCbYCr(ctx,coordX,coordY,imgWidth,imgHeight,bufferWidth,bufferHeight,buffer) \
\
PNGU_DecodeToYCbYCr (ctx, imgWidth, imgHeight, ((void *) buffer) + (coordY) * (bufferWidth) * 2 + \
(coordX) * 2, (bufferWidth) - (imgWidth))
// Expands selected image into a linear RGB565 buffer. You need to specify context, image dimensions,
// destination address and stride in pixels (stride = buffer width - image width).
int PNGU_DecodeToRGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
// Macro for decoding an image inside a buffer at given coordinates.
#define PNGU_DECODE_TO_COORDS_RGB565(ctx,coordX,coordY,imgWidth,imgHeight,bufferWidth,bufferHeight,buffer) \
\
PNGU_DecodeToRGB565 (ctx, imgWidth, imgHeight, ((void *) buffer) + (coordY) * (bufferWidth) * 2 + \
(coordX) * 2, (bufferWidth) - (imgWidth))
// Expands selected image into a linear RGBA8 buffer. You need to specify context, image dimensions,
// destination address, stride in pixels and default alpha value, which is used if the source image
// doesn't have an alpha channel.
int PNGU_DecodeToRGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride, PNGU_u8 default_alpha);
// Macro for decoding an image inside a buffer at given coordinates.
#define PNGU_DECODE_TO_COORDS_RGBA8(ctx,coordX,coordY,imgWidth,imgHeight,default_alpha,bufferWidth,bufferHeight,buffer) \
\
PNGU_DecodeToRGBA8 (ctx, imgWidth, imgHeight, ((void *) buffer) + (coordY) * (bufferWidth) * 2 + \
(coordX) * 2, (bufferWidth) - (imgWidth), default_alpha)
// Expands selected image into a 4x4 tiled RGB565 buffer. You need to specify context, image dimensions
// and destination address.
int PNGU_DecodeTo4x4RGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer);
// Expands selected image into a 4x4 tiled RGB5A3 buffer. You need to specify context, image dimensions,
// destination address and default alpha value, which is used if the source image doesn't have an alpha channel.
int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha);
// Expands selected image into a 4x4 tiled RGBA8 buffer. You need to specify context, image dimensions,
// destination address and default alpha value, which is used if the source image doesn't have an alpha channel.
int PNGU_DecodeTo4x4RGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha);
// Encodes an YCbYCr image in PNG format and stores it in the selected device or memory buffer. You need to
// specify context, image dimensions, destination address and stride in pixels (stride = buffer width - image width).
int PNGU_EncodeFromYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
// Macro for encoding an image stored into an YCbYCr buffer at given coordinates.
#define PNGU_ENCODE_TO_COORDS_YCbYCr(ctx,coordX,coordY,imgWidth,imgHeight,bufferWidth,bufferHeight,buffer) \
\
PNGU_EncodeFromYCbYCr (ctx, imgWidth, imgHeight, ((void *) buffer) + (coordY) * (bufferWidth) * 2 + \
(coordX) * 2, (bufferWidth) - (imgWidth))
#ifdef __cplusplus
}
#endif
#endif

BIN
examples/bluechip/composition/blue70.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.8 KiB

153
examples/bluechip/composition/composition.c Normal file
View file

@ -0,0 +1,153 @@
/*------------------------------------------------------------------------------
Copyright (c) 2009 The GRRLIB Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------*/
//------------------------------------------------------------------------------
// Test Harness for alpha composition functions
/*
PaintShopPro_X2 readings:
| | Blue-over-Red | Red-over-Blue |
|--------+---------------+---------------|
| Normal | 0x2D'00'D2'D8 | 0x96'00'69'D8 |
| | | |
*/
//------------------------------------------------------------------------------
#include <stdlib.h> // exit
#include <wiiuse/wpad.h>
#include <grrlib.h>
#include "red50.h"
#include "blue70.h"
//------------------------------------------------------------------------------
void wscan(ir_t* ir) ;
// Wiimote overscan (to allow the cursor to move off the dge of the screen)
#define WOVERX (200)
#define WOVERY (300)
#define WMU_MAX (2) // How many wiimotes to read
ir_t ir[WMU_MAX];
//------------------------------------------------------------------------------
void test_compose(void)
{
int redOnTop = 0; // Red square starts behind the blue one
// Our two translucent test images
GRRLIB_texImg* red = GRRLIB_LoadTexture(red50);
GRRLIB_texImg* blu = GRRLIB_LoadTexture(blue70);
// The canvas we will be composing on
GRRLIB_texImg* cnv = GRRLIB_CreateEmptyTexture(400,400);
// Loop until home key pressed
do {
// Scan the wiimotes
wscan(ir);
// 'A' toggles z-coord of red sqaure (on-top / behind)
if (WPAD_ButtonsDown(0) & WPAD_BUTTON_A) redOnTop ^= 1 ;
// Clear canvas
GRRLIB_ClearTex(cnv);
// Compose canvas
if (!redOnTop)
GRRLIB_Compose(ir[0].x-180,ir[0].y-180, red, cnv, GRRLIB_COMPOSE_NORMAL);
GRRLIB_Compose(125,125, blu, cnv, GRRLIB_COMPOSE_NORMAL) ;
if ( redOnTop)
GRRLIB_Compose(ir[0].x-180,ir[0].y-180, red, cnv, GRRLIB_COMPOSE_NORMAL);
// Paint the screen black
GRRLIB_FillScreen(0x000000FF);
// Draw frame
GRRLIB_Rectangle(38,38,404,404,0x808080FF,false);
GRRLIB_Rectangle(39,39,402,402,0x808080FF,false);
// Draw Test bar
GRRLIB_Rectangle(283,50,20,380,0xFFFFFFFF, true);
// Draw Composed Canvas
GRRLIB_DrawImg(40,40, cnv,0.0, 1.0,1.0, 0xFFFFFFFF);
// Test card (alpha performed by Wii)
GRRLIB_Rectangle(570,50,20,450,0xFFFFFFFF, true);
GRRLIB_DrawImg(450, 65, red,0.0, 1.0,1.0, 0xFFFFFFFF);
GRRLIB_DrawImg(450,165, blu,0.0, 1.0,1.0, 0xFFFFFFFF);
GRRLIB_DrawImg(450,265, red,0.0, 1.0,1.0, 0xFFFFFFFF);
// Draw it [and workaround bug in GRRLIB]
GRRLIB_Render();
if (rmode->viTVMode &VI_NON_INTERLACE) VIDEO_WaitVSync() ;
} while(!(WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME)); // Exit on home key
// Free up the resources we are using to hold the canvas and layers
GRRLIB_FreeTexture(blu);
GRRLIB_FreeTexture(red);
GRRLIB_FreeTexture(cnv);
}
//------------------------------------------------------------------------------
void wscan(ir_t* ir)
{
int i;
WPAD_ScanPads();
for (i = 0; i < WMU_MAX; i++) {
WPAD_IR(i, &ir[i]);
ir->x -= WOVERX/2;
ir->y -= WOVERY/2;
}
}
//------------------------------------------------------------------------------
int main(int argc, char** argv)
{
(void)argc;
(void)argv;
int i;
// Init graphics subsystem
GRRLIB_Init();
// Init the Wiimotes
WPAD_Init();
for (i = 0; i < WMU_MAX; i++) {
WPAD_SetVRes(i, rmode->fbWidth+WOVERX, rmode->xfbHeight+WOVERY);
WPAD_SetDataFormat(i, WPAD_FMT_BTNS_ACC_IR);
}
// Call the demo
test_compose();
// Clear up memory
GRRLIB_Exit();
exit(0);
}

76
examples/bluechip/composition/makefile Normal file
View file

@ -0,0 +1,76 @@
# Quick'n'dirty makefile [BC] v2
ifeq ($(strip $(DEVKITPPC)),)
$(error "Use export DEVKITPPC=<path to>devkitPPC and try again")
endif
ifeq ($(strip $(DEVKITPRO)),)
$(error "Use export DEVKITPRO=<path to>devkitPRO and try again")
endif
APP := compose
ELF := $(APP).elf
DOL := $(APP).dol
MAP := $(notdir $(ELF)).map
LIBS := -lgrrlib -lpngu -lpng -ljpeg -lz
LIBS += -lwiiuse
#LIBS += -lmodplay -lasnd
LIBS += -lbte -logc
LIBS += -lm
BINDIR := $(DEVKITPPC)/bin
PREFIX := $(BINDIR)/powerpc-gekko-
CC := $(PREFIX)gcc
CXX := $(PREFIX)g++
AR := $(PREFIX)ar
AS := $(PREFIX)as
LD := $(CC)
OBJCOPY := $(PREFIX)objcopy
ELF2DOL := $(BINDIR)/elf2dol
UPLOAD := $(BINDIR)/wiiload
OGC := $(DEVKITPRO)/libogc
INCD := $(OGC)/include
LIBD := $(OGC)/lib/wii
MACHDEP := -DGEKKO -mrvl -mcpu=750 -meabi -mhard-float
CFLAGS := -O2 -Wall $(MACHDEP) -I $(INCD)
LDFLAGS = $(MACHDEP) -Wl,-Map,$(MAP)
LIBPATHS := -L$(DEVKITPRO)/libogc/lib/wii
SRC := $(shell ls *.c)
SRCOBJ := $(patsubst %.c,%.o,$(SRC))
RES := $(shell ls *.png)
RESOBJ := $(patsubst %.png,%.o,$(RES))
RESC := $(patsubst %.png,%.c,$(RES))
RESH := $(patsubst %.png,%.h,$(RES))
OBJ := $(RESOBJ) $(SRCOBJ)
all : $(DOL)
$(DOL) : $(ELF)
@echo Converting to: $@
@$(ELF2DOL) $< $@
$(ELF) : $(OBJ)
@echo Linking as: $@
@$(CC) $^ $(LDFLAGS) $(LIBPATHS) $(LIBS) -o $@
clean :
rm -f $(OBJ) $(RESC) $(RESH) $(ELF) $(DOL) $(MAP)
run : $(DOL)
$(UPLOAD) $(DOL)
%.o : %.c
@echo Compiling: $<
@$(CC) $(CFLAGS) -c $< -o $@
.PRECIOUS : %.c
%.c : %.png
@echo Converting resource: $<
@./raw2c.exe $<

BIN
examples/bluechip/composition/raw2c.exe Normal file
View file

Binary file not shown.

BIN
examples/bluechip/composition/red50.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 3.3 KiB