uf... la verdad es que acojona, no me extraña que mucha gente sea reacia a cambiar.

Pero si los otros navegadores se instalan en un minuto!! te importan todo del IE y si usas cliente de correo hasta los emails y direcciones. Vamos, mas comodo imposible.
Ademas, un flamante XP con el IE es una castaña...para que sea flamante del todo necesita un firefox, opera o cia.... jajajajaja  :D

hablaba sarcasticamente desde el punto de vista del que no tiene ni idea.

Eso de que le da igual lo dirás tú, yo no conozco a *nadie*, por ignorante que sea, técnicamente hablando, que sea feliz

Es un decir lo de ser feliz, me refiero a que mucha gente con acceder a sus paginas favoritas le basta y no quiere saber nada más, ni le interesa. Aunque luego su ordenador sea el chocho de la Bernarda, el piensa que "es asi".

 

La verdad, a mí me acojona mucho más todo el spyware y demás aberraciones que se le cuela a esa gente con su flamante XP, muchas veces a causa del mismo IE.

A ti si, pero a la gente no le importa y es feliz. muchos viven como en un estado de hipnosis colectiva informática en el que piensan que lo mas popular o lo más caro es lo mejor, se sienten protegidos a todos los niveles. Cuando la verdad es que casi siempre sucede todo lo contrario.

Y hay un ley que creo que se cumple siempre, cuanto más conocida y divulgada entre las masas es una aplicación, más insegura es.

 Yo no me he cepillado el IE porque es cierto que a veces no solo es recomendable, sino imprescindible para algunas páginas, eso si, debidamente bloqueado con el cortafuegos para que no se escape el muy...

Cambiando de tema, dile a un usuario medio con su flamante XP que rompas la perfección, el orden, el mandato divino de su ordenador personal para que irrumpa en él un objeto extraño y oscuro venido de un mundo oculto y peligroso, que solo pueden manejar unos cuantos sabios, y que provocara el caos y el desorden, y quebrantará las leyes del universo.

uf... la verdad es que acojona, no me extraña que mucha gente sea reacia a cambiar.

 Se me olvidó apuntar que para acceder a la superficie trasera hay que crear el Device con el flag D3DPRESENTFLAG_LOCKABLE_BACKBUFFER, si sigue sin funcionar consulta GetDC porque tiene alguna que otra restricción más, aunque son más bien para otro tipo de superficies.

 Puedes probar a usar el GDI para texto, yo lo use para no complicarme la vida y me fue siempre bién.

Solo hay que obtener el identificador del buffer trasero, y escribir en él.
No se si es lo más correcto pero rapido y sencillo de implementar sí que es.

Código [Seleccionar] Expand


// Obtenemos el buffer trasero
LPDIRECT3DSURFACE9 lpDSBackBuffer;
lpDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &lpDSBackBuffer);

// Obtenemos el contexto de dispositivo del buffer trasero
HDC hdc;
if (FAILED(lpDSBackBuffer->GetDC(&hdc))) return FALSE;

// Escribimos
TextOut(hdc, 20,20, "hola",  4);

// Liberamos el contexto de dispositivo
lpDSBackBuffer->ReleaseDC(hdc);



 Justo lo que buscaba, quiero hacer un motor 2D basado en OpenGL para cargar, dibujar y desplazar graficos 2D de la manera mas fácil y rápida posible, y nada más empezar ya me encontre el primer problemilla, (y mira que he buscado por las ayudas y google).  Seguramente os daré más la lata en el futuro.

Gracias y hasta otra.

 Hola, quiero crear una ventana de windows con RegisterClass y CreateWindow dentro de una función propia, sin tener que pasarle directamente como parámetro el hInstance del WinMain.

Se me ocurren dos posibles soluciones pero no se como resolverlas.

1: Obtener la instancia principal en cualquier punto del programa

2: Crear una nueva instancia, puesto que es un simple número de identificador debería poder obtenerlo de algún modo.

También quiero saber cual es la mejor, (si es que no hay una tercera).

 No lo he mirado detenidamente pero quizas te sirve esto:

conociendo la posición del piloto en el archivo y siendo todos de igual tamaño:

fseek(archivo, sizeof(ficha) * PosPiloto, SEEK_SET);

