scripting/irrlicht/asRect.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            asRect.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Binds the rect<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 "asIrrHelper.h"
#include "asRect.h"
#include "asDimension2d.h"
#include "asVector2d.h"


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

template<typename T>
void constructor(const position2d<T> &pos, const dimension2d<T> &size, void *memory)
{
    new (memory) rect<T>(pos, size);
}

template<typename T>
void constructor(const position2d<T> &upperLeft, const position2d<T> &lowerRight, void *memory)
{
    new (memory) rect<T>(upperLeft, lowerRight);
}

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


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

    // Bind Rect<T> class.
    r = engine->RegisterObjectType(typeName, sizeof(rect<T>), asOBJ_VALUE | asOBJ_APP_CLASS_CDA); assert(r >= 0);

    // Set rect<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 " << getVector2dName(asType) << " &in, const " << getDimension2dName(asType) << " &in)";
    r = engine->RegisterObjectBehaviour(typeName, asBEHAVE_CONSTRUCT, ss.str().c_str(), asFUNCTIONPR(constructor<T>,
                                        (const position2d<T>&, const dimension2d<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 position2d<T>&, const position2d<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.
    ss.str("");
    ss << typeName << " f(const " << typeName << " &in, const " << getVector2dName(asType) << "&in)";
    std::string declActionType = ss.str();

    ss.str("");
    ss << typeName << "& f(const " << getVector2dName(asType) << "&in)";
    std::string declAssignType = ss.str();

    // Add (+)
    r = engine->RegisterGlobalBehaviour(asBEHAVE_ADD, declActionType.c_str(),
                                        asFUNCTIONPR((add< rect<T>, rect<T>, position2d<T> >),
                                        (const rect<T>&, const position2d<T>&), rect<T>),
                                        asCALL_CDECL); assert(r >= 0);

    // Add Assign (+=)
    ss.str("");
    ss << typeName << "& f(const " << getVector2dName(asType) << "&in)";
    r = engine->RegisterObjectBehaviour(typeName, asBEHAVE_ADD_ASSIGN, declAssignType.c_str(),
                                        asMETHODPR(rect<T>, operator+=, (const position2d<T>&),
                                        rect<T>&), asCALL_THISCALL); assert(r >= 0);

    // Subtract (-)
    r = engine->RegisterGlobalBehaviour(asBEHAVE_SUBTRACT, declActionType.c_str(),
                                        asFUNCTIONPR((substract< rect<T>, rect<T>, position2d<T> >),
                                        (const rect<T>&, const position2d<T>&), rect<T>),
                                        asCALL_CDECL); assert(r >= 0);

    // Subtract Assign (-=)
    r = engine->RegisterObjectBehaviour(typeName, asBEHAVE_SUB_ASSIGN, declAssignType.c_str(),
                                        asMETHODPR(rect<T>, operator-=, (const position2d<T>&),
                                        rect<T>&), asCALL_THISCALL); assert(r >= 0);

    // Comparison behaviours.
    ss.str("");
    ss << "bool f(const " << typeName << " &in, const " << typeName << " &in)";
    std::string declComparison = ss.str();

    r = engine->RegisterGlobalBehaviour(asBEHAVE_EQUAL, declComparison.c_str(), asFUNCTIONPR(equal< rect<T> >,
                                        (const rect<T>&, const rect<T>&), bool), asCALL_CDECL); assert(r >= 0);
    r = engine->RegisterGlobalBehaviour(asBEHAVE_NOTEQUAL, declComparison.c_str(), asFUNCTIONPR(not_equal< rect<T> >,
                                        (const rect<T>&, const rect<T>&), bool), asCALL_CDECL); assert(r >= 0);
    r = engine->RegisterGlobalBehaviour(asBEHAVE_LESSTHAN, declComparison.c_str(), asFUNCTIONPR(less_than< rect<T> >,
                                        (const rect<T>&, const rect<T>&), bool), asCALL_CDECL); assert(r >= 0);

    // Bind rect<T> class functions.
    ss.str("");
    ss << "void addInternalPoint(const " << getVector2dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHODPR(rect<T>, addInternalPoint, (const position2d<T>&), void),
                                     asCALL_THISCALL); assert(r >= 0);

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

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

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

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

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

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

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

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

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

    r = engine->RegisterObjectMethod(typeName, "bool isValid()",
                                     asMETHOD(rect<T>, isValid), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod(typeName, "void repair()",
                                     asMETHOD(rect<T>, repair), asCALL_THISCALL); assert(r >= 0);

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

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

void bindRect(asIScriptEngine *engine)
{
    bindRectT<f32>(engine, "rectf", "f32");
    bindRectT<s32>(engine, "recti", "s32");
}

std::string getRectName(const std::string &asType)
{
    if(asType == "f32")   return std::string("rectf");
    if(asType == "s32")   return std::string("recti");
    else return std::string("");
}

// End of File

---