kfbxcamera.h

Go to the documentation of this file.

#ifndef FBXFILESDK_KFBXPLUGINS_KFBXCAMERA_H
#define FBXFILESDK_KFBXPLUGINS_KFBXCAMERA_H

/**************************************************************************************

 Copyright (C) 2001 - 2010 Autodesk, Inc. and/or its licensors.
 All Rights Reserved.

 The coded instructions, statements, computer programs, and/or related material 
 (collectively the "Data") in these files contain unpublished information 
 proprietary to Autodesk, Inc. and/or its licensors, which is protected by 
 Canada and United States of America federal copyright law and by international 
 treaties. 
 
 The Data may not be disclosed or distributed to third parties, in whole or in
 part, without the prior written consent of Autodesk, Inc. ("Autodesk").

 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO
 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR ARISING
 BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES OF TITLE, 
 NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OR USE. 
 WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT WARRANT THAT THE OPERATION
 OF THE DATA WILL BE UNINTERRUPTED OR ERROR FREE. 
 
 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS
 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR EXPENSES
 OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE DAMAGES OR OTHER
 SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS OF PROFITS, REVENUE
 OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR DAMAGES OF ANY KIND),
 HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF LIABILITY, WHETHER DERIVED
 FROM CONTRACT, TORT (INCLUDING, BUT NOT LIMITED TO, NEGLIGENCE), OR OTHERWISE,
 ARISING OUT OF OR RELATING TO THE DATA OR ITS USE OR ANY OTHER PERFORMANCE,
 WHETHER OR NOT AUTODESK HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS
 OR DAMAGE. 

**************************************************************************************/
#include <fbxfilesdk/fbxfilesdk_def.h>

#include <fbxfilesdk/kfbxplugins/kfbxnodeattribute.h>
#include <fbxfilesdk/kfbxplugins/kfbxcolor.h>

#include <fbxfilesdk/kfbxmath/kfbxvector4.h>

#include <fbxfilesdk/components/kbaselib/klib/kstring.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

class KFbxTexture;
class KFbxSdkManager;
class KFbxMatrix;
class KFbxXMatrix;
class KTime;

class KFBX_DLL KFbxCamera : public KFbxNodeAttribute
{
    KFBXOBJECT_DECLARE(KFbxCamera,KFbxNodeAttribute);

public:
    virtual EAttributeType GetAttributeType() const;

    void Reset();

    typedef enum
    {
        ePERSPECTIVE,
        eORTHOGONAL
    } ECameraProjectionType;



        typedef enum
        {
            eCUSTOM_FORMAT,
            eD1_NTSC,
            eNTSC,
            ePAL,
            eD1_PAL,
            eHD,
            e640x480,
            e320x200,
            e320x240,
            e128x128,
            eFULL_SCREEN
        } ECameraFormat;

        void SetFormat(ECameraFormat pFormat);

        ECameraFormat GetFormat() const;

        typedef enum
        {
            eWINDOW_SIZE,
            eFIXED_RATIO,
            eFIXED_RESOLUTION,
            eFIXED_WIDTH,
            eFIXED_HEIGHT
        } ECameraAspectRatioMode;

        void SetAspect(ECameraAspectRatioMode pRatioMode, double pWidth, double pHeight);

        ECameraAspectRatioMode GetAspectRatioMode() const;

        void SetPixelRatio(double pRatio);

        double GetPixelRatio() const;

        void SetNearPlane(double pDistance);

        double GetNearPlane() const;

        void SetFarPlane(double pDistance);

        double GetFarPlane() const;



    typedef enum
    {
        eCUSTOM_APERTURE_FORMAT = 0,
        e16MM_THEATRICAL,
        eSUPER_16MM,
        e35MM_ACADEMY,
        e35MM_TV_PROJECTION,
        e35MM_FULL_APERTURE,
        e35MM_185_PROJECTION,
        e35MM_ANAMORPHIC,
        e70MM_PROJECTION,
        eVISTAVISION,
        eDYNAVISION,
        eIMAX
    } ECameraApertureFormat;

    void SetApertureFormat(ECameraApertureFormat pFormat);

    ECameraApertureFormat GetApertureFormat() const;

