De CursosGpl

En esta parte del tutorial haremos exactamente lo mismo que en la anterior, pero vamos a estructurarlo todo mejor para seguir trabajando en las siguientes secciones.

Vamos a definir una clase llamada DelBase con la funcionalidad de la parte anterior, la declaración de la clase está en delbase.h y la implementación en delbase.cpp.

El archivo main.cpp lo limpiaremos para que contenga sólo algunas llamadas a esta clase.

código c++

Tabla de contenidos 1 Conceptos 2 Programación 2.1 DelBase 3 Código 3.1 main.cpp 3.2 delbase.h 3.3 delbase.cpp 3.3.1 Constructor y destructor 3.3.2 Gestión de eventos 3.3.3 Inicializa 3.3.4 BuclePrincipal 3.3.5 Finaliza

[editar] Conceptos

A lo largo del tutorial iremos definiendo una clase que sirva de base para futuras aplicaciones que queramos desarrollar. Esto es muy útil porque así en el futuro para crear una aplicación solo tendremos que crear una clase derivada de esta y derivar las funciones que nos interesen hacia la nuestra, dejando a la clase base que se ocupe de lo básico.

[editar] Programación

[editar] DelBase

Definimos algunas variables del motor interesantes, para tenerlas simplemente accesibles desde nuestra clase.

 iObjectRegistry* object_reg;
 csRef<iEngine> engine;
 csRef<iLoader> loader;
 csRef<iGraphics3D> g3d;
 csRef<iKeyboardDriver> kbd;
 csRef<iVirtualClock> vc;

Constructor y destructor

 DelBase (int argc, char const* argv[]);
 ~DelBase ();

Varias funciones de entrada

 bool Inicializa(int argc, char const* argv[]);
 bool BuclePrincipal();
 bool Finaliza();
 bool GestionaEvento (iEvent& ev);
 static bool GestorDeEventos(iEvent& ev);

Nótese que para el caso de la gestión de eventos hemos definido dos funciones, esto es porque a SetupEventHandler le tenemos que pasar una función estática, y desde esta llamamos a la otra.

Por lo demás no tiene ningún secreto, Inicializa para inicializar los componentes básicos, BuclePrincipal para entrar en el bucle principal y Finaliza para cerrar el motor.

[editar] Código

[editar] main.cpp

#include <cssysdef.h>           //debe estar en todos los .cpp
#include "csutil/sysfunc.h"
#include "delbase.h"

// CS_IMPLEMENT_APPLICATION debe estar al principio de uno de los ficheros de código
CS_IMPLEMENT_APPLICATION

// El Puntero Global a la Base
DelBase *delbase;

/*-----------------------------*
* Función Main
* ---------------------------*/

int main(int argc, char const* argv[])
{

       delbase = new DelBase (argc, argv);

       delbase->BuclePrincipal();

       delbase->Finaliza();

       return 0;
}

[editar] delbase.h

#ifndef __DELBASE_H__
#define __DELBASE_H__

#include <stdarg.h>

struct iEngine;
struct iLoader;
struct iGraphics3D;
struct iKeyboardDriver;
struct iSector;
struct iView;
struct iVirtualClock;
struct iObjectRegistry;
struct iEvent;

class DelBase
{
private:
 iObjectRegistry* object_reg;
 csRef<iEngine> engine;
 csRef<iLoader> loader;
 csRef<iGraphics3D> g3d;
 csRef<iKeyboardDriver> kbd;
 csRef<iVirtualClock> vc;
float rotX, rotY;

public:
 DelBase (int argc, char const* argv[]);
 ~DelBase ();
 bool Inicializa(int argc, char const* argv[]);
 bool BuclePrincipal();
 bool Finaliza();
 bool GestionaEvento (iEvent& ev);
 static bool GestorDeEventos(iEvent& ev);
};

#endif // __DELBASE_H__

[editar] delbase.cpp

