scripting/vendor/irrlicht/asSColor.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            SColor.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Binds the SColor 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 "asSColor.h"

#ifdef __COMPILE_WITH_ANGELSCRIPT__

#include "asIrrHelper.h"


// SColor behaviour functions.
void constructor(void *memory)
{
    new (memory) SColor();
}

void constructor(u32 clr, void *memory)
{
    new (memory) SColor(clr);
}

void constructor(u32 a, u32 r, u32 g, u32 b, void *memory)
{
    new (memory) SColor(a, r, g, b);
}

void deconstructor(void *memory)
{
    ((SColor*)memory)->~SColor();
}

int compare(const SColor &a, const SColor &b)
{
    if( a < b ) return -1;
    if( b < a ) return 1;
    return 0;
}

void bindSColor(asIScriptEngine *engine)
{
    // Forward declarations.
    int r;

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

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

    r = engine->RegisterObjectBehaviour("SColor", asBEHAVE_CONSTRUCT, "void f(u32)", asFUNCTIONPR(constructor,
                                        (u32, void*), void), asCALL_CDECL_OBJLAST); assert(r >= 0);

    r = engine->RegisterObjectBehaviour("SColor", asBEHAVE_CONSTRUCT, "void f(u32)", asFUNCTIONPR(constructor,
                                        (u32, u32, u32, u32, void*), void), asCALL_CDECL_OBJLAST); assert(r >= 0);

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

    // Calculation behaviours.
    r = engine->RegisterObjectMethod("SColor", "SColor opAdd(const SColor &in)",
                                     asFUNCTIONPR((add< SColor, SColor, SColor >),
                                     (const SColor&, const SColor&), SColor),
                                     asCALL_CDECL_OBJFIRST); assert(r >= 0);

    // Comparison behaviours.
    r = engine->RegisterObjectMethod("SColor", "bool opEquals(const SColor &in)", asFUNCTIONPR(equal<SColor>,
                                     (const SColor&, const SColor&), bool), asCALL_CDECL_OBJFIRST); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "bool opCmp(const SColor &in)", asFUNCTIONPR(compare,
                                     (const SColor&, const SColor&), int), asCALL_CDECL_OBJFIRST); assert(r >= 0);

    // Bind SColor class functions.
    r = engine->RegisterObjectMethod("SColor", "u32 getAlpha()",
                                     asMETHOD(SColor, getAlpha), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "u32 getAverage()",
                                     asMETHOD(SColor, getAverage), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "u32 getBlue()",
                                     asMETHOD(SColor, getBlue), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "u32 getGreen()",
                                     asMETHOD(SColor, getGreen), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "SColor getInterpolated(const SColor &in, f32)",
                                     asMETHOD(SColor, getInterpolated), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "SColor getInterpolated_quadratic(const SColor &in, " \
                                     "const SColor &in, f32)", asMETHOD(SColor, getInterpolated_quadratic),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "f32 getLuminance()",
                                     asMETHOD(SColor, getLuminance), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "u32 getRed()",
                                     asMETHOD(SColor, getRed), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "void set(u32)",
                                     asMETHODPR(SColor, set, (u32), void), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "void set(u32, u32, u32, u32)",
                                     asMETHODPR(SColor, set, (u32, u32, u32, u32), void), asCALL_THISCALL);
                                     assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "void setAlpha(u32)",
                                     asMETHOD(SColor, setAlpha), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "void setBlue(u32)",
                                     asMETHOD(SColor, setBlue), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "void setGreen(u32)",
                                     asMETHOD(SColor, setGreen), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SColor", "void setRed(u32)",
                                     asMETHOD(SColor, setRed), asCALL_THISCALL); assert(r >= 0);

    // Bind SColor class properties.
    r = engine->RegisterObjectProperty("SColor", "u32 color", offsetof(SColor, color)); assert(r >= 0);
}

#endif // __COMPILE_WITH_ANGELSCRIPT__

// End of File

---