camera.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_BASE_GF_CAMERA_H
#define PXR_BASE_GF_CAMERA_H


#include "pxr/pxr.h"
#include "pxr/base/gf/matrix4d.h"
#include "pxr/base/gf/range1f.h"
#include "pxr/base/gf/vec4f.h"
#include "pxr/base/gf/api.h"

#include <vector>

PXR_NAMESPACE_OPEN_SCOPE

class GfFrustum;

class GfCamera
{
public:
    enum Projection {
        Perspective = 0,
        Orthographic,
    };

    enum FOVDirection {
        FOVHorizontal = 0,
        FOVVertical
    };

    GF_API static const double APERTURE_UNIT;
    GF_API static const double FOCAL_LENGTH_UNIT;
    
    GF_API static const double DEFAULT_HORIZONTAL_APERTURE;
    GF_API static const double DEFAULT_VERTICAL_APERTURE;

public:
    GF_API GfCamera(
        const GfMatrix4d &transform = GfMatrix4d(1.0),
        Projection projection = Perspective,
        float horizontalAperture = DEFAULT_HORIZONTAL_APERTURE,
        float verticalAperture = DEFAULT_VERTICAL_APERTURE,
        float horizontalApertureOffset = 0.0,
        float verticalApertureOffset = 0.0,
        float focalLength = 50.0,
        const GfRange1f &clippingRange = GfRange1f(1, 1000000),
        const std::vector<GfVec4f> &clippingPlanes = std::vector<GfVec4f>(),
        float fStop = 0.0,
        float focusDistance = 0.0);

    GF_API void SetTransform(const GfMatrix4d &val);

    GF_API void SetProjection(const Projection &val);



    
    GF_API void SetFocalLength(const float val);

    GF_API void SetHorizontalAperture(const float val);

    GF_API void SetVerticalAperture(const float val);

    GF_API void SetHorizontalApertureOffset(const float val);

    GF_API void SetVerticalApertureOffset(const float val);



    GF_API void SetPerspectiveFromAspectRatioAndFieldOfView(
        float aspectRatio,
        float fieldOfView,
        FOVDirection direction,
        float horizontalAperture = DEFAULT_HORIZONTAL_APERTURE);


    GF_API void SetOrthographicFromAspectRatioAndSize(
        float aspectRatio, float orthographicSize, FOVDirection direction);


    GF_API void SetFromViewAndProjectionMatrix(
        const GfMatrix4d &viewMatrix, const GfMatrix4d &projMatix,
        const float focalLength = 50.0);


    GF_API void SetClippingRange(const GfRange1f &val);

    GF_API void SetClippingPlanes(const std::vector<GfVec4f> &val);

    GF_API void SetFStop(const float val);

    GF_API void SetFocusDistance(const float val);

    GF_API GfMatrix4d GetTransform() const;

    GF_API Projection GetProjection() const;

    GF_API float GetHorizontalAperture() const;

    GF_API float GetVerticalAperture() const;

    GF_API float GetHorizontalApertureOffset() const;

    GF_API float GetVerticalApertureOffset() const;

    GF_API float GetAspectRatio() const;

    GF_API float GetFocalLength() const;

    GF_API float GetFieldOfView(FOVDirection direction) const;

    GF_API GfRange1f GetClippingRange() const;

    GF_API const std::vector<GfVec4f> &GetClippingPlanes() const;

    GF_API GfFrustum GetFrustum() const;

    GF_API float GetFStop() const;

    GF_API float GetFocusDistance() const;

    GF_API bool operator==(const GfCamera& other) const;

    // Inequality operator. true iff not equality.
    GF_API bool operator!=(const GfCamera& other) const;

private:
    // frustum
    GfMatrix4d              _transform;
    Projection              _projection;
    float                   _horizontalAperture;
    float                   _verticalAperture;
    float                   _horizontalApertureOffset;
    float                   _verticalApertureOffset;
    float                   _focalLength;
    GfRange1f               _clippingRange;
    std::vector<GfVec4f>    _clippingPlanes;

    // focus
    float                   _fStop;
    float                   _focusDistance;
};

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_BASE_GF_CAMERA_H