camera.h

Go to the documentation of this file.

#line 1 "S:/jenkins/workspace/ufe-full-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);

        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 */