[TUTORIAL]Instalar y poner a punto psl1ght en Windows

(mensaje borrado)
He probado el jpg de psl1gth y se sigue congaldo la PS3 en la propia llamada de LoadJPG. Es que no llega a salir de ahí, por lo tanto no puedo hacer nada después. Ni llego a pasarlo a la memoria para el RSX. Y lo cargo llamando desde el propio main. He llegado a pensar que sea la propia libjpgdec.a que la tenga mal.
Da igual, voy a pasar del tema y dejarlo para el final. No os voy a dar más la vara ... que ya os la he dado bastante ... [+risas].
Probando ejemplo de Hermes en 3, 2, 1 .... [360º]

Chao.
Hermes escribió:
varios escribió:He probado el jpg de psl1gth y se sigue congaldo la PS3 en la propia llamada de LoadPNG. Es que no llega a salir de ahí, por lo tanto no puedo hacer nada después. Ni llego a pasarlo a la memoria para el RSX. Y lo cargo llamando desde el propio main. He llegado a pensar que sea la propia libjpgdec.a que la tenga mal.
Da igual, voy a pasar del tema y dejarlo para el final. No os voy a dar más la vara ... que ya os la he dado bastante ... [+risas].
Probando ejemplo de Hermes en 3, 2, 1 .... [360º]

Chao.


Fail XD

Por cierto, el ejemplo tira de buffer Z16. Y otra cosa que he olvidado contar, es que ahora Tiny3D se ocupa del evento de salida (programa el evento 3) e incluso informará si se tiene un menú activo, etc.

El evento hace un exit() así que se supone que registrando una función con atexit() debería valer para "soltar" la carga.



Si que es un Epic Fail, [+risas]

Pero al escribir ... no al hacer el self y en el código que sino me daría error de compilación, es que he cambiado tantas veces PNG por JPG y al revés que ya las confundo ..XD.

Juro y perjuro de que en *.c tengo LoadJPG y no LoadPNG ... [mamaaaaa]
Hola Hermes ... del ejemplo, iba a poner algo, pero sé que se me iba a escapar lo del final, [+risas].

¿Pero dices que la iluminación es por soft? Se ve muy bien, ¿y poniendole una textura de más resolución no se vería mejor?
Si quieres que haga algún ejemplo dimelo...

PD: sin usar jpg ... [+risas]

Mira que restearme la PS3, vaya mierda con el HAL ... [+risas]


Editado:
PD: Una cosilla, acabo de bajarme Tiny 3D 2.0 y para compilarlo he tenido que cambiar sysutils\events.h y añadir los eventos
#define EVENT_DRAWING_BEGIN 0x201
#define EVENT_DRAWING_END 0x202
#define EVENT_MENU_OPEN 0x203
#define EVENT_MENU_CLOSE 0x204

Para poder compilar Tiny 3D, eso o ¿lo añado en tiny3D.h?
OK, gracias.

Me lo he descargado de aqui
https://github.com/hermesEOL/tiny3d

Y tu ejemplo este, ¿no?
http://mods.elotrolado.net/~hermes/ps3/ ... eres3D.rar

Editado:
Por cierto, deberías crear una función en Tiny3D ...

int getRandomNumber()
{
return 4;
}

[qmparto]
Hermes escribió:A mi lo que me hace gracia es cuando leo a gente diciendo que llevamos un mes "sin novedades" cuando esto es un no parar [+risas]

Saludos



mas que gracia lo que da es pena ver como el personal confunde scene con cargar copias que requieren 3.50 en un firm inferior, que parece es lo unico que interesa, ojala tuviese conocimientos para poder hacer algo con toda la informacion que hay posteada en este hilo


SAludos
Hola, estoy en el desarrollo del Free PStore, y nos han surgido algunos problemas, a ver si alguien puede ayudar, gracias.

El Store trabaja con un buffer virtual de 768 x 512, y intentamos mostrar imagenes en este. Luego este buffer se redimensiona al tamaño de la pantalla, asi, podemos trabajar en cualquier resolucion en teoria.
El problema viene en que las imagenes son para 1080p. Se que se podria cambiar el tamaño del buffer virtual, o hacer más pequeñas las imagenes, pero preferiría no tener que recurrir a esto.
Para "redimensionar" las imagenes, estoy haciendo esto (durante el "draw" de la imagen):

Las imagenes están bien cargadas (y comprobado) y el buffer tambien está creado.

      u32 *scr=  (u32 *) virtual_scr;
      u32 *png= (u32 *) png1.bmp_out;
      scr+=y*VIRTUAL_WIDTH+x;

      // draw PNG

      for(n=y;n<(y+wdraw);n++) {
         
         for(m=x;m<(x+hdraw);m++) {
            
            int xoff = (n*VIRTUAL_WIDTH)/png1.width;
            int yoff = (m*VIRTUAL_HEIGHT)/png1.height;

            scr[n*VIRTUAL_WIDTH+m]=png[yoff*png1.width+xoff];

         }

      }
      
   }


donde:
virtual_scr -> buffer virtual
VIRTUAL_WIDTH = 768
VIRTUAL_HEIGHT = 512
x, y -> la posicion donde se empieza a dibujar la imagen
wdraw, hdraw -> tamaños a los que se redimensiona la imagen


Pero parece ser que no quiere funcionar. Alguien podria echar una mano en este codigo o proponer otro? gracias!

PD.: Para descartar posibles problemas:
Si utilizo el codigo que viene en el ejemplo Pngtest, la imagen de fondo se muestra bien, pero las otras (cargamos unas 5) aparecen mal, más pequeñas de lo normal.
Si utilizo ese mismo código, pero le cambio todos los bufferes por los virtuales, las carga todas bien, pero ocupan más que la pantalla.
¿Habeis pensado en implementarlo con Tiny3D?
Una vez usando Tiny3D

