// Varias funciones para la rotacion de graficos
	// Requiere DevkitARM R30 o superior
	// Requiere NightFox's Lib
	// Codigo por NightFox
	// http://www.nightfoxandco.com	
 
 
 
	// Funcion Rotate16bitsImage();
	void Rotate16bitsImage(u8 id) {
 
		// Variables
		s16 x = 0;
		s16 y = 0;
 
		// Crea un buffer temporal de 16 bits
		u16* temp;
		temp = NULL;
		temp = (u16*) calloc ((NF_BG16B[id].size >> 1), sizeof(u16));
		if (temp == NULL) NF_Error(102, NULL, NF_BG16B[id].size);
 
		// Copia los bytes del buffer original al temporal, invirtiendo el orden
		for (y = 0; y < 192; y ++) {
			for (x = 0; x < 256; x ++) {
				temp[(((191 - y) << 8) + (255 - x))] = NF_BG16B[id].buffer[((y << 8) + x)];
			}
		}
 
		// Copia el buffer temporal ya invertido al original
		memcpy(NF_BG16B[id].buffer, temp, NF_BG16B[id].size);
 
		// Libera el buffer
		free(temp);
		temp = NULL;
 
	}
 
 
 
	// Funcion RotateTiledBg();
	void RotateTiledBg(const char* name) {
 
		// Variables
		s32 n = 0;			// Bucle
		s32 z = 0;
		s32 address = 0;	// Direccion
		u8 slot = 255;		// Slot seleccionado
		char bg[32];		// Nombre
 
		// Busca el fondo solicitado
		sprintf(bg, "%s", name);							// Obten el nombre del fondo a buscar
		for (n = 0; n < NF_SLOTS_TBG; n ++) {				// Busca en todos los slots
			if (strcmp(bg, NF_TILEDBG[n].name) == 0) {		// Si lo encuentras
				slot = n;									// Guarda el slot a usar
				n = NF_SLOTS_TBG;							// Deja de buscar
			}
		}
		// Si no se encuentra, error
		if (slot == 255) {
			NF_Error(104, name, 0);
		}
 
		//////////////////////
		// Invierte el mapa //
		//////////////////////
 
		// Crea el buffer temporal
		char* temp;
		temp = NULL;
		temp = (char*) calloc (NF_TILEDBG[slot].mapsize, sizeof(char));
		if (temp == NULL) NF_Error(102, NULL, NF_TILEDBG[slot].mapsize);
 
		// Copia el buffer del mapa al temporal, invirtiendo el orden
		for (n = 0; n < NF_TILEDBG[slot].mapsize; n += 2) {
			address = ((NF_TILEDBG[slot].mapsize - 2) - n);
			temp[address] = *(NF_BUFFER_BGMAP[slot] + n);
			temp[(address + 1)] = *(NF_BUFFER_BGMAP[slot] + (n + 1));
		}
 
		// Copia el buffer temporal, ya invertido, al original
		memcpy(NF_BUFFER_BGMAP[slot], temp, NF_TILEDBG[slot].mapsize);
 
		// Borra el buffer temporal
		free(temp);
		temp = NULL;
 
		/////////////////////////
		// Invierte el tileset //
		/////////////////////////
 
		// Crea el buffer temporal
		temp = (char*) calloc (NF_TILEDBG[slot].tilesize, sizeof(char));
		if (temp == NULL) NF_Error(102, NULL, NF_TILEDBG[slot].tilesize);
 
		// Copia el buffer del tileset al temporal, invirtiendo el orden
		for (n = 0; n < NF_TILEDBG[slot].tilesize; n += 64) {
			for (z = 0; z < 64; z ++) {
				temp[(n + (63 - z))] = *(NF_BUFFER_BGTILES[slot] + (n + z));
			}
		}
 
		// Copia el buffer temporal, ya invertido, al original
		memcpy(NF_BUFFER_BGTILES[slot], temp, NF_TILEDBG[slot].tilesize);
 
		// Borra el buffer temporal
		free(temp);
		temp = NULL;
 
	}
 
 
 
	// Funcion RotateSprite();
	void RotateSprite(u16 id) {
 
		// Variables
		s32 n = 0;			// Bucle
		s32 address = 0;
 
		// Crea el buffer temporal
		char* temp;
		temp = NULL;
		temp = (char*) calloc (NF_SPR256GFX[id].size, sizeof(char));
		if (temp == NULL) NF_Error(102, NULL, NF_SPR256GFX[id].size);
 
		// Copia el buffer del sprite al temporal, invirtiendo el orden
		for (n = 0; n < NF_SPR256GFX[id].size; n += 2) {
			address = ((NF_SPR256GFX[id].size - 2) - n);
			temp[address] = *(NF_BUFFER_SPR256GFX[id] + (n + 1));
			temp[(address + 1)] = *(NF_BUFFER_SPR256GFX[id] + n);
		}
 
		// Copia el buffer temporal, ya invertido, al original
		memcpy(NF_BUFFER_SPR256GFX[id], temp, NF_SPR256GFX[id].size);
 
		// Borra el buffer temporal
		free(temp);
		temp = NULL;
 
	}
 
 
 
	// Funcion Rotate3dSprite();
	void Rotate3dSprite(u16 id) {
 
		// Variables
		s32 n = 0;			// Bucle
 
		// Crea el buffer temporal
		char* temp;
		temp = NULL;
		temp = (char*) calloc (NF_SPR256GFX[id].size, sizeof(char));
		if (temp == NULL) NF_Error(102, NULL, NF_SPR256GFX[id].size);
 
		// Copia el buffer del sprite al temporal, invirtiendo el orden
		for (n = 0; n < NF_SPR256GFX[id].size; n ++) {
			temp[((NF_SPR256GFX[id].size - 1) - n)] = *(NF_BUFFER_SPR256GFX[id] + n);
		}
 
		// Copia el buffer temporal, ya invertido, al original
		memcpy(NF_BUFFER_SPR256GFX[id], temp, NF_SPR256GFX[id].size);
 
		// Borra el buffer temporal
		free(temp);
		temp = NULL;
 
	}