Avances, Diario de...

[SplinterGU]

Eso díselo a los de RARE, que usaron la N64 en modo 32 bits para ganar velocidad en algunos de sus juegos :D :D :D (verídico).

porque seguramente tenian muchas conversiones de 32 a 64 y viceversa, o corrian en procesadores de 32bits.
en la version 64bits que estoy cocinando, tengo todos los puntos donde se usan mucho procesamiento (runtime, funciones, bytecode bennugd, etc) a 64bits, asi mismo todas las librerias de uso general, con lo que se gana mucho de performance.
el procesador (si es de 64bits) accede mas rapido a datos en memoria alineados a 64bits.

pero bueno, digamos que este rendimiento no es solamente por lo que yo toque de codigo, tambien todas las librerias incluso la SDL ahora son 64bits.

[warrior_rockk]

Me parece muy interesante el debate sobre incorporar PPO a Bennu2 y, leyendo lo que ponéis, ambas partes tenéis razón. Considero PPO extremadamente útil para la programación y en videojuegos mas todavía, pero, implementarlo en un lenguaje que nativamente no tiene PPO, como es C, lo veo complicado. Yo buscaría soluciones intermedias.
Como bien dice Splinter, es posible implementarlo cualquier cosa de otra manera, pero el problema es la eficiencia de memoria.
Hace tiempo puse un post donde explicaba una manera de realizar "herencia" pero de variables publicas (http://forum.bennugd.org/index.php?topic=3992.msg64504#msg64504). Resumidamente, se trababa de crear un proceso ficticio con las variables publicas necesarias, y luego declarar los procesos que quieren que las hereden como ese tipo. Para Bennu2 iría un poco mas allá y permitiría poder declarar código dentro de ese proceso ficticio que se ejecutaría en los procesos de ese tipo. Una opción sería implementarlo como las rutinas locales que ya existen, un salto de código al código del proceso padre y luego continuar con el posible codigo extendido del proceso hijo. (no entender padre/hijo como la relacion de Bennu si no como clase y proceso heredado). Evidentemente el código que se ejecute de la clase, debería usar las variables del proceso que lo llama.
De esta manera podríamos definir comportamientos básicos y heredar y crear en arbol comportamientos mas complejos (clase spirte->entidad hereda de sprite->enemigo hereda de entidad->etc..) y sólo añadir el codigo que los caracteriza.




De todas maneras y como conclusión final, todo es mejorable pero ahora mismo, no me veo limitado por Bennu en cuanto a funcionalidad. Me centraría en mejorar el rendimiento y dejaría esto como opcional.

[Drumpi]

Eso díselo a los de RARE, que usaron la N64 en modo 32 bits para ganar velocidad en algunos de sus juegos :D :D :D (verídico).

porque seguramente tenian muchas conversiones de 32 a 64 y viceversa, o corrian en procesadores de 32bits.

No, RARE trabajaba en exclusiva para N64 en aquella época, igual que hizo en NES, SNES y parte de la vida de GC hasta que fue comprada por M$.
Lo que pasaba en aquel entonces es que N64 usaba uno de los primeros procesadores de 64bits, y aun hay debates de si N64 era realmente una CPU de 64 bits o de 32bits (mis conclusiones, de momento, apuntan a una CPU de 32bits en cuestión de registros y demás, pero con bus de direcciones de 64 bits, pero no me hagas mucho caso).

Ahora aquí es al revés, estábamos intentando trabajar a 32bits en máquinas de 64bits, y la conversión es lo que reducía el rendimiento (aparte de todas las mejoras que traen los modos 64bits para acelerar la ejecución).

De todas formas, lo de RARE te lo decía en broma :P

[SplinterGU]

Eso díselo a los de RARE, que usaron la N64 en modo 32 bits para ganar velocidad en algunos de sus juegos :D :D :D (verídico).

porque seguramente tenian muchas conversiones de 32 a 64 y viceversa, o corrian en procesadores de 32bits.

No, RARE trabajaba en exclusiva para N64 en aquella época, igual que hizo en NES, SNES y parte de la vida de GC hasta que fue comprada por M$.
Lo que pasaba en aquel entonces es que N64 usaba uno de los primeros procesadores de 64bits, y aun hay debates de si N64 era realmente una CPU de 64 bits o de 32bits (mis conclusiones, de momento, apuntan a una CPU de 32bits en cuestión de registros y demás, pero con bus de direcciones de 64 bits, pero no me hagas mucho caso).

Ahora aquí es al revés, estábamos intentando trabajar a 32bits en máquinas de 64bits, y la conversión es lo que reducía el rendimiento (aparte de todas las mejoras que traen los modos 64bits para acelerar la ejecución).

De todas formas, lo de RARE te lo decía en broma :P

RARE! me bloquee completamente, olvide quien era RARE, y pense que te referias a algun emulador... dios mio, que mal estoy...

[Drumpi]

Haré gala del topicazo de mi tierra ("los sevillanos son unos exageraos"), y te diré que probablemente yo esté peor que tu :D

[SplinterGU]

que les va pareciendo esta sintaxis

Code Select Expand


import "libmod_misc";

int alto = 12345;

int po()
begin
    public int va = 123;
    int b;
    while(1)
        frame;
    end
end

po pid;

begin
    string var2, var_string;
    int id1, id2, id3;
    po po1;

    po1 = po();

    say(po1.va);

    let_me_alone();
end


[SplinterGU]

para los curiosos eso genera

BGDC 2.0.0 (Jul 11 2016 21:13:28)
Bennu Game Development Compiler

Copyright (c) 2006-2016 SplinterGU (Fenix/BennuGD)
Copyright (c) 2002-2006 Fenix Team (Fenix)
Copyright (c) 1999-2002 José Luis Cebrián Pagüe (Fenix)


---- Global variables

[0000:0007]     INT ARGC
[0008:0271]     ARRAY [33] OF STRING ARGV
[0272:0279]     INT OS_ID
[0280:0359]     STRUCT FILEINFO:
[0000:0007]      + STRING PATH
[0008:0015]      + STRING NAME
[0016:0023]      + INT DIRECTORY
[0024:0031]      + INT HIDDEN
[0032:0039]      + INT READONLY
[0040:0047]      + INT SIZE
[0048:0055]      + STRING CREATED
[0056:0063]      + STRING MODIFIED
[0064:0071]      + STRING ACCESSED
[0072:0359]      + STRING STATECHG
[0360:0487]     ARRAY [16] OF STRING REGEX_REG
[0488:0567]     ARRAY [10] OF INT TIMER
[0568:0575]     INT ALTO
[0576:0583]     INT PID

---- Local variables

[0000:0007]     INT ID
[0008:0047]     STRUCT RESERVED:
[0000:0007]      + INT PROCESS_TYPE
[0008:0015]      + INT FRAME_PERCENT
[0016:0023]      + INT STATUS
[0024:0031]      + INT SAVED_STATUS
[0032:0047]      + INT SAVED_PRIORITY
[0048:0055]     INT FATHER
[0056:0063]     INT SON
[0064:0071]     INT SMALLBRO
[0072:0079]     INT BIGBRO
[0080:0087]     INT PRIORITY
[0088:0119]     STRUCT __PROCCESS_RESERVED:
[0000:0007]      + INT TYPE_SCAN
[0008:0015]      + INT ID_SCAN
[0016:0023]      + INT CONTEXT
[0024:0119]      + QWORD SIGNAL_ACTION


---------- Process 0 (MAIN)

---- Private variables
[0000:0007]     STRING VAR2
[0008:0015]     STRING VAR_STRING
[0016:0023]     INT ID1
[0024:0031]     INT ID2
[0032:0039]     INT ID3
[0040:0047]     INT PO1

        00000000000000FF 0000000000000015                              string_cat.prg:21       

        0000000000000092 0000000000000028          PRIVATE             40

        0000000000000089 0000000000000001          CALL                PO (1)

        0000000000000048                           LETNP               

        00000000000000FF 0000000000000017                              string_cat.prg:23       

        0000000000000097 0000000000000028          GET_PRIVATE         40

        00000000000000FD 0000000000000000          GET_REMOTE_PUBLIC   0

        00000000000000C4 0000000000000000          INT2STR             0

        000000000000008C 0000000000000063          SYSPROC             SAY (99)

        00000000000000FF 0000000000000019                              string_cat.prg:25       

        000000000000008C 0000000000000058          SYSPROC             LET_ME_ALONE (88)

        0000000000000000                           END                 

22:


---------- Process 1 (PO)

---- Private variables
[0000:0007]     INT B

---- Public variables
[0000:0007]     INT VA

        0000000000000084 000000000000007B          PUSH                123


Start 1:

2:
        00000000000000FF 0000000000000009                              string_cat.prg:9         

        0000000000000084 0000000000000001          PUSH                1

        000000000000009C 0000000000000011          JFLASE              17

        00000000000000FF 000000000000000A                              string_cat.prg:10       

        0000000000000084 0000000000000064          PUSH                100

        0000000000000002                           FRAME               

        00000000000000FF 000000000000000B                              string_cat.prg:11       

        000000000000009B 0000000000000002          JUMP                2


End 1:

17:
        0000000000000000                           END                 

18:

recorte la parte final del log porque el post solo permite 20000 caracteres

[SplinterGU]

definitivamente voy a retrasar un poco la salida de bennugd2, adios SDL2 para los el render... voy a usar openGL... por que?

aca paso numeros

*** BennuGD2 con SDL2 ***
max texture size: 8192 x 8192
frames=197 time=11068 fps=17.79906

*** C puro con SDL2 ***
Width of graph.bmp: 27
Height of graph.bmp: 33
frames=242 time=8890 fps=27.221597

*** C puro con OpenGL ***
Width of graph.bmp: 27
Height of graph.bmp: 33
frames=360 time=7865 fps=45.772409

resultado de 10000 (10 mil) procesos con grafico de 27x33, rebotando por una ventana de 640x480 32bits.

maldito SDL2! casi duplica el costo de renderear...

demas esta explicar el motivo de por que quiero pasarlo, ni hablar que puedo de esta forma emplear con opengl trucos, aprovechando nuevas caracteristicas de bennugd para mejorar la performance de rendereado...

ademas, de que segun mis viejos test (el primer ejemplo opengl fue con ese test que hice inicialmente), podia manejar texturas de todas las profundidades (al menos las mas importantes)... (tengo que revisarlo bien, a ver si tenia algun problema o no...)

[panreyes]

Splinter, el único problema que le veo a que utilices Open GL directamente es que si luego quieres dar soporte a Vulcan, OpenGLES o DirectX, tendrás que hacerlo manualmente, ¿me equivoco?

[AmakaSt]

SDL2 no renderizaba con OpenGL y Direct3D?  ???

[SplinterGU]

Splinter, el único problema que le veo a que utilices Open GL directamente es que si luego quieres dar soporte a Vulcan, OpenGLES o DirectX, tendrás que hacerlo manualmente, ¿me equivoco?

si, asi es... pero eso no me da miedo... a Vulkan lo tengo en la mira...

[SplinterGU]

SDL2 no renderizaba con OpenGL y Direct3D?  ???

si, pero no muy eficientemente.

y con mucho overhead.

el tema es que la arquitectura de SDL2 impide hacer algunas optimizaciones en el uso de opengl.

[Drumpi]

que les va pareciendo esta sintaxis

Code Select Expand


import "libmod_misc";

int alto = 12345;

int po()
begin
    public int va = 123;
    int b;
    while(1)
        frame;
    end
end

po pid;

begin
    string var2, var_string;
    int id1, id2, id3;
    po po1;

    po1 = po();

    say(po1.va);

    let_me_alone();
end


¿Entonces ahí po() es un proceso? Lo digo porque no tiene return y usa frame ¿O finalmente no va a haber distinción entre funciones y procesos? porque a mi me ha resultado muy útil en el último proyecto el tener un proceso esperando una función que había llamado a otros procesos, por aquello de que detiene su ejecución y espera un valor (es lo más parecido a envío de mensajes entre procesos que he visto :)).
Aparte de eso, prefiero no opinar si se va a prescindir de los icónicos "process" o "function", ya sabes que a mi hay ciertos cambios que no me gustan hasta que ha pasado un tiempo y me he acostumbrado.

