transform3d.h

Go to the documentation of this file.

#line 1 "S:/jenkins/workspace/ECP/ufe/ufe-full-python3.10-windows/ufe/include/transform3d.h"
#ifndef _transform3d
#define _transform3d
// ===========================================================================
// 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 "transform3dUndoableCommands.h"
#include "types.h"

#include <memory>
#include <array>

UFE_NS_DEF {


class UFE_SDK_DECL EditTransform3dHint
{
public:

    // The None enumerant is deprecated, and may be removed in a future
    // major version of UFE.
    enum Type {NoHint, None = NoHint, Translate, Rotate, Scale, RotatePivot, ScalePivot};
    EditTransform3dHint() = default;
    EditTransform3dHint(const EditTransform3dHint&) = delete;
    EditTransform3dHint& operator=(const EditTransform3dHint&) = delete;
    EditTransform3dHint(Type);
    virtual ~EditTransform3dHint();

    inline Type type() const { return fType; }

private:
    
    const Type fType{None};
};


class UFE_SDK_DECL Transform3dRead
{
public:
    typedef std::shared_ptr<Transform3dRead> Ptr;
    
    static Ptr transform3dRead(const SceneItem::Ptr& item);

    Transform3dRead();

    Transform3dRead(const Transform3dRead&) = default;

    virtual ~Transform3dRead();

    virtual const Path& path() const = 0;

    virtual SceneItem::Ptr sceneItem() const = 0;

    virtual Matrix4d matrix() const = 0;

    Matrix4d inclusiveMatrix() const; 

    Matrix4d exclusiveMatrix() const;

    virtual Matrix4d segmentInclusiveMatrix() const = 0; 

    virtual Matrix4d segmentExclusiveMatrix() const = 0;
};


class UFE_SDK_DECL Transform3d : public Transform3dRead
{
public:
    typedef std::shared_ptr<Transform3d> Ptr;
    
    static Ptr transform3d(const SceneItem::Ptr& item);

    static Ptr editTransform3d(
        const SceneItem::Ptr&      item,
        const EditTransform3dHint& hint = EditTransform3dHint()
    );

    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);

    Transform3d();
    Transform3d(const Transform3d&) = default;
    virtual ~Transform3d() override;

    virtual TranslateUndoableCommand::Ptr translateCmd(
        double x, double y, double z) = 0;

    inline TranslateUndoableCommand::Ptr translateCmd() {
        return translateCmd(0, 0, 0); }

    virtual void translate(double x, double y, double z) {
        auto cmd = translateCmd(x, y, z);
        if (cmd) {
            cmd->execute();
        }
    }

    virtual Vector3d translation() const = 0;

    virtual RotateUndoableCommand::Ptr rotateCmd(
        double x, double y, double z) = 0;

    inline RotateUndoableCommand::Ptr rotateCmd() {
        return rotateCmd(0, 0, 0); }

    virtual void rotate(double x, double y, double z) {
        auto cmd = rotateCmd(x, y, z);
        if (cmd) {
            cmd->execute();
        }
    }

    virtual Vector3d rotation() const = 0;

    virtual ScaleUndoableCommand::Ptr scaleCmd(
        double x, double y, double z) = 0;

    inline ScaleUndoableCommand::Ptr scaleCmd() {
        return scaleCmd(1, 1, 1); }

    virtual void scale(double x, double y, double z) {
        auto cmd = scaleCmd(x, y, z);
        if (cmd) {
        cmd->execute();
        }
    }

    virtual Vector3d scale() const = 0;

    virtual TranslateUndoableCommand::Ptr rotatePivotCmd(
        double x, double y, double z) = 0;

    inline TranslateUndoableCommand::Ptr rotatePivotCmd() {
        return rotatePivotCmd(0, 0, 0); }

    virtual void rotatePivot(double x, double y, double z) {
        auto cmd = rotatePivotCmd(x, y, z);
        if (cmd) {
            cmd->execute();
        }
    }

    virtual Vector3d rotatePivot() const = 0;

    virtual TranslateUndoableCommand::Ptr scalePivotCmd(
        double x, double y, double z) = 0;

    inline TranslateUndoableCommand::Ptr scalePivotCmd() {
      return scalePivotCmd(0, 0, 0); }

    virtual void scalePivot(double x, double y, double z)  {
        auto cmd = scalePivotCmd(x, y, z);
        if (cmd) {
            cmd->execute();
        }
    }

    virtual Vector3d scalePivot() const = 0;

    virtual TranslateUndoableCommand::Ptr translateRotatePivotCmd(
        double x, double y, double z) {
        (void) x; (void) y; (void) z;
        return nullptr;
    }

    inline TranslateUndoableCommand::Ptr translateRotatePivotCmd() {
      return translateRotatePivotCmd(0, 0, 0); }

    virtual void translateRotatePivot(double x, double y, double z)  {
        auto cmd = translateRotatePivotCmd(x, y, z);
        if (cmd) {
            cmd->execute();
        }
    }

    virtual Vector3d rotatePivotTranslation() const {
        return Vector3d(0, 0, 0);
    }

    virtual TranslateUndoableCommand::Ptr translateScalePivotCmd(
        double x, double y, double z) {
        (void) x; (void) y; (void) z;
        return nullptr;
    }

    inline TranslateUndoableCommand::Ptr translateScalePivotCmd() {
      return translateScalePivotCmd(0, 0, 0); }

    virtual void translateScalePivot(double x, double y, double z)  {
        auto cmd = translateScalePivotCmd(x, y, z);
        if (cmd) {
            cmd->execute();
        }
    }

    virtual Vector3d scalePivotTranslation() const {
        return Vector3d(0, 0, 0);
    }

    virtual RotateUndoableCommand::Ptr rotateAxisCmd(
        double x, double y, double z) {
        (void) x; (void) y; (void) z;
        return nullptr;
    }

    inline RotateUndoableCommand::Ptr rotateAxisCmd() {
        return rotateAxisCmd(0, 0, 0); }

    virtual void rotateAxis(double x, double y, double z) {
        auto cmd = rotateAxisCmd(x, y, z);
        if (cmd) {
            cmd->execute();
        }
    }

    virtual Vector3d rotateAxis() const {
        return Vector3d(0, 0, 0);
    }

    virtual ShearUndoableCommand::Ptr shearCmd(
        double xy, double xz, double yz) {
        (void) xy; (void) xz; (void) yz;
        return nullptr;
    }

    inline ShearUndoableCommand::Ptr shearCmd() {
      return shearCmd(0, 0, 0); }

    virtual void shear(double xy, double xz, double yz)  {
        auto cmd = shearCmd(xy, xz, yz);
        if (cmd) {
            cmd->execute();
        }
    }

    virtual Vector3d shear() const {
        return Vector3d(0, 0, 0);
    }

    virtual SetMatrix4dUndoableCommand::Ptr setMatrixCmd(const Matrix4d& m) = 0;

    virtual void setMatrix(const Matrix4d& m) {
        auto cmd = setMatrixCmd(m);
        if (cmd) {
            cmd->execute();
        }
    }
};

}

#endif /* _transform3d */