components/scene/SceneComponent.h

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            SceneComponent.h
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Declaration of the SceneComponent class.
//
// 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.
//
// /////////////////////////////////////////////////////////////////////////////

#ifndef __SCENECOMPONENT_H__
#define __SCENECOMPONENT_H__

// Include files
#include "../../dependencies.h"
#include "../../core/EntityComponent.h"


// SceneComponent class
class SceneComponent : public EntityComponent
{
public:

    // Initialisation and deinitialisation
    SceneComponent(Entity *parent);
    ~SceneComponent();

    // AngelScript binding
    static SceneComponent* refFactory(Entity *parent);

    // Methods
    ISceneNode* getSceneNode();
    IMetaTriangleSelector* getMetaSelector() const;
    ITriangleSelector* getTriangleSelector() const;

    void addAnimator(ISceneNodeAnimator *animator);

    void addCollisionResponseAnimator(const vector3df &ellipsoidRadius = vector3df(30, 60, 30),
                                      const vector3df &gravityPerSecond = vector3df(0, -10, 0),
                                      const vector3df &ellipsoidTranslation = vector3df(0, 0, 0),
                                      f32 slidingValue = 0.0005f);

    void addFlyCircleAnimator(const vector3df &center = vector3df(0, 0, 0), f32 radius = 100,
                              f32 speed = 0.001f, const vector3df &direction = vector3df(0, 0, 0));

    void addFlyStraightAnimator(const vector3df &startPoint, const vector3df &endPoint,
                                u32 timeForWay, bool loop = false);

    void addToMetaSelector(Entity *entity);
    void addToMetaSelector(SceneComponent *component);
    void addToMetaSelector(ITriangleSelector *selector);

    vector3df getAbsolutePosition() const;
    E_CULLING_TYPE getAutomaticCulling() const;
    virtual const aabbox3df& getBoundingBox() const;
    u32 getMaterialCount() const;
    matrix4 getRelativeTransformation() const;
    const vector3df getPosition() const;
    const vector3df& getRotation() const;
    const vector3df& getScale() const;

    void removeAnimators();

    void setAbsolutePosition(const vector3df &position);
    void setAutomaticCulling(E_CULLING_TYPE state);
    void setCanAffectParent(bool value);
    void setDebugDataVisible(s32 state);
    void setMaterialFlag(E_MATERIAL_FLAG flag, bool value);
    void setMaterialTexture(u32 layer, const std::string &fileName);
    void setMaterialTexture(u32 layer, ITexture *texture);
    void setMaterialType(E_MATERIAL_TYPE type);
    void setPosition(const vector3df &position);
    void setRotation(const vector3df &rotation);
    void setScale(const vector3df &scale);
    void setVisible(bool value);

    // Events
    void onPositionChange(void *p);
    void onUpdate(void *p);
    void onPause(void *p);
    void onUnPause(void *p);

protected:

    // Initialisation
    SceneComponent(Entity *parent, bool isDerived);

    // Protected Members
    ISceneNode *mSceneNode;
    IMetaTriangleSelector *mMetaSelector;
    ITriangleSelector *mTriSelector;

private:

    // Private members
    vector3df mLastPos;
    bool mCanAffectParent;

    bool mEvokedParentChange;
    bool mWasVisible;
};


// SceneComponent Angelscript binding.
extern void bindSceneComponent(asIScriptEngine *engine);


template<typename T>
void bindSceneComponentBase(asIScriptEngine *engine, const char *type)
{
    // Forward declaration.
    int r;
    std::string sType = type;

    // Bind inherited functions.
    bindEntityComponentBase<SceneComponent>(engine, type);

    // Set common behaviour.
    r = engine->RegisterGlobalBehaviour(asBEHAVE_REF_CAST, std::string(sType + "@ f(SceneComponent @)").c_str(),
                                        asFUNCTION((asRefCast<SceneComponent,T>)), asCALL_CDECL); assert( r >= 0 );
    r = engine->RegisterGlobalBehaviour(asBEHAVE_IMPLICIT_REF_CAST, std::string("SceneComponent@ f(" + sType +" @)").c_str(),
                                        asFUNCTION((asRefCast<T,SceneComponent>)), asCALL_CDECL); assert( r >= 0 );

    // Bind common class functions.
    r = engine->RegisterObjectMethod(type, "void addCollisionResponseAnimator(const vector3df &in, " \
                                     "const vector3df &in, const vector3df &in, f32)",
                                     asMETHOD(T, addCollisionResponseAnimator), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void addFlyCircleAnimator(const vector3df &in, f32, " \
                                     "f32, const vector3df &in)",
                                     asMETHOD(T, addFlyCircleAnimator), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void addFlyStraightAnimator(const vector3df &in, " \
                                     "const vector3df &in, u32, bool)",
                                     asMETHOD(T, addFlyStraightAnimator), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod(type, "void addToMetaSelector(Entity@)",
                                     asMETHODPR(T, addToMetaSelector, (Entity*), void), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void addToMetaSelector(SceneComponent@)",
                                     asMETHODPR(T, addToMetaSelector, (SceneComponent*), void), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod(type, "const vector3df& getAbsolutePosition()",
                                     asMETHOD(T, getAbsolutePosition), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "E_CULLING_TYPE  getAutomaticCulling()",
                                     asMETHOD(T, getAutomaticCulling), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "const aabbox3df& getBoundingBox()",
                                     asMETHODPR(T, getBoundingBox, (void) const, const aabbox3df&), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "u32 getMaterialCount()",
                                     asMETHOD(T, getMaterialCount), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "const matrix4& getRelativeTransformation()",
                                     asMETHOD(T, getRelativeTransformation), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "const vector3df& getPosition()",
                                     asMETHOD(T, getPosition), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "const vector3df& getRotation()",
                                     asMETHOD(T, getRotation), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "const vector3df& getScale()",
                                     asMETHOD(T, getScale), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod(type, "void removeAnimators()",
                                     asMETHOD(T, removeAnimators), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod(type, "void setAbsolutePosition(const vector3df &in)",
                                     asMETHOD(T, setAbsolutePosition), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void setAutomaticCulling(E_CULLING_TYPE)",
                                     asMETHOD(T, setAutomaticCulling), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void setCanAffectParent(bool)",
                                     asMETHOD(T, setCanAffectParent), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void setDebugDataVisible(s32)",
                                     asMETHOD(T, setDebugDataVisible), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void setMaterialFlag(E_MATERIAL_FLAG, bool)",
                                     asMETHOD(T, setMaterialFlag), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void setMaterialTexture(u32, const string &)",
                                     asMETHODPR(T, setMaterialTexture, (u32 layer, const std::string &fileName), void),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void setMaterialType(E_MATERIAL_TYPE)",
                                     asMETHOD(T, setMaterialType), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void setPosition(const vector3df &in)",
                                     asMETHOD(T, setPosition), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void setRotation(const vector3df &in)",
                                     asMETHOD(T, setRotation), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void setScale(const vector3df &in)",
                                     asMETHOD(T, setScale), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod(type, "void setVisible(bool)",
                                     asMETHOD(T, setVisible), asCALL_THISCALL); assert(r >= 0);
}

#endif

---