Hola.

Loover, a ti te lo paso por el messenger esta noche, será porque nunca hablamos... :D

 Hola.

La web de Loover es muy buena, pero como todo, siempre se aprende mejor con ejemplos. Yo tengo clases que gestiona la busqueda de cáminos con el A*mediante un mapa de booleanos (tiles vamos).

Si me das tu mail te lo envio por correo. Es bastante facil de entender y demas.
Se podria usar como codigo de la semana, si alguien lo quiere lo podria poner. :D

 Hola.

Código [Seleccionar] Expand



 IDirect3DSurface8* FrontBuffer;

 m_pD3DDevice->CreateImageSurface(ancho,alto, D3DFMT_A8R8G8B8, &FrontBuffer );  
 
 m_pD3DDevice->GetFrontBuffer(FrontBuffer));
 D3DXSaveSurfaceToFile(FileName,D3DXIFF_BMP,FrontBuffer, NULL, NULL);

   
RELEASE(FrontBuffer);


Supongo que habrá varias formas de hacerlo.

También puedes hacer capturas escalables, si te interesa dilo.

Chao.  

 Hola.

El valor del HWND hwnd del Init, pues sacalo de la ventana que hayas creado para tu aplicación. Si es una aplicacion Direct3D (sin usar MFC, ni VCL) pues habras creado la ventana por tu cuenta (supongo), vamos el mismo handle a la ventana que necesitas para crear los controles de las Direct-X.
La funcion Init no es más que para iniciar, es una mania que tengo (que me enseño un amiguete) de usar Init,End,etc.. Asi primero hago asi:

Código [Seleccionar] Expand


CVideo *pVideo;
pVideo = NEW CVideo; // NEW es una macro :P
if (pVideo)
{
 if (!pVideo->Init(.......))
 {
   // controlas errores y demas :)
   return false;
 }
}
...




El m_sToken, olvidate de el ya que es algo que uso en mi código. Tengo en otra clase una lista ligada con todos los videos segun el token y asi en el script solo hago PlayVideo("TOKEN_VIDEO"); y me olvido de la ruta,etc..

Y sobre lo que dice ethernet sobre el ActiveX roñoso, pues no se, quizas sería más facil o quizas no, quizas sea mejor o quizas no, la verdad que a mi gusto contra menos cosas "externas" uses pienso que es mejor. Pero vamos, el uso de las DirectShow para playear videos y hacer 3 cosas no es dificil. Ademas, yo he implementado DirectX con las VCL (Builder) y el código de los videos no he tenido ni que retocarlo, lo cual me ha permitido reproducir videos en controles dentro de un formulario sin nada de complicaciones.

El pch.base.h no e snada más que un fichero que posee una serie de macros personales, esa clase solo usa (a simple vista -creo-) el RELEASE(...); <-- no es más que una macro para hacer "release" de los interfaces.

Espero que te sirva, chao.  :D

 Hola.
Aqui te pego las clases que yo uso para reproducir videos:

Código [Seleccionar] Expand



/*********************************************************************************
Nombre:      Video.cpp
Descripción: Clase que lleva el control de un video
/*********************************************************************************/

#include "Pch_Base.h"