Respecto a OpenGL vs SDL, para el usuario final va a ser transparente, así que realmente la decisión depende de lo que te sea más cómodo. Si con OpenGL tienes más velocidad, acceso a más profundidades de mapa, más control del sistema, y no supone una pega con las librerías que quieres usar ni con portarlo a diferentes plataformas, entonces usa OpenGL.
¿Algunas de las alternativas te permite ejecutar código en la tarjeta gráfica? Lo digo por aquello que te daba problemas de modificar mapas y demás una vez estaban en la VRAM, y poder aplicar filtros de postprocesado. Y si podemos programar shaders, para modificar los maps en la RAM de la gráfica o el buffer de video justo antes del volcado para, yo que sé, aplicar efecto blur, hacer un croma, modificar los colores para los daltónicos... pues estaría genial :D

[SplinterGU]

po() es un proceso

aparentemente siempre estuvo esa forma de declarar procesos, uno puede no poner la palabra PROCESS delante e incluso tampoco un tipo de dato al proceso

por ejemplo

po()
begin
end

es igual que

process po()
begin
end

el int que agregue es porque estoy probando el compilador

por otro lado, no se pierde PROCESS / FUNCTION, eso sigue estando

pueden probar este ejemplo en la actual bennugd

Code Select Expand


po()
begin
end

