LuaBind and Irrlicht

jcfalcone · Post by **jcfalcone** » Tue Mar 23, 2010 2:25 am

Hello every one.

This time i'm trying to put a scripting language on my game engine, and i choice lua and luabind to work, but a some days i'm having problem to put the class ISceneNode on my scripts, when i do that:

Code: Select all

ISceneNode * Node = irrWidget->getSceneManager()->getSceneNodeFromName("miku1") ;

luabind::globals(LuaState)["MyNode"] = Node;

The program has unexpectedly finished And i don't know why if i change to this everything work:

Code: Select all

ISceneNode * Node = irrWidget->getSceneManager()->getSceneNodeFromName("miku1") ;

luabind::globals(LuaState)["MyNode"] = Node->getPosition();

Someone know what to do? i really need help

Brkopac · Post by **Brkopac** » Tue Mar 23, 2010 5:16 am

What is the exact error output?

jcfalcone · Post by **jcfalcone** » Wed Mar 24, 2010 3:09 am

nothing only close the program, and i don't know whats the problem, i'm trying a some days to put this to work

jcfalcone · Post by **jcfalcone** » Wed Mar 24, 2010 3:30 pm

Please someone put the luabind to work with irrlicht?

i don't know wat to do with this, always when i try to put a ISceneNode in a lua var the program Crash. and i don't find any example of irrlicht with luabind to see what i'm doing wrong.

Follow my Lua Class:

Code: Select all

FLuaMachine::FLuaMachine()
{
    this->LuaState = lua_open();

    // load the libs
    luaL_openlibs(this->LuaState);

    luabind::open(this->LuaState);

    this->StartClasses();

}

FLuaMachine::~FLuaMachine()
{
    this->close();
}

bool FLuaMachine::runScript(QString Script)
{
  try {

    luaL_dofile(this->LuaState,Script.toStdString().c_str());

  }
  catch(const std::exception &TheError)
  {
    return false;
    std::cerr << TheError.what() << std::endl;
  }

  return true;
}

lua_State * FLuaMachine::getLuaState()
{
    return this->LuaState;
}

void FLuaMachine::close()
{

    lua_close(this->LuaState);
}

