› Foros › Retro y descatalogado › Consolas clásicas
BMBx64 escribió:Aún así menudo cuello de botella se iba a generar con eso
Se rumoreaba que la CPU iba a ir a 105Mhz, eso sería si el RCP fuera a 70Mhz
uint32_t get_pixel( display_context_t disp, int x, int y )
{
if( disp == 0 ) { return 0; }
if( __bitdepth == 2 )
{
uint16_t *buffer16 = (uint16_t *)__get_buffer( disp );
uint16_t packed_rdp = __get_pixel( buffer16, x, y );
return packed_rdp | (packed_rdp << 16);
}
else
{
uint32_t *buffer32 = (uint32_t *)__get_buffer( disp );
return __get_pixel( buffer32, x, y );
}
}
}
uint32_t conv = ((r & 0x1F) << 11) | ((g & 0x1F) << 6) | ((b & 0x1F) << 1) | (color.a >> 7);
color=get_pixel(disp,mouse_x,mouse_y);
// Extract
uint8_t r1 = (color & 0xF800) >> 11; // 63488
uint8_t g1 = (color & 0x7C0) >> 6; // 1984
uint8_t b1 = (color & 0x3E) >> 1; // 62
// Expand to 8-bit
r = r1 << 3;
g = g1 << 3;
b = b1 << 3;
uint32_t test1 = (255 & 0x1F) << 11;
uint32_t test2 = (255 & 0x1F) << 6;
uint32_t test3 = (255 & 0x1F) << 1;
BMBx64 escribió:...
Lo cual me lleva a pensar que tendría que hacer un hilo dedicado de programación en N64 y separarlo de este
static uint32_t __rdp_load_texture(sprite_t *sprite, int sl, int tl, int sh, int th )
{
/* Invalidate data associated with sprite in cache */
if( flush_strategy == FLUSH_STRATEGY_AUTOMATIC )
{
data_cache_hit_writeback_invalidate( sprite->data, sprite->width * sprite->height * sprite->bitdepth );
}
/* Point the RDP at the actual sprite data */
__rdp_ringbuffer_queue( 0xFD000000 | ((sprite->bitdepth == 2) ? 0x00100000 : 0x00180000) | (sprite->width - 1) );
__rdp_ringbuffer_queue( (uint32_t)sprite->data );
__rdp_ringbuffer_send();
/* Figure out the s,t coordinates of the sprite we are copying out of */
int twidth = sh - sl + 1;
int theight = th - tl + 1;
uint8_t mirror_enabled = 0;
/* Figure out the power of two this sprite fits into */
uint32_t real_width = __rdp_round_to_power( twidth );
uint32_t real_height = __rdp_round_to_power( theight );
uint32_t wbits = __rdp_log2( real_width );
uint32_t hbits = __rdp_log2( real_height );
/* Because we are dividing by 8, we want to round up if we have a remainder */
int16_t round_amount = (real_width % 8) ? 1 : 0;
/* Instruct the RDP to copy the sprite data out */
__rdp_ringbuffer_queue( 0xF5000000 | ((sprite->bitdepth == 2) ? 0x00100000 : 0x00180000) |
(((((real_width / 8) + round_amount) * sprite->bitdepth) & 0x1FF) << 9));
__rdp_ringbuffer_queue( (mirror_enabled == 0 ? 0x40100 : 0) | (hbits << 14 ) | (wbits << 4) );
__rdp_ringbuffer_send();
/* Copying out only a chunk this time */
__rdp_ringbuffer_queue( 0xF4000000 | (((sl << 2) & 0xFFF) << 12) | ((tl << 2) & 0xFFF) );
__rdp_ringbuffer_queue( (((sh << 2) & 0xFFF) << 12) | ((th << 2) & 0xFFF) );
__rdp_ringbuffer_send();
/* Save sprite width and height for managed sprite commands */
cache.width = twidth - 1;
cache.height = theight - 1;
cache.s = sl;
cache.t = tl;
cache.real_width = real_width;
cache.real_height = real_height;
/* Return the amount of texture memory consumed by this texture */
return ((real_width / 8) + round_amount) * 8 * real_height * sprite->bitdepth;
}
if ( tx < -cache.width ) { return; }
if (flags > 0)
{
if (flags != 2)
s += ( (cache.width+1) + ((cache.real_width-(cache.width+1))<<1) ) << 5;
if (flags != 1)
t += ( (cache.height+1) + ((cache.real_height-(cache.height+1))<<1) ) << 5;
}
void __rdp_draw_textured_rectangle_scaled( int tx, int ty, int bx, int by, double x_scale, double y_scale, int flags )
{
uint16_t s = cache.s << 5;
uint16_t t = cache.t << 5;
/* Cant display < 0, so must clip size and move S,T coord accordingly */
if( tx < 0 )
{
if ( tx < -cache.width ) { return; }
s += (int)(((double)((-tx) << 5)) * (1.0 / x_scale));
tx = 0;
}
if( ty < 0 )
{
t += (int)(((double)((-ty) << 5)) * (1.0 / y_scale));
ty = 0;
}
/* Calculate the scaling constants based on a 6.10 fixed point system */
int xs = (int)((1.0 / x_scale) * 4096.0);
int ys = (int)((1.0 / y_scale) * 1024.0);
if (flags > 0)
{
if (flags != 2)
s += ( (cache.width+1) + ((cache.real_width-(cache.width+1))<<1) ) << 5;
if (flags != 1)
t += ( (cache.height+1) + ((cache.real_height-(cache.height+1))<<1) ) << 5;
}
/* Set up rectangle position in screen space */
__rdp_ringbuffer_queue( 0xE4000000 | (bx << 14) | (by << 2) );
__rdp_ringbuffer_queue( (tx << 14) | (ty << 2) );
/* Set up texture position and scaling to 1:1 copy */
__rdp_ringbuffer_queue( (s << 16) | t );
__rdp_ringbuffer_queue( (xs & 0xFFFF) << 16 | (ys & 0xFFFF) );
/* Send command */
__rdp_ringbuffer_send();
}
Flash-Original escribió:Ya parecen que estan saliendo copias de juegos de n64
¿Pronto veremos mods que funcionen en n64?? xD
Lo digo porque encontre esto
https://nintendocn.es.aliexpress.com/st ... 5.1.lTiQGN
Y el master quest nunca salio en n64
Flash-Original escribió:@Calculinho
Pero no sabia que ya se podian hacer copias que esa era la cosa..
void rdp_cp_sprite( int x, int y, int flags, int cp_x, int cp_y, int line );
void rdp_cp_sprite_scaled( int x, int y, double x_scale, double y_scale, int flags, int cp_x, int cp_y, int line );
Flash-Original escribió:@BMBx64 Me mola lo que veo y lo que leo tanto tecnico como el resultado
¿como se hace para las animaciones de los sprites?
// CARGA SPRITES
for(i=0;i<480;i++)
{
sprintf(ruta_mapa,"/%d.sprite",i);
graph[i] = read_sprite(ruta_mapa);
if (graph[i]==0)
{
error=i+1;
break;
}
}
BMBx64 escribió:En el e3 han mostrado el nuevo Mario Odyssey donde puedes controlar o poseer enemigos con la gorra, resulta que un hábil programador también ha metido eso en Super Mario 64
Dejo el vídeo:
https://www.youtube.com/watch?v=YGcsVQB1NAA
// tile size: (16x16)
// 16 x 13
const char map [208] =
{
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,1,
16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
32,33,34,35,36,37,38,39,40,41,37,42,43,44,45,46,
47,48,49,50,51,52,53,54,54,53,52,51,55,56,57,58,
59,60,61,62,63,64,65,66,66,65,64,63,67,68,69,70,
71,72,73,74,75,76,77,78,78,77,76,75,74,79,80,81,
82,83,84,53,54,85,86,87,87,86,85,54,53,88,89,90,
91,92,93,94,95,96,97,98,98,97,96,95,94,99,100,101,
102,103,104,94,95,96,97,98,98,97,96,95,94,105,106,107,
108,109,110,111,112,113,114,115,115,114,113,112,111,116,117,118,
119,120,121,122,123,124,125,126,127,128,129,123,122,130,131,132,
133,134,135,136,137,138,139,140,141,142,143,137,136,144,145,146,
147,148,149,150,150,150,150,151,152,150,150,150,150,153,154,155
};
BMBx64 escribió:De todas formas en el hilo de nesdev se ha pasado a participar marshall (autor de 64drive, mod HMDI,etc) y me ha comentado que hay un SDK mucho más potente en desarrollo para N64 con soporte de hilos, con mejor rendimiento y me invitó a pasarme por el canal irc que tienen, así que igual estaba perdiendo el tiempo con esta librería, tengo que ver que se cuece y ya traeré novedades.
Sogun escribió:Nivelazo como siempre BMBx64
Es un juego que abusa mucho de texturas de 64x64 en 16 colores. A priori parece una buena opción porque son texturas con más resolución de lo habitual en N64 y si no se requiere gran variedad de color como en paredes de ladrillo, suelos pavimentados, césped, rocas... esos 16 colores son suficientes. El problema es que no tienes espacio en la caché para hacer mipmapping y eso hace que todo se vea pixelado. El juego me dio la impresión de que tampoco tiene anti-aliasing, lo que lo empeora todo. Y tampoco es buena idea usar este tipo de texturas para los rostros de los personajes, ya que aunque tengas más resolución la falta de colores te permite mostrar menos detalles y el resultado es muy cartoon y poco realista.
dirtymagic escribió:Sogun escribió:Nivelazo como siempre BMBx64
Es un juego que abusa mucho de texturas de 64x64 en 16 colores. A priori parece una buena opción porque son texturas con más resolución de lo habitual en N64 y si no se requiere gran variedad de color como en paredes de ladrillo, suelos pavimentados, césped, rocas... esos 16 colores son suficientes. El problema es que no tienes espacio en la caché para hacer mipmapping y eso hace que todo se vea pixelado. El juego me dio la impresión de que tampoco tiene anti-aliasing, lo que lo empeora todo. Y tampoco es buena idea usar este tipo de texturas para los rostros de los personajes, ya que aunque tengas más resolución la falta de colores te permite mostrar menos detalles y el resultado es muy cartoon y poco realista.
En teoría si debería poder hacerlo,64*64*4 bits (16 colores) son 2 KB,no podría hacer mip-mapping si fueran de 8 bits de profundidad (256 colores) ya que sería 64*64*8 bits igual a 4 KB y llenaría todo el cache, a lo mejor me equivoco.Por cierto¿ la N64 no soporta texturas indexadas en profundidades de bits raras? , como el Amiga que soportaba 5 y 6 bits (32 y 64 colores), a lo mejor se podría rascar algo por ahí.
Salud.
ashurek escribió:@BMBx64 Grandisos comentarios. Seguimos esperando la comparativa del ocarina con el majora's
Señor Ventura escribió:La verdad es que una N64 orientada a las 2D, y mas aún con las ventajas del cartucho, tiene pinta de que no tendrá nada que ver a todo lo visto en psone y saturn.
Martajuru escribió:The world is not enough también salió para psx y creo recordar que funcionaba a una resolución horizontal mayor que la standard de sus juegos.
El juego tenía las mismas misiones que la versión de n64 aunque era bastante diferente. Bff no se con cual me quedaría
Con misión imposible me pasa igual, en mi infancia tuve la versión de n64 pero ahora la versión de psx me parece algo mejor.
BMBx64 escribió:Calculo que solo estoy accediendo a un 40% de potencia de la consola, en cuanto empiece a usar el RSP para comunicarse directamente con el RDP, a usar texturas de 4bit que son 4 veces más rápidas de cargar y sobretodo todas las virguerías que puede hacer el RDP en efectos gráficos, hilos para hacer trabajar paralelamente a la CPU/RSP/RDP y código especializado para usar bien los 24KB de cache de la CPU el rendimiento se va a disparar.
Sogun escribió:dirtymagic escribió:Sogun escribió:Nivelazo como siempre BMBx64
Es un juego que abusa mucho de texturas de 64x64 en 16 colores. A priori parece una buena opción porque son texturas con más resolución de lo habitual en N64 y si no se requiere gran variedad de color como en paredes de ladrillo, suelos pavimentados, césped, rocas... esos 16 colores son suficientes. El problema es que no tienes espacio en la caché para hacer mipmapping y eso hace que todo se vea pixelado. El juego me dio la impresión de que tampoco tiene anti-aliasing, lo que lo empeora todo. Y tampoco es buena idea usar este tipo de texturas para los rostros de los personajes, ya que aunque tengas más resolución la falta de colores te permite mostrar menos detalles y el resultado es muy cartoon y poco realista.
En teoría si debería poder hacerlo,64*64*4 bits (16 colores) son 2 KB,no podría hacer mip-mapping si fueran de 8 bits de profundidad (256 colores) ya que sería 64*64*8 bits igual a 4 KB y llenaría todo el cache, a lo mejor me equivoco.Por cierto¿ la N64 no soporta texturas indexadas en profundidades de bits raras? , como el Amiga que soportaba 5 y 6 bits (32 y 64 colores), a lo mejor se podría rascar algo por ahí.
Salud.
El problema es que las texturas a color de 4 y 8 bits utilizan 2 Kb para la paleta de colores y los otros 2 Kb para la textura en sí. Una textura de 4 bits en escala de grises sí que hace mipmapping porque no tiene paleta y después puedes pintar los vértices de los polígonos para darle color. Esto se hace en mucho juegos y queda bastante bien.
Señor Ventura escribió:Háblame de números estimados con todo el sistema haciendo uso del hardware al 100%
Ya que no son sprites, ¿algún tipo de fill rate?, ¿por scanline?, ¿fill rate total en pixels?, ¿número de "planos" estimados en un ejemplo real?, ¿uso y eficiencia del 2D+3D?, ¿ancho de banda?.
Y mas importante, ¿hubo algún arcade con un rendimiento 2D equivalente al estimado en la N64?.
Danos salseoooooo
dirtymagic escribió:¿Entonces las paletas ocupan siempre 2KB?,si usas solo 1bit (2 colores),y es blanco y negro sin paleta no gastaría los 2 KB ,pero si en vez de esos colores son rojo y azul,si que gastaría paleta,¿no?.
A mi el Mip-mapping que hace la N64 y DC,me parece horrendo,casi prefiero que no lo haga.
Salud.
BMBx64 escribió:Yo calculo que con el "40%" podría hacer un Metal Slug a 60fps usando los 8MB de RAM probablemente por el gasto de las texturas de 16bits, me gustaría comprobarlo de hecho.
Señor Ventura escribió:BMBx64 escribió:Yo calculo que con el "40%" podría hacer un Metal Slug a 60fps usando los 8MB de RAM probablemente por el gasto de las texturas de 16bits, me gustaría comprobarlo de hecho.
Estaría chula una ampliación de 16MB en lugar de 4MB
¿Y deben ser texturas de 16 bits?, si un objeto completo del metal slug dificilmente superará los 256 colores, ¿no?.
Señor Ventura escribió:@Sexy MotherFucker Yo también ando algo disperso, a ver si para los dos siguientes meses del verano consigo tener mas tiempo para mi.
@BMBx64 Osea, que son limitaciones del SDK... ya me parecía raro que fuese tan obligatorio gastar memoria de esa forma.
De todos modos, es una llave, ¿habría posibilidades de que la N64 admitiese mas memoria ram en su ampliación?, ¿cual sería su límite hipotético?.
editado: ¿La caché de texturas de 4KB no la puedes salvar con nada?.