Prueba a reiniciar la posición inmediatamente después.

Código [Seleccionar] Expand


lpBufferSonido1->play(0,0,0)
lpBufferSonido2->play(0,0,0)

lpBufferSonido1->SetCurrentPosition(0);
lpBufferSonido2->SetCurrentPosition(0);



 No se si conoceis esta página, a mi me resultó curiosa cuando la vi.

Se trata de una cámara situada en la ciudad de Zurich que puede ver y controlar cualquiera en tiempo real.

http://cam.switch.ch/

 hola.

¿Alguien sabe cómo puedo obtener el HWND o el HDC de una ventana de OpenGL creada usando GLUT?

Concretamente con glutCreateWindow.

Ya he mirado por todas partes y no encuentro na.

gracias.

 Gracias Elthan. (ole)  

 Por lo que yo recuerdo 2 contra mi no me ganaba ni de coña, a no ser que estemos hablando de un modo de juego diferente, a partir de 3 quizás, y si lo hacían era usando la fuerza bruta y sin el inconveniente de tener que usar un ratón para controlar a montones de bichos.

Siempre tengo la imagen de ese tipo de juegos de unidades enemigas suicidándose contra mis defensas. Aunque tampoco es mi intención criticar a uno de los mejores juegos de la historia pero lo veo un poco antiguo. Estoy convencido de que si sacan el Starcraft 2, el planteamiento va a ser diferente.

 Las texturas en OpenGL tienen que ser potencia de dos.

Solución:

Ampliar la textura a 512x512 y luego darle otras coordenadas de textura.

Puedes usar la siguiente fórmula para obtener las coordenadas a partir de la posición en la imagen (si no me equivoco):

MinTexturaX = PosSpriteX / TamTextura;
MinTexturaY = PosSpriteY / TamTextura;
MaxTexturaX = (PosSpriteX + TaxSpriteX) / TamTextura;
MaxTexturaY = (PosSpriteY + TaxSpriteY)  / TamTextura);

También puedes meter varias texturas en una única imagen de 1024x1024 y calcular las coordenadas a partir de su posición y su tamaño dentro de la imagen, con esa fórmula.

Yo te recomendaría que creases una clase una clase "Sprite" que contenga la información de textura, el ID (bind) de la imagen, su tamaño, características, etc, y funciones para crear, situar, dibujar, etc. También vendría bien hacer una clase "Imagen". En realidad como no hagas clases vas a tener un follón de narices cuando haya muchos sprites diferentes y te va a ser dificilísimo mantenerlo y actualizarlo.

Quizás te parezca un coñazo hacerlo, pero cuando lo termines bastará con hacer esto:

Código [Seleccionar] Expand



MiImagen.Cargar("imagen1.png");

MiSprite.Crear( &MiImagen, 0,0, 400, 300 );

MiSprite.Situar( 100, 20 );

MiSprite.Dibujar();



Despues crea otra clase llamada "Entidad" , que entre sus propiedades tenga un puntero a un Sprite, o varios punteros a Sprites para hacer animaciones, su posición, rotación, velocidad, etc. y métodos para comprobar colisiones, animar, etc, etc, etc..............

Empiezas respondiendo a una cuestión rapida y al final acabas haciendo un tutorial  :lol:

 Starcraft para ganarte debía jugar al menos con 2 o 3 equipos, y si tiene que estar semi-dirigido mediante scripts para tener alguna táctica, no lo tomaría como ejemplo de IA cooperativa, aunque sí se podrían tomar de él algunos conceptos o técnicas específicas.

 Lo único que tienes que hacer es comprobar el formato de pixel de la surface y crear la textura con el mismo formato.

El formato de pixel lo puedes obtener de la propia surface, alguien que sepa del SDL podrá decirte como hacerlo, y con un switch asignar a una variable el formato del OpenGL, y posteriormente usarlo al crear la textura.

El problema del bmp creo que usa el formato BGR, que creo que no usa el OpenGL, entonces tienes que usar el codigo que has puesto al principio para intercambiar el Red por el Blue y que quede como RGB, pero solo en ese caso tendrás que hacerlo.

Seguramente el png del icono tiene canal alpha (RGBA), y el que has guardado con el gimp no (RGB), por eso te vuelves loco.

 Creo que no me he explicado bien.

El bmp que te funciona tiene formato BGR, 3 componentes de 8 bits cada uno.

Creo que en el código que has puesto lo que hace es intercambiar el azul por el rojo para obtener RGB, de manera que la memoria que está así.

B.G.R-B.G.R-B.G.R

quedaría así despues de hacer el intercambio:

R.G.B-R.G.B-R.G.B

el png con canal alpha tiene 32 bits RGBA. 4 componentes de color.

