ICameraSceneNode.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in nirtcpp/nirtcpp.hpp
 
#ifndef NIRT_I_CAMERA_SCENE_NODE_HPP_INCLUDED
#define NIRT_I_CAMERA_SCENE_NODE_HPP_INCLUDED
 
#include <nirtcpp/core/engine/ISceneNode.hpp>
#include <nirtcpp/core/engine/IEventReceiver.hpp>
 
namespace nirt
{
namespace scene
{
    class SViewFrustum;
 
 
    class ICameraSceneNode : public ISceneNode, public IEventReceiver
    {
    public:
 
        ICameraSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id,
            const core::vector3df& position = core::vector3df(0,0,0),
            const core::vector3df& rotation = core::vector3df(0,0,0),
            const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f))
            : ISceneNode(parent, mgr, id, position, rotation, scale), IsOrthogonal(false) {}
 
 
        virtual void setProjectionMatrix(const core::matrix4& projection, bool isOrthogonal=false) =0;
 
 
        virtual const core::matrix4& getProjectionMatrix() const =0;
 
 
        virtual const core::matrix4& getViewMatrix() const =0;
 
 
        virtual void setViewMatrixAffector(const core::matrix4& affector) =0;
 
 
        virtual const core::matrix4& getViewMatrixAffector() const =0;
 
 
        virtual bool OnEvent(const SEvent& event) override =0;
 
 
        virtual void setTarget(const core::vector3df& pos) =0;
 
 
        virtual void setRotation(const core::vector3df& rotation) override =0;
 
 
        virtual const core::vector3df& getTarget() const =0;
 
 
        virtual void setUpVector(const core::vector3df& pos) =0;
 
 
        virtual const core::vector3df& getUpVector() const =0;
 
 
        virtual f32 getNearValue() const =0;
 
 
        virtual f32 getFarValue() const =0;
 
 
        virtual f32 getAspectRatio() const =0;
 
 
        virtual f32 getFOV() const =0;
 
 
        virtual void setNearValue(f32 zn) =0;
 
 
        virtual void setFarValue(f32 zf) =0;
 
 
        virtual void setAspectRatio(f32 aspect) =0;
 
 
        virtual void setFOV(f32 fovy) =0;
 
 
        virtual const SViewFrustum* getViewFrustum() const =0;
 
 
        virtual void setInputReceiverEnabled(bool enabled) =0;
 
        virtual bool isInputReceiverEnabled() const =0;
 
        virtual bool isOrthogonal() const
        {
            return IsOrthogonal;
        }
 
 
        virtual void bindTargetAndRotation(bool bound) =0;
 
 
        virtual void updateMatrices() = 0;
 
 
        virtual bool getTargetAndRotationBinding(void) const =0;
 
        virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const override
        {
            ISceneNode::serializeAttributes(out, options);
 
            if (!out)
                return;
            out->addBool("IsOrthogonal", IsOrthogonal);
        }
 
        virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) override
        {
            ISceneNode::deserializeAttributes(in, options);
            if (!in)
                return;
 
            if ( in->findAttribute("IsOrthogonal") )
                IsOrthogonal = in->getAttributeAsBool("IsOrthogonal");
        }
 
    protected:
 
        void cloneMembers(const ICameraSceneNode* toCopyFrom)
        {
            IsOrthogonal = toCopyFrom->IsOrthogonal;
        }
 
        bool IsOrthogonal;
    };
 
} // end namespace scene
} // end namespace nirt
 
#endif