#include "Video.h"

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
CVideo::CVideo()
{
 m_bOk = false;
}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
CVideo::~CVideo()
{
 End();
}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
void CVideo::BorraVars()
{
 m_bOk             = false;
 m_bVideoActivo    = false;
 m_bFullScreen     = false;
 m_bLoad           = false;

 m_hwnd            = NULL;

 m_dwGraphRegister = 0;

 m_tVideoState     = VS_STOP;

 m_pGraphBuilder   = NULL;
 m_pMediaControl   = NULL;
 m_pMediaEvent     = NULL;
 m_pVideoWindow    = NULL;

 ZeroMemory(m_sToken,sizeof(m_sToken));
 ZeroMemory(m_sFileVideo,sizeof(m_sFileVideo));
}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
void CVideo::LiberaVars()
{
 
 if (m_pVideoWindow)
 {
   m_pVideoWindow -> put_Visible(OAFALSE);
   m_pVideoWindow -> put_Owner(NULL);
 }

 //if (m_pMediaEvent)
   //m_pMediaEvent->SetNotifyWindow((OAHWND)NULL, 0, 0);


 #ifdef REGISTER_FILTERGRAPH

   if (m_dwGraphRegister)
   {
     RemoveGraphFromRot(m_dwGraphRegister);
     m_dwGraphRegister = 0;
   }
 
 #endif // REGISTER_FILTERGRAPH

 RELEASE (m_pMediaControl);
 RELEASE (m_pVideoWindow);
 RELEASE (m_pMediaEvent);
 RELEASE (m_pGraphBuilder);
}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
void CVideo::End()
{
 if (m_bOk)
 {
   LiberaVars();
   CoUninitialize();
   m_bLoad = false;
   m_bOk = false;
 }
}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
bool CVideo::Init(HWND hwnd,char *sFileVideo,char *sTokenVideo,bool bFullScreen)
{
 End();
 BorraVars();

 if (sTokenVideo[0]) strcpy(m_sToken,sTokenVideo);
 if (sFileVideo[0])  strcpy(m_sFileVideo,sFileVideo);

 m_hwnd = hwnd;
 m_bFullScreen = bFullScreen;
 
 m_bOk = true;
 return (m_bOk);
}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
void CVideo::InitInterfaces()
{
 /* -- Interface: Filter Graph" -- */
 CoCreateInstance(CLSID_FilterGraph,NULL,CLSCTX_INPROC,
                  IID_IGraphBuilder,(void**)&m_pGraphBuilder);

 /* -- Interfaces: PlayBack & ScreenSize & Control de eventos -- */
 m_pGraphBuilder -> QueryInterface (IID_IMediaControl,  (void**) &m_pMediaControl);
 m_pGraphBuilder -> QueryInterface (IID_IVideoWindow,   (void**) &m_pVideoWindow );
 m_pGraphBuilder -> QueryInterface (IID_IMediaEventEx,  (void**) &m_pMediaEvent  );

}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
void CVideo::LoadVideo(char *sFileVideo)
{
 WCHAR wstrFileName[MAX_PATH];
 RECT area_ventana;
 
 GetClientRect(m_hwnd,&area_ventana);
 MultiByteToWideChar(CP_ACP, 0, sFileVideo, -1, wstrFileName, MAX_PATH);

 CoInitialize(NULL);
 InitInterfaces();
 
 m_pGraphBuilder->RenderFile(wstrFileName,NULL);

 m_pVideoWindow->put_MessageDrain((OAHWND)m_hwnd);

 if ((m_pVideoWindow->put_Owner((OAHWND)m_hwnd)) == S_OK)
 {
     //m_pVideoWindow -> put_Visible  (OAFALSE);
     //m_pVideoWindow -> put_AutoShow (OAFALSE);
     m_pVideoWindow -> put_WindowStyle   (WS_CHILD | WS_CLIPSIBLINGS);
     m_pVideoWindow -> SetWindowPosition (area_ventana.left,area_ventana.top,area_ventana.right,area_ventana.bottom);
 }

 m_bLoad = true;
}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
void CVideo::SetFullScreen()
{
 LONG lMode;
 
 if (m_pVideoWindow)
 {
   m_pVideoWindow->get_FullScreenMode(&lMode);
   if (lMode == 0) /* -- No fullscreen -- */
   {
     m_pVideoWindow->put_MessageDrain((OAHWND)m_hwnd);
     
     lMode = -1; /* -- FullScreen mode -- */
     m_pVideoWindow->put_FullScreenMode(lMode);
   }
 }
   
}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
void CVideo::Play()
{
 if (!m_bLoad)
   LoadVideo();

 if (m_bFullScreen)
   SetFullScreen();

 m_pMediaControl->Run();
 m_tVideoState = VS_PLAY;

 /* -- Loop principal mientras el video se reproduce... -- */
 while (m_tVideoState == VS_PLAY)
 {
   MSG msg;
   long lEventCode, lParam1, lParam2;

   if(E_ABORT != m_pMediaEvent->GetEvent(&lEventCode, (LONG_PTR *) &lParam1,
                             (LONG_PTR *) &lParam2, 0))
   {
   
     m_pMediaEvent->FreeEventParams(lEventCode, lParam1, lParam2);
           
     if (lEventCode == EC_COMPLETE)
       m_tVideoState = VS_STOP;
   }

   while (PeekMessage (&msg, m_hwnd, 0, 0, PM_REMOVE))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
 }
 
 m_pMediaControl->Stop();
 End();
}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
void CVideo::Run()
{
 LONG code;

 if (m_pMediaControl)
 {
   m_bVideoActivo  = true;
   m_pVideoWindow  ->  put_Visible(OATRUE);
   m_pMediaControl ->  Run();
   m_pMediaEvent   ->  WaitForCompletion (INFINITE,&code);
   m_pVideoWindow  ->  put_Visible(OAFALSE);

 }
}