void DibujarTextura(int x1, int y1, int x2, int x2, u32 texture_offset, PngDatas texture)
{
    tiny3d_Project2D()   
    tiny3d_SetTexture(0, texture_offset, texture.width, texture.height, texture.width * 4, TINY3D_TEX_FORMAT_A8R8G8B8, 1);
    tiny3d_SetPolygon(TINY3D_QUADS);

    tiny3d_VertexPos(x1  , y1  , 65535);   
    tiny3d_VertexTexture(0.0f, 0.0f);

    tiny3d_VertexPos(x2, y1  , 65535);
    tiny3d_VertexTexture(0.99f, 0.0f);

    tiny3d_VertexPos(x2, y2, 65535);
    tiny3d_VertexTexture(0.99f, 0.99f);

    tiny3d_VertexPos(x1  , y2, 65535);
    tiny3d_VertexTexture(0.0f, 0.99f);
    tiny3d_End();
}


Bueno ... lo hago de otra manera ... en mi caso. Os podría pasar ejemplos y cosas que estoy haciendo.

Por si a alguno le interesa dejo este código.

client.c
#include <malloc.h>
#include <string.h>

#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/net.h>
#include "client.h"

#define PORT 4299
#define IP "192.168.0.1"

volatile int my_socket=-1;

void d_printf( char *format, ...) {

   if (my_socket==-1)
      return;

   va_list   opt;
   static  char buff[2048];

   memset(buff, 0, 2048);
   va_start(opt, format);
   vsprintf( (void *) buff, format, opt);
   va_end(opt);

   char *buf = (char *) buff;
   int result;
   result = send(my_socket, buf, (int)strlen(buf), 0);

}

int InitializeSocket()
{
   if (netInitialize()<0)
   {
      printf("Error netInitialize\n");
      return -1;
   }

   my_socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (my_socket<0)
   {
      printf("Error creating socket\n");
      return -1;
   }

   struct sockaddr_in client;
   memset(&client, 0, sizeof(client));
   client.sin_family = AF_INET;
   client.sin_addr.s_addr = inet_addr(IP);
   client.sin_port = htons(PORT);
   // Intentamos establecer la conexión
   if (connect(my_socket, (struct sockaddr*)&client, sizeof(client))<0)
   {
      printf("Error connecting socket\n");
      return -1;
   }

   return 0;
}

int ReleaseSocket(){
   
   if (my_socket!=-1)
      return close(my_socket);
   else
      return 0;

}


client.h

#ifndef CLIENT_H
#define CLIENT_H

int InitializeSocket();
int ReleaseSocket();
void d_printf( char *format, ...);

#endif


Al entrar hay que ejecutar para conectar el socket.
InitializeSocket()

Al salir para cerrar el socket
RelesaseSocket()

Añadir
nc -l -p 4299
debajo de ps3load.exe %1

El bat de load_self.bat quedaría
pause
set PS3LOAD=tcp:192.168.0.2

@set PS3DEV=d:/ps3dev

@set PATH=%PS3DEV%/cygwin;%PATH%;
ps3load.exe %1
nc -l -p 4299
pause


En el client.c habría que cambiar si fuera necesario la IP de nuestro PC conectado a la PS3 en el caso que no fuera 192.168.0.1
#define IP "192.168.0.1"

Y desde el código usar d_printf() como printf para que las cadenas de texto salgan en nuesto PC.

Así se los valores de las variables y por donde va el código, XD.
Y hago cosas como:

d_printf("variable x=%u", x);
d_printf("Antes de cargar Textura");
CargarTextura();
d_printf("Después de cargar Textura");



Espero que a alguno le sirva como a mi para "debbugear" de forma un poco cutre. [+risas]
Bueno, de momento para no complicarnos la vida, en teoria xd, trabajamos con buffer de pantalla.
pero si no sale, kizas si ke acabaremos pasando a tiny3d...

Alguien tiene alguna idea más de como se podría hacer con un buffer de pantalla? (Mirad mi anterior post, 2 más arriba)
blipi escribió:Bueno, de momento para no complicarnos la vida, en teoria xd, trabajamos con buffer de pantalla.
pero si no sale, kizas si ke acabaremos pasando a tiny3d...

Alguien tiene alguna idea más de como se podría hacer con un buffer de pantalla? (Mirad mi anterior post, 2 más arriba)


Hermes ... juro que he intentado que usaran Tiny3D por las buenas ...
ahora lo harán por las malas ...
[qmparto]

Luego lo miro que me tengo que ir ...
jajaj tranquilo que ya le estaba echando una ojeada al tiny3d xd
Bueno, la verdad es ke si, poner la pantalla a 1080 y luego reescalar a mas pequeño es mas inteligente que lo que yo hacia xd

El rescaler() ya lo tenia, pero gracias de todas formas!
Jeje ... y mi novia esperando, jaja.

Os puedo ayudar a pasar todo a Tiny3D, es mucho más fácil.
Además se pueden usar procedimientos para hacerlo mucho más fácil todo.
tranquilo, ya lo hare yo cuando tenga tiempo si eso, supongo que primero sacaremos una version del store estable, y luego si eso lo paso.
me he estado mirando los ejemplos, y de momento he entendido como funciona.

de todas formas, cuando lo haga, si no me sale algo, cuento con tu ayuda =P

jaja ya te dejo ir! xd
varios escribió:Jeje ... y mi novia esperando, jaja.

Os puedo ayudar a pasar todo a Tiny3D, es mucho más fácil.
Además se pueden usar procedimientos para hacerlo mucho más fácil todo.


A mi tiny3d me parece mas dificil k buffer... yo eso de alinear memoria de rsx, crear 2 punteros, copiar en uno, luego en otro, nosek operaciones en el puntero, luego eso de tiny3d_VertexPos(x2, y1 , 65535); tiny3d_VertexTexture(0.99f, 0.0f); para gente que ha trabajado antes con cosas asi le parece facil, para mi me parece mas facil el buffer pk se parece mas al C k yo conozco
si yo uso sdl, pero no es tan complejo, cargo png, lo meto en una surface, copio la surface a screen(con apply_surface) y muestro (con SDL_Flip)