R.G.B.A-R.G.B.A-R.G.B.A

si haces la misma operación de intercambio (el primero por el tercero) va a salir un desastre. Tienes que intercambiar los componentes adecuadamente hasta obtener el formato deseado.

si tienes RGBA de jpg, pero necesitas que esté en formato ARGB tienes que usar una rutina que lo modifique, o crearla tu mismo.

 Yo haría diferentes grupos y subgrupos de unidades y mandos virtuales. Cada grupo de unidades tendría un mando virtual y estos a su vez formarían un árbol con más mandos virtuales hasta llegar al mando superior que sería el jugador.

Las decisiones de cada mando estarían determinadas por las ordenes recibidas del mando inmediatamente superior y por la información de los mandos inferiores. La actuación final de la unidad estaría determinada por las decisiones del mando inmediatamente superior y las decisiones propias de cada una.

Creo que de esta forma los mandos al ser pocos podrían tener una IA compleja y estructurada, mientras que cada unidad se ocuparía de cosas sencillas para luchar y moverse lo mejor posible.

No estoy seguro de que sirva, es solo una intuición :rolleyes:  

 Haz una prueba ignorando (con los /*    */)  la parte de intercambiar los colores, si te sale bien los pixels pero mal los colores, tendrás que hacer una rutina para intercambiar los componentes de color, igual que la que ya hay pero sobre 4 bytes, actualmente el intercambio es sobre grupos de 3.

 El ejemplo que he puesto ni lo he usado ni tengo intención de hacerlo, ni de hacerlo lo más rapido posible, era simplemente para hacer referencia a la conveniencia o no de tratar toda la memoria de forma lineal (de ahí el uso de punteros) sin preocuparse independientemente de como ha sido creada, a propósito de este comentario que has hecho anteriormente.

Hay estas creando un array de bytes de tamaño fijo que dependiendo de uno u otro compilador puede que tengas que tener acceso a el mediante un indice ya que nadie te asegura que la memoria de ese array sea continua

Entonces me dió a entender que esto no era valido (cambiaré el ejemplo).

Código [Seleccionar] Expand


int DATA[10000];
int *pData=DATA;

for (int i=0;i<10000;i++)
{
*(pData++) = 0;
}


pero esto sí:

Código [Seleccionar] Expand


int DATA[10000];
for (int i=0;i<10000;i++)
{
DATA[i]=0;
}


yo entiendo que es tan válido uno como otro.

Dios que manía tiene la gente de usar la aritmética de punteros, cuando podrían usar el [] y sería más claro XD Además no se que problema hay con usar un int para el indice, y si te apuras usas un unsigned int, que creo que cadenas de más de 4GB no vais a encontrar por ahí, de hecho cadenas de texto de 2GB tampoco son especialmente frecuentes en memoria... Yo lo hubiera hecho así:

Código [Seleccionar] Expand


void DesplazarCadena (char * cadena)
{
  int i;
  int tam = strlen(cadena);

  for(i = 0; i < tam; i++)
     cadena[i] = cadena[i+1];
}


Hombre, tampoco es que yo use siempre la aritmética de punteros, y menos para tratar una simple cadena de texto, simplemente trataba un poco de llevar al extremo el ejemplo para asegurarme.

Me ha sorprendido incluso que en una prueba que he hecho con los ejemplos anteriores va igual de velocidad de las dos maneras, con punteros como con índices [], en cambio con el memcpy aumenta en muchas veces su velocidad.

 Gracias, tampoco me fiaba yo mucho del segundo caso, ni se gana mucho en velocidad, aunque lo cierto es que funciona.

Pero si alguien me dice que el primer caso pueda dar algun problema en alguna circustancia........... me la corto. (asco)

Tendría que tirar a la basura todo lo que he hecho hasta ahora. :lol:  

 He visto en el hilo anterior que se está discutiendo sobre si la memoria está en ocasiones dividida, o fragmentada y alguien dijo anteriormente que había limitaciones con la memoria estática en cuanto al acceso.

Supongamos que quiero quitar el primer carácter de la cadena, desplazando el resto al principio, y lo hago así:.

Código [Seleccionar] Expand


char cadena[]="@quítame la berruga";

char *pIndCadena = cadena;
char *pFinCadena = cadena + strlen(cadena);

do
{
    *(pIndCadena) = *(pIndCadena+1);
}
while ( (pIndCadena++) != pFinCadena );



y ya puestos me interesaría asegurarme de que esta forma también es correcta, a mi no me da ningún problema:

Código [Seleccionar] Expand


memcpy( cadena, cadena+1, strlen(cadena));


¿Veis algún problema en manejar así la memoria en cualquier compilador o circustancia?