K3dVM.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "K3dVM.h"


void *K3dVM::ms_pObject;        
K3dLua *K3dVM::ms_pLua;
K3dScene *K3dVM::ms_pScene;
K3dGameData *K3dVM::ms_pGameData;
K3dCameraBuild *K3dVM::ms_pCameraBuild;

K3dVM::K3dVM(K3dGameData *_pGameData, K3dScene *_pScene)
{
        ms_pGameData = _pGameData;
        ms_pScene = _pScene;
        // Set this virtual machine to the global game data
        ms_pGameData->SetVM(this);
        ms_pLua = ms_pGameData->GetLua();
        ms_pCameraBuild = new K3dCameraBuild(_pGameData);
        RegisterFunctions();
}

K3dVM::~K3dVM()
{
        std::cout << "Destructor K3dVM::~K3dVM()" << endl;
        if(ms_pCameraBuild)
        {
                delete ms_pCameraBuild;
                ms_pCameraBuild = NULL;
        }
}

void K3dVM::RegisterFunctions()
{
        std::cout << "void K3dVM::RegisterFunctions()" << endl;
        ms_pLua->LuaRegister("K3d_LoadMap", K3d_LoadMap);
        ms_pLua->LuaRegister("K3d_AddVertex", K3d_AddVertex);
        ms_pLua->LuaRegister("K3d_GetObject", K3d_GetObject);
        ms_pLua->LuaRegister("K3d_GetCamPos", K3d_GetCamPos);
        ms_pLua->LuaRegister("K3d_GetCamDir", K3d_GetCamDir);
        ms_pLua->LuaRegister("K3d_GetAimRay", K3d_GetAimRay);
        ms_pLua->LuaRegister("K3d_GetRayOrigDir", K3d_GetRayOrigDir);
        ms_pLua->LuaRegister("K3d_GetIntersection", K3d_GetIntersection);
        ms_pLua->LuaRegister("K3d_SetVertexPos", K3d_SetVertexPos);
        ms_pLua->LuaRegister("K3d_SetColor", K3d_SetColor);
        ms_pLua->LuaRegister("K3d_SetRay", K3d_SetRay);
        ms_pLua->LuaRegister("K3d_SetLine", K3d_SetLine);
        ms_pLua->LuaRegister("K3d_Hide", K3d_Hide);
        ms_pLua->LuaRegister("K3d_Print", K3d_Print);
        ms_pLua->LuaRegister("K3d_PrintValue", K3d_PrintValue);
        ms_pLua->LuaRegister("K3d_GetDistance", K3d_GetDistance);
        ms_pLua->LuaRegister("K3d_IsMouseLeft", K3d_IsMouseLeft);
        ms_pLua->LuaRegister("K3d_IsMouseRight", K3d_IsMouseRight);
        ms_pLua->LuaRegister("K3d_IsMouseLeftUp", K3d_IsMouseLeftUp);
        ms_pLua->LuaRegister("K3d_IsMouseRightUp", K3d_IsMouseRightUp);
        ms_pLua->LuaRegister("K3d_MoveByMouse", K3d_MoveByMouse);
        ms_pLua->LuaRegister("K3d_GetSpherePos", K3d_GetSpherePos);
        ms_pLua->LuaRegister("K3d_Wait", K3d_Wait);
        ms_pLua->LuaRegister("K3d_IncludeScript", K3d_IncludeScript);
        ms_pLua->LuaRegister("K3d_Link", K3d_Link);
        ms_pLua->LuaRegister("K3d_GetGuiObject" ,K3d_GetGuiObject);
        ms_pLua->LuaRegister("K3d_ButtonIsPressed",K3d_ButtonIsPressed);
        ms_pLua->LuaRegister("K3d_HideGui",K3d_HideGui);
        ms_pLua->LuaRegister("K3d_ShowGui",K3d_ShowGui);
        ms_pLua->LuaRegister("K3d_ShowFileListBox",K3d_ShowFileListBox);
        ms_pLua->LuaRegister("K3d_LoadMapFromListBox",K3d_LoadMapFromListBox);
        ms_pLua->LuaRegister("K3d_CheckKeyboardKey",K3d_CheckKeyboardKey);
        ms_pLua->LuaRegister("K3d_LoadNewScript",K3d_LoadNewScript);
        ms_pLua->LuaRegister("K3d_Exit",K3d_Exit);
}