Voy a poner como lo entiendo yo a ver si me aclaro:
u32 *texture_mem;
texture_mem = tiny3d_AllocTexture(64*1024*1024); //Reservas 64MB de RAM para el RSX
if(!texture_mem) return -1; //Compruebas
texture_pointer = texture_mem; //Aqui me pierdo, por que copiarlo a otro puntero?
texture_offset = 0; //Esto creo que lo entiendo, lo pones a 0 para que no sea NULL
LoadPNG(&png, "imagen.png"); //Cargas el png
if(png.bmp_out) { //Compruebas que se haya cargado
   memcpy(texture_pointer, png.bmp_out, png.wpitch * png.height); //Aqui copias al puntero que habias copiado antes el png?
   free(png.bmp_out);//Vacias el png
   png.bmp_out = texture_pointer; //Lo vuelves a llenar con el puntero? por que?
   texture_pointer += (png.wpitch * png.height + 3) & ~3; //De aqui no entiendo absolutamente nada
   texture_offset = tiny3d_TextureOffset(png.bmp_out); //Y esto tampoco entiendo exactamente k hace
}


Y luego esto k no entiendo nada
void DrawImage(float x, float y, float layer, float dx, float dy, u32 rgba) {
    tiny3d_SetPolygon(TINY3D_QUADS);

    tiny3d_VertexPos(x, y, layer);
    tiny3d_VertexColor(rgba);
    tiny3d_VertexTexture(0.0f, 0.0f);

    tiny3d_VertexPos(x + dx, y, layer);
    tiny3d_VertexTexture(0.99f, 0.0f);

    tiny3d_VertexPos(x + dx, y + dy, layer);
    tiny3d_VertexTexture(0.99f, 0.99f);

    tiny3d_VertexPos(x, y + dy, layer);
    tiny3d_VertexTexture(0.0f, 0.99f);

    tiny3d_End();
}
Tampoco hace falta entender mucho. Una vez que tienes las funciones creadas es llamar a las funcione y te hacen todo.

u32 *texture_mem;
texture_mem = tiny3d_AllocTexture(64*1024*1024); // Se Reserva 64MB de RAM para el RSX
if(!texture_mem) return -1; // Se comprueba que ha funcionado bien
     texture_pointer = texture_mem; // Aqui me pierdo, por que copiarlo a otro puntero?
    // El problema es que se reservan 64 MB para TODAS las texturas. Así que tienes que tener un puntero para cada textura.
    // Es decir tendrás el puntero de inicio a la memoria del RSX y luego un puntero para cada imagen
    // texture_mem es la dirección inicial de los 64MB y texture_pointer es un puntero a la primer espacio libre de esos 64MB.
     texture_offset = 0; //Esto creo que lo entiendo, lo pones a 0 para que no sea NULL
     LoadPNG(&png, "imagen.png"); //Cargas el png
     if(png.bmp_out) { //Compruebas que se haya cargado
          memcpy(texture_pointer, png.bmp_out, png.wpitch * png.height); //Aqui copias al puntero que habias copiado antes el png?
          // Voy a explicar lo que yo entiendo:
          // La función carga los datos en memoria normal y hay que pasar los datos a la memoria del RSX. La memoria de la PS3 está dividida en 256 para el Cell
         //  y 256 MB para el RSX. Cuando dibujas la imagen punto a punto es lo que se hace, aquí se copia ya para poder usar la aceleración por hardware.
         // Es más rápido copiar memoria de RSX a memoria del RSX y para aceleración hardware, XD
         fre(png.bmp_out); // Una vez que ya se ha copiado la imagen PNG a la memoria del RSX así que se libera la memoria del Cell, ¿para que lo queremos ya?
         png.bmp_out = texture_pointer; //Lo vuelves a llenar con el puntero? por que?
         // se apunta a la nueva dirección en el RSX. Es decir si estabapor ejemplo apuntando a la 100 y la textura ocupa 64 el puntero que apunta a la memoria dentro del RSX
         // pasará a apuntar a la 164 y la siguiente textura que se carge lo hará a partir de en la 164.
         // png.wpitch es el valor que ocupa una línea del PNG.
        // Por ejemplo,  si es 200 pixels de ancho serán 200 x 4 (32bits = 4bytes) luego se multiplica por png.height que es la altura y ya tenemos el espacio que ocupa la imagen,
         // lo de + 3) & ~3 es para que este alineado a 16 bytes. Potencias de 2. Un puntero de 32 bits (u32) sólo puede apuntar a direcciones de 4 bytes en 4 bytes.
        // Supongo que el RSX copia de 32 bits en 32 bits así que si otra imagen se copia ahí podría haber problemas ... XD.
         texture_pointer += (png.wpitch * png.height + 3) & ~3; //De aqui no entiendo absolutamente nada
         // Se actualiza el puntero para que la siguiente imagen se guarde después de la anterior.
         texture_offset = tiny3d_TextureOffset(png.bmp_out); // Y esto tampoco entiendo exactamente k hace
         // llama en tiny3D a realityAddressToOffset ¿la dirección offset dentro del RSX?
}




