Hola, pego aquí un temilla que me está dando dolores de cabeza...

Trato de explicar la situación:

Estoy usando DirectInput 8 para una pequeña librería de manejo de entradas. Por ahora no hace mucho, pero ya tengo mapeados los eventos de DirectInput tanto de teclado como de Mouse y Joystick. (No hace falta decir que estoy ya está hecho, es para algo distinto de lo que hace SDL).

Todo funciona a las mil maravillas excepto por un pequeño detalle: Al salir de la aplicación, por alguna razón, la función IDirectInputDevice8::Release, se cuelga si mi ventana perdió el foco, y sólo se cuelga cuando el dispositivo es un Joystick. Si la aplicación no pierde el foco, el release funciona bien; adicionalmente, el Teclado y Mouse se liberan correctamente independientemente de si la ventana perdió o no el foco.

El código para Liberar y Adquirir dispositivos va más o menos así:

Código [Seleccionar] Expand


map <input_device, LPDIRECTINPUTDEVICE8> diDevice;


void unacquire_devs ()
{
map <input_device, LPDIRECTINPUTDEVICE8>::iterator Pos;
    for (Pos = diDevice.begin (); Pos != diDevice.end (); ++Pos)
    {
        cout << "Unacquiring dev " << Pos->first << endl;

        if (Pos->second != NULL)
            Pos->second->Unacquire ();
    }
}


void acquire_devs ()
{
map <input_device, LPDIRECTINPUTDEVICE8>::iterator Pos;
    for (Pos = diDevice.begin (); Pos != diDevice.end (); ++Pos)
        Pos->second->Acquire ();
}


Y en la función que procesa los mensajes tengo esto:

Código [Seleccionar] Expand


