camera.h

Go to the documentation of this file.

#line 1 "D:/Jenkins/workspace/EMS/ECG/ufe/full/ufe-full-python3.13-windows/ufe/include/camera.h"
#ifndef UFE_CAMERA_H
#define UFE_CAMERA_H
 
// ===========================================================================
// Copyright 2025 Autodesk, Inc. All rights reserved.
//
// The use of this software is subject to the Autodesk Terms of Use or other
// license agreement provided at the time of installation or download, or
// which otherwise accompanies this software.
// ===========================================================================
 
#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;
 
    virtual bool renderable() const = 0;
 
    virtual bool computedVisibility() const;
};
 
}
 
#endif /* UFE_CAMERA_H */