void K3dVM::LoadScript(K3dString _strFilename)
{
        std::cout << "void K3dVM::LoadScript()" << endl;
        std::cout << "_strFilename = " << _strFilename.GetString( ) << endl;
        if(!ms_pLua->LuaLoadFile(_strFilename.GetString().c_str()))
        {
                ms_pLua->LuaError("void K3dVM::LoadScript(K3dString _strFilename) -- Error - cannot run script file: %s", ms_pLua->LuaToString(-1));
        }
}

void K3dVM::Engine_Init()
{
        //ms_pLua->LuaCallEngine_Init();
        // Function to be called 
        ms_pLua->LuaGetGlobal("Engine_Init");
        // Do the call (0 arguments, 0 result) 
        if (ms_pLua->LuaPCall(0, 0, 0) != 0)
        {
        ms_pLua->LuaError("Error running function `Engine_Init': %s", lua_tostring(ms_pLua->GetLuaState(), -1));
        }
}

void K3dVM::Engine_Update()
{
        // Function to be called 
        ms_pLua->LuaGetGlobal("Engine_Update");
        // do the call (0 arguments, 0 result) 
        if (ms_pLua->LuaPCall(0, 0, 0) != 0)
        {
        ms_pLua->LuaError("error running function `Engine_Update': %s", lua_tostring(ms_pLua->GetLuaState(), -1));
        }
}

void K3dVM::Engine_Delete()
{
        std::cout << "void K3dVM::Engine_Delete()" << endl;
        lua_State *pLuaState = ms_pLua->GetLuaState();
        if(pLuaState)
        {
                // Function to be called 
                ms_pLua->LuaGetGlobal("Engine_Delete");
                // do the call (0 arguments, 0 result) 
                if (ms_pLua->LuaPCall(0, 0, 0) != 0)
                {
                        ms_pLua->LuaError("error running function `Engine_Delete': %s", lua_tostring(ms_pLua->GetLuaState(), -1));
                }
        }
        else
        {
                cerr << "Error :: void K3dVM::Engine_Delete() -- lua_State is not initialized !!!" << endl;
        }
}

void K3dVM::LoadMap(K3dString &_strFilename)
{
        std::cout << "void K3dVM::LoadMap()" << endl;
        std::cout << "_strFilename" << _strFilename.GetString() << endl;
        ms_pScene->Load( _strFilename);
}

int K3dVM::K3d_LoadMap(lua_State *_pState)
{
        std::cout << "int K3dVM::K3d_LoadMap(lua_State *_pState)" << endl;
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        if (NULL == ms_pLua->GetLuaState())
        {
                printf("Error Initializing lua\n");
                return -1;
        }
        K3dString str;
        str = lua_tostring(_pState, 1);
        // Try call non static function
        pSomeClass->LoadMap(str);
        return 0;
}

int K3dVM::GetObject(const char* _strObjName, const int _iObjType)
{
        // Get object index by object name and object type
        int iId = ms_pScene->FindObjectId(_strObjName, _iObjType);
        return iId;
}