begin
po();
end


[SplinterGU]

definitivamente voy a retrasar un poco la salida de bennugd2, adios SDL2 para los el render... voy a usar openGL... por que?

aca paso numeros

*** BennuGD2 con SDL2 ***
max texture size: 8192 x 8192
frames=197 time=11068 fps=17.79906

*** C puro con SDL2 ***
Width of graph.bmp: 27
Height of graph.bmp: 33
frames=242 time=8890 fps=27.221597

*** C puro con OpenGL ***
Width of graph.bmp: 27
Height of graph.bmp: 33
frames=360 time=7865 fps=45.772409

resultado de 10000 (10 mil) procesos con grafico de 27x33, rebotando por una ventana de 640x480 32bits.

maldito SDL2! casi duplica el costo de renderear...

demas esta explicar el motivo de por que quiero pasarlo, ni hablar que puedo de esta forma emplear con opengl trucos, aprovechando nuevas caracteristicas de bennugd para mejorar la performance de rendereado...

ademas, de que segun mis viejos test (el primer ejemplo opengl fue con ese test que hice inicialmente), podia manejar texturas de todas las profundidades (al menos las mas importantes)... (tengo que revisarlo bien, a ver si tenia algun problema o no...)

prueba con pixstudio de esto me da

Code Select Expand


$ ./pxtp lesson6
DEPRECATION WARNING: Setting the bit depth in set_mode is no longer valid
frames=197 time=18471 fps=10.665367


me pregunto por que diablos tal diferencia? quizas los 64bits? ahora mismo usamos SDL2, pero no de la misma forma... mmm... maldicion, creo que voy a tener que intentar hacer un binario 32bits del actual bennugd2.

me gustaria ver hasta donde podemos optimizar el motor... en fin...