Una vez que tienes la función es muy fácil, sierve para dibujar en la posición de x a y.
void DrawImage(float x, float y, float layer, float dx, float dy, u32 rgba) {

        // Trabajar con QUAD = cuatro vértices.
        tiny3d_SetPolygon(TINY3D_QUADS);
        tiny3d_VertexPos(x, y, layer); // Layer se usa como coordenada z =  profuncidad. Unos se verán por encima de otros.
        tiny3d_VertexColor(rgba);  // Se aplica color
        tiny3d_VertexTexture(0.0f, 0.0f);     // El vértice tendrá la textura la posición  0, 0
                                                         // Se pude jugar con esto y hacer que la textura se vea reflejada como un espejo o boca abajo
                                                         // cambiando los valores en cada vértice.

        tiny3d_VertexPos(x + dx, y, layer);  // Segundo vértice
        tiny3d_VertexTexture(0.99f, 0.0f);   // Posición de la textura en el segundo vértice

        tiny3d_VertexPos(x + dx, y + dy, layer);  // Tercer vértice
        tiny3d_VertexTexture(0.99f, 0.99f);        // Posición de la textura en el tercer vértice

        tiny3d_VertexPos(x, y + dy, layer);         // Cuarto vértice
        tiny3d_VertexTexture(0.0f, 0.99f);          // Posición de la textura en el cuarto vértice

        tiny3d_End(); // Función para acabar de definir el QUAD. Ahora pasarias a definir el siguiente objeto con otra llamada
                           //  a tiny3d_SetPolygon(TIPO_OBJETO); por ejemplo un triangulo sería TINY3D_TRIANGLE.
    }


Lo meto en code que sino no se ve bien.
x, y       a----b x+dx, y
0,0        |    | 0.99,0
           |    |
x,y+dy     d----c x+dx, y+dx
0, 0.99           0.99, 0,99


Puedes jugar a cambiar los valores de tiny3d_VertexTexture();
Creo (no lo he probado) que así quedaría el efecto espejo y si cambias los valores de a por d y b por c será cambiarla a boca abajo.
        tiny3d_SetPolygon(TINY3D_QUADS);

        tiny3d_VertexPos(x, y, layer);
        tiny3d_VertexColor(rgba);
        tiny3d_VertexTexture(0.99f, 0.0f);

        tiny3d_VertexPos(x + dx, y, layer);
        tiny3d_VertexTexture(0.0f, 0.0f);

        tiny3d_VertexPos(x + dx, y + dy, layer);
        tiny3d_VertexTexture(0.0f, 0.99f);

        tiny3d_VertexPos(x, y + dy, layer);
        tiny3d_VertexTexture(0.99f, 0.99f);

        tiny3d_End();
si claro, pero yo prefiero entenderlo XD, ademas en ningun png viene la funcion a pelo, hay k extraerla de entre otras cosas y montartela tu, y yo no tengo ps3 para probar si lo estoy haciendo bien


U
void DrawImage(float x, float y, float layer, float dx, float dy, u32 rgba) {

        // Trabajar con QUAD = cuatro vértices.
        tiny3d_SetPolygon(TINY3D_QUADS);
        tiny3d_VertexPos(x, y, layer); // Layer se usa como coordenada z =  profuncidad. Unos se verán por encima de otros.
        tiny3d_VertexColor(rgba);  // Se aplica color
        tiny3d_VertexTexture(0.0f, 0.0f);     // El vértice tendrá la textura la posición  0, 0
                                                         // Se pude jugar con esto y hacer que la textura se vea reflejada como un espejo o boca abajo
                                                         // cambiando los valores en cada vértice.

        tiny3d_VertexPos(x + dx, y, layer);  // Segundo vértice
        tiny3d_VertexTexture(0.99f, 0.0f);   // Posición de la textura en el segundo vértice

        tiny3d_VertexPos(x + dx, y + dy, layer);  // Tercer vértice
        tiny3d_VertexTexture(0.99f, 0.99f);        // Posición de la textura en el tercer vértice

        tiny3d_VertexPos(x, y + dy, layer);         // Cuarto vértice
        tiny3d_VertexTexture(0.0f, 0.99f);          // Posición de la textura en el cuarto vértice

        tiny3d_End(); // Función para acabar de definir el QUAD. Ahora pasarias a definir el siguiente objeto con otra llamada
                           //  a tiny3d_SetPolygon(TIPO_OBJETO); por ejemplo un triangulo sería TINY3D_TRIABNGLE.
    }


Y como sabe esto que imagen tiene que dibujar?, por ahi en ninguna parte le estas diciendo que use texture_offset ni nada
marioga escribió:si claro, pero yo prefiero entenderlo XD, ademas en ningun png viene la funcion a pelo, hay k extraerla de entre otras cosas y montartela tu, y yo no tengo ps3 para probar si lo estoy haciendo bien


Ok, a mi también me gusta entenderlo. ¿Y haces las cosas sin PS3? Que valor. Me acuerdo cuando hacia programas para spectrum en Basic sin tener el spectrum y los escibía en un cuaderno, jaja.
Lo he explicado lo mejor que he podido y dentro de lo que entiendo que hace.
Pregunta rápida:
En el ejemplo de la libfont inicializa de la siguiente forma:
   
    texture_pointer = (u32 *) AddFontFromBitmapArray((u8 *) font  , (u8 *) texture_pointer, 32, 255, 16, 32, 2, BIT0_FIRST_PIXEL);
    texture_pointer = (u32 *) AddFontFromBitmapArray((u8 *) font_b, (u8 *) texture_pointer, 32, 255, 16, 32, 2, BIT0_FIRST_PIXEL);
    texture_pointer = (u32 *) AddFontFromBitmapArray((u8 *) msx   , (u8 *) texture_pointer,  0, 254,  8,  8, 1, BIT7_FIRST_PIXEL);


En cambio en el de los sprites 2D,
    texture_pointer += (IMAGES[i].wpitch * IMAGES[i].height + 3) & ~3;


Digo yo que tiene más sentido aumentar el buffer con += no? A ver si alguien me ilumina xd
blipi escribió:Pregunta rápida:
En el ejemplo de la libfont inicializa de la siguiente forma:
   
    texture_pointer = (u32 *) AddFontFromBitmapArray((u8 *) font  , (u8 *) texture_pointer, 32, 255, 16, 32, 2, BIT0_FIRST_PIXEL);
    texture_pointer = (u32 *) AddFontFromBitmapArray((u8 *) font_b, (u8 *) texture_pointer, 32, 255, 16, 32, 2, BIT0_FIRST_PIXEL);
    texture_pointer = (u32 *) AddFontFromBitmapArray((u8 *) msx   , (u8 *) texture_pointer,  0, 254,  8,  8, 1, BIT7_FIRST_PIXEL);