#include <cssysdef.h>           //debe estar en todos los .cpp
#include <iutil/objreg.h>       //por el puntero a iObjectRegistry
#include <cstool/initapp.h>     //Por el csInitializer
#include <csutil/sysfunc.h>     //por el csDefaultRunLoop
#include <csutil/event.h>       //por csKeyEventHelper & CO
#include <iutil/eventq.h>
#include <csutil/cmdhelp.h>     //por el csCommandLineHelper
#include <iengine/engine.h>     // iEngine
#include <imap/parser.h>        // iLoader
#include <ivideo/graph3d.h>     // iGraphics3d
#include <iutil/csinput.h>      // IKeyboardDriver
#include <iutil/virtclk.h>      // iVirtualClock

#include "delbase.h"

extern DelBase *delbase;

[editar] Constructor y destructor

/*-----------------------------*
* Constructor
* ---------------------------*/
DelBase::DelBase (int argc, char const* argv[])
{
       Inicializa(argc, argv);
}

/*-----------------------------*
* Destructor
* ---------------------------*/
DelBase::~DelBase ()
{
}

[editar] Gestión de eventos

/*-----------------------------*
* Función De Gestión de Eventos
* ---------------------------*/

bool DelBase::GestorDeEventos(iEvent& ev)
{
       return delbase->GestionaEvento(ev);
}

bool DelBase::GestionaEvento (iEvent& ev)
{
   if (ev.Type == csevKeyboard &&
             csKeyEventHelper::GetEventType (&ev) == csKeyEventTypeDown &&
             csKeyEventHelper::GetCookedCode (&ev) == CSKEY_ESC)
   {
         csRef<iEventQueue> q (CS_QUERY_REGISTRY (object_reg, iEventQueue));
         if (q)
            q->GetEventOutlet()->Broadcast (cscmdQuit);
         return true;
   }
   return false;
}

[editar] Inicializa

/*-----------------------------*
* Función de Inicialización
* ---------------------------*/
bool DelBase::Inicializa(int argc, char const* argv[])
{

       int error = 0;

       //Crea el Registro de Objetos, el Gestor de Plugins, la cola de Eventos, 
       //el reloj Virtual, el parseador de linea de Comandos, el gestor de 
       //configuracion, los drivers de input
       object_reg = csInitializer::CreateEnvironment(argc,argv);

       //Configura el Gestor de Configuracion indicandole el fichero de configuración.
       error = csInitializer::SetupConfigManager(object_reg, "/config/walktest.cfg");

       // Carga los plugins
       error = csInitializer::RequestPlugins (object_reg,CS_REQUEST_END);

       // Chequea la linea de comandos por se pide ayuda
       if (csCommandLineHelper::CheckHelp (object_reg))
       {
           csCommandLineHelper::Help (object_reg);
           return false;
       }

       //Inicia el sistema principal
       error = csInitializer::OpenApplication (object_reg);

       // Define el gestor de eventos
       error = csInitializer::SetupEventHandler(object_reg, GestorDeEventos);

       // Ahora obtenemos punteros a todos los plugins principales
       vc = CS_QUERY_REGISTRY (object_reg, iVirtualClock);     // El Reloj Virtual
       engine = CS_QUERY_REGISTRY (object_reg, iEngine);       // El Motor
       loader = CS_QUERY_REGISTRY (object_reg, iLoader);       // El Parseador de Mapas
       g3d = CS_QUERY_REGISTRY (object_reg, iGraphics3D);      // El Renderizador 3D
       kbd = CS_QUERY_REGISTRY (object_reg, iKeyboardDriver);  // El Teclado
       return true;
}

[editar] BuclePrincipal

/*-----------------------------*
* Función que inicia el bucle principal del programa
* ---------------------------*/

bool DelBase::BuclePrincipal()
{
       // El loop principal
       csDefaultRunLoop (object_reg);
}

[editar] Finaliza

/*-----------------------------*
* Función que libera los recursos del programa
*---------------------------*/

bool DelBase::Finaliza()
{
       // Cuando termina el loop limpiamos la aplicación
       csInitializer::DestroyApplication (object_reg);
       return true;
}