transform3d.h

Go to the documentation of this file.

#line 1 "D:/Jenkins/workspace/EMS/ECG/ufe/full/ufe-full-python3.11-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 */