fwrite(...

 Por el problema que planteas veo complicado que alguien te pueda ayudar porque creo que es necesaria una planificación previa de lo que pretendes hacer, (y encima es la hora de la siesta).

Solo te puedo dar un par de consejos.

1) Sustituye la estructura por una clase, te facilitará la automatización de los datos, si sabes C aprende C++, mas concretamente la programación orientada a objetos (POO), con un libro a ser posible, y usa cadenas de tipo String en lugar de char, facilitan mucho todo.

2) No se que compilador usas, pero si no es imprescindible que tu programa sea una aplicación de consola te recomiendo que lo hagas en un entorno visual, que es más rapido, más facil, y más bonito. Si no sabes como conseguirlo ve a un kiosko de revistas y encargale al kiosquero que te consiga la unidad 15 del curso IBM de programación, que por 1000 pelas incluye un cd-rom con el compilador C++ Builder 5 de Borland, que trae casi de todo, y esta bastante bién.  Quizas alguien te pueda aconsejar como conseguir uno mejor o mas facilmente.

Siento no poder ayudarte en tu problema concreto.

 La verdad es que es lioso el tema, te digo como lo he hecho.

He creado una curva Bezier con OpenGL, a la cual le he pasado los puntos de control, y me ha devuelto 11 puntos para dibujarla (son 11 como podría haber solicitado 100.000), estos puntos vistos en la pantalla por las zonas mas curvas tienden a agruparse para definir bien la curva, y a alejarse unos de otros en las zonas mas rectas porque son necesarios menos puntos para describir esa zona.

He creado el algoritmo para que se redistribuyan esos puntos a lo largo de la trayectoria de toda la curva y que produzca una animación suave.

El algoritmo acepta cualquier numero de puntos que sigan la ruta de un camino. bien sea una curva bezier o un montón de curvas y rectas hechas de cualquier manera enlazadas unas con otras. De manera que se distribuyen todos los puntos unos detrás de otros a una distancia igual a la suma de todas las distancias dividido entre el numero total de puntos menos 1.

Yo lo que hago es obtener todos los puntos que me de la gana de las curvas Bezier o de otro tipo de curvas, y luego me despreocupo de sus puntos de control que tal vez sea muy lioso trabajar con ellos (sobre todo para los que no controlamos de mates). Pero si ya consigues hacerlo de otra manera pues perfecto.

Suerte con el proyecto y hasta otra.

 Los puntos a trasformar en mi algoritmo son una secuencia de puntos que describen una curva, o un conjunto indeterminado de curvas y rectas (un camino).

Cuando dibujas curvas lo que te queda al final son los puntos que la describen, a mayor número de estos mayor precisión. En mi opinión quizas sea mejor quedarse solo con esos puntos (Segun cuentas asi lo hace Beetle Bomp) en lugar de los parámetros de las curvas o los puntos de control que pueden liar o complicar mucho el desarrollo del programa.

Mi algoritmo simplemente soluciona el problema de la distancia entre puntos que produce el defecto en la animación, En el ejemplo que he puesto se convierte una curva Bézier descrita por 11 puntos (logicamente en la zona más recta de la curva estan mas alejados unos de otros) en otra similar pero con los puntos equidistantes unos detras de otros.

De todas formas no he probado la función lo suficiente como para garantizar que no este exenta de errores, ni está optimizada, y no se si habrá otro codigo mejor por ahí. Estaría bién que la peña lo probase a ver que le sale.  Solo hay que pasarle a la función los puntos de un camino, y recuperar los puntos convertidos, después dibujarlos trazando rectas de cada array de puntos con diferente color para comprobar la diferencia.

Un saludo.

 Si no he entendido mal, el problema está en que la distancia de los puntos que describen las splines es menor cuanto mas pronunciada es la curva en la que se encuentra, y en las zonas mas rectas sucede todo lo contrario, la distancia aumenta, con lo que al visualizar la animación da la sensación de cambiar de velocidad constantemente.

Entonces supongo que la solución está en recolocar dichos puntos para que queden todos a la misma distancia unos detras de otros, siguiendo siempre la trayectoria de la curva, me he decidido a intentar hacerlo y me funciona perfecto, las posiciones y las distancias entre ellos quedan exactas, por lo menos en las pruebas que he hecho con una curva Bezier, aunque estoy casi convencido de que el procedimiento es totalmente independiente del tipo de curva.