#ifdef REGISTER_FILTERGRAPH

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------

HRESULT CVideo::AddGraphToRot(IUnknown *pUnkGraph, DWORD *pdwRegister)
{
   IMoniker * pMoniker;
   IRunningObjectTable *pROT;
   if (FAILED(GetRunningObjectTable(0, &pROT)))
   {
       return E_FAIL;
   }

   WCHAR wsz[128];
   wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR)pUnkGraph,
             GetCurrentProcessId());

   HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
   if (SUCCEEDED(hr))
   {
       hr = pROT->Register(0, pUnkGraph, pMoniker, pdwRegister);
       pMoniker->Release();
   }

   pROT->Release();
   return hr;
}

//----------------------------------------------------------------------
//  Uso:            
//  Retorno:        
//  Parametros:    
//----------------------------------------------------------------------
void CVideo::RemoveGraphFromRot(DWORD pdwRegister)
{
   IRunningObjectTable *pROT;

   if (SUCCEEDED(GetRunningObjectTable(0, &pROT)))
   {
       pROT->Revoke(pdwRegister);
       pROT->Release();
   }
}

#endif // REGISTER_FILTERGRAPH

-----------------------------------------------------------------------------
/*********************************************************************************
Nombre:      Video.h
Descripción: Clase que lleva el control de un video                          
/*********************************************************************************/

#ifndef _Video_H
#define _Video_H

#include <DShow.h>

//#define REGISTER_FILTERGRAPH

class CVideo
{

public:

 enum TVideoState
 {
   VS_PLAY  = 1,
   VS_PAUSE = 2,
   VS_STOP  = 3,
 };

                   CVideo              ();
                  ~CVideo              ();

 bool              Init                (HWND hwnd,char *sFileVideo,char *sTokenVideo,bool bFullScreen);
 void              End                 ();

 void              Run                 ();
 void              Play                ();

 void              SetFullScreen       ();

 HRESULT           RunMensajesDelVideo ();

 bool              IsVideoActivo       ()                    { return (m_bVideoActivo);  }
 bool              IsOk                ()                    { return (m_bOk);           }

 char             *GetTokenVideo       ()                    { return (m_sToken);        }

 void              LoadVideo           ()                    { LoadVideo(m_sFileVideo); }
 void              LoadVideo           (char *sFileVideo);

private:

 void              BorraVars           ();
 void              LiberaVars          ();

 void              InitInterfaces      ();
 
 HRESULT           AddGraphToRot       (IUnknown *pUnkGraph, DWORD *pdwRegister);
 void              RemoveGraphFromRot  (DWORD pdwRegister);

 IGraphBuilder    *m_pGraphBuilder;
 IMediaControl    *m_pMediaControl;
 IMediaEventEx    *m_pMediaEvent;
 IVideoWindow     *m_pVideoWindow;

 HWND              m_hwnd;

 DWORD             m_dwGraphRegister;

 TVideoState       m_tVideoState;
 char              m_sToken[255];
 char           m_sFileVideo[255];

 bool              m_bLoad;
 bool              m_bFullScreen;
 bool              m_bVideoActivo;
 bool              m_bOk;
};

#endif // _VideDevice_H


Yo para "playear" un video uso PLAY, puedes usar Run, pero te recomiendo que uses Play, puedes pasar del Run.
Esto reproduce mpeg sin problemas (es el formato que yo uso). No está adaptado para videos con sonido, pero vamos, mirate el SDK que viene la interface que necesita la clase para videos con sonido y el fullscreen no esta muy testeado, miratelo. La clase que yo uso es más completa que esa, pero esta es más sencilla de entender. Suerte.

PD: Perdona que no esté tabulado, pero no se ponerlo.  :rolleyes:  :P

Modificado por Mars Attacks: ya está "encodado" ;)

 Hola.

El masters no parece nada bueno, todos dan muchas cosas de diseño y demas. Ademas, 4750 €, solos dos dias a la semana.

