components/scene/AnimatedMeshComponent.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            AnimatedMeshComponent.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Component wrapper of Irrlicht's IAnimatedMeshSceneNode.
//
// 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 "AnimatedMeshComponent.h"
#include "../../core/GameManager.h"


// AnimatedMeshComponent class
// TextComponent constructor (default).
AnimatedMeshComponent::AnimatedMeshComponent(Entity *parent)
: SceneComponent(parent, true)
{
    // Get pointers to needed sub-systems of the Game Manager.
    ISceneManager *pSceneMgr = GameManager::Instance()->getSceneManager();

    // Create the internal scene node.
    mAnimatedMeshSN = pSceneMgr->addAnimatedMeshSceneNode(0, 0, parent->getID(),
                                                          parent->getPosition(), vector3df(0, 0, 0),
                                                          vector3df(1.0f, 1.0f, 1.0f), true);
    mSceneNode = mAnimatedMeshSN;
    mShadowVolumeSN = NULL;

    // Set-up internal mechanism for collision detection.
    mTriSelector = pSceneMgr->createTriangleSelectorFromBoundingBox(mAnimatedMeshSN);
    mMetaSelector = pSceneMgr->createMetaTriangleSelector();
}

// AnimatedMeshComponent constructor.
AnimatedMeshComponent::AnimatedMeshComponent(Entity *parent, const std::string &fileName,
                                             const vector3df &rotation, const vector3df &scale)
: SceneComponent(parent, true)
{
    // Get pointers to needed sub-systems of the Game Manager.
    ISceneManager *pSceneMgr = GameManager::Instance()->getSceneManager();

    // Create the internal scene node.
    mAnimatedMeshSN = pSceneMgr->addAnimatedMeshSceneNode(pSceneMgr->getMesh(fileName.c_str()), 0,
                                                          parent->getID(), parent->getPosition(),
                                                          rotation, scale, true);
    mSceneNode = mAnimatedMeshSN;
    mShadowVolumeSN = NULL;

    // Set-up internal mechanism for collision detection.
    mTriSelector = pSceneMgr->createTriangleSelectorFromBoundingBox(mAnimatedMeshSN);
    mMetaSelector = pSceneMgr->createMetaTriangleSelector();
}

// AnimatedMeshComponent constructor.
AnimatedMeshComponent::AnimatedMeshComponent(Entity *parent, IAnimatedMesh *mesh,
                                             const vector3df &rotation, const vector3df &scale)
: SceneComponent(parent, true)
{
    ISceneManager *pSceneMgr = GameManager::Instance()->getSceneManager();

    mAnimatedMeshSN = pSceneMgr->addAnimatedMeshSceneNode(mesh, 0, parent->getID(),
                                                          parent->getPosition(), rotation, scale,
                                                          true);
    mSceneNode = mAnimatedMeshSN;

    // Set-up internal mechanism for collision detection.
    mTriSelector = pSceneMgr->createTriangleSelectorFromBoundingBox(mAnimatedMeshSN);
    mMetaSelector = pSceneMgr->createMetaTriangleSelector();
}

// AnimatedMeshComponent deconstructor.
AnimatedMeshComponent::~AnimatedMeshComponent()
{
    mAnimatedMeshSN->remove();
    mSceneNode = NULL;
}

// AngelScript: Will be used to instanciate objects of this class.
AnimatedMeshComponent* AnimatedMeshComponent::refFactory(Entity *parent)
{
    return new AnimatedMeshComponent(parent);
}

// AngelScript: Will be used to instanciate objects of this class.
AnimatedMeshComponent* AnimatedMeshComponent::refFactory(Entity *parent, const std::string &fileName,
                                                         const vector3df &rotation,
                                                         const vector3df &scale)
{
    return new AnimatedMeshComponent(parent, fileName, rotation, scale);
}

// Returns a direct pointer to the IAnimatedMeshSceneNode.
IAnimatedMeshSceneNode* AnimatedMeshComponent::getAnimatedMeshSceneNode()
{
    return mAnimatedMeshSN;
}

// Animates the mesh based upon the current frame.
void AnimatedMeshComponent::animate()
{
    mAnimatedMeshSN->animateJoints();
}

// Returns the current end frame number.
s32 AnimatedMeshComponent::getEndFrame() const
{
    return mAnimatedMeshSN->getEndFrame();
}

// Returns the current displayed frame number.
f32 AnimatedMeshComponent::getFrame() const
{
    return mAnimatedMeshSN->getFrameNr();
}

// Returns the current mesh.
IMesh* AnimatedMeshComponent::getMesh()
{
    return mAnimatedMeshSN->getMesh();
}

// Gets the shadow volume scene node associated with this component.
IShadowVolumeSceneNode* AnimatedMeshComponent::getShadowVolumeSceneNode()
{
    return mShadowVolumeSN;
}

// Returns the current start frame number.
s32 AnimatedMeshComponent::getStartFrame() const
{
    return mAnimatedMeshSN->getStartFrame();
}

// Sets the speed (in frames/s) with which the animation is played.
void AnimatedMeshComponent::setAnimationSpeed(f32 speed)
{
    mAnimatedMeshSN->setAnimationSpeed(speed);
}

// Sets the current frame number.
void AnimatedMeshComponent::setCurrentFrame(f32 frame)
{
    mAnimatedMeshSN->setCurrentFrame(frame);
}

