|
Este es el quito y ultimo tutorial sobre DirectX.
Hemos cubierto las tecnologías principales para el
desarrollo de videojuegos sobre la plataforma directx que son:
Direct3D
XACT
DirectInput
La idea es que poco a poco veamos más a fondo cada una de
estas tecnologías.
Cabe señalar que estas tecnologías encierran algunas otras,
pero ya verán en su momento.
Otra vez partimos del supuesto de que han seguido los 4
tutoriales, así que todo el código que se genero en ellos aquí no se explicara
aunque se entregara el proyecto final [de todos los tutoriales] y en el, esta código
esta bien documentado.
DirectInput nos permite interactuar con el usuario, específicamente,
saber que quiere que hagamos, mediante el teclado o el mouse.
Así que comenzamos agregando dinput8.lib a las dependencias
de nuestro proyecto, ya debemos de tener todas las anteriores, mas las que son
heredadas por default.
Después agregar una macro y una librería.
#define _WIN32_DCOM
#define null NULL
#include <d3d9.h>
#include <d3dx9.h>
#include <d3dx9core.h>
#include <xact.h>
La macro solo dicta la versión de DirectInput que usaremos,
en este caso será la 8.
#define
DIRECTINPUT_VERSION 0x0800
Después agregamos la librería dinput.h, la cual contiene
todas las funciones, interfaces, clases, tipos y macros que necesitaremos.
#include
<dinput.h>
struct Objeto
{
IDirect3DTexture9* Textura;
D3DXVECTOR3 Posicion;
};
struct ObjetoBola : public Objeto
{
int VelX, VelY;
};
struct AudioSt
{
IXACTEngine* pEngine;
IXACTWaveBank* pWaveBank;
IXACTSoundBank* pSoundBank;
unsigned short iSonido;
void* pbWaveBank;
void* pbSoundBank;
};
IDirect3D9* D3D9 = null;
IDirect3DDevice9* D3D9Dispositivo = null;
ID3DXSprite* Sprite;
Objeto* PaletaJugador;
Objeto* PaletaCPU;
ObjetoBola* Bola;
IXACTEngine* pXACT3Engine;
AudioSt audio;
A continuación debemos de crear nuestras variables que nos ayudaran
a manejar DirectInput [ej. obtener información del teclado.
IDirectInput8*
DirectInput = NULL;
IDirectInputDevice8*
DispositivoDITeclado = NULL;
Ahora, al resto del código que se encarga comenzar todos los
motores, debemos agregarle las instrucciones que se encargaran de inicializar
DirectInput, así que buscamos la siguiente linea: audio.iSonido =
audio.pSoundBank->GetCueIndex("sonido") y debajo va el nuevo código.
Recuerda que el código en verde no será explicado por que ya
lo tienes.
void Liberar();
long Iniciar(HWND hWindow)
{
if (null == (D3D9 = Direct3DCreate9(D3D_SDK_VERSION)))
return E_FAIL;
D3DDISPLAYMODE ModosDisplay = {0};
D3D9->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,
&ModosDisplay);
D3DPRESENT_PARAMETERS pPresentacion = {0};
pPresentacion.Windowed = true;
pPresentacion.SwapEffect = D3DSWAPEFFECT_DISCARD;
pPresentacion.BackBufferFormat = ModosDisplay.Format;
pPresentacion.EnableAutoDepthStencil = true;
pPresentacion.AutoDepthStencilFormat = D3DFMT_D16;
if (FAILED(D3D9->CreateDevice(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
hWindow,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&pPresentacion,
&D3D9Dispositivo)))
{
return E_FAIL;
}
::D3D9Dispositivo->SetRenderState(D3DRS_ALPHABLENDENABLE,
true);
if (FAILED(D3DXCreateSprite(::D3D9Dispositivo,
&Sprite)))
return E_FAIL;
::PaletaJugador = new Objeto();
::PaletaJugador->Posicion = D3DXVECTOR3(5.0f, 200.0f,
0.0f);
if (FAILED(D3DXCreateTextureFromFile(::D3D9Dispositivo, L"tJugador.jpg",
&PaletaJugador->Textura)))
return E_FAIL;
::PaletaCPU = new Objeto();
::PaletaCPU->Posicion = D3DXVECTOR3(758.0f, 200.0f,
0.0f);
if (FAILED(D3DXCreateTextureFromFile(::D3D9Dispositivo, L"tCPU.jpg",
&PaletaCPU->Textura)))
return E_FAIL;
::Bola = new ObjetoBola();
::Bola->Posicion = D3DXVECTOR3(350.0f, 250.0f, 0.0f);
::Bola->VelX = ::Bola->VelY = 2;
if (FAILED(D3DXCreateTextureFromFile(::D3D9Dispositivo, L"tBola.jpg",
&Bola->Textura)))
return E_FAIL;
::D3D9Dispositivo->SetSamplerState(0, D3DSAMP_MINFILTER,
D3DTEXF_LINEAR);
long hr;
void* hFile;
unsigned long dwFileSize;
unsigned long dwBytesRead;
void* hMapFile;
ZeroMemory(&audio, sizeof(AudioSt));
hr = CoInitializeEx(null, COINIT_MULTITHREADED);
if(SUCCEEDED(hr))
hr = XACTCreateEngine(0, &audio.pEngine);
if(FAILED(hr) || audio.pEngine == null)
return E_FAIL;
XACT_RUNTIME_PARAMETERS xrParams = {0};
xrParams.lookAheadTime = XACT_ENGINE_LOOKAHEAD_DEFAULT;
hr = audio.pEngine->Initialize(&xrParams);
if(FAILED(hr))
return hr;
hFile = CreateFile( L"audioWB.xwb",
GENERIC_READ, FILE_SHARE_READ, null, OPEN_EXISTING, 0, null );
if( hFile != INVALID_HANDLE_VALUE )
{
dwFileSize = GetFileSize( hFile, null );
if(dwFileSize != -1)
{
hMapFile = CreateFileMapping( hFile, null,
PAGE_READONLY, 0, dwFileSize, null );
if(hMapFile)
{
audio.pbWaveBank = MapViewOfFile(
hMapFile, FILE_MAP_READ, 0, 0, 0 );
if(audio.pbWaveBank)
{
hr =
audio.pEngine->CreateInMemoryWaveBank( audio.pbWaveBank, dwFileSize, 0, 0,
&audio.pWaveBank );
}
CloseHandle(hMapFile);
}
}
CloseHandle(hFile);
}
if(FAILED(hr))
return E_FAIL;
hr = E_FAIL;
hFile = CreateFile( L"audioSB.xsb",
GENERIC_READ, FILE_SHARE_READ, null, OPEN_EXISTING, 0, null );
if( hFile != INVALID_HANDLE_VALUE )
{
dwFileSize = GetFileSize( hFile, null );
if( dwFileSize != -1 )
{
audio.pbSoundBank = new BYTE[dwFileSize];
if( audio.pbSoundBank )
{
if( 0 != ReadFile( hFile,
audio.pbSoundBank, dwFileSize, &dwBytesRead, null ) )
{
hr =
audio.pEngine->CreateSoundBank(audio.pbSoundBank, dwFileSize, 0, 0,
&audio.pSoundBank);
}
}
}
CloseHandle( hFile );
}
if( FAILED( hr ) )
return E_FAIL;
audio.iSonido = audio.pSoundBank->GetCueIndex("sonido");
Lo primero es crear una instancia de DirectInput ayudándonos
con el método DirectInput8Create al cual se le pasan algunos los parámetros
de creación, como la versión de DirectInput, una identificador de la interfaz
que usaremos, en este caso interfaces de DirectInput8, también se le pasa un
puntero [de hecho, puntero a puntero) con nuestra variable para que llene los
campos del objeto.
if (FAILED(DirectInput8Create(GetModuleHandle(null),
DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&DirectInput,
NULL)))
return E_FAIL;
Enseguida creamos el dispositivo al que estará vinculado
DirectInput, en este caso será con el teclado, como lo podemos ver en los parámetros
que se le pasan a la función.
if
(FAILED(DirectInput->CreateDevice(GUID_SysKeyboard,
&::DispositivoDITeclado, NULL)))
return E_FAIL;
Una vez que hemos creado el dispositivo debemos darle el
formato de los datos que obtendremos, en este caso seran el formato por default
del teclado, osea que ya que lo vinculamos con un dispositivo debemos decirle
como nos mandara los datos.
if (FAILED(DispositivoDITeclado->SetDataFormat(&c_dfDIKeyboard)))
return E_FAIL;
Por ultimo le damos el nivel de operatividad del dispositivo
con el entorno, es decir como interactúa con Windows, los parámetros que le
pasamos es la ventana al que estará vinculado el dispositivo, después le
decimos que será de tipo Exlusive, ósea que la información del teclado que
entre cuando la ventana este activa solo será vista por esta venta y por nadie
mas, así que si seleccionas esta y durante la ejecución presionas Alt + F4
o Alt + Tab, no se ejecutaran los comandos ya que la entrada es
exclusiva y no hace eco en el sistema, esta opción de exclusividad se combina
mediante un OR con el tipo Foreground, ósea que la pantalla solo puede recibir información
cuando es la ventana activa y no es alguna de las que se encuentra detrás de la
ventana activa.
if
(FAILED(DispositivoDITeclado->SetCooperativeLevel(hWindow, DISCL_EXCLUSIVE |
DISCL_FOREGROUND)))
return E_FAIL;
Todo lo anterior lleva un manejo de errores para salir de la
aplicación en caso de algún fallo.
return S_OK;
}
Dentro del método update debemos a agregar el código para
manejar la información sobre que tecla esta presionando el jugador.
void Update()
{
::Bola->Posicion.x += ::Bola->VelX;
::Bola->Posicion.y += ::Bola->VelY;
//IA
if (::PaletaCPU->Posicion.y + 64 <
Bola->Posicion. y)
PaletaCPU->Posicion.y += 3.0f;
else if (::PaletaCPU->Posicion.y + 64 >
Bola->Posicion. y)
PaletaCPU->Posicion.y -= 3.0f;
//Colisiones
if (::Bola->Posicion.y <= 0.0f)
::Bola->VelY *= -1;
else if (::Bola->Posicion.y + 32.0f + 24.0f >=
600.0f)
Bola->VelY *= -1;
if (::PaletaJugador->Posicion.y <= 0.0f)
::PaletaJugador->Posicion.y = 0.0f;
if (::PaletaJugador->Posicion.y + 160.0f >= 600.0f)
::PaletaJugador->Posicion.y = 440.0f;
if (::PaletaCPU->Posicion.y <= 0.0f)
::PaletaCPU->Posicion.y = 0.0f;
if (::PaletaCPU->Posicion.y + 160.0f >= 600.0f)
::PaletaCPU->Posicion.y = 440.0f;
if (Bola->Posicion.x <
::PaletaJugador->Posicion.x + 32)
{
if (Bola->Posicion.y + 16.0f < ::PaletaJugador->Posicion.y
||
Bola->Posicion.y + 16.0f >
::PaletaJugador->Posicion.y + 128.0f)
{
MessageBox(null, L"Has perdido", L"Has
perdido", MB_OK);
::Bola->Posicion = D3DXVECTOR3(350.0f,
250.0f, 0.0f);
::Bola->VelX *= -1; // GAME OVER
}
else
{
audio.pSoundBank->Play(audio.iSonido, 0, 0,
null );
Bola->VelX *= -1;
}
}
if (Bola->Posicion.x + 33.0f >
::PaletaCPU->Posicion.x)
{
Bola->VelX *= -1;
audio.pSoundBank->Play(audio.iSonido, 0, 0, null
);
}
audio.pEngine->DoWork();
Primero creamos un arreglo con capacidad de 256 elementos y
lo ponemos todo en ceros.
unsigned char
Teclas[256];
ZeroMemory(&Teclas,
sizeof(Teclas));
Obtenemos el dispositivo, es decir tomamos una muestra de
este y enseguida obtenemos el estado del dispositivo al momento de tomar la
muestra.
DispositivoDITeclado->Acquire();
DispositivoDITeclado->GetDeviceState(sizeof(Teclas), &Teclas);
Y verificamos que teclas se presionaron, si fue DIK_UP, ósea
flecha->arriba, decrementamos la posición de la paleta del jugador.
if (Teclas[DIK_UP] & 0x80)
{
::PaletaJugador->Posicion.y
-= 3.0f;
}
Después checamos si se presiono DIK_DOWN [flecha-abajo] y si
fue presionada incrementamos la posición de la paleta del jugador en 3 pixeles.
else if
(Teclas[DIK_DOWN] & 0x80)
{
::PaletaJugador->Posicion.y
+= 3.0f;
}
Solo nos falta el código para liberar los recursos usados
por DirectInput, que esta mas abajo, en el método Liberar.
}
void Renderear()
{
if (::D3D9Dispositivo == null)
return;
::D3D9Dispositivo->Clear(0, null, D3DCLEAR_TARGET,
0xFFFFFFFF, 1.0f, 0);
if (SUCCEEDED(::D3D9Dispositivo->BeginScene()))
{
if
(SUCCEEDED(::Sprite->Begin(D3DXSPRITE_ALPHABLEND)))
{
::Sprite->Draw(::PaletaJugador->Textura,
null, null, &::PaletaJugador->Posicion, 0xFFFFFFFF);
::Sprite->Draw(::PaletaCPU->Textura,
null, null, &::PaletaCPU->Posicion, 0xFFFFFFFF);
::Sprite->Draw(::Bola->Textura, null,
null, &::Bola->Posicion, 0xFFFFFFFF);
::Sprite->End();
}
::D3D9Dispositivo->EndScene();
}
::D3D9Dispositivo->Present(null, null, null, null);
}
void Liberar()
{
if(audio.pEngine)
{
audio.pEngine->ShutDown();
audio.pEngine->Release();
}
if(audio.pbSoundBank)
delete[] audio.pbSoundBank;
audio.pbSoundBank = null;
if(audio.pbWaveBank)
UnmapViewOfFile(audio.pbWaveBank);
audio.pbWaveBank = null;
CoUninitialize();
Antes de cualquier cosa debemos de des-ligarnos del
dispositivo.
if (::DispositivoDITeclado)
::DispositivoDITeclado->Unacquire();
Los siguientes pasos son básicos, verificamos si existe el
puntero, si es así, liberamos los recursos usados y finalmente hacemos nuestro
puntero inválido.
if (::DispositivoDITeclado)
::DispositivoDITeclado->Release();
::DispositivoDITeclado
= null;
Ya lo hicimos con el dispositivo ligado a DirectInput, ahora
debemos de hacerlo con el mismo DirectInput.
if (::DirectInput)
::DirectInput->Release();
::DirectInput
= null;
if (::Sprite != null)
::Sprite->Release();
if (::PaletaCPU->Textura != null)
::PaletaCPU->Textura->Release();
if (::PaletaJugador->Textura != null)
::PaletaJugador->Textura->Release();
if (::Bola->Textura != null)
::Bola->Textura->Release();
if(::D3D9Dispositivo != null)
::D3D9Dispositivo->Release();
if(::D3D9 != null)
::D3D9->Release();
}
Para terminar debemos borrar el siguiente código de la función
de procedimientos de la ventana.
case WM_KEYDOWN:
{
switch(wParametros)
{
case VK_UP:
::PaletaJugador->Posicion.y -= 4.0f;
break;
case VK_DOWN:
::PaletaJugador->Posicion.y += 4.0f;
break;
case VK_ESCAPE:
{
Liberar();
PostQuitMessage(0);
return 0;
}
}
break;
}
Ya que en caso de que exista alguna tecla presionada,
DirectInput es el que se encargara de manejar este evento y ya no este método.
Quedara como a continuación:
__w64 long __stdcall Procedimientos(HWND hWindow,
unsigned int
Mensaje,
__w64 unsigned
int wParametros,
__w64 long
lParametros)
{
switch(Mensaje)
{
case WM_DESTROY:
{
Liberar();
PostQuitMessage(0);
return 0;
}
}
return DefWindowProc(hWindow, Mensaje, wParametros,
lParametros);
}
int __stdcall WinMain(HINSTANCE hInst, HINSTANCE, char*, int)
{
WNDCLASSEX ClaseWnd = {0};
ClaseWnd.cbSize = sizeof(ClaseWnd);
ClaseWnd.lpszClassName = L"PrimerF5";
ClaseWnd.lpfnWndProc = Procedimientos;
ClaseWnd.style = CS_CLASSDC;
ClaseWnd.hInstance = GetModuleHandle(null);
RegisterClassEx(&ClaseWnd);
HWND hWindow = CreateWindow(L"PrimerF5",
L"PrimerF5",
WS_SYSMENU,
10,
10,
800,
600,
null,
null,
ClaseWnd.hInstance,
null);
if (SUCCEEDED(::Iniciar(hWindow)))
{
ShowWindow(hWindow, SW_SHOWDEFAULT);
UpdateWindow(hWindow);
MSG Mensaje;
ZeroMemory(&Mensaje, sizeof(Mensaje));
while (Mensaje.message != WM_QUIT)
{
if (PeekMessage(&Mensaje, null, 0U, 0U,
PM_REMOVE))
{
TranslateMessage(&Mensaje);
DispatchMessage(&Mensaje);
}
else
{
::Update();
::Renderear();
}
}
}
UnregisterClass(L"PrimerF5", ClaseWnd.hInstance
);
return 0;
}
|
.jpg)
