scripting/irrlicht/asAabbox3d.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            asAabbox3d.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Binds the aabbox3d<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 "asAabbox3d.h"
#include "asVector3d.h"
#include "asLine3d.h"


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

template<typename T>
void constructor(T minX, T minY, T minZ, T maxX, T maxY, T maxZ, void *memory)
{
    new (memory) aabbox3d<T>(minX, minY, minZ, maxX, maxY, maxZ);
}

template<typename T>
void constructor(const vector3d<T> &init, void *memory)
{
    new (memory) aabbox3d<T>(init);
}

template<typename T>
void constructor(const vector3d<T> &min, const vector3d<T> &max, void *memory)
{
    new (memory) aabbox3d<T>(min, max);
}

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


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

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

    // Set aabbox3d<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(" << asType << ", " << asType << ", " << asType << ", " << asType << ", "
       << asType << ", " << asType << ", " << asType << ")";
    r = engine->RegisterObjectBehaviour(typeName, asBEHAVE_CONSTRUCT, ss.str().c_str(), asFUNCTIONPR(constructor<T>,
                                        (T, T, T, T, T, T, void*), void), asCALL_CDECL_OBJLAST); assert(r >= 0);

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

    ss.str("");
    ss << "void f(const " << getVector3dName(asType) << " &in, const " << getVector3dName(asType) << " &in)";
    r = engine->RegisterObjectBehaviour(typeName, asBEHAVE_CONSTRUCT, ss.str().c_str(), asFUNCTIONPR(constructor<T>,
                                        (const vector3d<T>&, const vector3d<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);

    // 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< aabbox3d<T> >,
                                        (const aabbox3d<T>&, const aabbox3d<T>&), bool), asCALL_CDECL); assert(r >= 0);
    r = engine->RegisterGlobalBehaviour(asBEHAVE_NOTEQUAL, declComparison.c_str(), asFUNCTIONPR(not_equal< aabbox3d<T> >,
                                        (const aabbox3d<T>&, const aabbox3d<T>&), bool), asCALL_CDECL); assert(r >= 0);

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

    ss.str("");
    ss << "void addInternalPoint(const " << getVector3dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHODPR(aabbox3d<T>, addInternalPoint, (const vector3d<T>&), void),
                                     asCALL_THISCALL); assert(r >= 0);

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

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

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

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

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

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

    ss.str("");
    ss << "bool intersectsWithLine(const " << getLine3dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHODPR(aabbox3d<T>, intersectsWithLine, (const line3d<T>&) const, bool),
                                     asCALL_THISCALL); assert(r >= 0);

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

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

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

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

    ss.str("");
    ss << "void reset(const " << getVector3dName(asType) << " &in)";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHODPR(aabbox3d<T>, reset, (const vector3d<T>&), void), asCALL_THISCALL);
                                     assert(r >= 0);

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

    ss.str("");
    ss << "void reset(" << asType << ", " << asType << ", " << asType << ")";
    r = engine->RegisterObjectMethod(typeName, ss.str().c_str(),
                                     asMETHODPR(aabbox3d<T>, reset, (T, T, T), void), asCALL_THISCALL);
                                     assert(r >= 0);

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

    ss.str("");
    ss << getVector3dName(asType) << " MinEdge";
    r = engine->RegisterObjectProperty(typeName, ss.str().c_str(), offsetof(aabbox3d<T>, MinEdge)); assert(r >= 0);
}

void bindAabbox3d(asIScriptEngine *engine)
{
    bindAabbox3dT<f32>(engine, "aabbox3df", "f32");
    bindAabbox3dT<s32>(engine, "aabbox3di", "s32");
}

std::string getAabbox3dName(const std::string &asType)
{
    if(asType == "f32")   return std::string("aabbox3df");
    if(asType == "s32")   return std::string("aabbox3di");
    else return std::string("");
}

// End of File

---