scripting/vendor/irrlicht/asLine2d.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            asVector2d.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Binds the line2d<T> class from the Irrlicht engine.
//
// License:         Copyright (C) 2009 Michael Bartsch and Contributors
//
//                  This program is free software: you can redistribute it
//                  and/or modify it under the terms of the zlib/libpng License.
//                  See main.cpp for conditions of distribution and use.
//
// /////////////////////////////////////////////////////////////////////////////

// Include files
#include "asVector2d.h"

#ifdef __COMPILE_WITH_ANGELSCRIPT__

#include "asIrrHelper.h"
#include "asLine2d.h"


// line2d<T> behaviour functions.
template<typename T>
void constructor(void *memory)
{
    new (memory) line2d<T>();
}

template<typename T>
void constructor(const line2d<T> &other, void *memory)
{
    new (memory) line2d<T>(other);
}

template<typename T>
void constructor(const vector2d<T> &start, const vector2d<T> &end, void *memory)
{
    new (memory) line2d<T>(start, end);
}

template<typename T>
void deconstructor(void *memory)
{
    ((line2d<T>*)memory)->~line2d<T>();
}


template<typename T>
void bindLine2dT(asIScriptEngine *engine, const char *typeName, const char *asType)
{
    // Forward declarations.
    int r;
    std::stringstream ss;

    // Bind Vector2d<T> class.
    r = engine->RegisterObjectType(typeName, sizeof(line2d<T>), asOBJ_VALUE | asOBJ_APP_CLASS_CD); assert(r >= 0);

    // Set line2d<T> behaviour.
    // Initialisation and deinitialisation
    r = engine->RegisterObjectBehaviour(typeName, asBEHAVE_CONSTRUCT, "void f()", asFUNCTIONPR(constructor<T>,
                                        (void*), void), asCALL_CDECL_OBJLAST); assert(r >= 0);

    ss.str("");
    ss << "void f(const " << typeName << " &in)";
    r = engine->RegisterObjectBehaviour(typeName, asBEHAVE_CONSTRUCT, ss.str().c_str(), asFUNCTIONPR(constructor<T>,
                                        (const line2d<T>&, void*), void), asCALL_CDECL_OBJLAST); assert(r >= 0);

    ss.str("");
    ss << "void f(const " << getVector2dName(asType) << " &in, const " << getVector2dName(asType) << " &in)";
    r = engine->RegisterObjectBehaviour(typeName, asBEHAVE_CONSTRUCT, ss.str().c_str(), asFUNCTIONPR(constructor<T>,
                                        (const vector2d<T>&, const vector2d<T>&, void*), void),
                                        asCALL_CDECL_OBJLAST); assert(r >= 0);

    r = engine->RegisterObjectBehaviour(typeName, asBEHAVE_DESTRUCT, "void f()", asFUNCTION(deconstructor<T>),
                                        asCALL_CDECL_OBJLAST); assert(r >= 0);

    // Calculation behaviours.
    // Add (+)
    ss.str("");
    ss << typeName << " opAdd(const " << getVector2dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asFUNCTIONPR((add< line2d<T>, line2d<T>, vector2d<T> >),
                                     (const line2d<T>&, const vector2d<T>&), line2d<T>),
                                     asCALL_CDECL_OBJFIRST); assert(r >= 0);

    // Add Assign (+=)
    ss.str("");
    ss << typeName << "& opAddAssign(const " << getVector2dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                        asMETHODPR(line2d<T>, operator+=, (const vector2d<T>&),
                                        line2d<T>&), asCALL_THISCALL); assert(r >= 0);

    // Subtract (-)
    ss.str("");
    ss << typeName << " opSub(const " << getVector2dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asFUNCTIONPR((substract< line2d<T>, line2d<T>, vector2d<T> >),
                                     (const line2d<T>&, const vector2d<T>&), line2d<T>),
                                     asCALL_CDECL_OBJFIRST); assert(r >= 0);

    // Subtract Assign (-=)
    ss.str("");
    ss << typeName << "& opSubAssign(const " << getVector2dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHODPR(line2d<T>, operator-=, (const vector2d<T>&),
                                     line2d<T>&), asCALL_THISCALL); assert(r >= 0);

    // Comparison behaviours.
    ss.str("");
    ss << "bool opEquals(const " << typeName << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(), asFUNCTIONPR(equal< line2d<T> >,
                                     (const line2d<T>&, const line2d<T>&), bool), asCALL_CDECL_OBJFIRST); assert(r >= 0);

    // Bind line2d<T> class functions.
    ss.str("");
    ss << "f64 getAngleWith(const " << typeName << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHOD(line2d<T>, getAngleWith), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << getVector2dName(asType) << " getClosestPoint(const " << getVector2dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHOD(line2d<T>, getClosestPoint), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod(typeName, "f64 getLength()",
                                     asMETHOD(line2d<T>, getLength), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << asType << " getLengthSQ()";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHOD(line2d<T>, getLengthSQ), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << getVector2dName(asType) << " getMiddle()";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHOD(line2d<T>, getMiddle), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << asType << " getPointOrientation(const " << getVector2dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHOD(line2d<T>, getPointOrientation), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << getVector2dName(asType) << " getUnitVector()";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHOD(line2d<T>, getUnitVector), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << getVector2dName(asType) << " getVector()";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHOD(line2d<T>, getVector), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << "bool intersectWith(const " << typeName << " &in, const " << getVector2dName(asType) << " &out)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHOD(line2d<T>, intersectWith), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << "bool isPointBetweenStartAndEnd(const " << getVector2dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHOD(line2d<T>, isPointBetweenStartAndEnd), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << "bool isPointOnLine(const " << typeName << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHOD(line2d<T>, isPointOnLine), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << "void setLine(const " << typeName << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHODPR(line2d<T>, setLine, (const line2d<T>&), void), asCALL_THISCALL); assert(r >= 0);

    ss.str("");
    ss << "void setLine(const " << getVector2dName(asType) << " &in, const " << getVector2dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHODPR(line2d<T>, setLine, (const vector2d<T>&, const vector2d<T>&), void),
                                     asCALL_THISCALL); assert(r >= 0);

    // Bind line2d<T> class properties.
    ss.str("");
    ss << getVector2dName(asType) << " end";
    r = engine->RegisterObjectProperty(typeName, ss.str().c_str(), offsetof(line2d<T>, end)); assert(r >= 0);

    ss.str("");
    ss << getVector2dName(asType) << " start";
    r = engine->RegisterObjectProperty(typeName, ss.str().c_str(), offsetof(line2d<T>, start)); assert(r >= 0);
}

void bindLine2d(asIScriptEngine *engine)
{
    bindLine2dT<f32>(engine, "line2df", "f32");
    bindLine2dT<s32>(engine, "line2di", "s32");
}

std::string getLine2dName(const std::string &asType)
{
    if(asType == "f32")   return std::string("line2df");
    if(asType == "s32")   return std::string("line2di");
    else return std::string("");
}

#endif // __COMPILE_WITH_ANGELSCRIPT__

// End of File

---