CCamera.h

Go to the documentation of this file.

//==============================================================================
/*
    Software License Agreement (BSD License)
    Copyright (c) 2003-2016, CHAI3D.
    (www.chai3d.org)

    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    * Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above
    copyright notice, this list of conditions and the following
    disclaimer in the documentation and/or other materials provided
    with the distribution.

    * Neither the name of CHAI3D nor the names of its contributors may
    be used to endorse or promote products derived from this software
    without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.

    \author    <http://www.chai3d.org>
    \author    Francois Conti
    \author    Dan Morris
    \version   3.2.0 $Rev: 2164 $
*/
//==============================================================================

//------------------------------------------------------------------------------
#ifndef CCameraH
#define CCameraH
//------------------------------------------------------------------------------
#include "audio/CAudioDevice.h"
#include "world/CGenericObject.h"
#include "math/CMaths.h"
#include "graphics/CImage.h"
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
namespace chai3d {
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
class cWorld;
class cDirectionalLight;
//------------------------------------------------------------------------------

enum cStereoMode
{
    C_STEREO_DISABLED,
    C_STEREO_ACTIVE,
    C_STEREO_PASSIVE_LEFT_RIGHT,
    C_STEREO_PASSIVE_TOP_BOTTOM,
    C_STEREO_PASSIVE_DUAL_DISPLAY
};

enum cEyeMode
{
    C_STEREO_LEFT_EYE,
    C_STEREO_RIGHT_EYE
};

//==============================================================================
//==============================================================================

//==============================================================================
//==============================================================================
class cCamera : public cGenericObject
{
    //--------------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //--------------------------------------------------------------------------

public:

    cCamera(cWorld* a_parentWorld);

    virtual ~cCamera();


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - GENERAL:
    //-----------------------------------------------------------------------

public:

