technik escribió:PD: Me vendria bien que alguien me pudiese pasar un modelo en 3ds, sin textura, sin animacion, y sencillito. En unos dias pedire tambien la version animada y al version con textura
int PNGU_Init ();
void PNGU_Release ();
int PNGU_SelectFileFromBuffer (const char *buffer);
int PNGU_SelectFileFromWiiSD (const char *filename);
int PNGU_GetImageProperties (PNGUPROP *fileproperties);
int PNGU_DecodeToYCbYCr (unsigned int width, unsigned int height, char *buffer, unsigned int stride);
int PNGU_LoadTo4x4RGB24 (unsigned int width, unsigned int height, char *buffer);
Mira a ver si alguno de los ejemplos de tehwii te puede servir.frontier escribió:¿Alguno habeis tocado el tema del sonido?
¿Hay alguna interfaz para eso en libogc?
¿Cuantos canales se pueden usar simultaneamente?
¿Que frecuencia y resolución tiene cada uno?
¿Hay librerías para reproducir de forma sencilla ficheros .wav o .mp3?
Agradecería cualquier indicación
frontier escribió:¿Alguno habeis tocado el tema del sonido?
¿Hay alguna interfaz para eso en libogc?
¿Cuantos canales se pueden usar simultaneamente?
¿Que frecuencia y resolución tiene cada uno?
¿Hay librerías para reproducir de forma sencilla ficheros .wav o .mp3?
Agradecería cualquier indicación
frontier escribió:Sobre el problema de colores que mencionabais más arriba, ¿Habeis descartado que se deba al formato de palabra de la máquina (endianness)? Supongo que no tendrá nada que ver, pero es lo único que se me ocurre.
Ya lo he dicho antes: accelerar la parte 2d de tinyGL es sencillo (el rasterizador de triángulos básicamente) -- sólo reescribiendo partes en assembler puedes ganar un 20%. Accelerar la parte 3d es demasiado complicado y no merece la pena; sale más a cuenta crear una desde 0.oyzzo escribió:Me estoy planteando si es buena idea lo de acelerar graficamente TinyGL, yo creo que seria mejor usar directamente GX.
oyzzo escribió:A mi me funciona bien en el emulador, pero en la wii original me va exactamente como tu dices.
EDIT:
Me estoy planteando si es buena idea lo de acelerar graficamente TinyGL, yo creo que seria mejor usar directamente GX.
Me lo he estado mirando y es muucho trabajo, mas trabajo que crear el motor en si y un juego que lo use xD Asi que yo por mi parte voto para hacer el engine sobre GX y me pongo a trabajar en esa direccion
Sasker escribió:El problema es que GX no es un standard, y no es facil de entender la correspondencia de algunas cosas ya que no se corresponden de manera identica a las funciones de oGL...
No es tan duro portar TinyGL, dame un poco mas de tiempo...
Tiny-FatFs Copyright (C) 2007, ChaN [URL=http://elm-chan.org/fsw/ff/00index_e.html]Webpage[/URL]
Fichero tff.h
/*-----------------------------------------------------*/
/* FatFs module application interface */
FRESULT f_mount (BYTE, FATFS*); /* Mount/Unmount a logical drive */
FRESULT f_open (FIL*, const char*, BYTE); /* Open or create a file */
FRESULT f_read (FIL*, void*, WORD, WORD*); /* Read data from a file */
FRESULT f_write (FIL*, const void*, WORD, WORD*); /* Write data to a file */
FRESULT f_lseek (FIL*, DWORD); /* Move file pointer of a file object */
FRESULT f_close (FIL*); /* Close an open file object */
FRESULT f_opendir (DIR*, const char*); /* Open an existing directory */
FRESULT f_readdir (DIR*, FILINFO*); /* Read a directory item */
FRESULT f_stat (const char*, FILINFO*); /* Get file status */
FRESULT f_getfree (const char*, DWORD*, FATFS**); /* Get number of free clusters on the drive */
FRESULT f_sync (FIL*); /* Flush cached data of a writing file */
FRESULT f_unlink (const char*); /* Delete an existing file or directory */
FRESULT f_mkdir (const char*); /* Create a new directory */
FRESULT f_chmod (const char*, BYTE, BYTE); /* Change file/dir attriburte */
FRESULT f_rename (const char*, const char*); /* Rename/Move a file or directory */
/* User defined function to give a current time to fatfs module */
DWORD get_fattime (void); /* 31-25: Year(0-127 +1980), 24-21: Month(1-12), 20-16: Day(1-31) */
/* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */
frontier escribió:Todavía no he hecho ninguna prueba de escritura en la SD, me imagino que será igual que leer pero invocando a f_write. De todas formas tengo pensado sacar de aquí a un par de días las 4 o 5 funciones básicas de escritura/lectura que os comenté.
De momento sigo depurando y creando mis rutinas PNGU de manejo de imágenes. He conseguido hacer un par de funciones bastante optimizadas que pasan una imágen a formato 4x4 RGB565 y 4x4 RGBA8. Como ya habreis supuesto sirven para cargar texturas. Si alguien tiene manejo con GX me gustaría que me dijera si, aparte de esos dos formatos, en la práctica se usa alguno más de entre los que soporta Wii (GX_TF_I4, GX_TF_I8, GX_TF_IA4, GX_TF_IA8, GX_TF_RGB5A3, GX_TF_C4, GX_TF_C8, GX_TF_CI4, GX_TF_CMPR).
También creo que sería buena idea que cada uno dijese a lo que se está dedicando, así no tendríamos gente haciendo trabajo repetido. Por supuesto cada uno es libre de decirlo o no...
Saludos!
oyzzo escribió:Si a alguien le interesa y lo pide puedo ir haciendo unos tutoriales y ejemplos sobre GX al estilo NeHe mientras sasker me dice algo.
technik escribió:Kontakatilu, casualmente he estado viendo esa llamada, y me estoy planteando un par de cosas a partir de ello. Os comento:
Creo que llegados a este punto estaria bien que fijasemos unas bases de trabajo aunque sea temporal para trabajar de forma mas eficiente...
...esta el tema de las SD, que son un recurso bastante versatil, y estaria bien que nos decidieramos por usar unas librerias fijas, por que aqui a veces se usa lo que trae GRRLib, otras veces las del ejemplo de carga de texto y otras se usan las de libogc. Yo personalmente optaria por aprender a usar las de libogc, porque probablemente tendran mas soporte en el futuro que las versione de terceros. Tambien esta el tema del control, wiimote y demas, pero eso aun no corre ninguna prisa y es suficiente (creo yo) con usar el mando de GC por ahora.
oyzzo escribió:Estoy deacuerdo con lo de usar el mando de game cube de momento.
También estoy deacuerdo con lo de usar las librerias wiisd para hacer las funciones de lectura y escritura en la SD y asi podemos ir implementando ya la carga de modelos.
Me parece bien usar el port de libpng con las funciones de soporte pngu que esta creando nuestro compañero frontier para cargar texturas de la SD.
Lo de usar GX o TinyGL depende de lo que diga sasker.
frontier escribió:Todavía no he hecho ninguna prueba de escritura en la SD, me imagino que será igual que leer pero invocando a f_write. De todas formas tengo pensado sacar de aquí a un par de días las 4 o 5 funciones básicas de escritura/lectura que os comenté. De momento sigo depurando y creando mis rutinas PNGU de manejo de imágenes. He conseguido hacer un par de funciones bastante optimizadas que pasan una imágen a formato 4x4 RGB565 y 4x4 RGBA8. Como ya habreis supuesto sirven para cargar texturas. Si alguien tiene manejo con GX me gustaría que me dijera si, aparte de esos dos formatos, en la práctica se usa alguno más de entre los que soporta Wii (GX_TF_I4, GX_TF_I8, GX_TF_IA4, GX_TF_IA8, GX_TF_RGB5A3, GX_TF_C4, GX_TF_C8, GX_TF_CI4, GX_TF_CMPR). También creo que sería buena idea que cada uno dijese a lo que se está dedicando, así no tendríamos gente haciendo trabajo repetido. Por supuesto cada uno es libre de decirlo o no... Saludos!
technik escribió:Sasker, si tu dices que te encargas de acelerar TinyGL, yo me encargo de usarlo jeje.
Por el momento he dejado un poco de lado el cargador de modelos desde la SD hasta que vea que es todo un poco mas estable y tengamos claro un standar con el que trabajar. Sigo esperando que alguien confirme si el libogc/include/sdcardn permite realmente utilizar la SD frontal, en cuyo caso creo que esta seria la mejor opcion.
// Textura de 100x100, a descomprimir en RGBA8
texture_data1 = MEM_K0_TO_K1(memalign (32, imgProp1.imgWidth*imgProp1.imgHeight*4));
// Textura de 100x100, a descomprimir en RGB565
texture_data2 = MEM_K0_TO_K1(memalign (32, imgProp2.imgWidth*imgProp2.imgHeight*2));
#include
#include
#include
#include
#include
#include "libpng/pngu/pngu.h"
#include "logo.h"
#define DEFAULT_FIFO_SIZE (256*1024)
typedef struct tagcamera {
Vector pos;
Vector up;
Vector view;
}camera;
s16 squares[] ATTRIBUTE_ALIGN(32) =
{
// x y z
-90, 30, 0, // 0
-30, 30, 0, // 1
-30, -30, 0, // 2
-90, -30, 0, // 3
30, 30, 0, // 0
90, 30, 0, // 1
90, -30, 0, // 2
30, -30, 0, // 3
};
// color data
u8 colors[] ATTRIBUTE_ALIGN(32) = {
// r, g, b, a
0, 255, 0, 0, // 0 purple
240, 0, 0, 255, // 1 red
255, 180, 0, 255, // 2 orange
255, 255, 0, 255, // 3 yellow
10, 120, 40, 255, // 4 green
0, 20, 100, 255 // 5 blue
};
static float rotby=0;
static void *xfb = NULL;
static u32 do_copy = GX_FALSE;
GXRModeObj *rmode;
GXTexObj texObj1;
GXTexObj texObj2;
camera cam = {{0.0F, 0.0F, 0.0F},
{0.0F, 1.0F, 0.0F},
{0.0F, 0.0F, -1.0F}};
void draw_init();
void draw_vert(u8 pos, u8 c, f32 s, f32 t);
void draw_square1(Mtx v);
void draw_square2(Mtx v);
static void copy_to_xfb(u32 count);
void movecamera(float speed);
void *texture_data1 = NULL;
void *texture_data2 = NULL;
PNGUPROP imgProp1;
PNGUPROP imgProp2;
int main() {
Mtx v,p; // view and perspective matrices
GXColor background = {0, 0, 0, 0xff};
VIDEO_Init();
switch(VIDEO_GetCurrentTvMode())
{
case VI_NTSC:
rmode = &TVNtsc480IntDf;
break;
case VI_PAL:
rmode = &TVPal528IntDf;
break;
case VI_MPAL:
rmode = &TVMpal480IntDf;
break;
default:
rmode = &TVNtsc480IntDf;
break;
}
PAD_Init();
xfb = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
VIDEO_Configure(rmode);
VIDEO_SetNextFramebuffer(xfb);
VIDEO_SetPostRetraceCallback(copy_to_xfb);
VIDEO_SetBlack(FALSE);
VIDEO_Flush();
VIDEO_WaitVSync();
if(rmode->viTVMode&VI_NON_INTERLACE) VIDEO_WaitVSync();
void *gp_fifo = NULL;
gp_fifo = MEM_K0_TO_K1(memalign(32,DEFAULT_FIFO_SIZE));
memset(gp_fifo,0,DEFAULT_FIFO_SIZE);
GX_Init(gp_fifo,DEFAULT_FIFO_SIZE);
GX_SetCopyClear(background, 0x00ffffff);
GX_SetViewport(0,0,rmode->fbWidth,rmode->efbHeight,0,1);
GX_SetDispCopyYScale((f32)rmode->xfbHeight/(f32)rmode->efbHeight);
GX_SetScissor(0,0,rmode->fbWidth,rmode->efbHeight);
GX_SetDispCopySrc(0,0,rmode->fbWidth,rmode->efbHeight);
GX_SetDispCopyDst(rmode->fbWidth,rmode->xfbHeight);
GX_SetCopyFilter(rmode->aa,rmode->sample_pattern,GX_TRUE,rmode->vfilter);
GX_SetFieldMode(rmode->field_rendering,((rmode->viHeight==2*rmode->xfbHeight)?GX_ENABLE:GX_DISABLE));
if (rmode->aa)
GX_SetPixelFmt(GX_PF_RGB565_Z16, GX_ZC_LINEAR);
else
GX_SetPixelFmt(GX_PF_RGB8_Z24, GX_ZC_LINEAR);
GX_SetCullMode(GX_CULL_NONE);
GX_CopyDisp(xfb,GX_TRUE);
GX_SetDispCopyGamma(GX_GM_1_0);
guPerspective(p, 60, 1.33F, 10.0F, 1000.0F);
GX_LoadProjectionMtx(p, GX_PERSPECTIVE);
// Load image data
PNGU_Init ();
//PNGU_SelectFileFromWiiSD ("logo.png");
PNGU_SelectFileFromBuffer (logo);
PNGU_GetImageProperties (&imgProp1);
texture_data1 = MEM_K0_TO_K1(memalign (32, imgProp1.imgWidth*imgProp1.imgHeight*4));
PNGU_DecodeTo4x4RGBA8 (imgProp1.imgWidth, imgProp1.imgHeight, texture_data1, 0xFF);
//PNGU_SelectFileFromWiiSD ("logo.png");
PNGU_SelectFileFromBuffer (logo);
PNGU_GetImageProperties (&imgProp2);
texture_data2 = MEM_K0_TO_K1(memalign (32, imgProp2.imgWidth*imgProp2.imgHeight*2));
PNGU_DecodeTo4x4RGB565 (imgProp2.imgWidth, imgProp2.imgHeight, texture_data2);
PNGU_Release ();
draw_init();
while(1)
{
guLookAt(v, &cam.pos, &cam.up, &cam.view);
GX_SetViewport(0,0,rmode->fbWidth,rmode->efbHeight,0,1);
GX_InvVtxCache();
GX_InvalidateTexAll();
GX_SetTevOp(GX_TEVSTAGE0, GX_DECAL);
GX_SetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
GX_SetNumChans(1);
GX_LoadTexObj(&texObj1, GX_TEXMAP0);
draw_square1(v);
GX_LoadTexObj(&texObj2, GX_TEXMAP0);
draw_square2(v);
GX_DrawDone();
do_copy = GX_TRUE;
VIDEO_WaitVSync();
PAD_ScanPads();
int stickY = PAD_StickY(0);
if( stickY > 18 || stickY < -18)
movecamera((float) stickY/-18);
if(PAD_ButtonsDown(0) & PAD_BUTTON_START) {
void (*reload)() = (void(*)())0x80001800;
reload();
}
}
return 0;
}
void draw_init() {
GX_ClearVtxDesc();
GX_SetVtxDesc(GX_VA_POS, GX_INDEX8);
GX_SetVtxDesc(GX_VA_CLR0, GX_INDEX8);
GX_SetVtxDesc(GX_VA_TEX0, GX_DIRECT);
GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_S16, 0);
GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
GX_SetArray(GX_VA_POS, squares, 3*sizeof(s16));
GX_SetArray(GX_VA_CLR0, colors, 4*sizeof(u8));
GX_SetNumTexGens(1);
GX_SetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
GX_InvalidateTexAll();
GX_InitTexObj(&texObj1, texture_data1, imgProp1.imgWidth, imgProp1.imgHeight, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
GX_InitTexObj(&texObj2, texture_data2, imgProp2.imgWidth, imgProp2.imgHeight, GX_TF_RGB565, GX_CLAMP, GX_CLAMP, GX_FALSE);
}
void draw_vert(u8 pos, u8 c, f32 s, f32 t)
{
GX_Position1x8(pos);
GX_Color1x8(c);
GX_TexCoord2f32(s, t);
}
void draw_square1(Mtx v) {
Mtx m; // model matrix.
Mtx mv; // modelview matrix.
Vector axis = {0,0,1};
guMtxIdentity(m);
guMtxRotAxisDeg(m, &axis, rotby);
guMtxTransApply(m, m, 0, 0, -100);
guMtxConcat(v,m,mv);
GX_LoadPosMtxImm(mv, GX_PNMTX0);
GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
draw_vert(0, 0, 0.0, 0.0);
draw_vert(1, 0, 1.0, 0.0);
draw_vert(2, 0, 1.0, 1.0);
draw_vert(3, 0, 0.0, 1.0);
GX_End();
}
void draw_square2(Mtx v) {
Mtx m; // model matrix.
Mtx mv; // modelview matrix.
Vector axis = {0,0,1};
guMtxIdentity(m);
guMtxRotAxisDeg(m, &axis, rotby);
guMtxTransApply(m, m, 0, 0, -100);
guMtxConcat(v,m,mv);
GX_LoadPosMtxImm(mv, GX_PNMTX0);
GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
draw_vert(4, 0, 0.0, 0.0);
draw_vert(5, 0, 1.0, 0.0);
draw_vert(6, 0, 1.0, 1.0);
draw_vert(7, 0, 0.0, 1.0);
GX_End();
}
// copy efb to xfb when ready
static void copy_to_xfb(u32 count) {
if(do_copy==GX_TRUE) {
GX_SetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
GX_SetColorUpdate(GX_TRUE);
GX_CopyDisp(xfb,GX_TRUE);
GX_Flush();
do_copy = GX_FALSE;
}
}
void movecamera(float speed) {
Vector v;
v.x = cam.view.x - cam.pos.x;
v.y = cam.view.y - cam.pos.y;
v.z = cam.view.z - cam.pos.z;
cam.pos.x += v.x * speed;
cam.pos.z += v.z * speed;
cam.view.x += v.x * speed;
cam.view.z += v.z * speed;
}
Sasker escribió:Mira a ver si es por no seguir el orden correcto...
1-. Reserva
2-. Inicia objeto
3-. Usa la memoria de textura
4-. DCFlushRange (para que no se quede en cache)
5-. Usa la textura en los modelos...
int PNGU_Init ();
void PNGU_Release ();
int PNGU_SelectFileFromBuffer (const void *buffer);
int PNGU_SelectFileFromWiiSD (const char *filename);
int PNGU_GetImageProperties (PNGUPROP *fileproperties);
int PNGU_DecodeToYCbYCr (PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
int PNGU_DecodeToRGBA8 (PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha);
int PNGU_DecodeTo4x4RGB565 (PNGU_u32 width, PNGU_u32 height, void *buffer);
int PNGU_DecodeTo4x4RGB5A3 (PNGU_u32 width, PNGU_u32 height, void *buffer);
int PNGU_DecodeTo4x4RGBA8 (PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha);
mp3play.c escribió:#include <gccore.h>
#include <ogcsys.h>
#include <mp3player.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
extern u8 mp3data[];
extern u32 mp3length;
GXRModeObj *vmode;
u32 *xfb = NULL;
int main ()
{
VIDEO_Init ();
PAD_Init ();
switch (VIDEO_GetCurrentTvMode ())
{
case VI_NTSC:
vmode = &TVNtsc480IntDf;
break;
case VI_PAL:
vmode = &TVPal528IntDf;
break;
case VI_MPAL:
vmode = &TVMpal480IntDf;
break;
default:
vmode = &TVNtsc480IntDf;
break;
}
VIDEO_Configure (vmode);
xfb = (u32 *) MEM_K0_TO_K1 (SYS_AllocateFramebuffer (vmode));
console_init (xfb, 20, 64, vmode->fbWidth, vmode->xfbHeight, vmode->fbWidth * 2);
VIDEO_ClearFrameBuffer (vmode, xfb, COLOR_BLACK);
VIDEO_SetNextFramebuffer (xfb);
VIDEO_SetBlack (0);
VIDEO_Flush ();
VIDEO_WaitVSync ();
if (vmode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync ();
MP3Player_Init ();
MP3Player_PlayBuffer (mp3data, mp3length, NULL);
while (MP3Player_IsPlaying ());
while (1);
return 0;
}
mp3file.s escribió:.rodata
.globl mp3data
.globl mp3length
.balign 32
mp3length: .long mp3end - mp3data
mp3data:
.incbin "../song.mp3"
mp3end:
"C:\Archivos de programa\CVSNT\cvs.exe" -z3 -d:pserver:anonymous@devkitpro.cvs.sourceforge.net:/cvsroot/devkitpro co -P libogc
pause
technik escribió:La verdad es que este es un proyecto totalmente amateur, que empezo por pura experimentacion. Toda ayuda es bienvenida, pero hasta verano no creo que pueda dedicarle suficiente tiempo como para convertirlo en un desarrollo estable (por los examenes mas que nada). Con esto lo unico que quiero decir es que aun no puedo dar datos seguros de la duracion del proyecto o de cuando saldra alguna demo, ni nada por el estilo. Sin embargo os animo a que os unais a nosotros porque estoy seguro de que cuando empecemos a mostrar resultados mucha gente se interesara, y sobretodo porque pocas plataformas hay como la wii para desarrollar ideas innovadoras (yo tengo en mente ya varias aplicaciones bastante atractivas, basadas en las posibilidades del wiimote y del bluetooth de la wii, poco a poco ire diciendo algunas de ellas. De momento a ver si consigo compilar de una vez el ejemplo de head-tracking que tengo programado. Si funciona aceptablemente lo pulire un poco y lo publicare.
technik escribió:Bueno, una pequeña novedad, como estaba atascado con el tema de las SD y el cargador me he puesto a trabajar sobre mi sistema de Head-tracking y tengo lista (creo) la primera prueba del sistema, sin embargo no puedo compilar el codigo por que tengo que actualizar las librerias de libOGC por CVS.
He intentado seguir el tutorial ese que enlazan en este foro pero cuando intento meter el primer comando de CVS me salta un error del Application loader: "Couldn't find Application loader. Check your installation" Y No se que hacer por que la instalacion era tan simple como descomprimir unos archivos.