LRESULT CALLBACK WndProc( HWND hWnd,   // Handle For This Window
                          UINT uMsg,   // Message For This Window
                          WPARAM wParam,   // Additional Message Information
                          LPARAM lParam)   // Additional Message Information
{

    switch (uMsg)         // Check For Windows Messages
    {
case WA_INACTIVE:
{
unacquire_devs ();
}
        case WM_ACTIVATE:       // Watch For Window Activate Message
        {
acquire_devs ();
        }
// ...



Entonces, al momento de cerrar la aplicación, entre las muchas otras cosas que hago es llamar a una función que hace el Release de cada dispositivo que haya sido creado:

Código [Seleccionar] Expand



bool release_dev (input_device Dev)
{
if (diDevice [Dev] != NULL)
{
diDevice [Dev]->Unacquire ();
diDevice [Dev]->Release ();
diDevice [Dev] = NULL;

        return true;
}

    return false;
}


void destroy_dx ()
{
map <input_device, LPDIRECTINPUTDEVICE8>::iterator Pos;

    unacquire_devs ();

    for (Pos = diDevice.begin (); Pos != diDevice.end (); ++Pos)
        release_dev (Pos->first);

if (DXInputObj != NULL)
{
DXInputObj->Release ();
DXInputObj = NULL;
}

}



El programa se cuelga en la línea:       diDevice [Dev]->Release ();
Pero ello sólo ocurre cuando el Dev a liberar es un joystick y la ventana perdió el foco anteriormente.

Alguien se ha enfrentado a algo como esto antes?


Si sirve de algo, pego la función con la que estoy creando los Dispositivos DXI; aclarando que input_device es un enum de los tipos posibles de dispositivos (teclado, mouse, joystick0 a joystick7, ...)

Código [Seleccionar] Expand


bool open_dev (input_device Dev)
{
GUID DevGUID;
LPCDIDATAFORMAT DevDataFormat;
DIPROPDWORD Props;
DWORD CopLevel;

if (diDevice [Dev] != NULL)
return true;

switch (Dev)
{
case device_keyboard:
DevGUID = GUID_SysKeyboard;
DevDataFormat = &c_dfDIKeyboard;
            CopLevel = DISCL_FOREGROUND | DISCL_NONEXCLUSIVE;
break;
case device_mouse:
DevGUID = GUID_SysMouse;
DevDataFormat = &c_dfDIMouse;
            CopLevel = DISCL_FOREGROUND | DISCL_NONEXCLUSIVE;
break;
case device_joystick0:
case device_joystick1:
case device_joystick2:
case device_joystick3:
case device_joystick4:
case device_joystick5:
case device_joystick6:
case device_joystick7:

if (AvailJoy.find (Dev) == AvailJoy.end ())
{
seterror ("open_dev: Attempt to open an unavailable joystick");
return false;
}

DevGUID = AvailJoy [Dev];
DevDataFormat = &c_dfDIJoystick2;
            CopLevel = DISCL_NONEXCLUSIVE | DISCL_FOREGROUND;
break;

default:
seterror ("open_dev: Attempt to open an unknown device type");
return false;
}

hr = DXInputObj->CreateDevice (DevGUID, &diDevice [Dev], NULL);
if (FAILED(hr))
{
seterror ("open_dev: could not open DirectInput 8 Device");
return false;
}

diDevice [Dev]->SetDataFormat (DevDataFormat);
diDevice [Dev]->SetCooperativeLevel(hWnd, CopLevel);

//We are using Buffered input
    Props.diph.dwSize       = sizeof(DIPROPDWORD);
    Props.diph.dwHeaderSize = sizeof(DIPROPHEADER);
    Props.diph.dwObj        = 0;
    Props.diph.dwHow        = DIPH_DEVICE;
    Props.dwData            = _input_buffer_size;

hr = diDevice [Dev]->SetProperty (DIPROP_BUFFERSIZE, &Props.diph);

if (FAILED(hr))
{
seterror ("open_dev: could not set buffered device");
return false;
}

diDevice [Dev]->Acquire();

return true;
}


wenas  :D
Tengo una duda sobre plantillas y los iteradores de STL.

Sucede que tengo una api donde tengo varios tipos distintos de clases, las cuales se entregan solo como punteros mediante llamadas a funciones "createobject", "createanim", "createetc" (Las clases están en una DLL y son derivadas de clases virtuales, que son las que ve el programador).

Estaba pensando en hacer un administrador de clases para llevar a cabo un registro de todo lo que se crea y hacer una respectiva labor de limpieza a la salida.

La primera idea que me vino a la mente es con un template como el que sigue:

Código [Seleccionar] Expand


template <class T> class ClassMan
{
private:
   vector <T *>MyLst;

public:
   ClassMan ()  {};
   ~ClassMan () {clear ();};

   T *create ()
   {
       T *Tmp = new T;

       if (Tmp != NULL)
           MyLst.push_back (Tmp);

       return Tmp;
   };

   void release (T *ClassPtr)
   {

       vector <T *>::iterator Pos;

       Pos = find (MyLst.begin (), MyLst.end (), ClassPtr);

       if (Pos != MyLst.end ())
       {
           delete (*Pos);
           MyLst.erase (Pos);
       }
   };

   void clear ()
   {
       vector <T *>::iterator Pos;
       Pos = MyLst.begin ();

       while (Pos != MyLst.end ())
       {
           (*Pos)->clear ();
           delete (*Pos);

           ++Pos;
       }

       MyLst.clear ();
   };
};



El problema es que, al momento de crear el iterador, el compilador me dice:

Código [Seleccionar] Expand


G:/yge/yg_sdk/include/YG/yg_classman.h: In member function `void ClassMan<T>::release(T*)':
G:/yge/yg_sdk/include/YG/yg_classman.h:62: error: expected `;' before "Pos"
G:/yge/yg_sdk/include/YG/yg_classman.h:64: error: `Pos' was not declared in this scope


ese "; before Pos" lo marca en la línea donde estoy tratando de crear el iterator. Imagino que esto se debe hacer de otra forma...


alguien sabe si se puede o una forma de darle la vuelta a esto?

Gracias de antemano :)

Wenas otra vez  :D

Tengo otra de esas preguntillas raras... bueno, esta vez no es tan rara:
alguien sabe de alguna librería multiplataforma para manejo de entradas en C++?

Y por "entradas" me refiero a Joystick, Teclado, mouse y semejantes. SDL no me sirve pues requiere crear su propia ventana utilizando sus propias funciones y eso no es lo que requiero.

De antemano, gracias ;)

Wenas!
Tenía rato que no me aparecía por aquí. Esta ves vengo con una dudilla sobre el compilador GNU GCC que viene con ubuntu.

Sucede que estoy haciendo una DLL que compila tanto en Güindous como en Linux.
La cosa está en que cuando compilo con Linux, el linker me marca el siguiente error:

Código [Seleccionar] Expand


/usr/bin/ld: ./obj/yg_aux.o: relocation R_X86_64_32 against `a local symbol' can not be used when making a shared object; recompile with -fPIC


Buen, lo solucioné agregando la dichosa opción -fPIC en los comandos de compilación, pero tengo curiosidad por saber qué es lo que hace esa opción exactamente.


Como nota adicional, comentar que estoy usando code::blocks en Ubuntu 7.10 para AMD64.

Gracias por sus comentarios y sugerencias :)

Wenas  :lol:

He vuelto con otra de mis preguntillas raras.

Como todos sabemos, los compiladores de C++ (tanto el de GNU como el de Microsoft) incluyen algunas macros predefinidas para el preprocesador, cosas como _MSVC_, _GNU (o algo así), etc.

La pregunta es:
hay algún sitio donde pueda consultar una lista de todas esas macros predefinidas y su intensión?

Gracias de antemano  :D


EDIT:
Encontré esto en MSDN:
http://msdn2.microsoft.com/en-us/library/b0084kay.aspx

Igual sigo interesado en una lista de las macros de GNU g++ (de preferencia el más reciente)

Wenas  :lol:

Estuve viendo en otro post sobre color keying usando direct x 9, y, viendo el post de ma]estre sobre como usar alpha test para aplicar efectos de color key, me nació la curiosidad...

el punto es este:
tengo un valor entero que representa un color de pixel a utilizar como color key, digamos 0xffff0000 (RGBA).

Como hago para convertir ese valor en algo que pueda usar con opengl como color key?

Lo único que se me ocurrió es que, al momento de cargar la imagen, establecer el valor alpha a 255 para todos los pixeles que son del mismo color que el colorkey... pero eso crea el problema de que no se puede cambiar dicho color durante la ejecución del programa  :cry:

Alguna idea?

gracias de antemano

Wenas...

Una pregunta de Newbie OpenGLero:
:idea: Es posible "paletizar" las texturas de OpenGL?

es decir, tener una textura con paleta de 8 bits y variar esa paleta de vez en cuando para dar efectos chulos a unas cuantas gráficas.

Es posible?

 Wenas  (ole)

Tengo una duda sobre derechos de autor, open source y cuestiones legales.

Me explico:

Estoy trabajando en una API sencilla (inspirada en Div Games Studio, pero con severas diferencias) para C++, que si bien no revolucionará la forma de programar videojuegos, espero que al menos le de a uno que otro programador novato como yo algo con qué entretenerse  :lol:

El proyecto está planeado para ser open source, bajo la licencia zlib ( http://www.zlib.net/zlib_license.html ).

Ahora la pregunta es:
Qué tengo que hacer para que pillines como Microsoft (quien patentó el S3TC, el doble click, y muchas otras cosas que no inventaron ellos) patenten mi software y me impidan seguir siendo el dueño del mismo?  :P

Ciertamente no creo que microsoft se tome la molestia de patentar una cosa como esta, pero estoy seguro que allá afuera, en ese vasto mundo llamado internet, no faltará el vago sin oficio que, por hacer la maldad, patente el software, prohibe su distribución empieza a cobrar regalias y me echa a perder todo el trabajo  (nooo)

Por ahora, estoy poniendo la licencia al inicio de cada archivo fuente, pero no creo que con eso baste.

Es necesario patentarlo? Cuanto costaría una patente?
o alguna otra forma de mantener un proyecto open source y evitarnos los lios esos?


Ayuda  (nooo)  

 Wenas (ole)

me he estado mirando un poco esta OpenAL y se mira bastante interesante.
Veo que viene, al muy estilo de OpenGL, con unas cuantas utilerías que ayudan a cargar archivos.

Según la especificación 1.1: "en lugar de proveer una función para cargar cada tipo de archivo, que ciertamente crecerá con el tiempo, se provee una sola función genértica que sirve para cargar cualquier archivo de audio conocido"
o algo así...

El caso es que he buscado por todas partes para ver una lista de estos Tipos de Archivos Soportados y hasta el momento no he encontrado ninguna.
Alguien sabe algo?


un saludo


Nota: En mi rancho decimos "archivo" queriendo decir "fichero"  :)

 Existe alguna forma de manejar las teclas especiales que traen algunos teclados?
