| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
To start with we first take the code of tutorial one
and remove the code that creates geometry. In addition we add
a new LoadMap() function. This results in the following
for `simple.h':
#ifndef __SIMPLE_H__
#define __SIMPLE_H__
#include <stdarg.h>
struct iEngine;
struct iLoader;
struct iGraphics3D;
struct iKeyboardDriver;
struct iVirtualClock;
struct iObjectRegistry;
struct iEvent;
struct iSector;
struct iView;
class Simple
{
private:
iObjectRegistry* object_reg;
iEngine* engine;
iLoader* loader;
iGraphics3D* g3d;
iKeyboardDriver* kbd;
iVirtualClock* vc;
iSector* room;
iView* view;
static bool SimpleEventHandler (iEvent& ev);
bool HandleEvent (iEvent& ev);
void SetupFrame ();
void FinishFrame ();
bool LoadMap ();
public:
Simple ();
~Simple ();
bool Initialize (int argc, const char* const argv[]);
void Start ();
};
#endif // __SIMPLE_H__
|
Similarly for `simple.cpp':
#include "cssysdef.h"
#include "cssys/sysfunc.h"
#include "iutil/vfs.h"
#include "csutil/cscolor.h"
#include "cstool/csview.h"
#include "cstool/initapp.h"
#include "simpmap.h"
#include "iutil/eventq.h"
#include "iutil/event.h"
#include "iutil/objreg.h"
#include "iutil/csinput.h"
#include "iutil/virtclk.h"
#include "iengine/sector.h"
#include "iengine/engine.h"
#include "iengine/camera.h"
#include "iengine/light.h"
#include "iengine/statlght.h"
#include "iengine/texture.h"
#include "iengine/mesh.h"
#include "iengine/movable.h"
#include "iengine/material.h"
#include "imesh/thing/polygon.h"
#include "imesh/thing/thing.h"
#include "imesh/object.h"
#include "ivideo/graph3d.h"
#include "ivideo/graph2d.h"
#include "ivideo/txtmgr.h"
#include "ivideo/texture.h"
#include "ivideo/material.h"
#include "ivideo/fontserv.h"
#include "igraphic/imageio.h"
#include "imap/parser.h"
#include "ivaria/reporter.h"
#include "ivaria/stdrep.h"
#include "csutil/cmdhelp.h"
CS_IMPLEMENT_APPLICATION
// The global pointer to simple
Simple *simple;
Simple::Simple ()
{
engine = NULL;
loader = NULL;
g3d = NULL;
kbd = NULL;
vc = NULL;
view = NULL;
}
Simple::~Simple ()
{
if (vc) vc->DecRef ();
if (engine) engine->DecRef ();
if (loader) loader->DecRef();
if (g3d) g3d->DecRef ();
if (kbd) kbd->DecRef ();
if (view) view->DecRef ();
csInitializer::DestroyApplication (object_reg);
}
void Simple::SetupFrame ()
{
// First get elapsed time from the virtual clock.
csTicks elapsed_time = vc->GetElapsedTicks ();
// Now rotate the camera according to keyboard state
float speed = (elapsed_time / 1000.0) * (0.03 * 20);
iCamera* c = view->GetCamera();
if (kbd->GetKeyState (CSKEY_RIGHT))
c->GetTransform ().RotateThis (CS_VEC_ROT_RIGHT, speed);
if (kbd->GetKeyState (CSKEY_LEFT))
c->GetTransform ().RotateThis (CS_VEC_ROT_LEFT, speed);
if (kbd->GetKeyState (CSKEY_PGUP))
c->GetTransform ().RotateThis (CS_VEC_TILT_UP, speed);
if (kbd->GetKeyState (CSKEY_PGDN))
c->GetTransform ().RotateThis (CS_VEC_TILT_DOWN, speed);
if (kbd->GetKeyState (CSKEY_UP))
c->Move (CS_VEC_FORWARD * 4 * speed);
if (kbd->GetKeyState (CSKEY_DOWN))
c->Move (CS_VEC_BACKWARD * 4 * speed);
// Tell 3D driver we're going to display 3D things.
if (!g3d->BeginDraw(
engine->GetBeginDrawFlags() | CSDRAW_3DGRAPHICS))
return;
// Tell the camera to render into the frame buffer.
view->Draw ();
}
void Simple::FinishFrame ()
{
g3d->FinishDraw ();
g3d->Print (NULL);
}
bool Simple::HandleEvent (iEvent& ev)
{
if (ev.Type == csevBroadcast && ev.Command.Code == cscmdProcess)
{
simple->SetupFrame ();
return true;
}
else if (ev.Type == csevBroadcast &&
ev.Command.Code == cscmdFinalProcess)
{
simple->FinishFrame ();
return true;
}
else if (ev.Type == csevKeyDown && ev.Key.Code == CSKEY_ESC)
{
iEventQueue* q = CS_QUERY_REGISTRY (object_reg, iEventQueue);
if (q)
{
q->GetEventOutlet()->Broadcast (cscmdQuit);
q->DecRef ();
}
return true;
}
return false;
}
bool Simple::SimpleEventHandler (iEvent& ev)
{
return simple->HandleEvent (ev);
}
bool Simple::Initialize (int argc, const char* const argv[])
{
object_reg = csInitializer::CreateEnvironment (argc, argv);
if (!object_reg) return false;
if (!csInitializer::RequestPlugins (object_reg,
CS_REQUEST_VFS,
CS_REQUEST_SOFTWARE3D,
CS_REQUEST_ENGINE,
CS_REQUEST_FONTSERVER,
CS_REQUEST_IMAGELOADER,
CS_REQUEST_LEVELLOADER,
CS_REQUEST_REPORTER,
CS_REQUEST_REPORTERLISTENER,
CS_REQUEST_END))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.simple",
"Can't initialize plugins!");
return false;
}
if (!csInitializer::SetupEventHandler(
object_reg, SimpleEventHandler))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.simple",
"Can't initialize event handler!");
return false;
}
// Check for commandline help.
if (csCommandLineHelper::CheckHelp (object_reg))
{
csCommandLineHelper::Help (object_reg);
return false;
}
// The virtual clock.
vc = CS_QUERY_REGISTRY (object_reg, iVirtualClock);
if (!vc)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.simple",
"Can't find the virtual clock!");
return false;
}
// Find the pointer to engine plugin
engine = CS_QUERY_REGISTRY (object_reg, iEngine);
if (!engine)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.simple",
"No iEngine plugin!");
return false;
}
loader = CS_QUERY_REGISTRY (object_reg, iLoader);
if (!loader)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.simple",
"No iLoader plugin!");
return false;
}
g3d = CS_QUERY_REGISTRY (object_reg, iGraphics3D);
if (!g3d)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.simple",
"No iGraphics3D plugin!");
return false;
}
kbd = CS_QUERY_REGISTRY (object_reg, iKeyboardDriver);
if (!kbd)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.simple",
"No iKeyboardDriver plugin!");
return false;
}
// Open the main system. This will open all the previously
// loaded plug-ins.
if (!csInitializer::OpenApplication (object_reg))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.simple",
"Error opening system!");
return false;
}
view = new csView (engine, g3d);
view->GetCamera ()->SetSector (room);
view->GetCamera ()->GetTransform ().SetOrigin (csVector3 (0, 5, -3));
iGraphics2D* g2d = g3d->GetDriver2D ();
view->SetRectangle (0, 0, g2d->GetWidth (), g2d->GetHeight ());
iTextureManager* txtmgr = g3d->GetTextureManager ();
txtmgr->SetPalette ();
return true;
}
void Simple::Start ()
{
csDefaultRunLoop (object_reg);
}
/*---------------*
* Main function
*---------------*/
int main (int argc, char* argv[])
{
simple = new Simple ();
if (simple->Initialize (argc, argv))
simple->Start ();
delete simple;
return 0;
}
|
One important note in the code above: we removed the following line:
engine->SetLightingCacheMode (0); |
That's because when we are loading from map file we actually want the lighting information to be read from the cache (if present). That's because relighting a map can be a time-consuming process.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |