|
|
Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.
Mensajes - Ruben3d
Páginas: 1 ... 18 19 [20] 21 22 ... 30
476
« en: Sábado 12 de Junio de 2004, 19:48 »
yo con los calificativos iria un poco más alla El que sólo ponga ' ladrones' de la SGAE es debido a la campaña para conseguir que cuando en Google se busque 'ladrones' el primer resultado sea la web de la SGAE. Puedes ver esta y otras iniciativas aqui. Un saludo. Ruben3d EDIT: He añadido links.
477
« en: Sábado 12 de Junio de 2004, 12:24 »
Hola
¿Te has acordado de linkar con la librería Wininet.lib?
Un saludo.
Ruben3d
478
« en: Sábado 12 de Junio de 2004, 00:40 »
si tiene el compilador de java tan solo compilen el siguiente codigo y sustituyan el punto class No tengo el SDK de Java instalado (y ando muy mal de espacio). Te agradecería que pusieras el .class. Un saludo. Ruben3d
479
« en: Viernes 11 de Junio de 2004, 22:46 »
Hola.
He estado probandolo y está muy bien. Me recuerda a las aventuras de texto que había en el Spectrum (Don quijote y demás), aunque ésta no tiene imágenes hechas con líneas y círculos. Me pregunto, ¿cómo haces cada estancia? ¿Usas algún script que va incluido como recurso en el .exe, o está codificado a pelo?
Un saludo.
Ruben3d
480
« en: Viernes 11 de Junio de 2004, 22:35 »
Hola. ¡Muchas gracias por tus propuestas! He probado la primera, por ser la única que carece de multiplicaciones. Los resultados, en cuanto a velocidad, son muy buenos. El único inconveniente es que el azul adquiere tanta luz como el rojo, aunque la luminosidad del blanco es muy buena, pues no pierde intensidad, y se aprecian tonos oscuros que antes no aparecían. No sé cuál de las dos utilizar, tu opción es más rápida y no se oscurece, pero la mia mantiene la intensidad de cada componente de color. Cuando escriba el código del gestor de texturas lo probaré sobre imágenes reales a ver qué resultados da cada técnica. De momento he compuesto una imagen a modo comparativo, con los colores sin aplicar ningún filtro, con mi versión de escala de grises y con la tuya (al final del post). Un saludo. Ruben3d Nota: La imagen está en formato PNG. Internet Explorer no trata bien los PNG y no tiene en cuenta la correción gamma de la imagen, por lo que podría aparecer más oscura de lo que en verdad es. Mejor abrirla con algún programa de dibujo (la he creado con Gimp2).  EDIT: No he guardado el gamma de la imagen y debería verse bien (me da esta opción la última versión del Gimp  )
481
« en: Viernes 11 de Junio de 2004, 17:55 »
Hola! Bueno, yo no voy a ser menos y también voy a participar  . Mi nombre es Rubén (sorpresa!) y tengo 21 años. Actualmente estoy estudiando tercero de Ingeniería Informática en la Universidad de Alcalá de Henares (en España). Respecto a mis gustos, diré que para mi el mejor juego de todos los tiempos es Doom, y los que menos soporto: Tetris y Pang (este lo odio, no sé el porqué). Música me gusta casi toda. Tengo canciones de todo género, época y siglo, excepto rap, punk y derivados de éstos (lo siento Blag  ). Mis hobbies con el ordenador comprenden la programación (si está relacionada con gráficos mejor que mejor), la infografía y jugar a Doom (bueno, también juego a algunos otros juegos, pero tengo 10 source ports de Doom diferentes en disco, y los uso todos!). Respecto a los hobbies del mundo real, lo mejor es salir con los amigos los fines de semana, y ver películas en cines decentes (no los que tengo en esta ciudad). Trago Favorito: Johnnie Walker Etiqueta Negra. Con cocacola . Así nos conocemos mejor entre nosotros. Un saludo a todos! Ruben3d
482
« en: Viernes 11 de Junio de 2004, 14:49 »
Hola. He realizado una función para pasar imágenes a escala de grises que es lo suficientemente rápida para ser usada en tiempo real. La he probado en un emulador de PocketPC con un display de 240x320 y supera los 100 fps en un ordenador a 1.5GHz con varios trabajos en segundo plano (entre ellos el seti@home). No sé a qué velocidad funcionará ejecutandose nativamente en un PC, pero supongo que será viable a 640x480 en una máquina equivalente. Para pasar a escala de grises tengo que obtener la luminosidad de cada píxel, multiplicando cada componente de color por un peso y redondeando a un número entero el resultado, de esta manera: gris = (unsigned char) (0.30*ROJO(pixel) + 0.59*VERDE(pixel) + 0.11*AZUL(pixel));
Esto implica tres multiplicaciones de números flotantes por píxel, dos sumas y un redondeo. Estuve meditando y me di cuenta de que podía hacerse sólo con números enteros, que sería más rápido: gris = (unsigned char) (30*ROJO(pixel) + 59*VERDE(pixel) + 11*AZUL(pixel))/100;
Esto elimina el uso de los números flotantes, pero añade una división entera, así que no me convenció. Pensé en usar sólo desplazamientos de bits, aunque de esta manera se pierde exactitud: gris = ((ROJO(pixel)<<1) + (VERDE(pixel)<<2) + AZUL(pixel))/7;
De esta manera, el peso del rojo sería 0.28, el del verde 0.57 y el del azul 0.14. No son iguales a los originales, pero es una aproximación bastante buena. Aún me quedaba solucionar la división. Es fácila darse cuenta de que 7 está muy próximo a 8, que se arregla con un desplazamiento de bits: gris = ((ROJO(pixel)<<1) + (VERDE(pixel)<<2) + AZUL(pixel))>>3;
De esta manera, paso un píxel a escala de grises y sólo realizo desplazamientos de bits y sumas de enteros. Sin embargo, he de pagar el precio de un leve oscurecimiento de la imagen final, causado por dividir entre 8 en vez de entre 7. Os dejo aqui la función acabada, por si a alguien le parece útil: void io3d::CGraphics2D::grayscaleArea(int x1, int y1, int x2, int y2) { if (x1>x2) { switchElems<int>(x1,x2); } if (y1>y2) { switchElems<int>(y1,y2); } unsigned char c; int next_line = -(x2-x1+1)+m_nNormYPitch; WORD *pPixel = &m_pBackBuffer[x1+y1*m_nNormYPitch]; for (int y=y1; y<=y2; y++) { for (int x=x1; x<=x2; x++) { // Los pesos son 0.30, 0.59 y 0.11, pero realizo una aproximación // Multiplico por 2, 4 y 1. Va incluido en el despl. el bajar G a 5 bits // Debería dividir por 7, pero hacerlo por 8 es mucho más rápido (aunque se // oscurece un poco la imagen). c = ( (CR5(*pPixel)<<1) + (CG6(*pPixel)<<1) + CB5(*pPixel) ) >> 3; *(pPixel++) = C565(c,c<<1,c); } // Reajuste para la siguiente línea pPixel += next_line; } }
La función está pensada para poder ser aplicada a áreas rectangulares arbitrarias. Para que se aplique a la pantalla completa hay que usar como parámetros (0,0, anchura-1, altura-1). Esta función asume que hay un puntero llamado m_pBackBuffer, que apunta a la memoria en donde se pinta y es de tipo WORD*, pues trabaja en modo de 16 bits de color. Las macros CR5, CG6 y CB5 extraen cada componente de color del píxel de tipo WORD con desplazamientos y máscaras, y lo devuelven en el rango [0,31] para el rojo y el azul y en el rango [0,63] para el verde (por tener un bit más). En m_nNormYPitch se guarda cuánto hay que sumarle al puntero que apunta a un píxel para avanzar a la siguiente fila. C565 es una macro que recibe las tres componentes de color en los rangos citados anteriormente y los compacta en un WORD. Por último, hay que tener en cuenta en todo momento que el verde ocupa un bit más y por eso hay que realizar algunos desplazamientos no esperados. Espero que esto os sirva. Se me ocurren diversas aplicaciones, como hacer que detrás de una pantalla en un escenario de un juego de plataformas se vea en escala de grises (algo así creo que vi en Jazz Jackrabbit, de Apogee?), o cualquier otro efecto (para escenas cinemáticas, junto a ruido añadido para dar impresión de película antigua). Un saludo. Ruben3d
483
« en: Jueves 10 de Junio de 2004, 19:57 »
Hola.
¿Qué es un conjunto potencia?
Un saludo.
Ruben3d
484
« en: Jueves 10 de Junio de 2004, 19:51 »
Me aparece esto en la consola de Java: cargar: bola.class no es público o no tiene ningún constructor público. java.lang.IllegalAccessException: Class sun.applet.AppletPanel can not access a member of class bola with modifiers "" at sun.reflect.Reflection.ensureMemberAccess(Unknown Source) at java.lang.Class.newInstance0(Unknown Source) at java.lang.Class.newInstance(Unknown Source) at sun.applet.AppletPanel.createApplet(Unknown Source) at sun.plugin.AppletViewer.createApplet(Unknown Source) at sun.applet.AppletPanel.runLoader(Unknown Source) at sun.applet.AppletPanel.run(Unknown Source) at java.lang.Thread.run(Unknown Source)
y esto en la barra de estado del explorador: Ha fallado la carga del applet de Java...
Un saludo. Ruben3d EDIT: Por favor, no escribas en rojo 
485
« en: Jueves 10 de Junio de 2004, 19:47 »
Hola. Tienes toda la razón. Yo aún sigo jugando a juegos bastante antiguos. De todas formas el tema original es: los videojuegos 2d aun tienen una ventana comercial?, vale la pena hacer videojuego 2d? Por muy divertidos que sean, para ordenador no venden (aunque ahora estén surgiendo para dispositivos portátiles), ya que la gente (refiriendome a 'gente' como a la masa de compradores de juegos que no saben de PC más que encenderlo y jugar) si no ve gráficos 3D rechaza el juego (y mira que el Counter Strike se me hizo ya cansado hace mucho y la gente lo juega como el primer día). Un saludo. Ruben3d
486
« en: Miércoles 9 de Junio de 2004, 21:59 »
Registrate y pregunta en el foro adecuado.
Un saludo.
Ruben3d
487
« en: Miércoles 9 de Junio de 2004, 21:42 »
Hola. Bueno, yo uso Visual Studio y sí trae la librería glaux. En Borland no sé cómo es que no viene. Puedes probar cargando un TGA, que está bastante bien explicado aqui (y tiene un formato sencillo): Busca 'Texture Mapping Part4 (TGA)'o puedes descargarte el tutorial de Nehe portado a Borland Borland C++ Builder 6 Code For This Lesson.Un saludo. Ruben3d
488
« en: Miércoles 9 de Junio de 2004, 21:04 »
entonces mi conclusion es que Windows es muuuuuucho mas lento que ms-dos, Piensa que esté en ventana o en pantalla completa lo sigues ejecutando en Windows. El que tarde más en ventana es debido a que estás en modo gráfico y se ha de mantener todo el resto del escritorio, además de simular el comportamiento de la consola en su ventana (que lo normal es que se ejecute en modo texto). no se si con esto le estoy creando un bucle infinito al pc, xk kon el mio se a estao unos 5 minutos y ahun no havia terminao Si no imprimieras por pantalla sería sólo un instante. Para imprimir por pantalla cada carácter el programa realiza una interrupción software (trap) para pedir al sistema operativo que le pinte un carácter. Esto conlleva saltar a modo protegido, guardar en la pila el contador de programa, los registros y la palabra de estado, ejecutar la rutina de atención de la interrupción y, si estás en Windows (o cualquier otro SO multitarea), ejecutar el planificador (scheduler) para ver si encima te quita el procesador para darselo a otro proceso con más prioridad, y esperar de nuevo a que te toque, con los cambios de contexto que todo esto ha implicado. Como ves, suceden muchas cosas cada vez que imprimes un carácter. Un saludo. Ruben3d
489
« en: Miércoles 9 de Junio de 2004, 20:43 »
Hola
Para desarrollar en Linux una aplicación pequeña uso un editor de texto, como KWrite ó Kate, y creo los makefiles a mano. Si la cosa se complica uso el KDevelop, que va por su tercera versión y está bastante bien. También está el JEdit, pero hay que configurarlo con plugins para que sirva para C y yo sólo lo uso como editor de HTML.
Un saludo.
Ruben3d
490
« en: Miércoles 9 de Junio de 2004, 20:34 »
Hola. En este tutorial te explican cómo abrir un BMP y usarlo como textura: Lesson 6: Texture MappingUn saludo. Ruben3d
491
« en: Miércoles 9 de Junio de 2004, 19:20 »
Fijate en la fecha del post 31/08/2002 ¡Le has respondido con casi dos años de diferencia! (más vale tarde que nunca) Un saludo. Ruben3d
492
« en: Miércoles 9 de Junio de 2004, 19:16 »
493
« en: Miércoles 9 de Junio de 2004, 14:58 »
PlaySound()Un saludo. Ruben3d
494
« en: Miércoles 9 de Junio de 2004, 14:47 »
Hola.
Me parece muy buena idea, ya que todos los foros suelen tener algún sitio para hablar de cualquier tema.
Un saludo.
Ruben3d
495
« en: Martes 8 de Junio de 2004, 22:25 »
Hola. Si programas en Windows este artículo te ayudará: Playing multiple wave files continuously and simultaneouslyEstá escrito para PocketPC pero es igualmente aplicacable a un ordenador normal. Está pensado para usar sólo la API de Windows y no estar limitado por la funcionalidad de PlaySound(), que no puede reproducir varios WAV simultáneamente (aunque si sólo quieres reproducir un sonido estilo evento de Windows, PlaySound() está muy bien). Un saludo. Ruben3d
496
« en: Martes 8 de Junio de 2004, 18:21 »
Hola. En mi ordenador tengo el eMbedded Visual C++ 4.0, con el Service Pack 3 instalado (para desarrollar para WinCE 4.1 y 4.2), SDK para Windows CE y el SDK de PocketPC 2003 (Windows Mobile 2003). Con todo esto no me aparece tu procesador (supongo que será de PocketPC 2002  ). Para Windows Mobile 2003 tengo: - WCE ARMV4</li>
- WCE emulator</li>
y para Windows CE 4.x tengo: - WCE ARMV4</li>
- WCE ARMV4I</li>
- WCE MIPSII</li>
- WCE MIPSII_FP</li>
- WCE MIPSIV</li>
- WCE MIPSIV_FP</li>
- WCE SH3</li>
- WCE SH4</li>
- WCE emulator</li>
- WCE x86</li>
Prueba a compilarlo en el disco duro y transferirlo a mano. O prueba con una versión más moderna del entorno, crea un nuevo proyecto e importa todos los ficheros fuente (así hice funcionar un proyecto de PPC2002 en el emulador de 2003). De todas formas, aún no he probado con ningún PocketPC real (a ver si algún día tengo uno) y de momento sólo uso el emulador. Un saludo. Ruben3d EDIT: Mira a ver si puedes contactar con la persona que inició el proyecto.
497
« en: Martes 8 de Junio de 2004, 11:33 »
Hola. #include <windows.h> ... SYSTEMTIME st; GetLocalTime(&st); printf("%02d/%02d/%04d %02d:%02d:%02d", st.wDay, st.wMonth, st.wYear, st.wHour, st.wMinute, st.wSecond);
Un saludo. Ruben3d
498
« en: Lunes 7 de Junio de 2004, 22:18 »
Hola. Hace unos días también implementé una función que manipulaba una imagen (realiza un blur). Inicialmente la realicé refiriendome a cada pixel con un método getPixel y otro putPixel que básicamente hacían lo que tú: multiplicaciones de enteros para situarse en los diferentes píxeles de la imagen (con los índices entre corchetes []). De este manera me funcionaba a 35-37 fps a 240x320. A continuación lo que hice fue mantener mis dos bucles anidados para moverme por la imagen pero, en vez de usar los contadores, iba sumando +1 a un puntero que inicialmente inicialicé con la dirección del primer píxel. De esta manera puedo recorrer la pantalla sin multiplicar en ningún punto. Para saber el valor del píxel de arriba o de abajo calculé cuánto debía sumar o restar al puntero para subir o bajar un píxel. De esta forma subí a 160-170 fps con una imagen del mismo tamaño. Para que lo veas más claro (porque no sé si me he explicado claro, que estoy espeso) te pongo el código del que hablo: Antes de optimizar int _x; int x_; int _y; int y_; int r; int g; int b; for (int y=1; y<io3dCore.getDisplay().getHeight()-2; y++) { int x; // caso de x=0 _x = g2d.getPixel(0, y); x_ = g2d.getPixel(0+1, y); _y = g2d.getPixel(0, y-1); y_ = g2d.getPixel(0, y+1); r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; g2d.putPixel(0,y, C565(r,g&0xFFFE,b)); for (x=1; x<io3dCore.getDisplay().getWidth()-2; x++) { _x = g2d.getPixel(x-1, y); x_ = g2d.getPixel(x+1, y); _y = g2d.getPixel(x, y-1); y_ = g2d.getPixel(x, y+1); r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; g2d.putPixel(x,y, C565(r,g&0xFFFE,b)); } // caso de x=width-1 x = io3dCore.getDisplay().getWidth()-2; _x = g2d.getPixel(x-1, y); x_ = g2d.getPixel(x, y); _y = g2d.getPixel(x, y-1); y_ = g2d.getPixel(x, y+1); r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; g2d.putPixel(x,y, C565(r,g&0xFFFE,b)); }
Tiene algunas diferencias (y algún bug) con respecto a la optimizada, ya que la generalicé para rectángulos de tamaño arbitrario. haz caso al bucle central, ya que trato por separado los casos de los extremos. Ahora la versión optimizada. Es un poco más larga, pero si te fijas en todo el código sólo hay una multiplicación (y no está en ningún bucle). Es tan larga porque trato las esquinas y los bordes por separado, pero fijate en el bucle más central (el que tiene el comentario '//centro'). Versión optimizadavoid io3d::CGraphics2D::blurArea(int x1, int y1, int x2, int y2) { if (x1>x2) { switchElems<int>(x1,x2); switchElems<int>(y1,y2); } if (y1>y2) { switchElems<int>(y1,y2); } int _x; // Píxel de la izquierda int x_; // Píxel de la derecha int _y; // Píxel de arriba int y_; // Píxel de abajo int r; int g; int b; int next_line = -(x2-x1+1)+m_nNormYPitch; int x; WORD *pPixel = &m_pBackBuffer[x1+y1*m_nNormYPitch]; // Esquina superior izq. _x = *pPixel; x_ = *(pPixel+1); _y = *(pPixel+1+m_nNormYPitch); // En diagonal abajo-dcha. y_ = *(pPixel+m_nNormYPitch); r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; *(pPixel++) = C565(r,g&0xFFFE,b); // Centro primera fila for (x=x1+1; x<x2; x++) { _x = *(pPixel-1); x_ = *(pPixel+1); _y = *pPixel; y_ = *(pPixel+m_nNormYPitch); r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; *(pPixel++) = C565(r,g&0xFFFE,b); } // Esquina superior dcha. _x = *(pPixel-1); x_ = *pPixel; _y = *(pPixel-m_nNormYPitch); y_ = *(pPixel-1+m_nNormYPitch); // En diagonal abajo-izq. r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; *(pPixel++) = C565(r,g&0xFFFE,b); // Parte central for (int y=y1+1; y<y2; y++) { // Reajuste para la siguiente línea pPixel += next_line; // caso de x=x1 _x = *pPixel; x_ = *(pPixel+1); _y = *(pPixel-m_nNormYPitch); y_ = *(pPixel+m_nNormYPitch); r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; (*pPixel++) = C565(r,g&0xFFFE,b); // Centro for (int x=x1+1; x<x2; x++) { _x = *(pPixel-1); x_ = *(pPixel+1); _y = *(pPixel-m_nNormYPitch); y_ = *(pPixel+m_nNormYPitch); r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; *(pPixel++) = C565(r,g&0xFFFE,b); // Optimizará cambiar 0xFFFE por 0xFE ? } // caso de x=x2 _x = *(pPixel-1); x_ = *pPixel; _y = *(pPixel-m_nNormYPitch); y_ = *(pPixel+m_nNormYPitch); r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; *(pPixel++) = C565(r,g&0xFFFE,b); } // Reajuste para la siguiente línea pPixel += next_line; // Esquina inferior izq. _x = *pPixel; x_ = *(pPixel+1); _y = *(pPixel-m_nNormYPitch); y_ = *(pPixel+1-m_nNormYPitch); // En diagonal arriba-dcha r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; *(pPixel++) = C565(r,g&0xFFFE,b); // Centro última fila for (x=x1+1; x<x2; x++) { _x = *(pPixel-1); x_ = *(pPixel+1); _y = *(pPixel-m_nNormYPitch); y_ = *pPixel; r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; *(pPixel++) = C565(r,g&0xFFFE,b); } // Esquina inferior dcha. _x = *(pPixel-1); x_ = *pPixel; _y = *(pPixel-m_nNormYPitch); y_ = *(pPixel-1-m_nNormYPitch); // En diagonal arriba-izq. r = (CR5(_x)+CR5(x_)+CR5(_y)+CR5(y_))>>2; g = (CG6(_x)+CG6(x_)+CG6(_y)+CG6(y_))>>2; b = (CB5(_x)+CB5(x_)+CB5(_y)+CB5(y_))>>2; *(pPixel++) = C565(r,g&0xFFFE,b); }
Espero que con todo esto veas lo que te estoy tratando de decir. Si tienes alguna duda pregunta por aqui. Un saludo. Ruben3d
499
« en: Domingo 6 de Junio de 2004, 23:30 »
Gracias, probaré a ver (ya no recordaba lo que salía durante el proceso de instalación).
Un saludo.
Ruben3d
500
« en: Domingo 6 de Junio de 2004, 22:47 »
Hola. A riesgo de equivocarme (pues no conozco Allegro), creo que se podría aplicar este método: Really Fast Software BlendingUn saludo. Ruben3d
Páginas: 1 ... 18 19 [20] 21 22 ... 30
|
|
|
Mostrar Mensajes
