IrrHaskell-0.1.1: irrlicht_interface.cpp

#include "irrlicht_interface.h"
#include "irrlicht.h"

#include <stdlib.h>
#include <iostream>

using namespace std;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
using namespace std;

class HelperEvent {

	public:
	
		int helper_event;
		char char_event;
	
		HelperEvent() {
			helper_event = -1;
			char_event = ' ';
		}	
		
		void setHelperEvent(int event_value) {			
			helper_event = event_value;
		}
		
		void setCharEvent(char event_char) {
			char_event = event_char;
		}
		
		int getHelperEvent() {
			return helper_event;
		}
		
		char getCharEvent() {
			return char_event;
		}

};

class MyEventReceiver : public IEventReceiver
{
public:

	MyEventReceiver(HelperEvent *irrlicht_helper_event) : Irrlicht_helper_event(irrlicht_helper_event)
	{
	}

	bool OnEvent(const SEvent& event)
	{

		if (event.EventType == irr::EET_KEY_INPUT_EVENT && !event.KeyInput.PressedDown)
		{

			switch (event.KeyInput.Key)
			{
			case irr::KEY_KEY_A:
				Irrlicht_helper_event->setHelperEvent(1);	
				Irrlicht_helper_event->setCharEvent('a');			
				return true;
				
			case irr::KEY_KEY_B:

				Irrlicht_helper_event->setHelperEvent(2);
				Irrlicht_helper_event->setCharEvent('b');
			    return true;	
			    
			case irr::KEY_KEY_C:
				Irrlicht_helper_event->setHelperEvent(3);
				Irrlicht_helper_event->setCharEvent('c');
			    return true;	    			    

			case irr::KEY_KEY_D:
				Irrlicht_helper_event->setHelperEvent(4);
				Irrlicht_helper_event->setCharEvent('d');
			    return true;
			    
			default:			    
				break;
			}
		}

		return false;
	}

private:
	HelperEvent* Irrlicht_helper_event;
};

class HelperSceneNode
{
	irr::scene::ISceneNode *sceneNode;
	irr::scene::IAnimatedMeshSceneNode *animatedMeshSceneNode;
	
	public:
		HelperSceneNode(IAnimatedMeshSceneNode* amsn)
		{
			animatedMeshSceneNode = amsn;
			sceneNode = amsn;
		}
		
		irr::scene::ISceneNode* getSceneNode()
		{
			return sceneNode;
		}
		
		irr::scene::IAnimatedMeshSceneNode* getAnimatedMeshSceneNode()
		{
			return animatedMeshSceneNode;
		}
};

class HelperMesh
{
	irr::scene::IMesh *mesh;
	irr::scene::IAnimatedMesh *animatedMesh;
	
	public:
		HelperMesh(IAnimatedMesh* am)
		{
			animatedMesh = am;
			mesh = am;
		}
		
		irr::scene::IMesh* getMesh()
		{
			return mesh;
		}
		irr::scene::IAnimatedMesh* getAnimatedMesh()
		{
			return animatedMesh;
		}
};


static IrrlichtDevice* irrDevice = 0;
static IVideoDriver* irrVideoDriver = 0;
static ISceneManager* irrSceneManager = 0;
static IGUIEnvironment* irrGuiEnvironment = 0;

static HelperEvent* helperEvent = new HelperEvent();

static MyEventReceiver receiver(helperEvent);


static wchar_t wcstring[2000];
wchar_t * toWchar(char* text)
{
	// Convert to a wchar_t*
	size_t convertedChars = 0;
	int len = strlen(text)+1; 
	
	if (len > 500)
	{
		return NULL;
	}
	else
	{
		mbstowcs(wcstring, text, strlen(text)+1);
		return wcstring;
	}
};


static char lastError[512];

void setError(char* error)
{
	strcpy(lastError, error);
};

char* getError()
{
	return lastError;
};

extern "C" int DeviceSetEventReceiver(int control) {

    if (irrDevice == 0) {
        setError("DeviceSetEventReceiver error");
        return -1;
    } else {
	        irrDevice->setEventReceiver(&receiver);
	        return 0;
    }

}

extern "C" int GetEvent() {

	int event = helperEvent->getHelperEvent();
	helperEvent->setHelperEvent(0);

    return event;

}

extern "C" char GetCharEvent() {

	char event = helperEvent->getCharEvent();
	helperEvent->setCharEvent(' ');	
	return event;

}

