[HILO OFICIAL] Nintendo 64

SuperPadLand escribió:Quizás se podrían modificar las ROM para que detecten cosas y las guarden en el save y al subir ese save se desbloqueasen los logros, pero sería mucho curro ir ROM a ROM modificando.

Pfff... Es reescribir el juego entero, casi...
@EMaDeLoC o inventar una misterFPGA con retroachievements integrado que puedas meter tus juegos y mandos y que de fondo corra el programa detectando lo que haces con IA. Son 1000€ [carcajad]
@SuperPadLand Sale más barato entrenar una IA que te diga que te dejes de tonterias de retroachievements. [burla2] [qmparto]
@SuperPadLand Sería algo increíble. Están hechos mirando los valores que hay en la RAM, así que vigilando esos valores en tiempo real y teniendo conexión a Internet podría funcionar.

De hecho ya hay un proyecto para NES que funciona en la consola original:

https://github.com/odelot/nes-ra-adapter

Y en SNES:

https://github.com/Factor-64/RA2Snes
Es un poco OT, pero...



super alpha/beta, pero funcionando.

Por cierto, alguien sabe qué le pasó a este tio? Hace años tenía un tono de voz y una prosodia normal, hablaba claro, se le entendía perfectamente... pero ahora tiene un tono y deje rarísimo (que mejor no adjetivo), atropella las palabras, y es un suplicio escucharle hablar...
radorn escribió:Es un poco OT, pero...



super alpha/beta, pero funcionando.

Por cierto, alguien sabe qué le pasó a este tio? Hace años tenía un tono de voz y una prosodia normal, hablaba claro, se le entendía perfectamente... pero ahora tiene un tono y deje rarísimo (que mejor no adjetivo), atropella las palabras, y es un suplicio escucharle hablar...

La verdad es que sí que le ha cambiado la voz bastante:



Cambiando de tema, el autor de Tiny3D ha sacado una serie de tests difíciles de emular:
https://github.com/HailToDodongo/repeater64



Como era de esperar, muchos de ellos también fallan en el Analogue 3D.
@cirote3 Interesante eso del tester Repeater64
Esperemos que sirva para fomentar la una mayor precisión en futuras implementaciones de la plataforma, ya sean emuladores por software o recreaciones sobre FPGA o lo que toque.

AÑADO: Ahora a la inversa:
Un tío que normalmente parece que hace recreaciones de juegos en Saturn, como por ejemplo MGS de PS1 y Shenmue de DC recreados en Saturn. Ahora saca una pequeña muestra de Spyro en N64



El autor ha puesto un artículo explicativo en Saturn, de lectura gratuíta pero que pide registro y no me ha apetecido hacerlo. Si alguien se anima a registrarse y pegarlo aqui se agradece,

Me suena que puede haber en marcha un proyecto de decompilado de Spyro y pensé si esto sería el resultado, pero diría que esto mas parece una recreación manual como las otras que ha hecho.
radorn escribió:Es un poco OT, pero...



super alpha/beta, pero funcionando.

Parece que han reformateado los modelos 3D al formato de PS1 de forma directa sin remodelar y de ahí la falta de corrección de perspectiva tan evidente de esa consola. No digo nada de las texturas mal puestas, puede ser un problema de interpretar las coordenada UV y que no tenga nada que ver con el port.

Es curioso ver como en los espacios abiertos hay un límite bastante cercano de poping, cuando en el juego en la consola original se puede ver la totalidad del escenario desde cualquier punto (o al menos, desde muy lejos). No sé si es problema del motor creado para el port o limite real de la consola. Creo que los escenarios de SM64 tienen menos triángulos que la escena más compleja vista en la PS1, que creo que es la cafetería de Silent Hill, pero la distancia de renderizado es muy superior en los primeros. ¿Problema de distancia? ¿De rendimiento?

En cualquier caso es un currazo y un logro. Mi mayor "pega" es que se usará para lo de siempre... "PS1 era superior en hardware a la N64!!!1!" [facepalm]
radorn escribió:El autor ha puesto un artículo explicativo en Saturn, de lectura gratuíta pero que pide registro y no me ha apetecido hacerlo. Si alguien se anima a registrarse y pegarlo aqui se agradece

