camera.h

Go to the documentation of this file.

#line 1 "S:/jenkins/workspace/ECP/ufe/ufe-full-python3.10-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 */