ya sea desde Visual Basic o desde Visual C.

Es decir: esas teclas que dicen "Anterior", "siguiente", "play/pause", "stop", etc. que vienen en algunos teclados con funciones multimedia, internet y esas cosas.

Se me ocurre esto porque acabo de comprar un teclado cuyos drivers no me permiten personalizar todas las teclas especiales, sólo unas cuantas  :( . He instalado los drivers de un teclado microsoft, y me permite personalizar más botones, pero los teclados microsoft no tienen las funciones en los mismos botones (Ejemplo: Presiono "Pista siguiente" y me trata de abrir el Excel XD; otros botones de plano no me los reconoce).

Existe alguna forma de hacer un programa residente en memoria que pueda detectar cuando el usuario presiona estas teclas y mandarle alguna llamada al sistema operativo según sea necesario?

o mejor aún:
Existe algún programa genérico para hacer esto? :D

nótese que quiero poder personalizar todas las teclas. O tantas como se pueda

Un saludo, y gracias de antemano

 wenas...
aquí vengo con una preguntilla estúpida:

Estoy haciendo un programa en Dev-cpp con SDL.
Sucede que el SDL cambia la salida estandar al archivo stdout.txt

pero mi proyecto es un proyecto de consola.
Como hago para cambiar la salida estandar a la consola otra vez?

gracias

 wenas  (ole) .

He vuelto con mis preguntillas atarantadoras  :lol:

Sucede que he estado trasteando un poco con Dev-cpp
y, en un intento por hacer todo mi código más porteable, pase un proyecto que tengo (de hecho el único >_>) a dev-cpp para ver que tan porteable soy  (rules)

El problema viene porque el proyecto en su estado original (Visual Studio .net) utiliza muchas DLLs:
-SDL
-SDL_image
-SDL_mixer
-AngelScript
(entre otras que no vienen al caso)

la cosa está en que...

al intentar usar los .lib de esas DLLs (compiladas en VC), el compilador del dev-cpp
no me dice que no debo usar esos archivos
en lugar de eso, se conforma con darme varios errores de linkeo de "undefined symbol"

eso lo solucioné para el caso de SDL usando las "development libraries" para MinGW
en pocas palabras: me bajé los .a de SDL

el problema es que no hay .a para SDL_image ni sdl_mixer
peor aún con AngelScript, que ni siquiera se distribuye como librería, sino que te dan todo el código fuente

para no hacer más largo el cuento:
al compilar con visual studio y con dev-cpp, obtengo dlls totalmente distintas, y si compilo una DLL con Dev-cpp, no la puedo usar con Visual Studio, y vice versa.
SDL viene con una DLL precompilada, que es la misma tanto para MinGW como para VS



la pregunta del millón es:
como hago pa tener una sola DLL que funcione con cualquier compilador?
(tal y como hicieron los de SDL)




o sea, crear los .a a partir de los .lib
o los .lib a partir de los .a
o que sé yo XD

soy totalmente newbie en esto de GNU, g++, mingw, bla bla bla (nooo)

 Wenas

aquí vengo con otra de esas intrigantes preguntillas del mundo de C++.
Sucede que estoy modificando la clase IniFile de ZaelSiuS; y en aras de hacerla non-case-sensitive, me puse a escribir una clase con sobrecargas de operadores y cosas raras que presento a continuación:

Código [Seleccionar] Expand


class caselessstr
{
private:
  inline string UPPERCASE (const string Str)
  {
     string Tmp;
#ifdef WIN32
     std::transform( Str.begin(), Str.end(), Tmp.begin(), toupper);
#else
     std::transform( Str.begin(), Str.end(), Tmp.begin(), std::toupper);
#endif

     return Tmp;
  };
public:
  std::string Data;

  caselessstr () {};
  caselessstr (const caselessstr &Src) {Data = Src.Data;};
  caselessstr (const std::string &Src) {Data = Src;};
  caselessstr (const char *Src)        {Data = Src;};

  ~caselessstr () {Data.clear ();};

  std::ostream &operator << (std::ostream &O) { O << Data; return O;};

  //con  Case-lessStr
  caselessstr &operator = (const caselessstr &Src) {Data = Src.Data; return *this;};
  bool operator == (const caselessstr &Src) {return (UPPERCASE (Data) == UPPERCASE (Src.Data));};
  bool operator != (const caselessstr &Src) {return !(operator== (Src));};
  bool operator <  (const caselessstr &Src) {return (UPPERCASE (Data) <  UPPERCASE (Src.Data));};
  bool operator >  (const caselessstr &Src) {return (UPPERCASE (Data) >  UPPERCASE (Src.Data));};
  bool operator <= (const caselessstr &Src) {return (UPPERCASE (Data) <= UPPERCASE (Src.Data));};
  bool operator >= (const caselessstr &Src) {return (UPPERCASE (Data) >= UPPERCASE (Src.Data));};

  //con std::string
  caselessstr &operator = (const std::string &Str) {Data = Str.c_str (); return *this;};
  bool operator == (const std::string &Src) {return (UPPERCASE (Data) == UPPERCASE (Src));};
  bool operator != (const std::string &Src) {return !(operator== (Src));};
  bool operator <  (const std::string &Src) {return (UPPERCASE (Data) < UPPERCASE (Src));};
  bool operator >  (const std::string &Src) {return (UPPERCASE (Data) > UPPERCASE (Src));};
  bool operator <= (const std::string &Src) {return (UPPERCASE (Data) <=UPPERCASE (Src));};
  bool operator >= (const std::string &Src) {return (UPPERCASE (Data) >=UPPERCASE (Src));};

  //con const char *
  caselessstr &operator = (const char *Src)  {Data = Src; return *this;};
  bool operator == (const char *Src) {return (UPPERCASE (Data) == UPPERCASE (Src));};
  bool operator != (const char *Src) {return !(operator== (Src));};
  bool operator <  (const char *Src) {return (UPPERCASE (Data) < UPPERCASE (Src));};
  bool operator >  (const char *Src) {return (UPPERCASE (Data) > UPPERCASE (Src));};
  bool operator <= (const char *Src) {return (UPPERCASE (Data) <=UPPERCASE (Src));};
  bool operator >= (const char *Src) {return (UPPERCASE (Data) >=UPPERCASE (Src));};

};


dicha clase se usa de la siguiente manera:

Código [Seleccionar] Expand


typedef std::map< caselessstr, std::map< std::string, std::string> > IniMap;
typedef std::map< std::string, std::string> IniPair;


ahora, en realidad tengo 2 problemas:
1- al hacer algo como:

Código [Seleccionar] Expand


  std::ofstream Archivo ("algo.txt",  std::ios_base::trunc);
  IniMap X;
  //...
  Archivo <<  X;
  //...

El compilador me dice que NO existe un operador para "<<" que acepte un caselessstr del lado derecho.
No parece importarle el hecho de que la clase en realidad contiene una sobrecarga para tal efecto >_>

bien. Eso lo "solucioné" poniendo una sobrecarga del operador global "<<"

Código [Seleccionar] Expand


std::ostream &operator << (std::ostream &O, const caselessstr &Src)
{
  O << Src.Data;
  return O;
}


2-Luego de eso, esta cosa me marca error en el operador "<", alegando que
"no existe un operador que tome un operando del lado izquierdo del tipo caselessstr"
cuando en realidad la clase tiene el tan mencionado operador.
El error lo marca en el include (que imagino es parte del estandar)

Código [Seleccionar] Expand


template<class _Ty>
struct less
 : public binary_function<_Ty, _Ty, bool>
{ // functor for operator<
bool operator()(const _Ty& _Left, const _Ty& _Right) const
 { // apply operator< to operands
 return (_Left < _Right);
 }
};

en ese "return (_Left < _Right)"

sugerencias?

 wenas  (ole)

aquí vengo con otra preguntilla inquietante del mundo de C++:

Cual es la finalidad del "famoso" size_t?

Es decir... de cualquier manera es lo mismo que poner "unsigned int".
Por qué no dejarlo simplemente en unsigned int?

Es cierto que el tamaño de unsigned int varía dependiendo si la plataforma es de 16 o 32 bit (no sé si también afecte a 64 bit)
pero igual lo hace nuestro querido tipo size_t


es decir: si la plataforma es de 16 bit, size_t es de 16, igual es unsigned int
lo mismo pasa cuando es de 32 bit


entonces...
cual es la verdadera finalidad de este tipo de dato?

(alguna vez escuché que tiene algo que ver con compatibilidad, pero no recuerdo ningún detalle)

 Wenas

parecería una pregunta tonta pero me he dado cuenta que no hay mucha información al respecto:

¿alguien sabe cómo trabajar con directorios en C++?
es decir:
-Obtener los archivos del directorio actual (nombre y extensión) y sus subdirectorios
-Obtener el directorio actual
-Obtener las unidades disponibles (C:, D:, A:, etc)
-Obtener atriburos de los archivos
-crear nuevos directorios
-etc...

 Wenas  (ole)

Estoy haciendo algunas cosillas con OpenGL para dibujar sprites 2D.
Tengo lo siguiente:

-Posición X, Y del srpite
-Textura (mapa de bits) para el sprite
-Alto y Ancho de la textura
-Ángulo de rotación

y tengo una función que me dibuja un sprite en la pantalla en base a esa información (Utilizando GL_QUADS).
Y cuando dibujo uno, todo corre mu xulo... el problema es cuando estoy dibujando 2000 o 3000 objetos en un frame... Se pone leeeeentoooo

Me he dado cuenta que el hecho de dibujar algunos Sprites que estarán fuera de la pantalla afecta el rendimiento.
Y dado que no todos los objetos están dentro de la pantalla, quería preguntar:

Cómo hago para detectar cuando las 4 esquinas de un cuadrado están fuera de la pantalla?
(Tengamos en cuenta que el ángulo en el que es dibujado el sprite influye mucho aquí)

 wenas a todos.
Les traigo una preguntilla sobre visual studio 2003:

verán, sucede que tengo un proyecto algo grande que hace un uso algo extensido de memoria dinámica (Gráficos, texturas, listas, bloques de scroll, cadenas de texto... etc...).

La cosa está en que, al cerrar el programa, el depurador me marca "Assertion Failure". Eso podría sonar lógico, de no se por que NO uso Asserts  <_< . Lo más curioso del caso es que el error sólo me lo marca cuando está activo el machine debug manager (mdm.exe); si lo descargo de memoria , mi programa se sale sin ningún problema.

Cuando uso lo compilo en Win32 release, en lugar del assertion failure me sale un espantoso error de los de Windows "Este programa ha efectuado una operación no válida... bla bla bla", pero igual, descargo el mdm.exe y ya no pasa nada.


recalco que esto ocurre al cerrar el programa, y que no estoy usando el Assert

 Alo de nuevo  :lol:


Pregunta ALRAZiana:
Alguien me podría dar alguna guía sobre como se hace eso de captar comandos al estilo de los juegos de lucha?

Ya saben el clásico Street Fighter:
"Abajo, abajo-adelante, Adelante + Botón" = Movimiento especial...

La cosa es... Como sé cuando el usuario ha marcado la secuencia anterior..?

Estoy usando SDL para obtener las entradas, aunque creo que eso es lo de menos, ya que las entradas se pueden convertir a cualquer otra cosa

 Existe alguna(s) función(es) dentro de las librerías estándar de C o C++ que permita cargar archivos de configuración en modo texto tal como hacen los .ini del Güindous?

O algún programilla que genere algo parecido?


De antamano gracias  (ole)  

 Alo genteeee  :lol:

Aquí les vengo con una duda interesante  :rolleyes:
O al menos espero que lo sea  :P


Verán, tengo una clase muy simpática:

Código [Seleccionar] Expand


class Algo
{
Public:
  void HacerAlgo ();
  void HacerOtraCosa ();
  void NoHacerNada ();
  void HacerComoQueHaceAlgo ();
};

Por poner un ejemplo

Ahora, lo que quiero hacer es, tener un puntero :huh: ... de hecho varios punteros
Cada uno de los cuales apunta a una función distinta de ESA clase.

Algo así como

Código [Seleccionar] Expand


 Puntero1 = MiClase.HacerOtraCosa;
 Puntero2 = MiClase.NoHacerNada;

Es posible? :blink:
(genial)  Cómo se hace?

(Sé cómo crear punteros a funciones, pero no punteros a funciones miembro de una clase (nooo)  )

Gracias de antemano  (ole)