› Foros › Multiplataforma › Desarrollo
saulotmalo escribió:pd: joer que putada más competencia xD
Eskematico escribió:
No te molestes hombre, si voy a ganar el proximo gbax con el comando2
la memoria en PSP no sobra
Hombre, no se yo donde ves el beneficio de usar sprites de 16 colores en un juego de Game BoyEskematico escribió:Osea q los graficos a 256 colores ya se ven pobres, ni te digo usar 16 colores, eso estaria bien para la gb o la gba, pero en una psp usar 16 colores...
¿Lo has probado? pq hablar de teoria esta muy bien, pero yo con 256 ya veo un acabado bastante cutre, con 16.......
Chano Marrano escribió:Creo que estás haciendo mal los cálculos. En las imágenes paletizadas se guardan por un lado la paleta y por otro lado la imagen, apuntando los píxeles de la imagen a los colores almacenados en la paleta:
Paleta: numColores * componentes * bitsPorComponente = 256 * 3 * 8 = 6144 bits = 768 bytes.
Imagen: imágenes * ancho * alto * punteroAPosiciónPaleta = 256 * 100 * 100 * 8 = 20480000 bits = 2560000 bytes.
Así que cada personaje debería ocupar en RAM 2560768 bytes = 2.44 MB. Además, si guardas los sprites con 16 colores en vez de con 256, el personaje ocupa la mitad, pudiendo meter en la RAM de la PSP hasta 25 personajes distintos. Por otro lado, 256 animaciones por personaje me parece un número excesivo incluso para un proyecto comercial.
http://sdb.drshnaps.com/sheets/Media/Other/JumpSuperstars/GokuFull.png
Tomando como ejemplo el Jump Superstars de la DS, cada personaje ocupa como máximo 64x64 pixels, usa una paleta de 16 colores tiene como mucho unas 128 animaciones. De esta forma, cada personaje ocupa:
Paleta: numColores * bitsPorColor = 16 * 16 = 256 bits = 32 bytes.
Imagen: imágenes * ancho * alto * punteroAPosiciónPaleta = 128 * 64 * 64 * 4 = 2097152 bits = 262144 bytes.
Por tanto, cada personaje ocupa unos 256 KB. Y todo esto sin tener en cuenta que la PSP soporta texturas comprimidas por hardware.
Eso es e el caso de que se use una paleta de colores!! pero si no se usa? que es en la mayoría de homebrew... en mi caso gasto SDL la cual NO usa una paleta de colores por lo tanto al menos para SDL, LUA y todo lo que pongas cargarImagen("nombreimagen") se suele gastar la imagen sin paleta de colores por eso ocupa tanto.
saulotmalo escribió:por lo que dice PiratePila yo he estado buscando tambien diseñadores y he encontrado alguno pero además tengo pensado gastar los sprites del animayhem... si quieres puedes gastarlos tambien supongo xD si no se enfadan los creadores
mira en la imagen que has mostrado... la verdad es que... deja mucho que desear
la gba, corrigeme si me equivoco, la memoria del cartucho es como una memoria ram pero en la PSP la memoria ram es ram y la vram vram
el caso es que SDL guarda las imagenes de una determinada manera... sin gastar paletas ni nada
PiratePila escribió:
¿ Que sprites son esos ?
Aclaramelo por que no entiendo lo que quieres decir.
saulotmalo escribió:es un juego que salió para psp homebrew tiene las imagenes en el conjunto que reparten y tal...
Chano Marrano escribió:Precisamente los sprites que usa el juego Animayhem son de 16 colores, aunque en la carpeta están guardados en formato PNG.
El archivo adjunto contiene los sprites de Naruto en formato BMP de 16 colores:
#include <pspkernel.h>
#include <pspdebug.h>
#include <pspctrl.h>
#include <pspdisplay.h>
#include <psppower.h>
#include <psprtc.h>
#include <png.h>
#include <SDL.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string>
#include <list>
#include <iostream>
#include <fstream>
//malo
#include <SDL.h>
#define IMG_4BIT 0
#define IMG_8BIT 1
#define IMG_24BIT 2
PSP_MODULE_INFO("Test", 0, 1, 1);
PSP_MAIN_THREAD_ATTR(THREAD_ATTR_USER | THREAD_ATTR_VFPU);
static bool isrunning = true;
static int curWindow = 1;
int exit_callback(int arg1, int arg2, void *common) {
isrunning = false;
sceKernelExitGame();
return 0;
}
// Callback thread
int CallbackThread(SceSize args, void *argp) {
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
sceKernelSleepThreadCB();
return 0;
}
// Sets up the callback thread and returns its thread id
int SetupCallbacks(void) {
int thid = 0;
thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
if(thid >= 0)
{
sceKernelStartThread(thid, 0, 0);
}
return thid;
}
int bench(int profundidadBmp, unsigned int bucles, SDL_Surface *pantalla, FILE *fichero)
{
int i;
Uint32 inicio, fin;
SDL_Surface *bmp, *imagen;
SDL_Rect dstrect;
// Inicializar el contador:
inicio = SDL_GetTicks();
// Ejecutar el número de bucles indicados por la variable bucles:
for(i = 0; i < bucles; i++)
{
// Cargar el BMP:
if(profundidadBmp == IMG_4BIT)
bmp = SDL_LoadBMP("imagen4.bmp");
else if(profundidadBmp == IMG_8BIT)
bmp = SDL_LoadBMP("imagen8.bmp");
else if(profundidadBmp == IMG_24BIT)
bmp = SDL_LoadBMP("imagen24.bmp");
else
{
fprintf(stderr, "Profundidad de BMP desconocida.\n");
return 1;
}
if (bmp == NULL)
{
fprintf(stderr, "Problema: %s\n", SDL_GetError());
return 1;
}
// Convertir la imagen al formato de la pantalla:
imagen = SDL_DisplayFormat(bmp);
SDL_FreeSurface(bmp);
if(imagen == NULL)
{
fprintf(stderr, "Problema: %s\n", SDL_GetError());
return 1;
}
// Pegar la imagen en pantalla:
dstrect.x = i % 480;
dstrect.y = i % 272;
dstrect.w = imagen->w;
dstrect.h = imagen->h;
if(SDL_BlitSurface(imagen, NULL, pantalla, &dstrect) < 0)
{
SDL_FreeSurface(imagen);
fprintf(stderr, "Problema: %s\n", SDL_GetError());
return 1;
}
SDL_FreeSurface(imagen);
// Actualizar la pantalla:
SDL_UpdateRects(pantalla, 1, &dstrect);
}
// Finalizar el contador:
fin = SDL_GetTicks();
// Imprimir el resultado en el fichero resultado.txt:
fprintf(fichero, "Tiempo usado: %d\n", fin - inicio);
return 0;
}
int main(int argc, char *argv[])
{
int error;
SDL_Surface *pantalla;
FILE *fichero;
// Inicializar SDL:
if(SDL_Init(SDL_INIT_VIDEO) < 0)
{
fprintf(stderr, "Problema: %s\n", SDL_GetError());
return 1;
}
// Inicializar el modo de video:
pantalla = SDL_SetVideoMode(480, 272, 8, SDL_SWSURFACE);
if(pantalla == NULL)
{
fprintf(stderr, "Problema: %s\n", SDL_GetError());
return 1;
}
pspDebugScreenInit();
SetupCallbacks();
// Crear el fichero resultado.txt:
fichero = fopen("resultado.txt", "w");
// Ejecutar el bench:
fprintf(fichero, "Imagen de 16 colores ");
error = bench(IMG_4BIT, 5000, pantalla, fichero);
if(error)
return 1;
fprintf(fichero, "Imagen de 256 colores ");
error = bench(IMG_8BIT, 5000, pantalla, fichero);
if(error)
return 1;
fprintf(fichero, "Imagen de 24 bits ");
error = bench(IMG_24BIT, 5000, pantalla, fichero);
if(error)
return 1;
// Cerrar el fichero resultado.txt:
fclose(fichero);
return 0;
}