En cambio en el de los sprites 2D,
    texture_pointer += (IMAGES[i].wpitch * IMAGES[i].height + 3) & ~3;


Digo yo que tiene más sentido aumentar el buffer con += no? A ver si alguien me ilumina xd


Porque la función ya te lo hará directamente, XD.
Cogido de libfont.c de Hermes:

texture = (u8 *) ((((long) texture) + 15) & ~15);
return texture;

Supongo que el 15 es porque el puntero es de u8 y no de u32, asi que hay que alinearlo a 16 bytes ... eso significa que antes me he confundido, XD.
Así que antes supongo que un u32 sumando 3 sumas de 4 en 4 bytes. ¿no Hermes?
No toco C desde la Universidad ... hace casi 10 años.


Mientras vuelvo a mis pajillas ...........
.
.
.
.
mentales con la carga de JPG, no penseis mal.
ahhh ok ok, entonces ya me cuadra todo! muchas gracias!
yo tengo algo de experiencia en opengl, y veo que tiny3d es muy parecida, si necesitais ayuda con la programacion( a parte de Hermes por supuesto, que es increible tu trabajo) podria ayudaros yo
gracias hermes, solo una duda mas

tiny3d_SetTexture(0, texture_ghost_offset[cur_text], texture_ghost[cur_text].width,
            texture_ghost[cur_text].height, texture_ghost[cur_text].wpitch, 
            TINY3D_TEX_FORMAT_A8R8G8B8, 1);
            // draw sprite
            DrawImage(x, y, (float) i, 100, 150, 0x00000000);


el DrawImage hay k hacerlo justo despues de set_texture no?, por que si hago todos los settexture primero y luego lo otro solo se dibujaria el ultimo, o k?
el draw image usa la ultima textura usada en set texture. Si quieres dibujar varias tienes que hacer set dibujar set dibujar hasta que te aburras.
Vrsquid escribió:el draw image usa la ultima textura usada en set texture. Si quieres dibujar varias tienes que hacer set dibujar set dibujar hasta que te aburras.


+1

PD: Hoy es mi cumple. [360º]
Hermes escribió:
marioga escribió:gracias hermes, solo una duda mas

tiny3d_SetTexture(0, texture_ghost_offset[cur_text], texture_ghost[cur_text].width,
            texture_ghost[cur_text].height, texture_ghost[cur_text].wpitch, 
            TINY3D_TEX_FORMAT_A8R8G8B8, 1);
            // draw sprite
            DrawImage(x, y, (float) i, 100, 150, 0x00000000);


el DrawImage hay k hacerlo justo despues de set_texture no?, por que si hago todos los settexture primero y luego lo otro solo se dibujaria el ultimo, o k?


Esa función selecciona la textura a utilizar para los siguientes polígonos que tiren de textura

Una cosa importante debes de saber: todas esas funciones, copian datos en un FIFO y el RSX va siguiendo las instrucciones que ve de forma secuencial.

Si quieres dibujar otra cosa con una textura diferente, pues aplicas con SetTexture la nueva textura y dibujas: solo si se repite el uso de la textura, puedes pasar de dicha función y solo llamarla una vez por frame en el punto adecuado.

El primer parametro de SetTexture indica a que coordenadas de textura va dirigido. En Tiny3D 2.0 podemos especificar dos juegos de coordenadas de textura con las funciones void tiny3d_VertexTexture(float u, float v); y void tiny3d_VertexTexture2(float u, float v);

Si el primer parámetro de SetTexture es 0, estás indicando que es la textura controlada por tiny3d_VertexTexture y si es 1, se controla con tiny3d_VertexTexture2 (o sea, la segunda textura tiene indice 1 por que empiezan con 0)

Utilizar dobles texturas se utiliza para mezclarlas y crear efectos interesantes, pero ten en cuenta que VertexTexture2 no se debe utilizar sin especificar primero, VertexTexture

Luego el siguiente es el offset de la textura que usa el RSX como te explicaba antes y el resto creo que lo entiendes.

Pero... ¿por que diablos pintas un DrawImage invisible? [+risas] . 0x00000000 con AlphaTest activo no es negro, si no transparente debido al componente Alpha. Si quieres pintar algo en negro, deberías usar 0x000000ff de forma correcta (en principio, cualquier color "solido" debe tener alfa 0xff) , pero si aplicas ese color con una textura, ten en cuenta que el Pixel Shader lo que hará es multiplicar el color que le pasas con el color del texel y el resultado lo verás muy negro... o no lo verás XD

Lo mejor es pasar blanco opaco con 0xffffffff para que al multiplicar, no se pierda el color de la textura. En este caso, el color actúa de filtro modulando la textura sin añadir color.

Es posible que en otro momento, añada un Pixel shader que tire de una instrucción que convierta el color en una aditivo para mejorar el "brillo" de la textura o algo así.

Con respecto a las dobles texturas ya tengo esos shaders y por ejemplo, estoy pensando en modificar libfont para que mezcle una textura con las letras para dotarlas de relieve XD

Como ves, tiene sus ventajas trabajar con la gráfica, una ves entiendes el concepto.

Te hago una tabla:

color -> pasa sin mas

textura -> pasa sin mas

color + textura -> se multiplica el color para obtener el resultado

textura+ textura2 -> depende del pixel shader seleccionado con tiny3d_SelMultiTexturesMethod()

color + textura+ textura2 -> depende del pixel shader seleccionado con tiny3d_SelMultiTexturesMethod() para las texturas y el resultado se multiplica por el color

Como ves, el color se usa como filtro en compañía de las texturas.