int K3dVM::K3d_GetObject(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        const char* strObjName = (const char*) lua_tostring(_pState, 1);
        const int iObjType = (int) lua_tonumber(_pState, 2);
        // Try call non static function
        int iResult = pSomeClass->GetObject(strObjName, iObjType);
        if(ms_pLua->LuaCheckStack(_pState, 1))
        {
                 // Push result into script function
                lua_pushnumber(_pState, iResult);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_GetObject() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 1;
}

void  K3dVM::GetCamPos(const int _iId, K3dVector3 &_rkCamPos)
{
        _rkCamPos = ms_pGameData->GetCameraObjSP().Get(_iId)->GetCameraPos();
}

int  K3dVM::K3d_GetCamPos(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameter
        int iCamId = (int) lua_tonumber(_pState, 1);
        K3dVector3 kCamPos;
        // Try call non static function
        pSomeClass->GetCamPos(iCamId, kCamPos);
        if(ms_pLua->LuaCheckStack(_pState, 3))
        {
                // Push result camera position into script function
                lua_pushnumber(_pState, kCamPos[0]);
                lua_pushnumber(_pState, kCamPos[1]);
                lua_pushnumber(_pState, kCamPos[2]);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_GetCamPos() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 3;
}

void  K3dVM::GetCamDir(const int _iId, K3dVector3 &_rkCamDir)
{
        _rkCamDir = ms_pGameData->GetCameraObjSP().Get(_iId)->GetView();
}

int  K3dVM::K3d_GetCamDir(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameter
        int iCamId = (int) lua_tonumber(_pState, 1);
        K3dVector3 kCamDir;
        // Try call non static function
        pSomeClass->GetCamDir(iCamId, kCamDir);
        if(ms_pLua->LuaCheckStack(_pState, 3))
        {
                // Push result camera direction into script function
                lua_pushnumber(_pState, kCamDir[0]);
                lua_pushnumber(_pState, kCamDir[1]);
                lua_pushnumber(_pState, kCamDir[2]);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_GetCamDir() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 3;
}

K3dRay *K3dVM::GetAimRay()
{
        return ms_pGameData->GetRayObjSP().Get(ms_pGameData->GetAimRayId());
}

int  K3dVM::K3d_GetAimRay(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        K3dRay *pRay = NULL;
        // Try call non static function
        pRay = pSomeClass->GetAimRay();
        if(ms_pLua->LuaCheckStack(_pState, 6))
        {
                if(pRay)
                {
                        // Push result camera direction into script function
                        lua_pushnumber(_pState, pRay->GetOrigin()->GetX());
                        lua_pushnumber(_pState, pRay->GetOrigin()->GetY());
                        lua_pushnumber(_pState, pRay->GetOrigin()->GetZ());
                        lua_pushnumber(_pState, pRay->GetDirection()->GetX());
                        lua_pushnumber(_pState, pRay->GetDirection()->GetY());
                        lua_pushnumber(_pState, pRay->GetDirection()->GetZ());
                }
                else
                {
                        cerr << "Error -- K3dVM::K3d_GetAimRay() -- pRay doesn`t allocated ! " << endl;
                        exit(1);
                }
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_GetAimRay() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 6;
}

K3dRayObj *K3dVM::GetRayOrigDir(const int _iRayId)
{
        return ms_pGameData->GetRayObjSP().Get(_iRayId);
}

int  K3dVM::K3d_GetRayOrigDir(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        K3dRayObj *pRay = NULL;
        // Get function parameter
        int iRayId = (int) lua_tonumber(_pState, 1);
        // Try call non static function
        pRay = pSomeClass->GetRayOrigDir(iRayId);

        if(ms_pLua->LuaCheckStack(_pState, 6))
        {
                if(pRay)
                {
                        // Push result camera direction into script function
                        lua_pushnumber(_pState, pRay->GetOrigin()->GetX());
                        lua_pushnumber(_pState, pRay->GetOrigin()->GetY());
                        lua_pushnumber(_pState, pRay->GetOrigin()->GetZ());
                        lua_pushnumber(_pState, pRay->GetDirection()->GetX());
                        lua_pushnumber(_pState, pRay->GetDirection()->GetY());
                        lua_pushnumber(_pState, pRay->GetDirection()->GetZ());
                }
                else
                {
                        cerr << "Error -- K3dVM::K3d_GetRayOrigDir() -- pRay doesn`t allocated ! " << endl;
                        exit(1);
                }
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_GetRayOrigDir() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 6;
}

bool K3dVM::GetIntersection(const int _iObjId0, const int _iObjId1, const int _iObjType0, const int _iObjType1)
{
        return  ms_pScene->GetIntersection( _iObjId0, _iObjId1, _iObjType0, _iObjType1);
}

bool K3dVM::GetIntersection(const int _iObjId0, const int _iObjId1, const int _iObjType0, const int _iObjType1, K3dVector3 &_rkInrPoint)
{
        return  ms_pScene->GetIntersection( _iObjId0, _iObjId1, _iObjType0, _iObjType1, _rkInrPoint);
}

int K3dVM::K3d_GetIntersection(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        int iObj0 = (int) lua_tonumber(_pState, 1);
        int iObj1 = (int) lua_tonumber(_pState, 2);
        int iObjType0 = (int) lua_tonumber(_pState, 3);
        int iObjType1 = (int) lua_tonumber(_pState, 4);
        bool bGetIntrPoint = (bool) lua_tonumber(_pState, 5);
        bool bIsIntr = false;
        // If we want return intersection point
        if(bGetIntrPoint)
        {
                K3dVector3 kIntrPoint;
                // Try call non static function
                bIsIntr = pSomeClass->GetIntersection(iObj0, iObj1, iObjType0,iObjType1,kIntrPoint );
                if(ms_pLua->LuaCheckStack(_pState, 4))
                {
                        // Push result intersection into script function
                        lua_pushboolean(_pState, bIsIntr);
                        // Push result intersection point into script function
                        lua_pushnumber(_pState, kIntrPoint[0]);
                        lua_pushnumber(_pState, kIntrPoint[1]);
                        lua_pushnumber(_pState, kIntrPoint[2]);
                }
                else
                {
                        cerr << "Error :: int K3dVM::K3d_GetIntersection() -- Lua stack overflow !!!" << endl;
                        return 0;
                }
                // Return number of results
                return 4;
        }
        else
        {
                // Try call non static function
                bIsIntr = pSomeClass->GetIntersection(iObj0, iObj1, iObjType0,iObjType1);
                if(ms_pLua->LuaCheckStack(_pState, 1))
                {
                        // Push result intersection into script function
                        lua_pushboolean(_pState, bIsIntr);
                }
                else
                {
                        cerr << "Error :: int K3dVM::K3d_GetIntersection() -- Lua stack overflow !!!" << endl;
                        return 0;
                }
                // Return number of results
                return 1;
        }
}

int K3dVM::AddVertex(const float _x,const float _y,const float _z,const char _r,const char  _g,const char  _b,const int _size)
{
        K3dVertexObj *pVertex = ms_pGameData->GetVertexBuild()->CreateNewVertexObj();
        pVertex->GetPosition()->GetX() = (float) _x;
        pVertex->GetPosition()->GetY() = (float) _y;
        pVertex->GetPosition()->GetZ() = (float) _z;
        pVertex->GetColor()->GetR() = (GLubyte) _r;
        pVertex->GetColor()->GetG() = (GLubyte) _g;
        pVertex->GetColor()->GetB() = (GLubyte) _b;
        pVertex->GetSize() = _size;
        // Return vertex index
        return pVertex->GetId();
}

int K3dVM::K3d_AddVertex(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        float x = (float) lua_tonumber(_pState, 1);
        float y = (float) lua_tonumber(_pState, 2);
        float z = (float) lua_tonumber(_pState, 3);
        char  r = (char ) lua_tonumber(_pState, 4);
        char  g = (char ) lua_tonumber(_pState, 5);
        char  b = (char ) lua_tonumber(_pState, 6);
        int iSize = (int) lua_tonumber(_pState, 7);
        // Try call non static function
        int iVertexId = pSomeClass->AddVertex(x,y,z,r,g,b,iSize);
        if(ms_pLua->LuaCheckStack(_pState, 1))
        {
                // Push result into script function
                lua_pushnumber(_pState, iVertexId);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_AddVertex() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 1;
}

void K3dVM::SetVertexPos(const int _iVertexId, const float _x,const float _y,const float _z)
{
        K3dVertexObj *pVertex = ms_pGameData->GetVertexObjSP().Get(_iVertexId);
        pVertex->GetPosition()->GetX() = (float) _x;
        pVertex->GetPosition()->GetY() = (float) _y;
        pVertex->GetPosition()->GetZ() = (float) _z;
}

int K3dVM::K3d_SetVertexPos(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        int iVertexId = (int) lua_tonumber(_pState, 1);
        float x = (float) lua_tonumber(_pState, 2);
        float y = (float) lua_tonumber(_pState, 3);
        float z = (float) lua_tonumber(_pState, 4);
        // Call non static function
        pSomeClass->SetVertexPos(iVertexId, x,y,z);
        return 0;
}

void K3dVM::SetColor(const int _iObjId, const int _iObjType, const char _r,const char _g,const char _b)
{
        ms_pScene->SetColor(_iObjId, _iObjType, _r, _g, _b);
}

int K3dVM::K3d_SetColor(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        int iObjId = (int) lua_tonumber(_pState, 1);
        int iObjType = (int) lua_tonumber(_pState, 2);
        char r = (char) lua_tonumber(_pState, 3);
        char g = (char) lua_tonumber(_pState, 4);
        char b = (char) lua_tonumber(_pState, 5);
        // Call non static function
        pSomeClass->SetColor(iObjId, iObjType,  r,g,b);
        return 0;
}


void K3dVM::SetRay(const int _iRayId, const float _origx,const float _origy,const float _origz,const float _dirx,const float _diry,const float _dirz)
{
        K3dRay *pRay = ms_pGameData->GetRayObjSP().Get(_iRayId);
        pRay->GetOrigin()->GetX() = _origx;
        pRay->GetOrigin()->GetY() = _origy;
        pRay->GetOrigin()->GetZ() = _origz;
        pRay->GetDirection()->GetX() = _dirx;
        pRay->GetDirection()->GetY() = _diry;
        pRay->GetDirection()->GetZ() = _dirz;
}

int K3dVM::K3d_SetRay(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        int iRayId = (int) lua_tonumber(_pState, 1);
        int origx = (int) lua_tonumber(_pState, 2);
        int origy = (int) lua_tonumber(_pState, 3);
        int origz = (int) lua_tonumber(_pState, 4);
        int dirx = (int) lua_tonumber(_pState, 5);
        int diry = (int) lua_tonumber(_pState, 6);
        int dirz = (int) lua_tonumber(_pState, 7);
        // Call non static function
        pSomeClass->SetRay(iRayId, origx,origy,origz,dirx,diry,dirz);
        // Return number of results
        return 0;
}

void K3dVM::SetLine(const int _iLineId, const float _origx,const float _origy,const float _origz,const float _dirx,const float _diry,const float _dirz)
{
        K3dLineObj *pLine = ms_pGameData->GetLineObjSP().Get(_iLineId);
        pLine->GetRelOrigin()->GetX() = _origx;
        pLine->GetRelOrigin()->GetY() = _origy;
        pLine->GetRelOrigin()->GetZ() = _origz;
        pLine->GetRelDirection()->GetX() = _dirx;
        pLine->GetRelDirection()->GetY() = _diry;
        pLine->GetRelDirection()->GetZ() = _dirz;
}

int K3dVM::K3d_SetLine(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        int iLineId = (int) lua_tonumber(_pState, 1);
        float origx = (float) lua_tonumber(_pState, 2);
        float origy = (float) lua_tonumber(_pState, 3);
        float origz = (float) lua_tonumber(_pState, 4);
        float dirx = (float) lua_tonumber(_pState, 5);
        float diry = (float) lua_tonumber(_pState, 6);
        float dirz = (float) lua_tonumber(_pState, 7);
        // Call non static function
        pSomeClass->SetLine(iLineId, origx,origy,origz,dirx,diry,dirz);
        // Return number of results
        return 0;
}

void K3dVM::Hide(const int _iObjId, const int _iObjType, const bool _bHide)
{
        ms_pScene->Hide(_iObjId, _iObjType, _bHide);
}

int K3dVM::K3d_Hide(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        int iObjId = (int) lua_tonumber(_pState, 1);
        int iObjType = (int) lua_tonumber(_pState, 2);
        bool bHide = (bool) lua_toboolean(_pState, 3);
        // Call non static function
        pSomeClass->Hide(iObjId, iObjType, bHide);
        // Return number of results
        return 0;
}

void K3dVM::PrintValue(const char* _strComment,const float _fValue)
{
        ms_pScene->DrawValue(_strComment, _fValue);
}

int K3dVM::K3d_PrintValue(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        const char* strComment = lua_tostring(_pState, 1);
        float fValue = (float) lua_tonumber(_pState, 2);
        // Call non static function
        pSomeClass->PrintValue(strComment, fValue);
        // Return number of results
        return 0;
}

void K3dVM::Print(const char* _str)
{
        ms_pScene->DrawValue(_str);
}

int K3dVM::K3d_Print(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        const char* str = lua_tostring(_pState, 1);
        // Call non static function
        pSomeClass->Print(str);
        // Return number of results
        return 0;
}

float K3dVM::GetDistance(const int _iObjId0, const int _iObjId1, const int _iObjType0, const int _iObjType1)
{
        return  ms_pScene->GetDistance( _iObjId0, _iObjId1, _iObjType0, _iObjType1);
}

int K3dVM::K3d_GetDistance(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameter
        int iObjId0 = (int) lua_tonumber(_pState, 1);
        int iObjId1 = (int) lua_tonumber(_pState, 2);
        int iObjType0 = (int) lua_tonumber(_pState, 3);
        int iObjType1 = (int) lua_tonumber(_pState, 4);
        // Try call non static function
        float fDist = pSomeClass->GetDistance(iObjId0,iObjId1,iObjType0,iObjType1);
        if(ms_pLua->LuaCheckStack(_pState, 1))
        {
                // Push result camera direction into script function
                lua_pushnumber(_pState, fDist);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_GetDistance() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 1;
}

bool K3dVM::IsMouseLeft()
{
        K3dMouse *pMouse = ms_pGameData->GetMouse();
        return pMouse->MouseButtonLeft();
}

int K3dVM::K3d_IsMouseLeft(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        bool bIsMouseLeft = pSomeClass->IsMouseLeft();
        if(ms_pLua->LuaCheckStack(_pState, 1))
        {
                // Push result camera direction into script function
                lua_pushboolean(_pState, bIsMouseLeft);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_IsMouseLeft() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 1;
}

bool K3dVM::IsMouseRight()
{
        K3dMouse *pMouse = ms_pGameData->GetMouse();
        return pMouse->MouseButtonRight();
}

int K3dVM::K3d_IsMouseRight(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        bool bIsMouseRight = pSomeClass->IsMouseRight();
        if(ms_pLua->LuaCheckStack(_pState, 1))
        {
                // Push result camera direction into script function
                lua_pushboolean(_pState, bIsMouseRight);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_IsMouseRight() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 1;
}


//
bool K3dVM::IsMouseLeftUp()
{
        K3dMouse *pMouse = ms_pGameData->GetMouse();
        return -pMouse->MouseButtonLeft();
}

int K3dVM::K3d_IsMouseLeftUp(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        bool bIsMouseLeftUp = pSomeClass->IsMouseLeftUp();
        if(ms_pLua->LuaCheckStack(_pState, 1))
        {
                // Push result camera direction into script function
                lua_pushboolean(_pState, bIsMouseLeftUp);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_IsMouseLeftUp() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 1;
}

bool K3dVM::IsMouseRightUp()
{
        K3dMouse *pMouse = ms_pGameData->GetMouse();
        return -pMouse->MouseButtonRight();
}

int K3dVM::K3d_IsMouseRightUp(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        bool bIsMouseRightUp = pSomeClass->IsMouseRightUp();
        if(ms_pLua->LuaCheckStack(_pState, 1))
        {
                // Push result camera direction into script function
                lua_pushboolean(_pState, bIsMouseRightUp);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_IsMouseRightUp() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 1;
}
//

void K3dVM::MoveByMouse(const int _iSphereId)
{
        ms_pScene->MoveByMouse(_iSphereId);
}

int K3dVM::K3d_MoveByMouse(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameter
        int iSphereId = (int) lua_tonumber(_pState, 1);
        pSomeClass->MoveByMouse(iSphereId);
        // Return number of results
        return 0;
}

void K3dVM::GetSpherePos(const int _iId, K3dVector3 &_rkPos)
{
        _rkPos = *ms_pGameData->GetSphereObjSP().Get(_iId)->GetPosition();
}

int K3dVM::K3d_GetSpherePos(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameter
        int iId = (int) lua_tonumber(_pState, 1);
        K3dVector3 kPos;
        // Try call non static function
        pSomeClass->GetSpherePos(iId, kPos);
        if(ms_pLua->LuaCheckStack(_pState, 3))
        {
                // Push result camera position into script function
                lua_pushnumber(_pState, kPos[0]);
                lua_pushnumber(_pState, kPos[1]);
                lua_pushnumber(_pState, kPos[2]);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_GetSpherePos() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 3;
}

bool K3dVM::Wait(const int _iMsec)
{
        return ms_pGameData->GetTimer()->Wait(_iMsec);
}

int  K3dVM::K3d_Wait(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameter
        int iMsec = (int) lua_tonumber(_pState, 1);
        // Try call non static function
        bool bWait = pSomeClass->Wait(iMsec);
        if(ms_pLua->LuaCheckStack(_pState, 1))
        {
                lua_pushboolean(_pState, bWait);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_Wait() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 1;
}

void K3dVM::IncludeScript(const char* _strFileName)
{
        K3dString strFilename = ms_pGameData->GetSysHome() + K3D_STR_SHARE_PATH + _strFileName;
        LoadScript(strFilename);
}

int K3dVM::K3d_IncludeScript(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameter
        const char* strFileName = lua_tostring(_pState, 1);
        pSomeClass->IncludeScript(strFileName);
        cout << "Load script OK... " << endl;
        // Return number of results
        return 0;
}

void K3dVM::Link(const int _iObjId0, const int _iObjId1, const int _iObjType0, const int _iObjType1)
{
        ms_pScene->Link( _iObjId0, _iObjId1, _iObjType0, _iObjType1);
}

int K3dVM::K3d_Link(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        int iObjId0 = (int) lua_tonumber(_pState, 1);
        int iObjId1 = (int) lua_tonumber(_pState, 2);
        int iObjType0 = (int) lua_tonumber(_pState, 3);
        int iObjType1 = (int) lua_tonumber(_pState, 4);
        // Try call non static function
        pSomeClass->Link(iObjId0,iObjId1,iObjType0,iObjType1);
        // Return number of results
        return 0;
}

bool K3dVM::ButtonIsPressed(const int _iButtonId)
{
        return ms_pScene->ButtonIsPressed(_iButtonId);
}

int K3dVM::K3d_ButtonIsPressed(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        int iButtonId = (int) lua_tonumber(_pState, 1);
        // Try call non static function
        bool bIsButtonPressed = pSomeClass->ButtonIsPressed(iButtonId);
        if(ms_pLua->LuaCheckStack(_pState, 1))
        {
                // Push result camera position into script function
                lua_pushboolean(_pState, bIsButtonPressed);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_ButtonIsPressed() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 1;
}

int K3dVM::GetGuiObject(const char* _strObjName, const int _iObjType)
{
        // Get object index by object name and object type
        int iId = ms_pScene->FindGuiObjectId(_strObjName, _iObjType);
        return iId;
}

int K3dVM::K3d_GetGuiObject(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        const char* strObjName = (const char*) lua_tostring(_pState, 1);
        const int iObjType = (int) lua_tonumber(_pState, 2);
        // Try call non static function
        int iResult = pSomeClass->GetGuiObject(strObjName, iObjType);
        if(ms_pLua->LuaCheckStack(_pState, 1))
        {
                // Push result into script function
                lua_pushnumber(_pState, iResult);
        }
        else
        {
                cerr << "Error :: int K3dVM::K3d_GetGuiObject() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        // Return number of results
        return 1;
}

void K3dVM::HideGui(const int _iObjId, const int _iObjType)
{
        ms_pScene->HideGui(_iObjId, _iObjType);
}

int K3dVM::K3d_HideGui(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        const int iObjId = (int) lua_tonumber(_pState, 1);
        const int iObjType = (int) lua_tonumber(_pState, 2);
        // Try call non static function
        pSomeClass->HideGui(iObjId, iObjType);
        // Return number of results
        return 0;
}

void K3dVM::ShowGui(const int _iObjId, const int _iObjType)
{
        ms_pScene->ShowGui(_iObjId, _iObjType);
}

int K3dVM::K3d_ShowGui(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        const int iObjId = (int) lua_tonumber(_pState, 1);
        const int iObjType = (int) lua_tonumber(_pState, 2);
        // Try call non static function
        pSomeClass->ShowGui(iObjId, iObjType);
        // Return number of results
        return 0;
}

void K3dVM::ShowFileListBox(const int _iListModel, const char * _strPath)
{
        ms_pScene->ShowFileListBox(_iListModel, _strPath);
}

int K3dVM::K3d_ShowFileListBox(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        const int iListModel = (int) lua_tonumber(_pState, 1);
        const char* strPath = lua_tostring(_pState, 2);
        // Try call non static function
        pSomeClass->ShowFileListBox(iListModel, strPath);
        // Return number of results
        return 0;
}

bool K3dVM::LoadMapFromListBox(const int _iListBoxId, const char * _strPath)
{
        return ms_pScene->LoadMapFromListBox(_iListBoxId, _strPath);
}

int K3dVM::K3d_LoadMapFromListBox(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        const int iListBox = (int) lua_tonumber(_pState, 1);
        const char* strPath = lua_tostring(_pState, 2);
        // Try call non static function
        bool bIsLoad = pSomeClass->LoadMapFromListBox(iListBox, strPath);
        // Return result
        lua_pushboolean(_pState, bIsLoad);
        // Return number of results
        return 1;
}

bool K3dVM::CheckKeyboardKey(const char* _strKey)
{
        // Get global keyboard map pointer
        K3dKeyMap *pKeyMap = ms_pGameData->GetKeyMap(); 
        K3dString str = _strKey;
        if(str == "Esc")
        {
                return pKeyMap->GetKeyEsc();
        }
        return false;
}
int K3dVM::K3d_CheckKeyboardKey(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        const char* strKey = lua_tostring(_pState, 1);
        // Try call non static function
        bool bIsPressed = pSomeClass->CheckKeyboardKey(strKey);
        // Return result
        lua_pushboolean(_pState, bIsPressed);
        // Return number of results
        return 1;
}

void K3dVM::LoadNewScript(const char* _strFileName)
{
        ms_pScene->LoadNewScript(_strFileName);
}
int K3dVM::K3d_LoadNewScript(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Get function parameters
        const char* strFileName = lua_tostring(_pState, 1);
        // Try call non static function
        pSomeClass->LoadNewScript(strFileName);
        // Return number of results
        return 0;
}

void K3dVM::Exit()
{
        cout << "Exit engine" << endl;
        ms_pScene->GetExit() = true;
}
int  K3dVM::K3d_Exit(lua_State *_pState)
{
        // Cast the void pointer
        K3dVM *pSomeClass = (K3dVM*)ms_pObject;
        // Try call non static function
        pSomeClass->Exit();
        // Return number of results
        return 0;
}

---