El precio es para gente con pasta (o sus padres) y que vivan en Madrid. Yo podría pagarlo (currando y ahorrando claro) pero vivo en Málaga, asi que...
Solo espero que las empresas no se fijen solo en gente de estos "cursos", porque sino... el resto de mortales pobres que no vivimos en Madrid ni de nuestros padres a ver que leches hacemos :).

Ademas, el masters no parece muy bueno.

                                Hola.

Cuando controlas el WM_DESTROY y llamas a la funcion PostQuitMessage(0);, estas enviando el mensaje WM_QUIT. En el bluce principal que usas para controlar los mensajes:

while(1)
{
 if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
 {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
 }
}

no estas controlando nada en si mismo. Tu aplicación se "apagara" al clikera en X, pero nunca se cerrará. Para terminar la aplicación pon esto en el bucle principal:

while(1)
{
 if (PeekMessage(&msg,NULL,0,0,PM_NOREMOVE))
 {
   if (!GetMessage(&msg,NULL,0,0))
     return msg.wParam;
   
   TranslateMessage(&msg);
   DispatchMessage(&msg);
 }
}

o esto otro:

while( GetMessage( &msg, NULL, 0, 0 ) )
{
 TranslateMessage( &msg );
 DispatchMessage( &msg );
}

Mira en la ayuda sobre la funcion GetMessage, pero basicamente si el mensaje pillado es WM_QUIT, devuelve 0, con lo que sale del while y con ello de la aplicación.

En el caso del primer control que te he puesto, si el mensaje pillado es WM_QUIT (que es 0, cumple el !GetMessage(...) ), devuelve el .wparam, que es 0,vaya...

Me explico muy mal, pero mirate la ayuda de la MSDN, que te explica muy bien las funciones esas y no te olvides de controlar WM_DESTROY en el WndProc.

Chao.                                

                                Hola.

Quiero usar videos para hacer algo similiar al transiciones de imagenes que hay en juegos como Myst, Riven y muchos de Cryo. Pero me encuentro con un problemilla, cuando ejecuto el video (run,play,etc..) se me nota un segundito el cambio de la imagen al video y ademas, no es instantaneo. Me gustaria saber si alguien ha hecho algo parecido y ha logrado ejecutar videos dentro del juego en si mismo y hacerlo de la mejor manera posible. (DirectShow me gustaria usar).

Muchas Gracias.                                

                                Hola.

Se puede usar para todo lo que ya han dicho, solo decir que el uso de un lenguaje de script para la programación lógica de juego es algo realmente práctico,comodo y ahorra mucho tiempo. Lua puede ser ejecutado compilado y sin compilar (hablando en plata), si tu eliges ejecutandolo sin compilar, nunca pierdes el tiempo en compilar codigo en c++, ni en lua, ni nada... tan solo cambias el código script y ejecutas el juego.
En mi caso, inclusive puedo cambiar el código script "en tiempo real", es decir, puedo tener mi aplicación en ejecución, activar un evento de un elemento y si está mal, cambiarlo en el código script y volver a ejecutar el evento sin tener que compilar,ejecutar,etc...

En mi web http://usuarios.lycos.es/pnoir , podeis bajaros la demo de un engine para hacer ags que usa lua, dentro del fichero podran ver los .lua y hacerse una idea de los usos que se le puede dar.

Sobre manuales en LUA, yo no he encontrado nada decente e inclusive la ayuda oficial es una mierda y si alguien lo quiere usar en juego, tendrá que averiguar por si mismo como pausar el script y no el juego, algo que es básico en la programación de estos. La mejor forma es visitar los grupos que usan LUA y bajarse los motores con el código fuente que muchos de ellos exponen y aprender por tu cuenta.

Chao.                                

                                Hola.