    typedef enum
    {
        eHORIZONTAL_AND_VERTICAL,
        eHORIZONTAL,
        eVERTICAL,
        eFOCAL_LENGTH
    } ECameraApertureMode;

    void SetApertureMode(ECameraApertureMode pMode);

    ECameraApertureMode GetApertureMode() const;

    void SetApertureWidth(double pWidth);

    double GetApertureWidth() const;

    void SetApertureHeight(double pHeight);

    double GetApertureHeight() const;

    void SetSqueezeRatio(double pRatio);

    double GetSqueezeRatio() const;

    typedef enum
    {
        eNO_FIT,
        eVERTICAL_FIT,
        eHORIZONTAL_FIT,
        eFILL_FIT,
        eOVERSCAN_FIT,
        eSTRETCH_FIT
    } ECameraGateFit;

    double ComputeFieldOfView(double pFocalLength) const;

    double ComputeFocalLength(double pAngleOfView) const;

    typedef enum
    {
        eROTATE_TRANSLATE,
        eTRANSLATE_ROTATE
    } ECameraFilmRollOrder;



    void SetBackgroundFileName(const char* pFileName);

    char const* GetBackgroundFileName() const;

    void SetBackgroundMediaName(const char* pFileName);

    char const* GetBackgroundMediaName() const;

    void SetForegroundFileName(const char* pFileName);

    char const* GetForegroundFileName() const;

    void SetForegroundMediaName(const char* pFileName);

    char const* GetForegroundMediaName() const;

    
    typedef enum
    {
        eBACKGROUND,
        eFOREGROUND,
        eBACKGROUND_AND_FOREGROUND
    } ECameraPlateDrawingMode;

    void SetBackgroundAlphaTreshold(double pThreshold);

    double GetBackgroundAlphaTreshold() const;


    void SetFitImage(bool pFitImage);

    bool GetFitImage() const;

    void SetCrop(bool pCrop);

    bool GetCrop() const;

    void SetCenter(bool pCenter);

    bool GetCenter() const;

    void SetKeepRatio(bool pKeepRatio);

    bool GetKeepRatio() const;


    void SetShowFrontPlate(bool pEnable);

    bool GetShowFrontPlate() const;
 
    void SetFrontPlateFitImage(bool pFrontPlateFitImage);

    bool GetFrontPlateFitImage() const;

    void SetFrontPlateCrop(bool pFrontPlateCrop);

    bool GetFrontPlateCrop() const;

    void SetFrontPlateCenter(bool pFrontPlateCenter);

    bool GetFrontPlateCenter() const;

    void SetFrontPlateKeepRatio(bool pFrontPlateKeepRatio);

    bool GetFrontPlateKeepRatio() const;

    void SetForegroundOpacity(double pOpacity);

    double GetForegroundOpacity() const;

    void SetForegroundTexture(KFbxTexture* pTexture);

    KFbxTexture* GetForegroundTexture() const;


    typedef enum
    {
        eRELATIVE_TO_INTEREST,
        eRELATIVE_TO_CAMERA
    } ECameraFrontBackPlaneDistanceMode;

    void SetBackPlaneDistanceMode(ECameraFrontBackPlaneDistanceMode pMode);

    ECameraFrontBackPlaneDistanceMode GetBackPlaneDistanceMode() const;

    void SetFrontPlaneDistance(double pDistance);

    double GetFrontPlaneDistance() const;

    void SetFrontPlaneDistanceMode(ECameraFrontBackPlaneDistanceMode pMode);

    ECameraFrontBackPlaneDistanceMode GetFrontPlaneDistanceMode() const;

    typedef enum
    {
        eDISABLED,
        eALWAYS,
        eWHEN_MEDIA
    } ECameraFrontBackPlaneDisplayMode;
    
    void SetViewFrustumFrontPlaneMode(ECameraFrontBackPlaneDisplayMode pMode);

    ECameraFrontBackPlaneDisplayMode GetViewFrustumFrontPlaneMode() const;

    void SetViewFrustumBackPlaneMode(ECameraFrontBackPlaneDisplayMode pMode);

    ECameraFrontBackPlaneDisplayMode GetViewFrustumBackPlaneMode() const;
    


    void SetViewCameraInterest(bool pEnable);

    bool GetViewCameraInterest() const;

    void SetViewNearFarPlanes(bool pEnable);

    bool GetViewNearFarPlanes() const;

    typedef enum
    {
        eROUND = 0,
        eSQUARE = 1
    } ECameraSafeAreaStyle;



    typedef enum
    {
        eINTERACTIVE,
        eAT_RENDER
    } ECameraRenderOptionsUsageTime;

    typedef enum
    {
        eOVERSAMPLING_ANTIALIASING,
        eHARDWARE_ANTIALIASING
    } ECameraAntialiasingMethod;

    typedef enum
    {
        eUNIFORM,
        eSTOCHASTIC
    } ECameraSamplingType;

    typedef enum
    {
        eCAMERA_INTEREST,
        eSPECIFIC_DISTANCE
    } ECameraFocusDistanceSource;



    bool IsBoundingBoxInView( const KFbxMatrix& pWorldToScreen, 
                             const KFbxMatrix& pWorldToCamera, 
                             const KFbxVector4 pPoints[8] ) const;

    bool IsPointInView( const KFbxMatrix& pWorldToScreen, const KFbxMatrix& pWorldToCamera, const KFbxVector4& pPoint ) const;

    KFbxMatrix ComputeWorldToScreen(int pPixelWidth, int pPixelHeight, const KFbxXMatrix& pWorldToCamera) const;

    KFbxMatrix ComputePerspective( int pPixelWidth, int pPixelHeight, bool pIncludePostPerspective ) const;


    //
    // Properties
    //

    // -----------------------------------------------------------------------
    // Geometrical
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxDouble3>                       Position;

    KFbxTypedProperty<fbxDouble3>                       UpVector;

    KFbxTypedProperty<fbxDouble3>                       InterestPosition;

    KFbxTypedProperty<fbxDouble1>                       Roll;

    KFbxTypedProperty<fbxDouble1>                       OpticalCenterX;

    KFbxTypedProperty<fbxDouble1>                       OpticalCenterY;

    KFbxTypedProperty<fbxDouble3>                       BackgroundColor;

    KFbxTypedProperty<fbxDouble1>                       TurnTable;

    KFbxTypedProperty<fbxBool1>                         DisplayTurnTableIcon;

    // -----------------------------------------------------------------------
    // Motion Blur
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1>                         UseMotionBlur;

    KFbxTypedProperty<fbxBool1>                         UseRealTimeMotionBlur;

    KFbxTypedProperty<fbxDouble1>                       MotionBlurIntensity;

    // -----------------------------------------------------------------------
    // Optical
    // -----------------------------------------------------------------------

    KFbxTypedProperty<ECameraAspectRatioMode>           AspectRatioMode;

    KFbxTypedProperty<fbxDouble1>                       AspectWidth;

    KFbxTypedProperty<fbxDouble1>                       AspectHeight;

    KFbxTypedProperty<fbxDouble1>                       PixelAspectRatio;

    KFbxTypedProperty<ECameraApertureMode>              ApertureMode;

    KFbxTypedProperty<ECameraGateFit>                   GateFit;

    KFbxTypedProperty<fbxDouble1>                       FieldOfView;


    KFbxTypedProperty<fbxDouble1>                       FieldOfViewX;

    KFbxTypedProperty<fbxDouble1>                       FieldOfViewY;

    KFbxTypedProperty<fbxDouble1>                       FocalLength;

    KFbxTypedProperty<ECameraFormat>                    CameraFormat;

    // -----------------------------------------------------------------------
    // Frame
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1>                         UseFrameColor;

    KFbxTypedProperty<fbxDouble3>                       FrameColor;

    // -----------------------------------------------------------------------
    // On Screen Display
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1>                         ShowName;

    KFbxTypedProperty<fbxBool1>                         ShowInfoOnMoving;

    KFbxTypedProperty<fbxBool1>                         ShowGrid;

    KFbxTypedProperty<fbxBool1>                         ShowOpticalCenter;

    KFbxTypedProperty<fbxBool1>                         ShowAzimut;

    KFbxTypedProperty<fbxBool1>                         ShowTimeCode;

    KFbxTypedProperty<fbxBool1>                         ShowAudio;

    KFbxTypedProperty<fbxDouble3>                       AudioColor;

    // -----------------------------------------------------------------------
    // Clipping Planes
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxDouble1>                       NearPlane;

    KFbxTypedProperty<fbxDouble1>                       FarPlane;


    KFbxTypedProperty<fbxBool1>                         AutoComputeClipPlanes;


    // -----------------------------------------------------------------------
    // Camera Film Setting
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxDouble1>                       FilmWidth;

    KFbxTypedProperty<fbxDouble1>                       FilmHeight;

    KFbxTypedProperty<fbxDouble1>                       FilmAspectRatio;

    KFbxTypedProperty<fbxDouble1>                       FilmSqueezeRatio;

    KFbxTypedProperty<ECameraApertureFormat>            FilmFormat;

    KFbxTypedProperty<fbxDouble1>                       FilmOffsetX;

    KFbxTypedProperty<fbxDouble1>                       FilmOffsetY;

    KFbxTypedProperty<fbxDouble1>                       PreScale;

    KFbxTypedProperty<fbxDouble1>                       FilmTranslateX;

    KFbxTypedProperty<fbxDouble1>                       FilmTranslateY;

    KFbxTypedProperty<fbxDouble1>                       FilmRollPivotX;

    KFbxTypedProperty<fbxDouble1>                       FilmRollPivotY;

    KFbxTypedProperty<fbxDouble1>                       FilmRollValue;

    KFbxTypedProperty<ECameraFilmRollOrder>             FilmRollOrder ;

    // -----------------------------------------------------------------------
    // Camera View Widget Option
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1>                         ViewCameraToLookAt;

    KFbxTypedProperty<fbxBool1>                         ViewFrustumNearFarPlane;

    KFbxTypedProperty<ECameraFrontBackPlaneDisplayMode> ViewFrustumBackPlaneMode;

    KFbxTypedProperty<fbxDouble1>                       BackPlaneDistance;

    KFbxTypedProperty<ECameraFrontBackPlaneDistanceMode>    BackPlaneDistanceMode;

    KFbxTypedProperty<ECameraFrontBackPlaneDisplayMode> ViewFrustumFrontPlaneMode;

    KFbxTypedProperty<fbxDouble1>                       FrontPlaneDistance;

    KFbxTypedProperty<ECameraFrontBackPlaneDistanceMode>    FrontPlaneDistanceMode;

    // -----------------------------------------------------------------------
    // Camera Lock Mode
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1>                         LockMode;

    KFbxTypedProperty<fbxBool1>                         LockInterestNavigation;

    // -----------------------------------------------------------------------
    // Background Image Display Options
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1>                         FitImage;

    KFbxTypedProperty<fbxBool1>                         Crop;

    KFbxTypedProperty<fbxBool1>                         Center;

    KFbxTypedProperty<fbxBool1>                         KeepRatio;

    KFbxTypedProperty<fbxDouble1>                       BackgroundAlphaTreshold;

    KFbxTypedProperty<fbxDouble1>                       BackPlaneOffsetX;

    KFbxTypedProperty<fbxDouble1>                       BackPlaneOffsetY;

    KFbxTypedProperty<fbxDouble1>                       BackPlaneRotation;

    KFbxTypedProperty<fbxDouble1>                       BackPlaneScaleX;

    KFbxTypedProperty<fbxDouble1>                       BackPlaneScaleY;

    KFbxTypedProperty<fbxBool1>                         ShowBackplate;

    KFbxTypedProperty<fbxReference> BackgroundTexture;


    // -----------------------------------------------------------------------
    // Foreground Image Display Options
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1> FrontPlateFitImage;

    KFbxTypedProperty<fbxBool1> FrontPlateCrop;

    KFbxTypedProperty<fbxBool1> FrontPlateCenter;

    KFbxTypedProperty<fbxBool1> FrontPlateKeepRatio;


    KFbxTypedProperty<fbxBool1> ShowFrontplate;

    KFbxTypedProperty<fbxDouble1>                       FrontPlaneOffsetX;

    KFbxTypedProperty<fbxDouble1>                       FrontPlaneOffsetY;

    KFbxTypedProperty<fbxDouble1>                       FrontPlaneRotation;

    KFbxTypedProperty<fbxDouble1>                       FrontPlaneScaleX;