Es una función que acepta un array de puntos 2D de entrada que describen un recorrido o curva, otro que devuelve los mismos puntos pero ya separados a la misma distancia unos de otros, por ultimo se acepta como parámetro el número de puntos a calcular. No entraré en mas detalles de momento del procedimiento que he usado a menos que a Colson o a otro le interese, porque es algo largo y complicado de explicar.

Código [Seleccionar] Expand


struct PUNTO { float x, y;};

void RecolocarPuntos(PUNTO PuntosOrig[], PUNTO PuntosDest[], int NumPuntos)
{
int NumLineas=NumPuntos-1;
float *DistAbsoluta= new float[NumLineas];
float AcumDist=0;

for (int n=0;n<NumLineas;n++)
   {
   AcumDist+=sqrt( (PuntosOrig[n+1].x-PuntosOrig[n].x) * (PuntosOrig[n+1].x-PuntosOrig[n].x) +
                   (PuntosOrig[n+1].y-PuntosOrig[n].y) * (PuntosOrig[n+1].y-PuntosOrig[n].y));
   DistAbsoluta[n]=AcumDist;
   }
   
float DistMedia=AcumDist/NumLineas;

PuntosDest[0]=PuntosOrig[0];
PuntosDest[NumPuntos-1]=PuntosOrig[NumPuntos-1];

float DifDistancia;
for (int n=1;n<NumLineas;n++)
   {
   int pRef=NumPuntos-1;
   while ( (DifDistancia = DistMedia * n - DistAbsoluta[pRef-1]) < 0 && pRef>0)
       pRef--;
   float angulo = atan2( PuntosOrig[pRef+1].y - PuntosOrig[pRef].y,  
           PuntosOrig[pRef+1].x - PuntosOrig[pRef].x );
   PuntosDest[n].x=PuntosOrig[pRef].x + cos(angulo) * DifDistancia;          
   PuntosDest[n].y=PuntosOrig[pRef].y + sin(angulo) * DifDistancia;
   }

delete[] DistAbsoluta;
}


Aquí un ejemplo de utilización con una típica curva Bezier.

Código [Seleccionar] Expand



...
PUNTO PuntosOrig[11]={-50,0, -47.2,6.3,  -39.7,8.5, -28.3,7.6, -14.8,4.4, 0,0,
              14.8,-4.4,  28.3,-7.6,  39.7,-8.5,  47.2,-6.3, 50,0};

PUNTO PuntosDest[11];

RecolocarPuntos(PuntosOrig, PuntosDest, 11);
...



 Como un apunte más me gustaría plantearte la posibilidad de que tal vez te interese programar un editor visual de propósito general para las pantallas o niveles tu proyecto, tal vez te ahorre muchísimo trabajo después, aunque te lleve algunas semanas hacerlo.

Si sabes OpenGL te facilitará muchísimo las cosas para hacer todo tipo de curvas sin perderte en las matemáticas ya que todo se basa en parámetros de curvas y coordenadas de puntos que deberías poder crear y modificar fácilmente con el ratón desde el propio editor, si ya sabes tu como dibujar esas lineas pues perfecto.

Si al editor le añades una opción de dividir las curvas o lineas en varias partes iguales obtienes un numero determinado de puntos de control que servirán de referencia para que se dirijan o situen progresivamente los personajes. No se si es ese exactamente tu problema pero si yo tuviera que hacerlo esa es la forma que se me ocurre.

Después puedes ampliar ese editor para otras cosas además de los caminos, como por ejemplo situar objetos, personajes, tipos de terreno, o cualquier otra cosa que pertenezca a un determinado nivel. Si es un proyecto a largo plazo yo creo que vale la pena hacer también su propio editor visual, incluso te puede ayudar gente que no sepa programar diseñando los niveles con él.