void FLuaMachine::StartClasses()
{
    luabind::module(this->LuaState, "irr")
    [
        luabind::class_<IAttributes>("IAttributes")
             .def("clear", &IAttributes::clear)
             .def("addInt", &IAttributes::addInt)
             .def("addFloat", &IAttributes::addFloat)
             .def("addBool", &IAttributes::addBool)
             .def("addColor", &IAttributes::addColor)
             .def("addColorf", &IAttributes::addColorf)
             .def("addVector3d", &IAttributes::addVector3d)
             .def("addBinary", &IAttributes::addBinary)
             .def("addTexture", &IAttributes::addTexture)
             .def("getAttributeCount", &IAttributes::getAttributeCount)
             .def("getAttributeName", &IAttributes::getAttributeName)
             .def("existsAttribute", &IAttributes::existsAttribute)
             .def("findAttribute", &IAttributes::findAttribute)
             .def("read", &IAttributes::read)
             .def("write", &IAttributes::write),

        luabind::class_<SAttributeReadWriteOptions>("SAttributeReadWriteOptions")
             .def_readwrite("Filename", &SAttributeReadWriteOptions::Filename)
             .def_readwrite("Flags", &SAttributeReadWriteOptions::Flags),

        luabind::class_<IAttributeExchangingObject>("IAttributeExchangingObject")
             .def("serializeAttributes", &IAttributeExchangingObject::serializeAttributes)
             .def("deserializeAttributes", &IAttributeExchangingObject::deserializeAttributes)
             .def("grab", &IAttributeExchangingObject::grab)
             .def("drop", &IAttributeExchangingObject::drop)
             .def("getDebugName", &IAttributeExchangingObject::getDebugName)
             .def("getReferenceCount", &IAttributeExchangingObject::getReferenceCount),

        luabind::class_<vector2df>("vector2df")
             .def(luabind::constructor<float, float>())
             .def("getLength", &vector2df::getLength)
             .def("dotProduct", &vector2df::dotProduct)
             .def("getDistanceFrom", &vector2df::getDistanceFrom)
             .def("rotateBy", &vector2df::rotateBy)
             .def("normalize", &vector2df::normalize)
             .def("getAngleTrig", &vector2df::getAngleTrig)
             .def("getAngle", &vector2df::getAngle)
             .def("getAngleWith", &vector2df::getAngleWith)
             .def("getInterpolated", &vector2df::getInterpolated)
             .def("interpolate", &vector2df::interpolate)
             .def_readwrite("X", &vector2df::X)
             .def_readwrite("Y", &vector2df::Y),

        luabind::class_<vector3df>("vector3df")
             .def(luabind::constructor<float, float, float>())
             .def("interpolate", &vector3df::equals)
             //.def("interpolate", &vector3df::set)
             .def("interpolate", &vector3df::getLength)
             .def("interpolate", &vector3df::getLengthSQ)
             .def("interpolate", &vector3df::dotProduct)
             .def("interpolate", &vector3df::getDistanceFrom)
             .def("interpolate", &vector3df::getDistanceFromSQ)
             .def("interpolate", &vector3df::crossProduct)
             .def("interpolate", &vector3df::isBetweenPoints)
             .def("interpolate", &vector3df::normalize)
             .def("interpolate", &vector3df::setLength)
             .def("interpolate", &vector3df::invert)
             .def("interpolate", &vector3df::rotateXZBy)
             .def("interpolate", &vector3df::rotateXYBy)
             .def("interpolate", &vector3df::rotateYZBy)
             .def("interpolate", &vector3df::getInterpolated)
             .def("interpolate", &vector3df::getHorizontalAngle)
             .def("interpolate", &vector3df::getAs4Values)
             .def_readwrite("X", &vector3df::X)
             .def_readwrite("Y", &vector3df::Y)
             .def_readwrite("Z", &vector3df::Z),

        luabind::class_<dimension2df>("dimension2df")
             .def("getArea", &dimension2df::getArea)
             .def("getInterpolated", &dimension2df::getInterpolated)
             .def("getOptimalSize", &dimension2df::getOptimalSize)
             .def("set", &dimension2df::set)
             .def_readwrite("Height", &dimension2df::Height)
             .def_readwrite("Width", &dimension2df::Width),
/*
        luabind::class_<position2df>("position2df")
             .def("dotProduct", &position2df::dotProduct)
             .def("getOptimalSize", &position2df::equals)
             .def("getInterpolated", &position2df::getAngle)
             .def("getAngleTrig", &position2df::getAngleTrig)
             .def("getAngleWith", &position2df::getAngleWith)
             .def("getDistanceFrom", &position2df::getDistanceFrom)
             .def("getDistanceFromSQ", &position2df::getDistanceFromSQ)
             .def("getInterpolated", &position2df::getInterpolated)
             .def("getInterpolated_quadratic", &position2df::getInterpolated_quadratic)
             .def("getLength", &position2df::getLength)
             .def("getLengthSQ", &position2df::getLengthSQ)
             .def("interpolate", &position2df::interpolate)
             .def("isBetweenPoints", &position2df::isBetweenPoints)
             .def("normalize", &position2df::normalize)
             .def("rotateBy", &position2df::rotateBy)
             //.def("set", &position2df::set)
             .def_readwrite("X", &position2df::X)
             .def_readwrite("Y", &position2df::Y),*/

        luabind::class_<line2df>("line2df")
             .def("getAngleWith", &line2df::getAngleWith)
             .def("getClosestPoint", &line2df::getClosestPoint)
             .def("getLength", &line2df::getLength)
             .def("getLengthSQ", &line2df::getLengthSQ)
             .def("getMiddle", &line2df::getMiddle)
             .def("getPointOrientation", &line2df::getPointOrientation)
             .def("getUnitVector", &line2df::getUnitVector)
             .def("getVector", &line2df::getVector)
             .def("intersectWith", &line2df::intersectWith)
             .def("isPointBetweenStartAndEnd", &line2df::isPointBetweenStartAndEnd)
             .def("isPointOnLine", &line2df::isPointOnLine)
             //.def("setLine", &line2df::setLine)
             .def_readwrite("start", &line2df::start)
             .def_readwrite("end", &line2df::end),

        luabind::class_<line3df>("line3df")
             .def("getClosestPoint", &line3df::getClosestPoint)
             .def("getIntersectionWithSphere", &line3df::getIntersectionWithSphere)
             .def("getLength", &line3df::getLength)
             .def("getLengthSQ", &line3df::getLengthSQ)
             .def("getMiddle", &line3df::getMiddle)
             .def("getVector", &line3df::getVector)
             .def("isPointBetweenStartAndEnd", &line3df::isPointBetweenStartAndEnd)
             //.def("isPointBetweenStartAndEnd", &line3df::setLine)
             //.def(self + other<vector3df>())
             //.def(self - other<vector3df>())
             //.def(luabind::const_self == other<line3df>())
             .def_readwrite("start",&line3df::start)
             .def_readwrite("end", &line3df::end),

        luabind::class_<plane3df>("plane3df")
             .def("classifyPointRelation", &plane3df::classifyPointRelation)
             .def("existsIntersection", &plane3df::existsIntersection)
             .def("getDistanceTo", &plane3df::getDistanceTo)
             .def("getIntersectionWithLimitedLine", &plane3df::getIntersectionWithLimitedLine)
             .def("getIntersectionWithLine", &plane3df::getIntersectionWithLine)
             .def("getIntersectionWithPlane", &plane3df::getIntersectionWithPlane)
             .def("getIntersectionWithPlanes", &plane3df::getIntersectionWithPlanes)
             .def("getKnownIntersectionWithLine", &plane3df::getKnownIntersectionWithLine)
             .def("getMemberPoint", &plane3df::getMemberPoint)
             .def("isFrontFacing", &plane3df::isFrontFacing)
             .def("recalculateD", &plane3df::recalculateD)
             //.def("setPlane", &plane3df::setPlane)
             .def_readwrite("D",&plane3df::D)
             .def_readwrite("Normal",&plane3df::Normal),

        luabind::class_<aabbox3df>("aabbox3df")
             .def("addInternalBox", &aabbox3df::addInternalBox)
             //.def("addInternalPoint", &aabbox3df::addInternalPoint)
             .def("classifyPlaneRelation", &aabbox3df::classifyPlaneRelation)
             .def("getArea", &aabbox3df::getArea)
             .def("getCenter", &aabbox3df::getCenter)
             .def("getEdges", &aabbox3df::getEdges)
             .def("getExtent", &aabbox3df::getExtent)
             .def("getInterpolated", &aabbox3df::getInterpolated)
             .def("getVolume", &aabbox3df::getVolume)
             .def("intersectsWithBox", &aabbox3df::intersectsWithBox)
             //.def("intersectsWithLine", &aabbox3df::intersectsWithLine)
             .def("isEmpty", &aabbox3df::isEmpty)
             .def("isFullInside", &aabbox3df::isFullInside)
             .def("isPointInside", &aabbox3df::isPointInside)
             .def("isPointTotalInside", &aabbox3df::isPointTotalInside)
             .def("repair", &aabbox3df::repair)
             //.def("reset", &aabbox3df::reset)
             .def_readwrite("MaxEdge",&aabbox3df::MaxEdge)
             .def_readwrite("MinEdge",&aabbox3df::MinEdge),

        luabind::class_<triangle3df>("triangle3df")
             .def("closestPointOnTriangle", &triangle3df::closestPointOnTriangle)
             .def("getArea", &triangle3df::getArea)
             .def("getIntersectionOfPlaneWithLine", &triangle3df::getIntersectionOfPlaneWithLine)
             .def("getIntersectionWithLimitedLine", &triangle3df::getIntersectionWithLimitedLine)
             .def("getIntersectionWithLine", &triangle3df::getIntersectionWithLine)
             .def("getNormal", &triangle3df::getNormal)
             .def("getPlane", &triangle3df::getPlane)
             .def("isFrontFacing", &triangle3df::isFrontFacing)
             .def("isPointInside", &triangle3df::isPointInside)
             .def("isPointInsideFast", &triangle3df::isPointInsideFast)
             .def("isTotalInsideBox", &triangle3df::isTotalInsideBox)
             .def("set", &triangle3df::set)
             .def_readwrite("pointA",&triangle3df::pointA)
             .def_readwrite("pointB",&triangle3df::pointB)
             .def_readwrite("pointC",&triangle3df::pointC),

        luabind::class_<S3DVertex>("S3DVertex")
             .def("getType", &S3DVertex::getType)
             .def_readwrite("Color",&S3DVertex::Color)
             .def_readwrite("Normal",&S3DVertex::Normal)
             .def_readwrite("Pos",&S3DVertex::Pos)
             .def_readwrite("TCoords",&S3DVertex::TCoords),

        luabind::class_<S3DVertex2TCoords>("S3DVertex2TCoords")
             .def("getType", &S3DVertex2TCoords::getType)
             .def_readwrite("Color",&S3DVertex2TCoords::Color)
             .def_readwrite("Normal",&S3DVertex2TCoords::Normal)
             .def_readwrite("Pos",&S3DVertex2TCoords::Pos)
             .def_readwrite("TCoords",&S3DVertex2TCoords::TCoords)
             .def_readwrite("TCoords2",&S3DVertex2TCoords::TCoords2),

        luabind::class_<S3DVertexTangents>("S3DVertexTangents")
             .def("getType", &S3DVertexTangents::getType)
             .def_readwrite("Color",&S3DVertexTangents::Color)
             .def_readwrite("Normal",&S3DVertexTangents::Normal)
             .def_readwrite("Pos",&S3DVertexTangents::Pos)
             .def_readwrite("TCoords",&S3DVertexTangents::TCoords)
             .def_readwrite("Tangent",&S3DVertexTangents::Tangent)
             .def_readwrite("Binormal",&S3DVertexTangents::Binormal),

        luabind::class_<ITexture>("ITexture")
             .def("drop", &ITexture::drop)
             .def("getColorFormat", &ITexture::getColorFormat)
             .def("getDebugName", &ITexture::getDebugName)
             .def("getDriverType", &ITexture::getDriverType)
             .def("getName", &ITexture::getName)
             .def("getOriginalSize", &ITexture::getOriginalSize)
             .def("getPitch", &ITexture::getPitch)
             .def("getReferenceCount", &ITexture::getReferenceCount)
             .def("getSize", &ITexture::getSize)
             .def("grab", &ITexture::grab)
             .def("hasAlpha", &ITexture::hasAlpha)
             .def("hasMipMaps", &ITexture::hasMipMaps)
             .def("isRenderTarget", &ITexture::isRenderTarget)
             .def("lock", &ITexture::lock)
             .def("regenerateMipMapLevels", &ITexture::regenerateMipMapLevels)
             .def("unlock", &ITexture::unlock),

        luabind::class_<rectf>("rectf")
             //.def("addInternalPoint", &rectf::addInternalPoint)
             .def("clipAgainst", &rectf::clipAgainst)
             .def("constrainTo", &rectf::constrainTo)
             .def("getArea", &rectf::getArea)
             .def("getCenter", &rectf::getCenter)
             .def("getHeight", &rectf::getHeight)
             .def("getSize", &rectf::getSize)
             .def("getWidth", &rectf::getWidth)
             .def("isPointInside", &rectf::isPointInside)
             .def("isRectCollided", &rectf::isRectCollided)
             .def("isValid", &rectf::isValid)
             .def("repair", &rectf::repair)
             .def_readwrite("LowerRightCorner",&rectf::LowerRightCorner)
             .def_readwrite("UpperLeftCorner",&rectf::UpperLeftCorner),

        luabind::class_<matrix4>("matrix4")
             .def("buildAxisAlignedBillboard", &matrix4::buildAxisAlignedBillboard)
             .def("buildCameraLookAtMatrixLH", &matrix4::buildCameraLookAtMatrixLH)
             .def("buildCameraLookAtMatrixRH", &matrix4::buildCameraLookAtMatrixRH)
             .def("buildNDCToDCMatrix", &matrix4::buildNDCToDCMatrix)
             .def("buildProjectionMatrixOrthoLH", &matrix4::buildProjectionMatrixOrthoLH)
             .def("buildProjectionMatrixOrthoRH", &matrix4::buildProjectionMatrixOrthoRH)
             .def("buildProjectionMatrixPerspectiveFovLH", &matrix4::buildProjectionMatrixPerspectiveFovLH)
             .def("buildProjectionMatrixPerspectiveFovRH", &matrix4::buildProjectionMatrixPerspectiveFovRH)
             .def("buildProjectionMatrixPerspectiveLH", &matrix4::buildProjectionMatrixPerspectiveLH)
             .def("buildProjectionMatrixPerspectiveRH", &matrix4::buildProjectionMatrixPerspectiveRH)
             .def("buildRotateFromTo", &matrix4::buildRotateFromTo)
             .def("buildShadowMatrix", &matrix4::buildShadowMatrix)
             .def("buildTextureTransform", &matrix4::buildTextureTransform)
             .def("getDefinitelyIdentityMatrix", &matrix4::getDefinitelyIdentityMatrix)
             .def("getInverse", &matrix4::getInverse)
             .def("getInversePrimitive", &matrix4::getInversePrimitive)
             .def("getRotationDegrees", &matrix4::getRotationDegrees)
             .def("getScale", &matrix4::getScale)
             .def("getTranslation", &matrix4::getTranslation)
             //.def("addInternalPoint", &matrix4::getTransposed)
             .def("interpolate", &matrix4::interpolate)
             .def("inverseRotateVect", &matrix4::inverseRotateVect)
             .def("inverseTranslateVect", &matrix4::inverseTranslateVect)
             .def("isIdentity", &matrix4::isIdentity)
             .def("isIdentity_integer_base", &matrix4::isIdentity_integer_base)
             .def("isOrthogonal", &matrix4::isOrthogonal)
             .def("makeIdentity", &matrix4::makeIdentity)
             .def("makeInverse", &matrix4::makeInverse)
             .def("multiplyWith1x4Matrix", &matrix4::multiplyWith1x4Matrix)
             //.def("addInternalPoint", &matrix4::pointer)
             //.def("addInternalPoint", &matrix4::rotateVect)
             .def("setbyproduct", &matrix4::setbyproduct)
             .def("setbyproduct_nocheck", &matrix4::setbyproduct_nocheck)
             .def("setDefinitelyIdentityMatrix", &matrix4::setDefinitelyIdentityMatrix)
             .def("setInverseRotationDegrees", &matrix4::setInverseRotationDegrees)
             .def("setRotationRadians", &matrix4::setRotationRadians)
             //.def("addInternalPoint", &matrix4::setScale)
             .def("setTextureRotationCenter", &matrix4::setTextureRotationCenter)
             .def("setTextureScale", &matrix4::setTextureScale)
             .def("setTextureScaleCenter", &matrix4::setTextureScaleCenter)
             .def("setTextureTranslate", &matrix4::setTextureTranslate)
             .def("setTextureTranslateTransposed", &matrix4::setTextureTranslateTransposed)
             .def("setTranslation", &matrix4::setTranslation)
             .def("transformBox", &matrix4::transformBox)
             .def("transformBoxEx", &matrix4::transformBoxEx)
             //.def("addInternalPoint", &matrix4::transformPlane)
             //.def("addInternalPoint", &matrix4::transformVect)
             .def("translateVect", &matrix4::translateVect)
             .def("translateVect", &matrix4::translateVect)
             .enum_("constants")
             [
                   luabind::value("EM4CONST_COPY", matrix4::EM4CONST_COPY),
                   luabind::value("EM4CONST_IDENTITY", matrix4::EM4CONST_IDENTITY),
                   luabind::value("EM4CONST_INVERSE", matrix4::EM4CONST_INVERSE),
                   luabind::value("EM4CONST_INVERSE_TRANSPOSED", matrix4::EM4CONST_INVERSE_TRANSPOSED),
                   luabind::value("EM4CONST_NOTHING", matrix4::EM4CONST_NOTHING),
                   luabind::value("EM4CONST_TRANSPOSED", matrix4::EM4CONST_TRANSPOSED)
             ],

        //luabind::class_<quartenion>("quartenion"),

        luabind::class_<ISceneNode>("ISceneNode")
             /*.def("addInternalPoint", &ISceneNode::addAnimator)
             .def("addInternalPoint", &ISceneNode::addChild)
             .def("addInternalPoint", &ISceneNode::clone)
             .def("addInternalPoint", &ISceneNode::deserializeAttributes)
             .def("addInternalPoint", &ISceneNode::drop)
             .def("addInternalPoint", &ISceneNode::getAbsolutePosition)
             .def("addInternalPoint", &ISceneNode::getAbsoluteTransformation)
             .def("addInternalPoint", &ISceneNode::getAnimators)*/
             .def("addInternalPoint", &ISceneNode::getPosition)

//093058
//100843

     ];
}

And i use in this Way:

Code: Select all

    FLuaMachine LuaMachine;

    ISceneNode * Node = irrWidget->getSceneManager()->getSceneNodeFromName("miku1") ;

    luabind::globals(LuaMachine.getLuaState())["MyNode"] = Node;

    LuaMachine.runScript("lua.lua");

jcfalcone · Post by **jcfalcone** » Fri Mar 26, 2010 4:46 am

no one have experience with luabind+irrlicht?

I think the logic with others script languages is the same to declare c++ class.

Or some one know a way to discover why a program has unexpectedly finished.