    cWorld* getParentWorld() { return (m_parentWorld); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - MOUSE SELECTION:
    //-----------------------------------------------------------------------

public:

    virtual bool selectWorld(const int a_windowPosX, const int a_windowPosY,
        const int a_windowWidth, const int a_windowHeight,
        cCollisionRecorder& a_collisionRecorder,
        cCollisionSettings& a_collisionSettings);

    virtual bool selectFrontLayer(const int a_windowPosX, const int a_windowPosY,
        const int a_windowWidth, const int a_windowHeight,
        cCollisionRecorder& a_collisionRecorder,
        cCollisionSettings& a_collisionSettings);

    virtual bool selectBackLayer(const int a_windowPosX, const int a_windowPosY,
        const int a_windowWidth, const int a_windowHeight,
        cCollisionRecorder& a_collisionRecorder,
        cCollisionSettings& a_collisionSettings);

    virtual bool selectLayers(const int a_windowPosX, const int a_windowPosY,
        const int a_windowWidth, const int a_windowHeight,
        cCollisionRecorder& a_collisionRecorder,
        cCollisionSettings& a_collisionSettings,
        bool a_checkFrontLayer = true,
        bool a_checkBackLayer = true);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - POSITION & ORIENTATION (CARTESIAN)
    //-----------------------------------------------------------------------

public:

    virtual bool set(const cVector3d& a_localPosition,
                     const cVector3d& a_localLookAt,
                     const cVector3d& a_localUp);

    cVector3d getLookVector()  const { return (-m_localRot.getCol0()); }

    cVector3d getUpVector()    const { return (m_localRot.getCol2()); }

    cVector3d getRightVector() const { return (m_localRot.getCol1()); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - POSITION & ORIENTATION (SPHERICAL)
    //-----------------------------------------------------------------------

public:

    void setSphericalRad(const double& a_radius,
                         const double& a_polarRad,
                         const double& a_azimuthRad);

    void setSphericalDeg(const double& a_radius,
                         const double& a_polarDeg,
                         const double& a_azimuthDeg);

    void setSphericalReferences(const cVector3d& a_originReference,
                                const cVector3d& a_zenithReference,
                                const cVector3d& a_azimuthReference);

    void setSphericalRadius(const double& a_radius);

    double getSphericalRadius() { return (m_posRadius); }

    void setSphericalPolarRad(const double& a_polarRad);

    double getSphericalPolarRad() { return (m_posPolarRad); }

    void setSphericalPolarDeg(const double& a_polarDeg);

    double getSphericalPolarDeg() { return (cRadToDeg(m_posPolarRad)); }

    void setSphericalAzimuthRad(const double& a_azimuthRad);

    double getSphericalAzimuthRad() { return (m_posAzimuthRad); }

    void setSphericalAzimuthDeg(const double& a_azimuthDeg);

    double getSphericalAzimuthDeg() { return (cRadToDeg(m_posAzimuthRad)); }

    void setSphericalZenithReference(const cVector3d& a_zenithReference);

    cVector3d getSphericalZenithReference() { return (m_zenithReference); }

    void setSphericalAzimuthReference(const cVector3d& a_azimuthReference);

    cVector3d getSphericalAzimuthReference() { return (m_azimuthReference); }

    void setSphericalOriginReference(const cVector3d& a_originReference);

    cVector3d getSphericalOriginReference() { return (m_originReference); }


    //-----------------------------------------------------------------------
    // PUBLIC MEMBER - MATRICES:
    //-----------------------------------------------------------------------

public:

    cTransform m_projectionMatrix;

    cTransform m_modelViewMatrix;

    bool m_useCustomProjectionMatrix;

    bool m_useCustomModelViewMatrix;


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - CLIPPING PLANES:
    //-----------------------------------------------------------------------

public:

    void setClippingPlanes(const double a_distanceNear, const double a_distanceFar);

    double getNearClippingPlane() { return (m_distanceNear); }

    double getFarClippingPlane() { return (m_distanceFar); }

    void adjustClippingPlanes();


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - FIELD OF VIEW & OPTICS:
    //-----------------------------------------------------------------------

public:

    void setOrthographicView(double a_viewWidth);

    void setFieldViewAngleDeg(double a_fieldViewAngleDeg);

    double getFieldViewAngleDeg() { return (m_fieldViewAngleDeg); }

    void setFieldViewAngleRad(double a_fieldViewAngleRad) { setFieldViewAngleDeg(cRadToDeg(a_fieldViewAngleRad)); }

    double getFieldViewAngleRad() { return (cDegToRad(m_fieldViewAngleDeg)); }

    double getAspectRatio();

    void setStereoFocalLength(double a_stereoFocalLength);

    double getStereoFocalLength() { return (m_stereoFocalLength); }

    void setStereoEyeSeparation(double a_stereoEyeSeparation);

    double getStereoEyeSeparation() { return (m_stereoEyeSeparation); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - RENDERING AND IMAGING:
    //-----------------------------------------------------------------------

public:

    virtual void renderView(const int a_windowWidth,
        const int a_windowHeight,
        const cEyeMode a_eyeMode = C_STEREO_LEFT_EYE,
        const bool a_defaultBuffer = true);

    void copyImageBuffer(cImagePtr a_image);

    virtual void setUseMultipassTransparency(bool a_enabled);

    bool getUseMultipassTransparency() { return (m_useMultipassTransparency); }

    int getDisplayWidth() { return (m_lastDisplayWidth); }

    int getDisplayHeight() { return (m_lastDisplayHeight); }

    void updateGPU();


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - STEREO:
    //-----------------------------------------------------------------------

public:

    virtual void setStereoMode(cStereoMode a_stereoMode);

    cStereoMode getStereoMode() { return (m_stereoMode); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - MIRRORING:
    //-----------------------------------------------------------------------

public:

    void setMirrorHorizontal(bool a_enabled);

    void setMirrorVertical(bool a_enabled);

    bool getMirrorHorizontal() { return (m_mirrorHorizontal); }

    bool getMirrorVertical() { return (m_mirrorVertical); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - AUDIO DEVICE:
    //-----------------------------------------------------------------------

public:

    void attachAudioDevice(cAudioDevice* a_audioDevice) { m_audioDevice = a_audioDevice; }

    void detachAudioDevice() { m_audioDevice = NULL; }


    //-----------------------------------------------------------------------
    // PUBLIC MEMBERS - FRONT AND BACK PLANES: (WIDGETS)
    //-----------------------------------------------------------------------

public:

    cWorld* m_frontLayer;

    cWorld* m_backLayer;

    cDirectionalLight* m_lightFrontLayer;

    cDirectionalLight* m_lightBackLayer;


    //-----------------------------------------------------------------------
    // PROTECTED MEMBERS:
    //-----------------------------------------------------------------------

protected:

    cWorld *m_parentWorld;

    double m_distanceNear;

    double m_distanceFar;

    double m_fieldViewAngleDeg;

    double m_orthographicWidth;

    bool m_perspectiveMode;

    bool m_useMultipassTransparency;

    bool m_useShadowCasting;

    double m_stereoFocalLength;

    double m_stereoEyeSeparation;

    cStereoMode m_stereoMode;

    unsigned int m_lastDisplayWidth;

    unsigned int m_lastDisplayHeight;

    bool m_markForUpdate;

    bool m_mirrorHorizontal;

    bool m_mirrorVertical;

    bool m_mirrorStatus;

    double m_scaleH;

    double m_scaleV;

    double m_posPolarRad;

    double m_posAzimuthRad;

    double m_posRadius;

    cVector3d m_zenithReference;

    cVector3d m_azimuthReference;

    cVector3d m_originReference;

    cAudioDevice* m_audioDevice;


    //-----------------------------------------------------------------------
    // PROTECTED METHODS:
    //-----------------------------------------------------------------------

protected:

    void renderLayer(cGenericObject* a_graph, int a_width, int a_height);
};

//------------------------------------------------------------------------------
} // namespace chai3d
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------