Un saludo.

 No creo que te sea muy complicado crear tu propia función que cargue texturas opengl a partir de surfaces, y aprovechar para incluir en ella las caracteristicas de la textura como el tipo de filtrado, mipmaps, etc. Quizas el unico inconveniente esta en los formatos diferentes, y debas usar SDL_ConvertSurface.

 Si ya sabes C++ ya puedes empezar a programar un juego al tiempo que aprendes, yo empezaría por hacer uno muy simple, por ejemplo el pong (el clásico de tenis), crear una replica exacta te servirá como ejercicio, quizás te lleve uno, dos, o más meses, pero si consigues acabarlo exactamente igual tendrás ya una buena base sobre la que empezar a crear otros más complejos además de la satisfacción de haber programado tu primer videojuego.

Descarga el emulador de máquinas recreativas MAME y haz replicas exactas fijándote en videojuegos clásicos, (aqui lo encontrarás junto con miles de juegos www.planetemu.net),  de manera que el hacerlos te obligue a buscarte la vida para conseguirlo, en lugar de hacer solo las cosas que se te den bién o te gusten más (consejo de expertos).

Con la ayuda de manuales y libros, Google, y los foros (siempre por este orden) encontrarás todo lo que necesitas, tampoco viene mal tener a mano un buen libraco de C++. Tambien creo que existe uno de SDL en castellano por ahí, que al parecer es lo mas recomendable para facilitar todo el tema de lo que necesitarás de momento. Busca tutoriales en castellano en formato PDF y archivos de ayuda en CHM o HLP que son muy útiles y prácticos como referencia rápida.

Céntrate en la metodología y el desarrollo general en lugar de los gráficos o sonidos, para este primer juego que te propongo te servirá con un simple pitido y rectángulos de un color. Hazlo independiente de los gráficos de manera que en lugar de llenar el programa de llamadas a SDL_FillRect (suponiendo que utilices SDL) Crea tu propia clase Graficos y un metodo llamado MiRectangulo, e incluye dentro de él la funcion SDL_Fillrect, de manera que la puedas sustituir fácilmente en un futuro por la de cualquier otra libreria (glRectf de OpenGL o FillRect de GDI), asi con sencillos cambios podras actualizar tus programas. Progresivamente ves haciendo clases para el sonido, los controles, y todo lo demas.

Apunta todo lo que vayas a usar en el juego (Raquetas, pelota, marcador...), y crea clases a partir de ello. Luego deberas pensar la forma en que interactúan unas clases con otras para desarrollar sus respectivos métodos. Aunque no sepas demasiado C++ puedes practicar este tipo de clases al tiempo que haces el juego. Usa la encapsulación de manera estricta, la herencia te servira para cuando tengas clases de objetos parecidas como por ejemplo la raqueta del jugador y la raqueta de la maquina. Tambien el polimorfismo sera de gran ayuda. Además procura que el código de la función principal sea legible e independiente de cualquier librería o plataforma, algo así:
...

Pelota.Desplazar();

if (Pelota.ComprobarGolpeRaqueta(RaquetaJugador1)==true)
    {
    Pelota.InvertirDireccion();
    Sonido.EmitirPitidoCorto();
    }
...

De esta manera "los problemas" del juego estarán en sus clases. Estas clases podrás reutilizarlas en otros juegos con el mínimo esfuerzo, modificándolas, ampliándolas, y desechando las que ya no uses, al final acabaras teniendo clases para todo tipo de cosas que te facilitará muchísimo el crear nuevos juegos.

Haz replicas de juegos pequeños y termínalos, no hace falta que hagas todas las fases o pantallas, haz versiones demo de dichos juegos, no pierdas tiempo diseñando tu los gráficos, cópialos directamente con la tecla y pégalos en el Paint u otro similar, recórtalos y guárdalos en un bmp sin mas complicaciones, haz lo mismo con los sonidos.  Si consigues acabar juegos como el Pac-Man, Asteroids, Arkanoid, tetris, etc... ya tendrás nivel más que suficiente para empezar a desarrollar tus propios juegos y para profundizar en la programación gráfica (incluida la 3D).

Y este es mi humilde consejo que no se si sera precisamente el mas correcto, pero tal vez algo de ello te sirva, tambien puede que no sea el mas divertido y espectacular, pero yo creo que se aprende mas y mejor a programar así que intentando hacer un Quake en el que te lo den todo hecho.

Un saludo y hasta otra.