#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include <stdlib.h>
#include <Irrlicht/irrlicht.h>
#include <time.h>
struct timespec my_time_spec;
/* ************************************************************************ */
/* our framerate monitor memory */
#define FRAMES_MAX 4096
unsigned int frames[FRAMES_MAX] = { 0 };
/* two pointers into the ringbuffer frames[] */
unsigned int frames_start = 0;
unsigned int frames_end = 0;
unsigned int last = 0;
double max_fps = 0;
double min_fps = 20000000;
unsigned int max_frame_time = 0;
unsigned int min_frame_time = 20000;
/* wake_time: the time we waited to long in this frame, and thus must be awake
(e.g. not sleep) the next frame to correct for this */
unsigned int wake_time = 0;
/* ************************************************************************ */
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace gui;
// this clashes with XSUBPP
//using namespace io;
IrrlichtDevice* device;
IVideoDriver* driver;
ISceneManager* smgr;
IGUIEnvironment* guienv;
ITimer* timer;
irr::io::IFileSystem* filesystem;
/* ************************************************************************ */
/*
To get events like mouse and keyboard input, or GUI events like
"the OK button has been clicked", we need an object wich is derived from the
IEventReceiver object. There is only one method to override: OnEvent.
This method will be called by the engine when an event happened.
*/
int disable_logging = 0;
// for xsubpp not to stumble
#define Cclass class
Cclass MyEventReceiver : public IEventReceiver
{
public: virtual bool OnEvent(SEvent event)
{
if (event.EventType == EET_LOG_TEXT_EVENT && disable_logging)
{
// consume this event and thus prevent log output
return true;
}
printf ("received event\n");
// should call a perl callback here and store the event
//return true;
return false;
}
};
MyEventReceiver receiver;
int _irrlicht_init_engine (
unsigned int rtype,
unsigned int w, unsigned int h, unsigned int d, unsigned int fs,
unsigned int ll)
{
ILogger* logger;
disable_logging = ll;
device =
createDevice(
(EDriverType)rtype, // renderer
dimension2d<s32>(w, h), // size
d, // bit depth
fs, // fullscreen?
false, // stencilbuffer
&receiver); // event receiver
if (NULL == device) { return 0; } // error
logger = device->getLogger();
logger->setLogLevel(ELL_ERROR);
driver = device->getVideoDriver();
smgr = device->getSceneManager();
guienv = device->getGUIEnvironment();
timer = device->getTimer();
filesystem = device->getFileSystem();
if (NULL == driver)
{
printf ("Could not get VideoDriver from Irrlicht device.\n");
return 0; // error
}
if (NULL == smgr)
{
printf ("Could not get SceneManager from the Irrlicht device.\n");
return 0; // error
}
if (NULL == guienv)
{
printf ("Could not get GUIEnvironment from the Irrlicht device.\n");
return 0; // error
}
if (NULL == filesystem)
{
printf ("Could not get FileSystem from the Irrlicht device.\n");
return 0; // error
}
// DEBUG XXX TODO
// add a static string
// guienv->addStaticText(L"Hello Perl! This is the Irrlicht Software engine!",
// rect<int>(10,10,200,30), true);
// add a camera
// smgr->addCameraSceneNode(0, vector3df(0,10,-40), vector3df(0,0,0));
return 1;
}
/* ************************************************************************ */
/*
Games::Irrlicht XS code (C) by Tels <http://bloodgate.com/perl/>
*/
MODULE = Games::Irrlicht PACKAGE = Games::Irrlicht
PROTOTYPES: DISABLE
#############################################################################
int
_init_engine(SV* classname, unsigned int rtype, unsigned int w, unsigned int h, unsigned int d, unsigned int fs, unsigned int ll)
CODE:
RETVAL = _irrlicht_init_engine(rtype,w,h,d,fs,ll);
OUTPUT:
RETVAL
void
_done_engine(SV* classname)
CODE:
device->drop();
#############################################################################
SV*
_run_engine(SV* classname)
PREINIT:
int rc;
CODE:
rc = device->run(); /* true when we still run */
/* Anything can be drawn between a beginScene() and an endScene() call.
The beginScene clears the screen with a color and also the depth buffer
if wanted. Then we let the Scene Manager and the GUI Environment draw
their content. With the endScene() call everything is presented on the
screen.
*/
driver->beginScene(true, true, SColor(0,100,100,100));
smgr->drawAll();
guienv->drawAll();
driver->endScene();
RETVAL = newSViv( rc ); /* return result */
OUTPUT:
RETVAL
#############################################################################
SV*
_get_ticks(SV* classname)
PREINIT:
int rc;
CODE:
rc = timer->getTime();
RETVAL = newSVuv( rc );
OUTPUT:
RETVAL
##############################################################################
# _delay() - if the time between last and this frame was too short, delay the
# app a bit. Also returns current time corrected by base_ticks.
SV*
_delay(min_time,base_ticks)
unsigned int min_time
unsigned int base_ticks
CODE:
/*
min_time - ms to spent between frames minimum
wake_time - ms we were late in last frame, so we slee this time shorter
last - time in ticks of last frame
*/
/* caluclate how long we should sleep */
unsigned int now, time, frame_cnt, diff;
int to_sleep;
double framerate;
//if (last == 0)
// {
// last = timer->getTime() - base_ticks;
// }
now = timer->getTime() - base_ticks;
if (min_time > 0)
{
to_sleep = min_time - wake_time - (now - last) - 1;
# sometimes Delay() does not seem to work, so retry until it we sleeped
# long enough
while (to_sleep > 2)
{
// printf ("to_sleep: %i\n", to_sleep);
my_time_spec.tv_sec = 0;
my_time_spec.tv_nsec = to_sleep * 1000;
nanosleep( &my_time_spec, NULL); // struct timespec *rem);
now = timer->getTime() - base_ticks;
// printf ("now: %i\n", now);
to_sleep = min_time - (now - last);
}
wake_time = 0;
if (now - last > min_time)
{
wake_time = now - last - min_time;
}
}
// printf (" now: %i\n", now);
diff = now - last;
ST(0) = newSViv(now);
ST(1) = newSViv(diff);
last = now;
/* ******************************************************************** */
/* monitor the framerate */
/* add current value to ringbuffer */
frames[frames_end] = now; frames_end++;
if (frames_end >= FRAMES_MAX)
{
frames_end = 0;
}
/* buffer full? if so, remove oldest entry */
if (frames_end == frames_start)
{
frames_start++;
if (frames_start >= FRAMES_MAX)
{
frames_start = 0;
}
}
/* keep only values in the buffer, that are at most 1000 ms old */
while (now - frames[frames_start] > 1000)
{
/* remove value from start */
frames_start++;
if (frames_start >= FRAMES_MAX)
{
frames_start = 0;
}
if (frames_start == frames_end)
{
/* buffer empty */
break;
}
}
framerate = 0;
if (frames_start != frames_end)
{
/* got some frames, so calc. current frame rate */
time = now - frames[frames_start] + 1;
/* printf ("time %i start %i (%i) end %i (%i) ",
time,frames_start,frames[frames_start],frames_end,now); */
if (frames_start < frames_end)
{
frame_cnt = frames_end - frames_start + 1;
}
else
{
frame_cnt = 1024 - (frames_start - frames_end - 1);
}
/* does it make sense to calc. fps? */
if (frame_cnt > 20)
{
framerate = (double)(10000 * frame_cnt / time) / 10;
if (min_fps > framerate) { min_fps = framerate; }
if (max_fps < framerate) { max_fps = framerate; }
if (diff > max_frame_time) { max_frame_time = diff; }
if (diff < min_frame_time && diff > 0) { min_frame_time = diff; }
}
/* printf (" frames %i time %i fps %f\n",frame_cnt,time,framerate);
printf (" min %f max %f\n",min_fps,max_fps); */
}
ST(2) = newSVnv(framerate);
XSRETURN(3);
##############################################################################
SV*
min_fps(SV* classname)
CODE:
RETVAL = newSVnv(min_fps);
OUTPUT:
RETVAL
SV*
max_fps(SV* classname)
CODE:
RETVAL = newSVnv(max_fps);
OUTPUT:
RETVAL
SV*
max_frame_time(SV* classname)
CODE:
RETVAL = newSViv(max_frame_time);
OUTPUT:
RETVAL
SV*
min_frame_time(SV* classname)
CODE:
RETVAL = newSViv(min_frame_time);
OUTPUT:
RETVAL
##############################################################################
# driver interface
double
getPrimitiveCountDrawn(SV* classname)
CODE:
RETVAL = driver->getPrimitiveCountDrawn();
OUTPUT:
RETVAL
# getTexture
double
getTexture(SV* classname)
CODE:
RETVAL = driver->getPrimitiveCountDrawn();
OUTPUT:
RETVAL
##############################################################################
# device interface
#virtual ~IrrlichtDevice ()
#virtual bool run ()=0
#virtual video::IVideoDriver * getVideoDriver ()=0
#virtual io::IFileSystem * getFileSystem ()=0
#virtual gui::IGUIEnvironment * getGUIEnvironment ()=0
#virtual scene::ISceneManager * getSceneManager ()=0
#virtual gui::ICursorControl * getCursorControl ()=0
#virtual ILogger * getLogger ()=0
#virtual video::IVideoModeList * getVideoModeList ()=0
#virtual IOSOperator * getOSOperator ()=0
#virtual ITimer * getTimer ()=0
#virtual void setWindowCaption (const wchar_t *text)=0
#virtual bool isWindowActive ()=0
#virtual void closeDevice ()=0
#virtual const wchar_t * getVersion ()=0
#virtual void setEventReceiver (IEventReceiver *receiver)=0
void
setVisible(SV* classname, int vis)
CODE:
device->getCursorControl()->setVisible(vis);
# set window title
void
setWindowCaption(SV* classname, char* caption)
PREINIT:
wchar_t mytitle[512];
CODE:
// TODO: find out length of scalar and alloc memory for myTitle?
mbstowcs(&mytitle[0], caption, 512);
device->setWindowCaption(mytitle);
char*
getVersion(SV* classname)
PREINIT:
char myversion[512];
const wchar_t* myver;
CODE:
myver = device->getVersion();
// TODO: find out length of scalar and alloc memory for myTitle?
wcstombs( &myversion[0], myver, 512);
RETVAL = myversion;
OUTPUT:
RETVAL
bool
isWindowActive(SV* classname)
CODE:
RETVAL = device->isWindowActive();
OUTPUT:
RETVAL
##############################################################################
# OSOperator
char*
getOperationSystemVersion(SV* classname)
PREINIT:
char myversion[512];
const wchar_t* myver;
IOSOperator* os;
CODE:
os = device->getOSOperator();
myver = os->getOperationSystemVersion();
// TODO: find out length of scalar and alloc memory for myTitle?
wcstombs( &myversion[0], myver, 512);
RETVAL = myversion;
OUTPUT:
RETVAL
##############################################################################
# scene manager interface
int
addCameraSceneNodeFPS(SV* classname)
CODE:
smgr->addCameraSceneNodeFPS();
RETVAL = 1;
OUTPUT:
RETVAL
int
loadBSP(SV* classname, char* name)
CODE:
scene::IAnimatedMesh* mesh = smgr->getMesh(name);
scene::ISceneNode* node = 0;
RETVAL = 0;
if (mesh)
{
node = smgr->addOctTreeSceneNode(mesh->getMesh(0));
RETVAL = 1;
}
##############################################################################
# file system interface
bool
addZipFileArchive(SV* classname, char* archive)
CODE:
RETVAL = filesystem->addZipFileArchive( archive );
OUTPUT:
RETVAL
# this does not work in Irrlicht v0.6 in Linux (returns always false)
bool
changeWorkingDirectoryTo(SV* classname, char* directory)
CODE:
RETVAL = filesystem->changeWorkingDirectoryTo( directory );
printf ("%i\n", filesystem->changeWorkingDirectoryTo( directory ));
OUTPUT:
RETVAL
# this does not work in Irrlicht v0.6 in Linux (returns null)
char*
getWorkingDirectory(SV* classname)
CODE:
RETVAL = (char*) filesystem->getWorkingDirectory( );
OUTPUT:
RETVAL
# EOF
##############################################################################