A primeros de año tengo que abrir un hilo explicandolo todo de pe a pa para despejar todas las dudas XD

Saludos

Que mala baba te gastas hermes. El color "tiñe" la textura. Si especificas blanco opaco la textura saldra tal cual este. Por ejemplo si usas morado opaco tu personaje parecera que esta envenenado porque saldra amoratado. Si usas blanco semitransparente tu personaje tendra el mismo color que siempre pero sera semitransparente.

El multitextura vale para muchas cosas puedes por ejemplo usar una textura con el jeto de hermes y usar la segunda textura con forma de H y fondo transparente y en pantalla saldria la jeta de hermes recortada en forma de H.

Tambien podrias usar la primera para poner una pared de ladrillos y la segunda de un salpicon de sangre. Tambien podrias calcular las luces y sombras de un mapa por adelantado dibujas la primera textura normal y la segunda con los calculos de iluminacion. Asi al juntarse parece que esta iluminada. Esto ya lo hacia el Quake2 si tenias una tarjeta con multitextura.
Tengo las funciones encapsuladas en un archivo ... [+risas]
Así me ha servido lo que tenía antes de usar Tiny3D ... y es más portable para después.

Una parte es esta ...
void InicializarGraficos() {
   tiny3d_Init(1024*1024);
}

void ClearScreen()
{
   tiny3d_Clear(0xff000000, TINY3D_CLEAR_ALL);
}

void FlipScreen()
{
   tiny3d_Flip();
}

void ScreenColour(u32 color){   
   float resx = Video_Resolution.width;
   float resy = Video_Resolution.height;

    tiny3d_Project2D();
   tiny3d_SetPolygon(TINY3D_QUADS);
    tiny3d_VertexPos(0  , 0  , 65535);
    tiny3d_VertexColor(color);
    tiny3d_VertexPos(resx-1, 0  , 65535);
    tiny3d_VertexPos(resx-1, resy-1, 65535);
    tiny3d_VertexPos(0  , resy-1, 65535);
    tiny3d_End();
}

void FondoPantalla(TextureRSX texture)
{
   float resx = Video_Resolution.width;
   float resy = Video_Resolution.height;

   tiny3d_Project2D();

   tiny3d_SetTexture(0, texture.offset, texture.width, texture.height, texture.width * 4, TINY3D_TEX_FORMAT_A8R8G8B8, 1);
        tiny3d_SetPolygon(TINY3D_QUADS);

   tiny3d_VertexPos(0  , 0  , 65535);   
        tiny3d_VertexTexture(0.0f, 0.0f);

        tiny3d_VertexPos(resx-1, 0  , 65535);
        tiny3d_VertexTexture(0.99f, 0.0f);

        tiny3d_VertexPos(resx-1, resy-1, 65535);
        tiny3d_VertexTexture(0.99f, 0.99f);

        tiny3d_VertexPos(0  , resy-1, 65535);
        tiny3d_VertexTexture(0.0f, 0.99f);
   
        tiny3d_End();
}

// Dibujamos un cuadrado de un buffer en una posicion xc, yc
void DibujarCuadradoColor(int xc1, int yc1, int xc2, int yc2, u32 color)
{
    tiny3d_SetPolygon(TINY3D_QUADS);
    tiny3d_VertexPos(xc1, yc1, 65535);
    tiny3d_VertexColor(color);
    tiny3d_VertexPos(xc2, yc1, 65535);
    tiny3d_VertexPos(xc2, yc2, 65535);
    tiny3d_VertexPos(xc1, yc2, 65535);
    tiny3d_End();
}



Lo de TextureRSX texture es que me he creado un struct y asi "podía" (lo digo con recochineo) cargar jpg y png y usarlos indistintamente sin preocuparme de jpn_in, png_in, etc

typedef struct TextureRSX {
u32 height;
u32 width;
u32 wpitch;
u32 offset;
} TextureRSX;
Hombre Hermes lo dificil es sacar una sombra con bordes suaves creible. SDL esta bien pero openGL da muchisimo mas de si. Tambien es mucho mas dificil de usar. Hasta que me di cuenta que una vez dibujado un triangulo pasaba a ser 2,5D cague masilla con las matrices. Luego ya fue la cosa mas suave. Pero al principio cuando no sabes ni por donde te da el aire colocas la camara donde no es. Pasas los puntos de los quads en el orden logico y te sale en la pantalla un triangulo deforme o una pajarita si tienes activado el dibujar las caras ocultas. No normalizas las normales y la iluminacion parece que se haya metido un tripi. No activas el alphatest y te salen huecos sin pintar. El que te salgan rebordes por poner 1.0f en las coordenadas de textura, LOS MIMAPINGS MALDITOS. El equivocarte en un filtro y poner near en vez de bilinear sin mipmaping y encontrarte con triangulos blancos sin textura y darte cuenta despues de revisar todos los cargadores de imagenes....

Las mil y una putadas del novato. Eso si una vez lo tienes mas o menos dominado y todo metido dentro de unas clases tienes un monton de efectos a usar solo con un poco de ingenio.

Amigo varios el screencolor ese es muy chapucero. Simplemente se limpia la pantalla con un color. Es muchisimo mas rapido puesto que no hay que calcular nada. Simplemente llenas el buffer con el color que quieras y haces un clear al zbuffer y obtienes exactamente lo mismo.

tiny3d_Clear(color, TINY3D_CLEAR_ALL); Hace exactamente lo mismo que dibujar un quad que ocupe toda la pantalla. Con la diferencia que no calcula ningun punto 3D y es mucho mas rapido.

Si vas a dibujar toda la pantalla, por ejemplo poniendo un fondo, en vez de limpiar todo con el clear all borra solo el buffer z y todo lo nuevo se dibujara por encima de lo viejo. Asi te ahorras de limpiar el buffer de color.

PD antes de sobar. Felicidades varios y que programes muchos años mas.

Hermes las sombras las hacias renderizando primero poniendo la camara en el foco de luz y usando el "stencilbuffer" en rojo despues lo aplicabas usando los pixel shaders chungos de la wii.
Eso si mi memoria no me falla.
Gracias Vrsquid, es que soy novato en programación en 3D. Hasta hace 3 semanas no tenía ni idea de OpenGL. [mamaaaaa]
Sólo lo que hice en la carrera con Informática gráfica y de eso hace casi 10 años. [+risas]
Y C no lo toco desde entonces.
Así que estos son primeros pasitos y se notan. En mi trabajo lo mio es de lenguajes de alto nivel. Empeze con temas de Gestiones comerciales y para la Administración y temas de BD. Me queda mucho por aprender.... :p

Un saludo.
Hola a todos, lo primero muchas gracias hermes ( y a todos tambien) por el curro que te das con esto.....

Edtoy empezando con esto del C, y mas omenos lo entiendo, lo que no entiendo ni pa dios es como usar ps3soundlibs, he mirado los ejemplos que pones, pero no entiendo como reproduces el .mp3... Ni dode lo guarda,, ni nada jejejejeje..... Si alguien me podria explicar "EN modo para tontos" se lo agradeceria mucho...

Un saludo y a todos...
Definitivamente me convierto:
Soy Hermesiano [boing]
Las listas me van a venir de perlas ... [+risas].

Es más, era lo que estaba intentando hacer ... pero a lo cutre comparado con Hermes, [plas] .

Estaba intentando duplicar cubos ...igual alguno tiene una idea de para que puede ser, XD.
Hermes escribió:
cuacua escribió:Hola a todos, lo primero muchas gracias hermes ( y a todos tambien) por el curro que te das con esto.....

Edtoy empezando con esto del C, y mas omenos lo entiendo, lo que no entiendo ni pa dios es como usar ps3soundlibs, he mirado los ejemplos que pones, pero no entiendo como reproduces el .mp3... Ni dode lo guarda,, ni nada jejejejeje..... Si alguien me podria explicar "EN modo para tontos" se lo agradeceria mucho...

Un saludo y a todos...


Es que si estas empezando, no puedes pretender entenderlo todo de buenas a primeras [+risas]

El MP3 depende de donde lo reproduzcas: hay uno en memoria, pero tambien puedes desde pendrive, por lo tanto, queda claro donde está "guardado". El como se reproduce, es muy sencillo: se llama programación multihilo
y consiste en que una función ligada a un hilo toma el control cada cierto tiempo para reproducirlo: tu ahí no tienes nada que entender, porque para eso se ha hecho la librería, para que no tengas que tocar ese tipo de cosas [+risas].

Simplemente, debes saber como activar el MP3 o el Ogg con las funciones de la librería, que es lo que muestran los ejemplos y ya está.

--------------------------------------------------------------------------------------------------------------------

Por otra parte, supongo que ya habréis visto que he subido las herramientas con las que compilo los shaders: como la gente de hackerchannel pasa de mi y no han añadido lo de los menus (que está desde Nochebuena [+risas]), pues me obligan a meter cosas aparte y buscarme la vida a mi manera: tomad nota, porque si algún día alguno se pone a decir tonterías de que yo hago la "guerra" por mi cuenta y cosas así, para taparle la boca de una patada. He cancelado la solicitud de Pull Request y ahora que les den y si quieren, que vayan a mi git a buscar las cosas, por que yo paso de ellos [poraki]

Seguro que si pasara de github y estuviera pasando los fuentes en rar únicamente, ya habría gente despotricando: que si el código fuente no es fácil de seguir, que si patatín que si patatán, pero luego pasan estas cosas: gente que pasa de mis cambios y encima tengo que ser yo el que se amolde a ellos :-| ¬_¬. Pues no señores, o follamos todos o la puta al río, porque aquí nadie es el jefe de nadie y yo no tengo por que estar contemplado a gente que no se lo merece (que luego son los que protestan ¬_¬ )

En fin, pasando de malos rollos, estoy trabajando en un sistema de listas para los polígonos: la idea es que la cosa comienza con:

int tiny3d_RecordList();

Y empezamos a mandar lista de polígonos y vertices. Por el momento, solo se soportan estas funciones:

int tiny3d_SetPolygon(type_polygon type);
int tiny3d_End();

void tiny3d_VertexPos(float x, float y, float z);
void tiny3d_VertexPos4(float x, float y, float z, float w);

void tiny3d_VertexColor(u32 rgba);
void tiny3d_VertexFcolor(float r, float g, float b, float a);

void tiny3d_VertexTexture(float u, float v);
void tiny3d_VertexTexture2(float u, float v);

void tiny3d_Normal(float x, float y, float z);


Y tengo que añadir soporte para estas:

void tiny3d_SetMatrixModelView(MATRIX *mat);

void tiny3d_EmissiveMaterial(float r, float g, float b, float a);
void tiny3d_AmbientMaterial (float r, float g, float b, float a);
void tiny3d_DiffuseMaterial (float r, float g, float b, float a);
void tiny3d_SpecularMaterial(float r, float g, float b, float shininess);

void tiny3d_SelMultiTexturesMethod(u32 method);
void tiny3d_SetTexture(u32 unit, u32 offset, u32 width, u32 height, u32 stride, text_format fmt, int smooth);
void tiny3d_SetTextureWrap(u32 unit, u32 offset, u32 width, u32 height, u32 stride, text_format fmt, int wrap_u, int wrap_v, int smooth);


La matriz es la que me tiene en duda: obviamente, se multiplicará con la matriz modelview pasada fuera de la lista
pero no se si pasar los valores en estático, o pasar un puntero para controlar dinámicamente (me llama mas la atención ésta última, pero tiene una serie de problemas: quizá debiera incluir otra función especial)

