components/scene/CameraComponent.cpp

Go to the documentation of this file.

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


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

    // Create the internal scene node.
    mCameraSN = pSceneMgr->addCameraSceneNode(0, parent->getPosition(), lookat, parent->getID());
    mSceneNode = mCameraSN;

    mCameraAnimator = NULL;

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

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

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

// AngelScript: Will be used to instanciate objects of this class.
CameraComponent* CameraComponent::refFactory(Entity *parent, const vector3df &lookat)
{
    return new CameraComponent(parent, lookat);
}

// Returns a direct pointer to the ICameraSceneNode.
ICameraSceneNode* CameraComponent::getCameraSceneNode()
{
    return mCameraSN;
}

// Binds the camera component's rotation to its target position and vice vera, or unbinds them.
void CameraComponent::bindTargetAndRotation(bool bound)
{
    mCameraSN->bindTargetAndRotation(bound);
}

// Queries if the camera component's rotation and its target position are bound together.
bool CameraComponent::getTargetAndRotationBinding() const
{
    return mCameraSN->getTargetAndRotationBinding();
}

// Gets the aspect ratio of the camera.
f32 CameraComponent::getAspectRatio() const
{
    return mCameraSN->getAspectRatio();
}

// Gets the value of the far plane of the camera.
f32 CameraComponent::getFarValue() const
{
    return mCameraSN->getFarValue();
}

// Gets the field of view of the camera.
f32 CameraComponent::getFOV() const
{
    return mCameraSN->getFOV();
}

// Gets the value of the near plane of the camera.
f32 CameraComponent::getNearValue() const
{
    return mCameraSN->getNearValue();
}

// Gets the current projection matrix of the camera.
const matrix4& CameraComponent::getProjectionMatrix() const
{
    return mCameraSN->getProjectionMatrix();
}

// Gets the current look at target of the camera.
const vector3df& CameraComponent::getTarget() const
{
    return mCameraSN->getTarget();
}

// Gets the up vector of the camera.
const vector3df& CameraComponent::getUpVector() const
{
    return mCameraSN->getUpVector();
}

// Gets the current view matrix of the camera.
const matrix4& CameraComponent::getViewMatrix() const
{
    return mCameraSN->getViewMatrix();
}

// Checks if the camera is orthogonal.
bool CameraComponent::getIsOrthogonal() const
{
    return mCameraSN->isOrthogonal();
}

// Sets this camera as the main camera.
void CameraComponent::setAsMainCamera()
{
    GameManager::Instance()->getSceneManager()->setActiveCamera(mCameraSN);
}

// Sets the aspect ratio (default: 4.0f / 3.0f).
void CameraComponent::setAspectRatio(f32 aspect)
{
    mCameraSN->setAspectRatio(aspect);
}

// Sets the value of the far clipping plane (default: 2000.0f).
void CameraComponent::setFarValue(f32 value)
{
    mCameraSN->setFarValue(value);
}

// Sets the field of view (Default: PI / 2.5f).
void CameraComponent::setFOV(f32 value)
{
    mCameraSN->setFOV(value);
}

// Sets the value of the near clipping plane. (default: 1.0f).
void CameraComponent::setNearValue(f32 value)
{
    mCameraSN->setNearValue(value);
}

// Sets the projection matrix of the camera.
void CameraComponent::setProjectionMatrix(const matrix4 &projection, bool isOrthogonal)
{
    mCameraSN->setProjectionMatrix(projection, isOrthogonal);
}

// Sets the rotation of the node.
void CameraComponent::setRotation(const vector3df &rotation)
{
    mCameraSN->setRotation(rotation);
}

// Sets the look at target of the camera.
void CameraComponent::setTarget(const vector3df &position)
{
    mCameraSN->setTarget(position);
}

// Sets the up vector of the camera.
void CameraComponent::setUpVector(const vector3df &position)
{
    mCameraSN->setUpVector(position);
}

// Sets the camera to normal mode.
void CameraComponent::setNormalMode()
{
    if(mCameraAnimator)
      mCameraSN->removeAnimator(mCameraAnimator);
}

