Using Irrlicht enums

Irrlicht's enum values are placed in the namespace where the enum resides when imported into IrrLua. For example, the C++ variable irr::video::E_DRIVER_TYPE::EDT_OPENGL becomes irr.video.EDT_OPENGL. Note that the enum type name 'E_DRIVER_TYPE' is not a part of the Lua definition.

Dealing with Inheritence

Some Irrlicht mechanisms such as the GUI callback mechanism only provide a base class like IGUIElement to the callback. In C++, you would cast the IGUIElement pointer to it's derived class and use the derived pointer. Example:

s32 pos = ((IGUIScrollBar*) Caller)->getPos();

To do the same thing in IrrLua, you would do:

local pos = tolua.cast(Caller, "irr::gui::IGUIScrollBar"):getPos()


Creating new Irrlicht objects in Lua

IrrLua supports the creation of 'pure virtual' Irrlicht classes, which allows you to dynamically extend the Irrlicht engine at runtime using Lua.
The following functions are used to create new Irrlicht classes based on a Lua class:

function irr.createIEventReceiver(lua_class)
function irr.gui.createIGUIElement(type, environment, parent, id, rectangle, lua_class)
function irr.gui.createIGUISkin(lua_class)
function irr.scene.createIAnimatedMesh(lua_class)
function irr.scene.createIAnimatedMeshSceneNode(parent, manager, id, lua_class)
function irr.scene.createIMesh(lua_class)
function irr.scene.createIParticleAffector(lua_class)
function irr.scene.createIParticleEmitter(lua_class)
function irr.scene.createISceneNode(parent, manager, id, lua_class)
function irr.scene.createISceneNodeAnimator(lua_class)
function irr.scene.createISceneNodeAnimatorCollisionResponse(lua_class)
function irr.scene.createITriangleSelector(lua_class)
function irr.video.createIShaderConstantSetCallBack(lua_class)

Example:

-- Create our custom scene node in Lua
CMySceneNode = {}

function CMySceneNode:init()
	self.Box = irr.core.aabbox3d(-1,-1,-1,1,1,1)
	self.Vertices = {
		irr.video.S3DVertex(0,0,10, 1,1,0, irr.video.SColor(255,0,255,255), 0, 1),
		irr.video.S3DVertex(10,0,-10, 1,0,0, irr.video.SColor(255,255,0,255), 1, 1),
		irr.video.S3DVertex(0,20,0, 0,1,1, irr.video.SColor(255,255,255,0), 1, 0),
		irr.video.S3DVertex(-10,0,-10, 0,0,1, irr.video.SColor(255,0,255,0), 0, 0)
	}
	self.Material = irr.video.SMaterial()
	self..Material.Wireframe = false
	self..Material.Lighting = false	
	self..Box:reset(self.Vertices[1].Pos)
	for i=2,4 do 
		self.Box:addInternalPoint(self.Vertices[i].Pos) 
	end
	return self	
end


function CMySceneNode:OnPreRender()
	if self:isVisible() then
		self.SceneManager:registerNodeForRendering(self)
	end
end

-- You must implement render() (required)
function CMySceneNode:render()
	local indices = {0,2,3, 2,1,3, 1,0,3, 2,0,1}
	local driver = self.SceneManager:getVideoDriver()
	driver:setMaterial(self.Material)
	driver:setTransform(irr.video.ETS_WORLD, self:getAbsoluteTransformation())
	driver:drawIndexedTriangleList(self.Vertices, indices)
end

-- You must implement getBoundingBox() (required)
function CMySceneNode:getBoundingBox()
	return self.Box
end
function CMySceneNode:getMaterialCount()
	return 1
end

function CMySceneNode:getMaterial(i)
	return self.Material
end


...


local myNode = irr.scene.createISceneNode(smgr:getRootSceneNode(), smgr, -1, CMySceneNode)
-- myNode now acts as an Irrlicht ISceneNode object and has members such as 
-- self.SceneManager that represent the protected member variables of class ISceneNode.

-- call constructor like init function
myNode:init()

-- example event layout

-- key input
Event = 
{
	EventType = SEvent.EventType,
	KeyInput = 
	{
		Char = Event.KeyInput.Char,
		Key = Event.KeyInput.Key,
		PressedDown = Event.KeyInput.PressedDown,
		Control = Event.KeyInput.Control,
		Shift = Event.KeyInput.Shift
	}
}

-- gui event
Event = 
{
	EventType = event.EventType,
	GUIEvent = 
	{
		Caller = Event.GUIEvent.Caller,
		EventType = Event.GUIEvent.EventType
	}
}

-- mouse input event
Event = 
{
	EventType = Event.EventType,
	MouseInput = 
	{
		X = Event.MouseInput.X,
		Y = Event.MouseInput.Y, 
		Wheel = Event.MouseInput.Wheel,
		Event = Event.MouseInput.Event,
	}
}

-- log text event
Event  = 
{
	EventType = Event.EventType,
	LogEvent = 
	{
		Text = Event.LogEvent.Text,
		Level = Event.LogEvent.Level
	}
}

-- user event
Event = 
{
	EventType = Event.EventType,
	UserEvent = 
	{
		UserData1 = Event.UserEvent.UserData1,
		UserData2 = Event.UserEvent.UserData2,
		UserData3 = Event.UserEvent.UserData3
	}
}

				
-- example handler

MyEventReceiver = {}

function MyEventReceiver:OnEvent(Event)
	if Event.EventType == irr.EET_KEY_INPUT_EVENT then
		if node and not Event.KeyInput.PressedDown then
			local v = node:getPosition()

			if Event.KeyInput.Key == irr.KEY_KEY_W then
				 v.Y = v.Y + 2
				 node:setPosition(v)
				return true
				end

			if Event.KeyInput.Key == irr.KEY_KEY_S then
				 v.Y = v.Y - 2
				 node:setPosition(v)
				return true
				end
			end
		end
	end

	return false
end

using namespace irr;
using namespace irr::core;
using namespace irr::scene;
...

vector3d = irr.core.vector3d
local myVector = vector3d(1,2,3) -- use new, shorter name for function

function using_namespace(t) 
	for i,v in pairs(t) do 
		_G[i] = _G[i] or v  -- don't overwrite existing variables
	end 
end


-- example

require "IrrLua"

using_namespace(irr.core)

local v = vector3d(1,3,3)
print(v.X, v.Y, v.Z) -- 1 2 3

irr.io.dofile(IReadFile)

device = irr.createDevice()

zipArchive = device:getFileSystem():addZipFileArchive("mypackage.zip") -- load mypackage.zip into irrlicht's file system
readfile = device:getFileSystem():createAndOpenFile("myscript.lua") -- load myscript.lua out of mypackage.zip

irr.io.dofile(readfile) -- run the script 'myscript.lua'