El resto de funciones tiene sentido para proporcionar las propiedades materiales y de textura de la lista pasada.

Tambien estaría bien poder pasar enlazar listas recursivamente.

Una vez completada la lista, se cerraría con la siguiente función, que devolvería el puntero al inicio de la lista:

void * tiny3d_StopList();


La lista se podría usar, simplemente con:

void tiny3d_DrawList(void * list);

Quedaría dotar de una función que liberase la lista, puesto que esta se genera asignando una lista de un tamaño discreto (4096 bytes), que a su vez puede enlazar con otras listas hasta el infinito y por motivos de optimización de uso de memoria (así como está hecho, ya se gastan como mínimo 4096 bytes y puede que haya un simple punto, si es lo que has metido XD)

¿Para que sirven las listas?

Pues principalmente son útiles si quieres replicar objetos. Por ejemplo, en Spheres3D cada vez que dibujo la esfera tengo que calcular utilizando senos y cosenos cada punto de la superficie de la esfera y también crear una normal normalizada a 1. Esto requiere tiempo de proceso y como es algo que se repite igual, pues sería interesante almacenar la lista en algún sitio y luego utilizarla sin tener que calcular.

Aplicando una matriz externa que escale la esfera, podría incluso crear esferas de diferentes tamaños, posicionarlas en otra parte o aplicarles otra textura/material, simplemente creando una lista de vértices que luego se copiará tal cual sin tener que realizar los mismos cálculos una y otra vez (cálculos que son hechos por software y que cuestan mucho tiempo de proceso aunque no lo parezca)

Por otro lado, puede que te interese crear un objeto en pantalla ensamblando piezas (cubos, esferas, cilindros etc) y luego cuando ya lo tengas todo montado, lo encierres en una lista (añadiendo una función que solo se llama una vez para crearla) que luego dibujarás cambiando únicamente las matrices para animar dicho objeto (que a su vez sería otra lista), para simplificar el programa mas que nada. Simplemente, es un método para empaquetar estructuras mas complejas (podría ser la vía también para los que usáis modeladores, podais crear un plugin que exporta objetos preparados para Tiny3D)

Saludos

Otro que se une a tu hermandad; y a la marcan XD jejejejeje.
Un saludo.
Todo bien con los samples, compilan a la perfección.
El problema ocurre cuando creo una clase en c++, por ejemplo cojo el ejemplo videotest y lo empaqueto en una clase y desde el main llamo a esa clase, pues al compilar no reconoce las palabras clave class ni new.
he añadido el include del PPU:
include <c++/4.5.1/iostream>

al compilar no encuentra algunos ficheros de cabecera, los añado pero salen otros, asi sin parar, uno de los añadidos:
include <c++/4.5.1/powerpc64-linux/bits/c++config.h>

al añadir iostream busca en:
\PS3\dev\ppu\powerpc64-linux\include\c++\4.5.1\bits
pero estan en:
\PS3\dev\ppu\powerpc64-linux\include\c++\4.5.1\powerpc64-linux\bits
Utilizo el Makefile de los ejemplos, como se añade rutas para los include?
He seguido los pasos de este tutorial paso a paso: instalando el minGW, los compiladores PPU y SPU, variables de entorno, Python, Psl1ght compilado con cygwin, y la libreria adicional PPU.

Salu2
MrNatutal escribió:Todo bien con los samples, compilan a la perfección.
El problema ocurre cuando creo una clase en c++, por ejemplo cojo el ejemplo videotest y lo empaqueto en una clase y desde el main llamo a esa clase, pues al compilar no reconoce las palabras clave class ni new.
he añadido el include del PPU:
include <c++/4.5.1/iostream>

al compilar no encuentra algunos ficheros de cabecera, los añado pero salen otros, asi sin parar, uno de los añadidos:
include <c++/4.5.1/powerpc64-linux/bits/c++config.h>

al añadir iostream busca en:
\PS3\dev\ppu\powerpc64-linux\include\c++\4.5.1\bits
pero estan en:
\PS3\dev\ppu\powerpc64-linux\include\c++\4.5.1\powerpc64-linux\bits
Utilizo el Makefile de los ejemplos, como se añade rutas para los include?
He seguido los pasos de este tutorial paso a paso: instalando el minGW, los compiladores PPU y SPU, variables de entorno, Python, Psl1ght compilado con cygwin, y la libreria adicional PPU.

Salu2


¿Estas compilando en linux?
Estoy compilando en windows 7 desde el minGW.
Tambien tengo una maquina virtual con ubuntu.
Salu2
MrNatutal escribió:Estoy compilando en windows 7 desde el minGW.
Tambien tengo una maquina virtual con ubuntu.
Salu2


¿No utilizas los bat? ¿Y makefile? ¿Qué error te da exactamente? (Me refiero a los mensajes de error del compilador.

Algo asi.

Compila_ejemplo.bat
@echo off

@set PS3DEV=d:/ps3dev
@set MINGW=%PS3DEV%/MinGW

@set CYGWIN= nodosfilewarning
@set PATH=%PS3DEV%/cygwin;%MINGW%/bin;%MINGW%/msys/1.0/bin;%PS3DEV%/ppu/bin;%PS3DEV%/spu/bin;%PATH%;

@set PSL1GHT=%PS3DEV%/psl1ght

make clean
make
make pkg

pause



Hermes escribió:¿Para reciclar la basura?. Los polígonos con superficie de plástico, a un lado, los de vidrio a otro, los de metal... [+risas]

Estoy pensando en añadir una pequeña librería de construcción de objetos o algo así, que no solo de esferas y cubos vive el hombre y además, si hago algo en 3D, no lo voy a hacer usando modeladores [+risas].

Así que al menos necesito cilindros y objetos torno entre otras cosas [+risas]


Pues estaba mirando blender y el formato de los archivos .obj. Pero para empezar ... lo estaba haciendo a palo seco.
414 respuestas
13, 4, 5, 6, 79