¿Éste es el texto? https://www.patreon.com/posts/spyro-64-how-it-144229946

A mí no me pide registro.
@cirote3 Parece que ha quitado el requisito de estar registrado. Ahora también lo puedo ver, pero antes no podía.

Y ya veo que puse "Saturn" donde debí poner "Patreon". Estoy medio senil...

Pero bueno, según explica ahí, este experimento de Spyro en N64 que nos muestra está hecho sobre HackerSM64, que un derivado de la decompilacion de SM64, añadiéndole modelos extraídos del juego de PS1. Paralelamente a esto, el artículo me confirma mi vago recuerdo de que había un proyecto de decompilación de Spyro, y expresa su esperanza de que alguien lo adapte a N64 en algún momento.

@EMaDeLoC Es muy alpha/beta aún. Obviamente han recurrido a grandes atajos para tener algo funcional que mostrar. Yo imagino que mejorará bastante, pero ya veremos hasta donde llega la cosa, y qué soluciones encuentran. Yo dudo que sea un equivalente 100% con pixels sin suavizar, texturas deformes y geometría bailonga. Tendrán que adaptar muchas cosas a los límites de PS1

Un port realmente pensado para la consola requerirá de teselar a saco la geometría y seguramente se tenga que reducir drásticamente la distancia de dibujado. Al final, para hacer algo de calidad para el sistema creo que se verá en la necesidad de hacer bastantes cambios, No debería quedar la cosa en un empeño de port 100% equivalente.

Recordermos también que la N64, en parte mediante hardware y en parte mediante software, lidia mejor que PS1 o Saturn con "primitivas" (tris o quads) que queden parcialmente fuera de pantalla:
Según entiendo, en PS1 y SAT, el límite absoluto de la pantalla a la hora de mapear véritces es el área visible y es necesario para que un polígono sea visible que todos sus vértices queden dentro de ese área. Si uno de ellos queda fuera el polígono no se puede dibujar, para lo cual los motores 3D de esos sistemas tienen que recalcular las coordenadas de pantalla de esos vértices para que queden dentro. Esto es lo que causa esas deformaciones de las texturas en los bordes de la imagen en esas consolas.
N64 permite tener una zona de seguridad al rededor de la zona visible donde se pueden mapear vértices y permitir el dibujado de la textura en la zona visible. Si el vértice queda fuera incluso de ese margen de seguridad, entonces hay que hacer algo similar a PS1 y SAT, pero con la ventaja de ser una función por hardware/microcódigo, y mucho mas limpia que en las otras consolas, pues genera nuevas coordenadas UV para evitar deformacion de texturas. La limitacion que tiene esta funcion es con respecto al gouraud shading. Quizá os hayais fijado, o no, en que en superficies muy amplias que quedan parcialmente fuera de pantalla, a veces hay un extrano efecto cuando nos movemos, por el cual parece que una sombra extraña se desplaza a través del polígono a medida que nos desplazamos. Esto es el nuevo vértice fuera de pantalla cambiando la geometría efectiva del triángulo correspondiente, y por tanto la posición del gradiente de color a lo largo de su superficie.

En fin. Obviamente PS1 no va a poder mostrar un nivel de mario 64 de un solo pantallazo como la N64, ni en términos de rendimiento ni en términos de problemas gráficos. Será interesante ver qué estrategias buscan para lidiar con ello. Y no olvidemos la falta de Zbuffer.

Veremos un Mario 32 con niebla a 20 metros? recurrirán a técnicas de texturizado como las de Spyro? Tratarán de mantener la geometría original con pocas modificaciones o la reharán a algo mas PS-friendly?
Será interesante de ver.

