Estoy desarrollando un nuevo motor que espero terminar esta semana. No os hagais ilusiones...¡no es 3D! Bueno, sí lo será, pero primero he preferido echar un cable a aquella gente que esto de las 3D les cuesta, y voy a sacar la primera versión para 2D(en realidad será 3D, para poder utilizar la potencia de las aceleradoras...¡ya sabeis!)

Es muy potente en 2D( o por lo menos me lo parece a mi!!) y he intentado que sea lo más sencillo posible. Si hay algún programador interesado en hacer cosas en 2D y tiene GRAFICOS, si quiere puede mandármelos y verámos si sacamos una demo(así él aprovecha y ya le hago un montón de código!)

Posteriormente aparecerá la versión del motor en 3D, que por cierto se llama Merlín. Esta vez no quiero caer en antiguos errores, de subir versiones beta que luego exigían mucho cambio de código y perdía mucho tiempo en rehacer los ejemplos! Ahora subiré la versión definitiva, o muy avanzada, donde los cambios que hayan serán mínimos y no hará falta rehacer código.

                               

                                Estoy haciendo una clase de strings. El problema viene cuando quiero hacer lo siguiente;

CXString a,b,c;
a=b+c;


La definición friend es la siguiente:

CXString operator+(const CXString &s1,const CXString &s2)
{
   CXString cus;
   cus = s1;
   cus += s2;
   return cus;
}
El PROBLEMA es que se llama al destructor de la clase CXString al hacer el return, y por tanto al volver a la línea de llamada, el programa da un error de memoria inválida y todo esto.

¿Cómo debe hacerlo ?
                               

                                Los que habeis intentado cargar escenas ASE, os habreis dado cuenta de que a veces las coordenadas de texturas son muy extrañas y erróneas. Esto parece coincidir con unos valores que se corresponden al Smoothing Groups.
¿Alguien sabe qué significa los Smoothing groups y qué efecto tienen sobre las coordenadas de textura?                                

                                Si yo quisiera hacer lo siguiente:

CEjemplo a,*b;
xx.Fijar(a);
xx.Fijar(B);

Debería definir los siguiente métodos:
class xx {
...
void Fijar(CEjemplo *nombre);
void Fijar(CEjemplo &nombre);
...
}

¿Hay alguna forma de escribir sólo 1 de estos métodos y que me acepte los dos tipos de llamada que he puesto arriba?
OJO, no me sirve esto:

CEjemplo a,*b;
xx.Fijar(*a);
xx.Fijar(B);


Y ahora otra duda:
Me gustaría crear esta función para sustituir al sprintf:

void Formato(const char *formato,...)
{
  va_list marker;char *tmp=new char[32000];

  va_start( marker, formato );
  sprintf(tmp,formato,*marker);

  ...

  delete tmp;
}

Así en mi programa la podría llamar como un miembro de una función. Sin embargo cuando la llamo..


xx.Formatear("%d,%2.2f",10,5.5f);

¡sólo me coge bien el 1er parámetro!

¿Porqué?

Muchas Gracias


[ Este Mensaje fue editado por: Drácula el 2002-03-26 00:08 ]

[ Este Mensaje fue editado por: Drácula el 2002-03-26 00:09 ]                                

                                Necesito tener más de un Rendering Context. En OGL esto es muy sencillo, pero en DX(como es de esperar) la cosa se complica.
¿Alguien conoce una forma sencilla de implementar varias ventanas asociadas a buffers de DX para ir renderizando a cada una por separado?
Sé que puede hacerlo cambiando el SetRenderingTarget, pero NO quiero hacerlo así. Quiero asociar un DeviceContext a un Rendering Target, así como se puede hacer en OGL.

El ejemplo perfecto sería utilizar MFC con multidocumentos!                                

                                He leido que MS ya pega el salto directamente a DX9.1 ( algo así como lo que hizo de DX3 a DX5)
Pronto se sabrá más, pero parece que potencian los vertex shader y "obligan" a que el hardware se adeque a sus técnicas. También dice que facilitarán bastante el trabajo del desarrollador.

Así que..¡como se predijo! Otra vez a rehacer el código!

¡Tengo unas ganas ya de que esto termine y se estandarice un poco!
¡Y tampoco podemos ir a OGL, porque la versión 2 promete cambios estructurales de bajo nivel!

Que locura.                                

                                Se habla mucho aqúí de la optimización BackFace Culling. Sin embargo, en mi primer motor implementé y estudié ampliamente esta opción y...¡no se ganaba tiempo en absoluto!
Y de verdad que estudié mucho el tema, probando diferentes técnicas y en ningún caso, en ninguno, valía la pena.

¿En qué me equivoqué?                                

                                ¿Alguien puede explicarme, o indicarme dónde puedo recabar información a parte de las SDK, sobre los POOL de memoria que hay en DX8? Sus tipos y para qué se debe usar cada caso.                                

                                Sé que ya he hecho esta pregunta más veces, pero a ver si hay más suerte esta vez.

La pregunta es:
¿alguien que tiene la beta podría comentar los cambios que supone DX9 ?