extern "C" int DeviceSetWindowCaption(char* caption)
{
	if (irrDevice == 0)
	{
		setError("DeviceSetWindowCaption: library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		wchar_t *wCaption = toWchar(caption);
		if (wCaption == NULL)
		{
			setError("DeviceSetWindowCaption: input text larger then 500 chars");
			return -1;
		}
		else
		{
			irrDevice->setWindowCaption(wCaption);
			return 0;
		}
	}
}

extern "C" int DeviceRun()
{
	if (irrDevice == 0)
	{
		setError("DeviceRun: library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
		return irrDevice->run();
}

extern "C" int DeviceDrop()
{
	if (irrDevice == 0)
	{
		setError("DeviceDrop: library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		irrDevice->drop();
		return 0;
	}
}

extern "C" int IrrCreateDevice (int dtype, int sizex, int sizey, int fullscreen, int stencilbuffer, int vsync)
{
	if (sizey < 0 || sizex < 0)
	{
		setError("IrrCreateDevice: sizex or sizey is negative");
		return -1;
	}
	
	irrDevice =
		createDevice( (irr::video::E_DRIVER_TYPE) dtype, dimension2d<u32>(sizex, sizey), 16,
			fullscreen, stencilbuffer, vsync, 0);

			
	if (!irrDevice)
	{
		setError("IrrCreateDevice: device could not be created");
		return -1;
	}
	else
	{
		irrVideoDriver = irrDevice->getVideoDriver();
		irrSceneManager = irrDevice->getSceneManager();
		irrGuiEnvironment = irrDevice->getGUIEnvironment();
		return 0;
	}
}

extern "C" int GuiAddStaticText(char* text, int topleftx, int toplefty, int lowrightx, int lowrighty)
{
	if (irrGuiEnvironment == 0)
	{
		setError("GuiAddStaticText: library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		wchar_t *wtext = toWchar(text);
		if (wtext == NULL)
		{
			setError("GuiAddStaticText: input text larger then 500 chars");
			return -1;
		}
		else
		{
			irrGuiEnvironment->addStaticText(wtext,
				rect<s32>(topleftx,toplefty,lowrightx,lowrighty), true);
			return 0;
		}
	}
}

extern "C" int GuiDrawAll()
{
	if (irrGuiEnvironment == 0)
	{
		setError("GuiDrawAll: library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		irrGuiEnvironment->drawAll();
		return 0;
	}
}

extern "C" int VideoBeginScene(int a, int b, int colr, int colg, int colb, int colt)
{
	if (irrVideoDriver == 0)
	{
		setError("VideoBeginScene: Irrlicht library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		irrVideoDriver->beginScene(a, b, SColor(colt,colr,colg,colb));
		return 0;
	}
}

extern "C" int VideoEndScene()
{
	if (irrVideoDriver == 0)
	{
		setError("VideoEndScene: Irrlicht library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		irrVideoDriver->endScene();
		return 0;
	}
}

extern "C" 	int VideoGetTexture(char* texture)
{
	if (irrVideoDriver == 0)
	{
		setError("VideoGetTexture: Irrlicht library not initialized (use irrCreateDevice)");
		return 0;
	}
	else
		return (int) irrVideoDriver->getTexture(texture);
}


extern "C" int SceneDrawAll()
{
	if (irrSceneManager == 0)
	{
		setError("SceneDrawAll: Irrlicht library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		irrSceneManager->drawAll();
		return 0;
	}
}

extern "C" 	int SceneGetMesh(char* mesh)
{
	if (irrSceneManager == 0)
	{
		setError("SceneGetMesh: Irrlicht library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		IAnimatedMesh* pMesh = irrSceneManager->getMesh(mesh);
		if (pMesh == 0)
		{
			setError("SceneGetMesh: could not load mesh");
			return -1;
		}
		else
			return (int) new HelperMesh(pMesh);
	}
}

extern "C" int SceneAddAnimatedMeshSceneNode(int pMesh)
{
	if (irrSceneManager == 0)
	{
		setError("SceneAddAnimatedMeshSceneNode: Irrlicht library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		IAnimatedMesh *pam = ((HelperMesh *) pMesh)->getAnimatedMesh();
		if (pam != NULL)
			return  (int) new HelperSceneNode((IAnimatedMeshSceneNode* )irrSceneManager->addAnimatedMeshSceneNode(pam));
		else
		{
			setError("SceneAddAnimatedMeshSceneNode: provided mesh pointer is of wrong type");
			return -1;
		}
	}
}

extern "C" int SceneAddCameraSceneNode(int posx, int posy, int posz, int tox, int toy, int toz)
{
	if (irrSceneManager == 0)
	{
		setError("SceneAddCameraSceneNode: Irrlicht library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		irrSceneManager->addCameraSceneNode(0, vector3df(posx,posy,posz), vector3df(tox,toy,toz));
		return 0;
	}
}


extern "C" int NodeSetMaterialTexture(int pNode, int pTexture)
{
	if (pNode == 0)
	{
		setError("NodeSetMaterialTexture: node parameter is zero in NodeSetMaterialTexture");
		return -1;
	}
	else if (pTexture == 0)
	{
		setError("NodeSetMaterialTexture: texture parameter is zero in NodeSetMaterialTexture");
		return -1;
	}
	else
	{
		ISceneNode* sceneNode = ((HelperSceneNode *) pNode)->getSceneNode();
		if (sceneNode == NULL)
		{
			setError("NodeSetMaterialTexture: node parameter is of wrong type");
			return -1;
		}
		else
		{
			sceneNode->setMaterialTexture(0, (ITexture *) pTexture);
			return 0;
		}
	}
}

extern "C" int NodeSetMaterialFlag(int pNode, int mflag, int value)
{
	if (pNode == 0)
	{
		setError("NodeSetMaterialFlag: node parameter is zero in NodeSetMaterialTexture");
		return -1;
	}
	else
	{
		ISceneNode* sceneNode = ((HelperSceneNode *) pNode)->getSceneNode();
		if (sceneNode == NULL)
		{
			setError("NodeSetMaterialFlag: node parameter is of wrong type");
			return -1;
		}
		else
		{
			sceneNode->setMaterialFlag((video::E_MATERIAL_FLAG) mflag, value);
			return 0;
		}
	}
}

extern "C" int NodeSetMd2Animation(int pNode, int atype)
{
	if (pNode == 0)
	{
		setError("NodeSetMd2Animation: node parameter is zero in NodeSetMaterialTexture");
		return -1;
	}
	else
	{
		IAnimatedMeshSceneNode* sceneNode = ((HelperSceneNode *) pNode)->getAnimatedMeshSceneNode();
		if (sceneNode == NULL)
		{
			setError("NodeSetMd2Animation: node parameter is of wrong type");
			return -1;
		}
		else
		{
			sceneNode->setMD2Animation((scene::EMD2_ANIMATION_TYPE) atype);
			return 0;
		}
	}
}

extern "C" int FileSystemAddZipFileArchive(char *file)
{

	int r;
	r = irrDevice->getFileSystem()->addZipFileArchive(file);

	if (r == 0) //false
	{
	setError("no file map loaded");
		return -1;
	} else {
	    return 0;
	}


}

extern "C" int SceneAddOctTreeSceneNode(int pMesh)
{

	if (irrSceneManager == 0)
	{
		setError("SceneAddOctTreeSceneNode: Irrlicht library not initialized (use irrCreateDevice)");
		return -1;
	}
	else
	{
		IAnimatedMesh *qMesh = ((HelperMesh *) pMesh)->getAnimatedMesh();
		if (qMesh != NULL)
			return  (int) new HelperSceneNode((IAnimatedMeshSceneNode* ) irrSceneManager->addOctTreeSceneNode(qMesh->getMesh(0), 0, -1, 1024));
		else
		{
			setError("SceneAddOctTreeSceneNode: provided mesh pointer is of wrong type");
			return -1;
		}
	}
}


extern "C" int SceneNodeSetPosition (int posx, int posy, int posz, int pNode)
{

	ISceneNode* sceneNode = ((HelperSceneNode *) pNode)->getSceneNode();
	
	if (sceneNode == NULL) {
	
		setError("NodeSetMaterialFlag: node parameter is of wrong type");
	
		return -1;
	} else {	
	
		sceneNode->setPosition( vector3df(posx,posy,posz) );
		return 0;
	}

}

extern "C" int SceneAddCameraSceneNodeFPS ()
{

	irrSceneManager->addCameraSceneNodeFPS();
	return 0;
}

extern "C" int GetVirtualTime () {
	int time = irrDevice->getTimer()->getTime();
	return time;
}