    KFbxTypedProperty<fbxDouble1>                       FrontPlaneScaleY;
    
    KFbxTypedProperty<fbxReference>                     ForegroundTexture;

    KFbxTypedProperty<fbxDouble1>                       ForegroundOpacity;

    // -----------------------------------------------------------------------
    // Safe Area
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1>                         DisplaySafeArea;

    KFbxTypedProperty<fbxBool1>                         DisplaySafeAreaOnRender;

    KFbxTypedProperty<ECameraSafeAreaStyle>             SafeAreaDisplayStyle;

    KFbxTypedProperty<fbxDouble1>                       SafeAreaAspectRatio;

    // -----------------------------------------------------------------------
    // 2D Magnifier
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1>                         Use2DMagnifierZoom;

    KFbxTypedProperty<fbxDouble1>                       _2DMagnifierZoom;

    KFbxTypedProperty<fbxDouble1>                       _2DMagnifierX;

    KFbxTypedProperty<fbxDouble1>                       _2DMagnifierY;

    // -----------------------------------------------------------------------
    // Projection Type: Ortho, Perspective
    // -----------------------------------------------------------------------

    KFbxTypedProperty<ECameraProjectionType>            ProjectionType;

    KFbxTypedProperty<fbxDouble1>                       OrthoZoom;

    // -----------------------------------------------------------------------
    // Depth Of Field & Anti Aliasing
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1>                         UseRealTimeDOFAndAA;

    KFbxTypedProperty<fbxBool1>                         UseDepthOfField;

    KFbxTypedProperty<ECameraFocusDistanceSource>       FocusSource;

    KFbxTypedProperty<fbxDouble1>                       FocusAngle;

    KFbxTypedProperty<fbxDouble1>                       FocusDistance;

    KFbxTypedProperty<fbxBool1>                         UseAntialiasing;

    KFbxTypedProperty<fbxDouble1>                       AntialiasingIntensity;

    KFbxTypedProperty<ECameraAntialiasingMethod>        AntialiasingMethod;

    // -----------------------------------------------------------------------
    // Accumulation Buffer
    // -----------------------------------------------------------------------

    KFbxTypedProperty<fbxBool1>                         UseAccumulationBuffer;

    KFbxTypedProperty<fbxInteger1>                      FrameSamplingCount;

    KFbxTypedProperty<ECameraSamplingType>              FrameSamplingType;

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS

    friend class KFbxGlobalCameraSettings;

    virtual KFbxObject& Copy(const KFbxObject& pObject);
    virtual KFbxObject* Clone(KFbxObject* pContainer, KFbxObject::ECloneType pCloneType) const;

protected:
    KFbxCamera(KFbxSdkManager& pManager, char const* pName);

    virtual bool ConstructProperties(bool pForceSet);

    virtual KString     GetTypeName() const;
    virtual KStringList GetTypeFlags() const;

private:
    double ComputePixelRatio(kUInt pWidth, kUInt pHeight, double pScreenRatio = 1.3333333333);

    // Background Properties
    KString mBackgroundMediaName;
    KString mBackgroundFileName;

    // Foreground Properties
    KString mForegroundMediaName;
    KString mForegroundFileName;

    friend class KFbxNode;

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

};

#define ImageFit    

typedef KFbxCamera* HKFbxCamera;

inline EFbxType FbxTypeOf( KFbxCamera::ECameraAntialiasingMethod const &pItem )         { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraApertureFormat const &pItem )             { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraApertureMode const &pItem )               { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraAspectRatioMode const &pItem )            { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraFrontBackPlaneDisplayMode const &pItem )  { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraFrontBackPlaneDistanceMode const &pItem ) { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraPlateDrawingMode const &pItem )           { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraFocusDistanceSource const &pItem )        { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraFormat const &pItem )                     { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraGateFit const &pItem )                    { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraProjectionType const &pItem )             { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraRenderOptionsUsageTime const &pItem )     { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraSafeAreaStyle const &pItem )              { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraSamplingType const &pItem )               { return eENUM; }
inline EFbxType FbxTypeOf( KFbxCamera::ECameraFilmRollOrder const &pItem )               { return eENUM; }

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXCAMERA_H