camera.h

Go to the documentation of this file.

#line 1 "S:/jenkins/workspace/ECP/ufe/ufe-full-python3.11-windows/ufe/include/camera.h"
#ifndef _camera
#define _camera
// ===========================================================================
// Copyright 2020 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include "common/ufeExport.h"
#include "sceneItem.h"
#include "observer.h"
#include "cameraUndoableCommands.h"
#include "types.h"
 
#include <memory>
#include <array>
 
UFE_NS_DEF
{
 
 
class UFE_SDK_DECL Camera
{
public:
    typedef std::shared_ptr<Camera> Ptr;
 
    enum Projection
    {
        Perspective,
        Orthographic
    };
 
    static Ptr camera(const SceneItem::Ptr &item);
 
    static bool addObserver(
        const SceneItem::Ptr &item, const Observer::Ptr &obs);
 
    static bool removeObserver(
        const SceneItem::Ptr &item, const Observer::Ptr &obs);
 
    typedef bool (*RemoveObserverItemType)(const SceneItem::Ptr &item, const Observer::Ptr& obs);
 
    static bool removeObserver(
        const Path &path, const Observer::Ptr &obs);
 
    typedef bool (*RemoveObserverPathType)(const Path& path, const Observer::Ptr& obs);
 
    static std::size_t nbObservers(const SceneItem::Ptr &item);
 
    static bool hasObserver(
        const SceneItem::Ptr &item, const Observer::Ptr &obs);
 
    static bool hasObservers(const Path &path);
 
    static bool hasObservers(Rtid runTimeId);
 
    static void notify(const Path &path);
 
    Camera();
    Camera(const Camera &) = default;
    virtual ~Camera();
 
    virtual const Path &path() const = 0;
 
    virtual SceneItem::Ptr sceneItem() const = 0;
 
    virtual HorizontalApertureUndoableCommand::Ptr horizontalApertureCmd(
        float ha) = 0;
 
    virtual void horizontalAperture(float ha)
    {
        auto cmd = horizontalApertureCmd(ha);
        if (cmd)
        {
            cmd->execute();
        }
    }
 
    virtual float horizontalAperture() const = 0;
 
    virtual VerticalApertureUndoableCommand::Ptr verticalApertureCmd(
        float va) = 0;
 
    virtual void verticalAperture(float va)
    {
        auto cmd = verticalApertureCmd(va);
        if (cmd)
        {
            cmd->execute();
        }
    }
 
    virtual float verticalAperture() const = 0;
 
    virtual HorizontalApertureOffsetUndoableCommand::Ptr horizontalApertureOffsetCmd(
        float hao) = 0;
 
    virtual void horizontalApertureOffset(float hao)
    {
        auto cmd = horizontalApertureOffsetCmd(hao);
        if (cmd)
        {
            cmd->execute();
        }
    }
 
    virtual float horizontalApertureOffset() const = 0;
 
    virtual VerticalApertureOffsetUndoableCommand::Ptr verticalApertureOffsetCmd(
        float vao) = 0;
 
    virtual void verticalApertureOffset(float vao)
    {
        auto cmd = verticalApertureOffsetCmd(vao);
        if (cmd)
        {
            cmd->execute();
        }
    }
 
    virtual float verticalApertureOffset() const = 0;
 
    virtual FStopUndoableCommand::Ptr fStopCmd(
        float fs) = 0;
 
    virtual void fStop(float fs)
    {
        auto cmd = fStopCmd(fs);
        if (cmd)
        {
            cmd->execute();
        }
    }
 
    virtual float fStop() const = 0;
 
    virtual FocalLengthUndoableCommand::Ptr focalLengthCmd(
        float fl) = 0;
 
    virtual void focalLength(float fl)
    {
        auto cmd = focalLengthCmd(fl);
        if (cmd)
        {
            cmd->execute();
        }
    }
 
    virtual float focalLength() const = 0;
 
    virtual FocusDistanceUndoableCommand::Ptr focusDistanceCmd(
        float fd) = 0;
 
    virtual void focusDistance(float fd)
    {
        auto cmd = focusDistanceCmd(fd);
        if (cmd)
        {
            cmd->execute();
        }
    }
 
    virtual float focusDistance() const = 0;
 
    virtual NearClipPlaneUndoableCommand::Ptr nearClipPlaneCmd(
        float ncp) = 0;
 
    virtual void nearClipPlane(float ncp)
    {
        auto cmd = nearClipPlaneCmd(ncp);
        if (cmd)
        {
            cmd->execute();
        }
    }
 
    virtual float nearClipPlane() const = 0;
 
    virtual FarClipPlaneUndoableCommand::Ptr farClipPlaneCmd(
        float fcp) = 0;
 
    virtual void farClipPlane(float fcp)
    {
        auto cmd = farClipPlaneCmd(fcp);
        if (cmd)
        {
            cmd->execute();
        }
    }
 
    virtual float farClipPlane() const = 0;
 
    virtual ProjectionUndoableCommand::Ptr projectionCmd(
        Projection p) = 0;
 
    virtual void projection(Projection p)
    {
        auto cmd = projectionCmd(p);
        if (cmd)
        {
            cmd->execute();
        }
    }
 
    virtual Projection projection() const = 0;
};
 
}
 
#endif /* _camera */