Por cierto, si os dais cuenta, han tenido que convertir los efectos de sonido a una calidad mucho mas baja. Si no recuerdo mal, así como la N64 tiene 4MB unificados y la mayoría de juegos usan el cartucho para cargar animaciones y audio a un bufer temporal cuando hay que renderizar audio o video para no ocupar la RAM permanentemente, la PS1, que tiene 2MB de RAM pricipal, 1MB para video y 1MB para audio (corregidme si me equivoco), y un almacenamiento secundario (CD) muy lento, supone un desafío diferente a hacerlo con una RAM mas flexible y un almacenamiento secundario mucho mas rápido (aunque mas pequeño)
No se si encontrarán alguna solución y cómo quedará la cosa, pero en esta demo el audio es de calidad inferior. Quizá no la música, pero si los efectos de sonido. Aunque, como ventaja, mientras que Mario 64 renderiza audio a una frecuencia cercana a 22050 Hz (la mitad que un CD) por tener que ser procesado el audio por el RSP que también se encarga de transformar la geometría 3D, la PS1 dispone de un procesador de audio dedicado, que hasta donde entiendo, siempre opera a 44100 Hz, como un CD, así que si el material lo llena, tiene en principio mas claridad que N64

Como curiosidad al respecto, añado que en N64 la mayoría de juegos usan frecuencias de sampleo de audio similares a Mario 64, que son próximas a los 22kHz, mientras que otros rondan los 32kHz, y algunos incluso llegan a algo cercano a 44kHz, como el CD, la mayoría de ellos juegos de Konami, como los de la saga Goemon, que tienen un audio especialmente potente.
He usado términos relativos como son "similar" "cercano", "rondar", etc, porque las frecuencias de muestreo no son las habituales, ya que tienen que encajar en el bus AV de la consola, que se aproxima a los los 50MHz (o mas bien 47-49, si no recuerdo mal) pero no son exactas, ya que se derivan del mismo oscilador que alimenta el DAC, y del que se deriva la portadora de color, por tanto varía según la consola sea NTSC (América/Asia), PAL (Europa y demás), o MPAL (Brasil) Así que nunca son 22050 exactos, ni 44100, ni 32000, ni 16000, ni otras frecuenicas a medida que tienen algunos juegos. La versión NTSC de SM64, si no recuerdo mal, tira por los 22047 Hz, o quizá eran 22037 o algo así. Los 44kHz de los juegos de Konami que menciono suelen ser 44095 en vez de 44100 redondos.
Yo lo entiendo más como un reto de programación que se ha puesto el dev más que un intento de buscar la solución más optima.