// Sets the frame numbers between which the animation is looped.
void AnimatedMeshComponent::setFrameLoop(s32 start, s32 end)
{
    mAnimatedMeshSN->setFrameLoop(start, end);
}

// Sets looping mode which is on by default.
void AnimatedMeshComponent::setLoopMode(bool value)
{
    mAnimatedMeshSN->setLoopMode(value);
}

// Starts a MD2 animation.
void AnimatedMeshComponent::setMD2Animation(const std::string &animationName)
{
    mAnimatedMeshSN->setMD2Animation(animationName.c_str());
}

// Starts a MD2 animation.
void AnimatedMeshComponent::setMD2Animation(EMD2_ANIMATION_TYPE anim)
{
    mAnimatedMeshSN->setMD2Animation(anim);
}

// Loads and sets a new mesh to display.
void AnimatedMeshComponent::setMesh(const std::string &fileName)
{
    IAnimatedMesh *mesh = GameManager::Instance()->getSceneManager()->getMesh(fileName.c_str());
    if(mesh)
      mAnimatedMeshSN->setMesh(mesh);
}

// Sets a new mesh to display.
void AnimatedMeshComponent::setMesh(IAnimatedMesh *mesh)
{
    mAnimatedMeshSN->setMesh(mesh);
}

// Loads and sets a new IShadowVolumeSceneNode to the component.
void AnimatedMeshComponent::setShadowVolumeSceneNode(const std::string &fileName, bool zfailmethod,
                                                     f32 infinity)
{
    if(!mShadowVolumeSN)
    {
       IMesh *mesh = GameManager::Instance()->getSceneManager()->getMesh(fileName.c_str());
       if(mesh)
         mShadowVolumeSN = mAnimatedMeshSN->addShadowVolumeSceneNode(mesh, pParent->getID(),
                                                                  zfailmethod, infinity);
    }
}

// Adds a new IShadowVolumeSceneNode to the component.
void AnimatedMeshComponent::setShadowVolumeSceneNode(IMesh *mesh, bool zfailmethod, f32 infinity)
{
    if(!mShadowVolumeSN)
    {
       mShadowVolumeSN = mAnimatedMeshSN->addShadowVolumeSceneNode(mesh, pParent->getID(),
                                                                   zfailmethod, infinity);
    }
}

// Sets the transition time in seconds.
void AnimatedMeshComponent::setTransitionTime(f32 time)
{
    mAnimatedMeshSN->setTransitionTime(time);
}


// AnimatedMeshComponent Angelscript binding.
void bindAnimatedMeshComponent(asIScriptEngine *engine)
{
    // Forward declarations.
    int r;

    // Bind AnimatedMeshComponent class.
    r = engine->RegisterObjectType("AnimatedMeshComponent", sizeof(AnimatedMeshComponent), asOBJ_REF); assert(r >= 0);

    // Bind inherited functions.
    bindSceneComponentBase<AnimatedMeshComponent>(engine, "AnimatedMeshComponent");

    // Set SkyDomeComponent behaviour.
    r = engine->RegisterObjectBehaviour("AnimatedMeshComponent", asBEHAVE_FACTORY, "AnimatedMeshComponent@ f(Entity @)",
                                        asFUNCTIONPR(AnimatedMeshComponent::refFactory, (Entity*), AnimatedMeshComponent*),
                                        asCALL_CDECL); assert(r >= 0);
    r = engine->RegisterObjectBehaviour("AnimatedMeshComponent", asBEHAVE_FACTORY, "AnimatedMeshComponent@ f(Entity @, " \
                                        "const string &, const vector3df &in, const vector3df &in)",
                                        asFUNCTIONPR(AnimatedMeshComponent::refFactory, (Entity*, const std::string&,
                                        const vector3df&, const vector3df&), AnimatedMeshComponent*), asCALL_CDECL);
                                        assert(r >= 0);

    // Bind AnimatedMeshComponent class functions.
    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "void animate()",
                                     asMETHOD(AnimatedMeshComponent, animate), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "s32 getEndFrame()",
                                     asMETHOD(AnimatedMeshComponent, getEndFrame), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "f32 getFrame()",
                                     asMETHOD(AnimatedMeshComponent, getFrame), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "s32 getStartFrame()",
                                     asMETHOD(AnimatedMeshComponent, getStartFrame), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "void setAnimationSpeed(f32)",
                                     asMETHOD(AnimatedMeshComponent, setAnimationSpeed), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "void setCurrentFrame(f32)",
                                     asMETHOD(AnimatedMeshComponent, setCurrentFrame), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "void setFrameLoop(s32, s32)",
                                     asMETHOD(AnimatedMeshComponent, setFrameLoop), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "void setLoopMode(bool)",
                                     asMETHOD(AnimatedMeshComponent, setLoopMode), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "void setMD2Animation(const string &)",
                                     asMETHODPR(AnimatedMeshComponent, setMD2Animation, (const std::string&), void),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "void setMesh(const string &)",
                                     asMETHODPR(AnimatedMeshComponent, setMesh, (const std::string&), void),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "void setShadowVolumeSceneNode(const string &fileName, " \
                                     "bool, f32)", asMETHODPR(AnimatedMeshComponent, setShadowVolumeSceneNode,
                                     (const std::string&, bool, f32), void), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("AnimatedMeshComponent", "void setTransitionTime(f32)",
                                     asMETHOD(AnimatedMeshComponent, setTransitionTime), asCALL_THISCALL); assert(r >= 0);
}

// End of File

---