Creo que no me entendiste bien o puede que sea yo el que lo explicara mal.
Yo no uso el calculo del scale correcto por el siguiente motivo:
Yo cargo una surface que será el fichero (tamaño 800x600, supongamos), a continuación calculo el numero de texturas necesarias tanto para el alto como para el ancho (de la surface), teniendo en cuenta el tamaño de textura que yo expongo, que puede ser el maximo permitido por tu tarjeta o uno forzado por ti (yo lo fuerzo a 256x256 o menores segun el tamaño de la surface). Una vez que ya conozco cuantas texturas en total necesito, proceso a leer desde la surface y copiar en la textura creada, si la textura es de 256x256, leere 256 pixeles de ancho y 256 pixeles de alto de la surface y los copiaré en la textura y asi hasta haber copiado toda la surface en las diferentes texturas. Teniendo al final un array de texturas de 256x256 que contiene la misma surface (la imagen del fichero), pero en texturas potencia de 2 que puede manejar mi tarjeta.
Es posible que si tu cargas una textura de 800x600, la pase al tamaño mas cercano potencia de 2 y como tu tarjeta puede manejar hasta texturas de 1024x1024 (por lo que veo) no tienes problemas, salvo en el escalado, que lo hace incorrecto. Pero esa aplicación no podrá ser ejecutada en tarjetas que usen texturas menores.
Tal como yo lo dibujo, eligiendo 1:1 de escalado, lo hace perfectamente.

Chao.                                

                                Hola.

No se cual es exactamente tu problema, o no lo has explicado bien o yo no lo he entendido como dios manda. Te diré que tengas en cuenta que al dibujar texturas, estan han de ser potencia de 2 (128x128,256x256,etc..), si tu has cargado una textura de 800x600 y te la dibuja bien, es porque tu tarjeta trabaja con texturas de 1024x1024, ten en cuenta esto porque mucha gente no tiene tarjetas que soporten eso y no es lo más optimo para la memoria. Si tu valor del scale tanto en x como en y es 1.0f, la textura no ha de dibujarse más grande de lo normal.
Una cosa si noté yo (al menos), si dibujas en modo ventana con los buffers (ancho y alto) declarados, ya no solo me bajaban los fps, sino que la imagen parecia dibujarse "mas grande", pruebalo, se nota algo. ¿Quizas es eso lo que tu dices?

En cuanto al tamaño de textura, yo recomiendo que te crees una clase (o algo asi), que te gestiona imagenes, si son mayores que un tamaño de textura expuesto por ti o el mayor permitido por la tarjeta (en ejecucion), pues que las partas (dividas) en varias texturas de ese tamaño elegido. Yo suelo trabajar con texturas de 256x256 (o menores), dando un resultado bastante optimo para todo.                                

                                Hola.

Si, tiene aceleración por hardware y demas historias. Y si, son realmente poligonos, solo que te ahorra el tener que crearlos tu, aplicar la textura y dibujarlos (y controlar la camara). Estos poligonos (sprites) dibujados, iran independiente de la camara, por mucho que la muevas, estos no se moveran (a menos que tu se lo indiques mediante el interfaz).
Mirate la ayuda, es muy sencilla.                                

                                Hola.

Sino te quieres complicar mucho la vida (sacando un buen resultado), usa la interfaz IDXSPRITE. Miratelo en la ayuda, no te hará falta usar la camara ni nada y puedes usar las coordenadas de pantalla sin problemas.                                

                                Hola.

Desde mi punto de vista es más complejo hacerte un sistema de scripting propio que usar LUA, cuando este es muy simple de usar en un codigo c/c++.

El uso del script es el que tu le quieras dar, pero está fuertemente orientado a usarlo en la "programación lógica" de algo, ya sea el comportamiento de diversos objetos segun que acciones se realizen y cosas asi. Yo en mi caso lo uso para programar el comportamientos de objetos y personajes en una aventura gráfica. Si haces click con el boton izquierda, derecho, si entras en una habitación, si sales, si usas un objeto con otro,etc... Ese es el tipico uso del script.
Aunque logicamente, también lo podrias usar para programar un juego entero, otorgando funciones de tu engine que se encarguen de iniciar,dibujar,etc... Pero esto último, creo que es mejor hacerlo directamente en codigo c/c++.

Si quieres información de LUA, mas que la oficial (que es un poco caca), leete el "mailing list" y bajate algunos codigos que hay en la seccion de proyectos.
Chao.                                

                                Hola.

Mi duda no es que si alguien ha logrado que CD3DFont (que no es IDXFONT), use todo el alfabeto castellano, osea, a mi no me dibuja los ¿ ni las tildes, ñ, y demas caracteres particulares del castellano. Me gustaria saber como corregir esto y si alguien tiene alguna forma de dibujar texto lo mas rapidamente posible, pues seria interesante.

Muchas gracias.