// Sets the camera to FPS mode.
void CameraComponent::setFPSMode(f32 rotateSpeed, f32 moveSpeed, bool verticalMovement,
                                 f32 jumpSpeed)
{
    // Remove previous camera animator.
    if(mCameraAnimator)
      mCameraSN->removeAnimator(mCameraAnimator);

    // Add FPS camera animator.
    ISceneNodeAnimatorCameraFPS *animFPS = (ISceneNodeAnimatorCameraFPS*)GameManager::Instance()->
                                           getSceneManager()->getDefaultSceneNodeAnimatorFactory()->
                                           createSceneNodeAnimator("cameraFPS", mCameraSN);

    animFPS->setRotateSpeed(rotateSpeed);
    animFPS->setMoveSpeed(moveSpeed);
    animFPS->setVerticalMovement(verticalMovement);
    animFPS->drop();

    mCameraAnimator = animFPS;
}

// Sets the camera to Maya mode.
void CameraComponent::setMayaMode(f32 rotateSpeed, f32 zoomSpeed, f32 translationSpeed)
{
    // Remove previous camera animator.
    if(mCameraAnimator)
      mCameraSN->removeAnimator(mCameraAnimator);

    // Add Maya camera animator.
    ISceneNodeAnimatorCameraMaya *animMaya = (ISceneNodeAnimatorCameraMaya*)GameManager::Instance()->
                                           getSceneManager()->getDefaultSceneNodeAnimatorFactory()->
                                           createSceneNodeAnimator("cameraMaya", mCameraSN);

    animMaya->setRotateSpeed(rotateSpeed);
    animMaya->setMoveSpeed(translationSpeed);
    animMaya->setZoomSpeed(zoomSpeed);
    animMaya->drop();

    mCameraAnimator = animMaya;
}


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

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

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

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

    // Bind CameraComponent class functions.
    r = engine->RegisterObjectMethod("CameraComponent", "void bindTargetAndRotation(bool)",
                                     asMETHOD(CameraComponent, bindTargetAndRotation), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "bool getTargetAndRotationBinding()",
                                     asMETHOD(CameraComponent, getTargetAndRotationBinding), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("CameraComponent", "f32 getAspectRatio()",
                                     asMETHOD(CameraComponent, getAspectRatio), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "f32 getFarValue()",
                                     asMETHOD(CameraComponent, getFarValue), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "f32 getFOV()",
                                     asMETHOD(CameraComponent, getFOV), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "f32 getNearValue()",
                                     asMETHOD(CameraComponent, getNearValue), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "const matrix4& getProjectionMatrix()",
                                     asMETHOD(CameraComponent, getProjectionMatrix), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "const vector3df& getTarget()",
                                     asMETHOD(CameraComponent, getTarget), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "const vector3df& getUpVector()",
                                     asMETHOD(CameraComponent, getUpVector), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "const matrix4& getViewMatrix()",
                                     asMETHOD(CameraComponent, getViewMatrix), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "bool getIsOrthogonal()",
                                     asMETHOD(CameraComponent, getIsOrthogonal), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("CameraComponent", "void setAsMainCamera()",
                                     asMETHOD(CameraComponent, setAsMainCamera), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "void setAspectRatio(f32)",
                                     asMETHOD(CameraComponent, setAspectRatio), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "void setFarValue(f32)",
                                     asMETHOD(CameraComponent, setFarValue), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "void setFOV(f32)",
                                     asMETHOD(CameraComponent, setFOV), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "void setNearValue(f32)",
                                     asMETHOD(CameraComponent, setNearValue), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "void setProjectionMatrix(const matrix4 &in, bool)",
                                     asMETHOD(CameraComponent, setProjectionMatrix), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "void setRotation(const vector3df &in)",
                                     asMETHOD(CameraComponent, setRotation), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "void setTarget(const vector3df &in)",
                                     asMETHOD(CameraComponent, setTarget), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "void setUpVector(const vector3df &in)",
                                     asMETHOD(CameraComponent, setUpVector), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("CameraComponent", "void setNormalMode()",
                                     asMETHOD(CameraComponent, setNormalMode), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "void setFPSMode(f32, f32, bool, f32)",
                                     asMETHOD(CameraComponent, setFPSMode), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("CameraComponent", "void setMayaMode(f32, f32, f32)",
                                     asMETHOD(CameraComponent, setMayaMode), asCALL_THISCALL); assert(r >= 0);
}

// End of File

---