Lleva mostrando resultados en Discord desde más o menos hace un año pero ahora ha salido fuera porque ha publicado el código en github (https://github.com/malucard/sm64-psx).

Para explicar un poco porqué yo lo veo más como un reto de programación son por ejemplo, porque ha hecho wrappers para las llamadas al SDK, emula los comandos que se envían al rsp (https://github.com/malucard/sm64-psx/blob/master/src/port/gfx/gfx_rsp_jit.c), o incluso ha creado un código bastante eficiente para emular operaciones de coma flotante (https://github.com/malucard/sm64-psx/blob/master/src/port/psx/float_asm_psx.s). Esto es una pasada y un currazo, el comportamiento será más cercano al original, pero el desempeño va a ser bastante peor que teniendo un render path dedicado y código ajustado a las necesidades, carencias y virtudes de la ps1.

El vídeo engaña un poco, por un par de razones. Está corriendo con una versión dev que tiene más ram disponible (el devkit de ps1 tiene 8mb de ram y el emulador en el que funciona soporta eso, puede correr con la RAM normal pero el juego crashea más a menudo) y además el emulador tiene la corrección de perspectiva activada.

El principal escollo que tiene ahora mismo con este código, es toda la gestión de la RAM. El principal son las animaciones de Mario las cuales ocupan como 1mb, en n64 las va cargando directamente de la ROM, aquí tiene parte dentro de la VRAM y otra parte dentro de la memoria del audio (por eso supongo que los samples son de baja calidad, no queda casi espacio) y hace un DMA a la cpu cada vez que hay un cambio de animación. Y a su vez la RAM parece estar llena de las display list, de las texturas del juego (que supongo que por el hecho de emular los comandos del RSP las deja en RAM y las sube 1 a 1 a VRAM como hace la n64 con la cache de texturas). Ósea todo manga por hombro en ese sentido. Las animaciones las tendría que cambiar a otro formato, no habría que hacer diplaylists, y la VRAM debería ser para tener todas las texturas. Todo eso requeriría cambios muy importantes al motor, y como comenté al principio creo que sus esfuerzos van por otro lado.

Y no solo cambios en el motor pero también en las assets. Además de los mencionados cambios en la animación, por ejemplo, el tema de la teselación, en teoría podrías dejar la topología de los niveles originales (la cual es terrible, la de DS es bastante más limpia) y recurrir a teselación adaptativa (calculas el tamaño del polígono y en un función a eso haces más o menos subdivisiones), pero hay un punto en el que empieza a ser altamente contraproducente, hacer subdivisiones en tiempo real es obviamente más costoso que traerlas subdivididas y ya que la ps1 no tiene cache de datos, hay una diferencia muy grande en que te entren todos los datos de la subdivisión en el scratchpad (1k) o que tengas que tirar de el stack normal, así que puedes tener polis grandes subdivididos pero hay un momento en el que son demasiado gigantes y son un lastre muy grande, y en Mario hay polígonos que son absurdamente grandes. Lo suyo es otra vez, alterar la topología antes de la compilación.

Actualmente solo tiene dos niveles de subdivisión alta (4x4) o baja (2x2) lo cual puede dar lugar a situaciones como esta:
Imagen
(lo cual puede ser la causa de tanto crash, ya que el número máximo de polis se define en tiempo de compilación y cuando pasa esto puedes pasarte el límite fácilmente)

El corte de los polígonos lejanos supongo que será solo por no ajustar la Z min y max de los paquetes, este rango se define en compilación. Imagina que dices: “quiero que tenga 256 niveles de profundidad” (0 cerca – 255 lejos) y la posición de Mario cae en la 128, eso significa que de la cámara a Mario tienes 128 niveles y de Mario hacía delante la misma distancia osea, sería muy corto. La solución es fácil es añadir por ejemplo un rango de 4096 y cada posición final la dividides por 2 (así los comprimes). Hoy en día la distancia de dibujado no debería ser un problema, hay muchas técnicas para salir del paso. Incluso en su día, el motor de Spyro podría haber soportado texturas en la lejanía (usando todavía la transición de geometría high-low poly) pero optaron por llenar la VRAM con un buffer horizontal superior 512x240 (añadir tanta resolución horizontal disimula en casi en un pixel el vertex snapping horizontal) y en poner texturas de 64x64.

@radorn
Las dos permiten mandar polígonos que tengan pixeles fuera del framebuffer, sino recuerdo mal el área es de -1024/1024. Lo que pasa con cada pixel que está fuera depende de varías situaciones, donde ha quedado fuera, si se empezó pintando dentro etc…

Los resultados si están fuera del frame buffer pero dentro de ese área van desde “no pasa nada”, hasta “tirar un montón de ciclos de la GPU a la basura”.

Fuera del área grande, en ps1 creo que coge el resto de dividir por 1024 y volvía al origen y en Saturn el comportamiento es “no-definido”.

El psx puedes cortar exactamente el polígono en la línea de la pantalla y reorganizar las UVs pero no se suele hacer porque los polígonos que entran suelen ser pequeños al entrar teselados y consume muchos menos recursos empujar la z hacia arriba comprimiendo el poly que hacer la división, y total al no tener corrección de perspectiva la cosa ya parece rara de cualquier manera.

En Saturn no puedes hacer el corte porque donde haces la subdivisión tienes que tenerlo definido en tiempo de compilación, ya que no tienen UVs, así que solo te queda empujar la z hacia arriba.
Todo se arregla metiendo un pasillo con cargas como Quake II [666]
@Misscelan
¿Las animaciones de Super Mario 64 ya ocupan cerca de 1 MB de los 8 MB del cartucho? Son muy elaboradas y además no se basan en esqueletos y keyframes, así que tienen que guardar los datos de cada posición frame a frame. Pero incluso con eso me parece muy exagerado.
He investigado un poco y he encontrado este "mapa de memoria de la rom" donde te dice que las animaciones de Mario están entre 4EC000 y 579C26. Sin saber muy bien lo que estoy haciendo, he hecho la resta en hexadecimal y luego la he convertido en decimal con la calculadora de Windows. Me sale un valor de 580.646 que supongo que son Bytes, que son 657 KB y 0.55 MB. La verdad es que es una cifra mucho más alta de lo que esperaba, que se aproxima a lo que dices.
Supongo que las animaciones con huesos e interpolación ocuparán muchísimo menos espacio.
Tenía una pinta muy decente el Viewpoint 2064, afortunadamente lo rescataron del olvido y ahora lo podemos disfrutar.

Aquí hay un gameplay completo:

Siempre está bien sumar un nuevo juego al catálogo de N64, y si el juego está bien, pues mucho mejor.
Habrá que probarlo para ver que tal.
Por cierto, ¿sabeis si el Dinosaur Planet lo siguieron puliendo para corregir los errores y poder completarlo?
Sogun escribió:@Misscelan
Me sale un valor de 580.646 que supongo que son Bytes, que son 657 KB y 0.55 MB. La verdad es que es una cifra mucho más alta de lo que esperaba, que se aproxima a lo que dices..

Tienes toda la razón, las animaciones son de un poco más de medio MB. No sé de donde saqué eso, además fui a revisar las conversaciones en discord y el dev de hecho menciona eso de que es sobre 550kb.

Las animaciones según esto [https://github.com/n64decomp/sm64/blob/9921382a68bb0c865e5e45eb594d9c64db59b1af/src/engine/graph_node.c#L773] parecen ser ristras de 8 elementos por hueso. Cada elemento son 16bits. Y parece que contienen -> Max Frame - Index - Tranlacion X, Y y Z - Rotación X, Y y Z.

Las animación se transfieren mediante dma llamando a la función load_patchable_table desde aquí [https://github.com/n64decomp/sm64/blob/9921382a68bb0c865e5e45eb594d9c64db59b1af/src/game/mario.c#L64]

Según esto otro [https://github.com/n64decomp/sm64/blob/9921382a68bb0c865e5e45eb594d9c64db59b1af/src/game/rendering_graph_node.c#L544], la traslación es acumulativa (ósea se almacenan deltas) y la rotación es absoluta (aquí no parece haber interpolación).

Aunque también se procesa algo de la animación aquí [https://github.com/n64decomp/sm64/blob/9921382a68bb0c865e5e45eb594d9c64db59b1af/src/goddard/objects.c#L1521] donde también se hace algo de interpolación pero es un poco raro porque el dt de la interpolación no parece venir del input del player o del framerate, así que no sé donde se interpola los estados de animar/correr, o lo mismo son estados fijos y solo se interpola el paso de uno al otro, además esta función no parece llamarse en ningún sitio en el código y además está dentro de la carpeta Goddard (que es lo de la cara del principio creo)

Lo de la agrandar los pies o el puño en el ataque por ejemplo está hardcoded y no viene especificado en los datos de la animación (no se guarda el escalado por hueso por frame): [https://github.com/n64decomp/sm64/blob/9921382a68bb0c865e5e45eb594d9c64db59b1af/src/game/mario_misc.c#L69]

Luego por encima de todo esto se aplica una rotación extra sobre el torso o la cara cuando se corre o se mira de cerca.

Si al final se guarda la rotación y traslación de todos los huesos a 30 fps, halla o no traslación o rotación, pues hay margen para almacenar menos e interpolar más o para añadir una compresión más fuerte. En cualquier caso a poco que quite las texturas de la RAM, siendo al final solo medio mega debería tener sitio para meterlas incluso en el formato original.
6266 respuestas
1122, 123, 124, 125, 126