MatrixNodes.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <AtomsGraph/Globals.h>
#include <AtomsGraph/Nodes/UnaryFunctionNode.h>
#include <AtomsGraph/Nodes/BinaryFunctionNode.h>
#include <AtomsGraph/Nodes/MathNodes.h>
#include <AtomsUtils/AtomsMath.h>
 
namespace AtomsGraph
{
 
    ATOMSGRAPH_EXPORT void registerMatrixNodes();
 
    ATOMS_IMPLEMENT_NODE(AddNode<AtomsMath::Matrix>, AddMatrix, ADDMATRIX_NODE_ID)
 
    ATOMS_IMPLEMENT_NODE(SubtractNode<AtomsMath::Matrix>, SubtractMatrix, SUBTRACTMATRIX_NODE_ID)
 
    ATOMS_IMPLEMENT_NODE(MultiplyNode<AtomsMath::Matrix>, MultiplyMatrix, MULTIPLYMATRIX_NODE_ID)
 
    UNARY_DOT_FUNCTION_NODE_DEFINITION(InverseNode, inverse)
    ATOMS_IMPLEMENT_NODE(InverseNode<AtomsMath::Matrix>, InverseMatrix, INVERSEMATRIX_NODE_ID)
 
    UNARY_DOT_FUNCTION_NODE_DEFINITION(TransposeNode, transposed)
    ATOMS_IMPLEMENT_NODE(TransposeNode<AtomsMath::Matrix>, TransposeMatrix, TRANSPOSEMATRIX_NODE_ID)
 
    UNARY_DOT_FUNCTION_NODE_DEFINITION(DeterminantMatrixNode, determinant)
    ATOMS_IMPLEMENT_NODE(DeterminantMatrixNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, double)>, DeterminantMatrix, DETERMINANTMATRIX_NODE_ID)
 
    BINARY_OPERATOR_NODE_DEFINITION_WITH_NAMES(MultiplyScalarMatrixNode, *, matrix, double, out)
    ATOMS_IMPLEMENT_NODE(MultiplyScalarMatrixNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, double, AtomsMath::Matrix)>, MultiplyScalarMatrix, MULTIPLYSCALARMATRIX_NODE_ID)
 
    BINARY_OPERATOR_NODE_DEFINITION_WITH_NAMES(AddScalarMatrixNode, +, matrix, double, out)
    ATOMS_IMPLEMENT_NODE(AddScalarMatrixNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, double, AtomsMath::Matrix)>, AddScalarMatrix, ADDSCALARMATRIX_NODE_ID)
 
    BINARY_OPERATOR_NODE_DEFINITION_WITH_NAMES(DivideScalarMatrixNode, / , matrix, double, out)
    ATOMS_IMPLEMENT_NODE(DivideScalarMatrixNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, double, AtomsMath::Matrix)>, DivideScalarMatrix, DIVIDESCALARMATRIX_NODE_ID)
 
    BINARY_NOREF_DOT_FUNCTION_NODE_DEFINITION_WITH_NAMES(RotateNode, rotate, matrix, vector, out)
    ATOMS_IMPLEMENT_NODE(RotateNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, AtomsMath::Vector3, AtomsMath::Matrix)>, RotateMatrix, ROTATEMATRIX_NODE_ID)
 
    BINARY_NOREF_DOT_FUNCTION_NODE_DEFINITION_WITH_NAMES(SetRotateNode, setEulerAngles, matrix, vector, out)
    ATOMS_IMPLEMENT_NODE(SetRotateNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, AtomsMath::Vector3, AtomsMath::Matrix)>, SetRotationMatrix, SETROTATEMATRIX_NODE_ID)
 
    BINARY_NOREF_DOT_FUNCTION_NODE_DEFINITION_WITH_NAMES(ScaleNode, scale, matrix, vector, out)
    ATOMS_IMPLEMENT_NODE(ScaleNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, AtomsMath::Vector3, AtomsMath::Matrix)>, ScaleMatrix, SCALEMATRIX_NODE_ID)
 
    BINARY_NOREF_DOT_FUNCTION_NODE_DEFINITION_WITH_NAMES(SetScaleNode, setScale, matrix, vector, out)
    ATOMS_IMPLEMENT_NODE(SetScaleNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, AtomsMath::Vector3, AtomsMath::Matrix)>, SetScaleMatrix, SETSCALEMATRIX_NODE_ID)
 
    BINARY_NOREF_DOT_FUNCTION_NODE_DEFINITION_WITH_NAMES(TranslateNode, translate, matrix, vector, out)
    ATOMS_IMPLEMENT_NODE(TranslateNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, AtomsMath::Vector3, AtomsMath::Matrix)>, TranslateMatrix, TRANSLATEMATRIX_NODE_ID)
 
    BINARY_NOREF_DOT_FUNCTION_NODE_DEFINITION_WITH_NAMES(SetTranslationNode, setTranslation, matrix, vector, out)
    ATOMS_IMPLEMENT_NODE(SetTranslationNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, AtomsMath::Vector3, AtomsMath::Matrix)>, SetTranslationMatrix, SETTRANSLATIONMATRIX_NODE_ID)
 
    BINARY_NOREF_DOT_FUNCTION_NODE_DEFINITION_WITH_NAMES(ShearNode, shear, matrix, vector, out)
    ATOMS_IMPLEMENT_NODE(ShearNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, AtomsMath::Vector3, AtomsMath::Matrix)>, ShearMatrix, SHEARMATRIX_NODE_ID)
 
    BINARY_NOREF_DOT_FUNCTION_NODE_DEFINITION_WITH_NAMES(SetShearNode, setShear, matrix, vector, out)
    ATOMS_IMPLEMENT_NODE(SetShearNode<CONCAT(AtomsMath::Matrix, AtomsMath::Matrix, AtomsMath::Vector3, AtomsMath::Matrix)>, SetShearMatrix, SETSHEARMATRIX_NODE_ID)
 
    class ATOMSGRAPH_EXPORT MultiDirMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        MultiDirMatrixNode();
 
        virtual ~MultiDirMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        MatrixPort *m_in1;
 
        VectorPort *m_in2;
 
        VectorPort *m_out;
    };
 
 
    class ATOMSGRAPH_EXPORT MultiVecMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        MultiVecMatrixNode();
 
        virtual ~MultiVecMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        MatrixPort *m_in1;
 
        VectorPort *m_in2;
 
        VectorPort *m_out;
    };
 
 
    class ATOMSGRAPH_EXPORT SetAxisAngleMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        SetAxisAngleMatrixNode();
 
        virtual ~SetAxisAngleMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        VectorPort *m_in1;
 
        DoublePort *m_in2;
 
        MatrixPort *m_out;
    };
 
 
    class ATOMSGRAPH_EXPORT AlignZAxisWithTargetDirMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        AlignZAxisWithTargetDirMatrixNode();
 
        virtual ~AlignZAxisWithTargetDirMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        VectorPort *m_in1;
 
        VectorPort *m_in2;
 
        MatrixPort *m_out;
    };
 
 
    class ATOMSGRAPH_EXPORT ComputeLocalFrameMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        ComputeLocalFrameMatrixNode();
 
        virtual ~ComputeLocalFrameMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        VectorPort *m_in1;
 
        VectorPort *m_in2;
 
        VectorPort *m_in3;
 
        MatrixPort *m_out;
    };
 
 
    class ATOMSGRAPH_EXPORT ComputeRSMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        ComputeRSMatrixNode();
 
        virtual ~ComputeRSMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        BooleanPort *m_in1;
 
        BooleanPort *m_in2;
 
        MatrixPort *m_in3;
 
        MatrixPort *m_in4;
 
        MatrixPort *m_out;
    };
 
 
    class ATOMSGRAPH_EXPORT ExtractEulerXYZMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        ExtractEulerXYZMatrixNode();
 
        virtual ~ExtractEulerXYZMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        MatrixPort *m_in1;
 
        VectorPort *m_out;
    };
 
 
    class ATOMSGRAPH_EXPORT ExtractEulerZYXMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        ExtractEulerZYXMatrixNode();
 
        virtual ~ExtractEulerZYXMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        MatrixPort *m_in1;
 
        VectorPort *m_out;
    };
 
    class ATOMSGRAPH_EXPORT ExtractQuaternionMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        ExtractQuaternionMatrixNode();
 
        virtual ~ExtractQuaternionMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        MatrixPort *m_in1;
 
        QuaternionPort *m_out;
    };
 
    class ATOMSGRAPH_EXPORT ExtractScalingMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        ExtractScalingMatrixNode();
 
        virtual ~ExtractScalingMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        MatrixPort *m_in1;
 
        VectorPort *m_out;
    };
 
    class ATOMSGRAPH_EXPORT ExtractScalingAndShearMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        ExtractScalingAndShearMatrixNode();
 
        virtual ~ExtractScalingAndShearMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        MatrixPort *m_in1;
 
        VectorPort *m_out1;
 
        VectorPort *m_out2;
    };
 
    class ATOMSGRAPH_EXPORT ExtractSHRTMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        ExtractSHRTMatrixNode();
 
        virtual ~ExtractSHRTMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        MatrixPort *m_in1;
 
        VectorPort *m_out1;
 
        VectorPort *m_out2;
 
        VectorPort *m_out3;
 
        VectorPort *m_out4;
    };
 
    class ATOMSGRAPH_EXPORT RotationMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        RotationMatrixNode();
 
        virtual ~RotationMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        VectorPort *m_in1;
 
        VectorPort *m_in2;
 
        MatrixPort *m_out;
    };
 
    class ATOMSGRAPH_EXPORT RotationWithUpDirMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        RotationWithUpDirMatrixNode();
 
        virtual ~RotationWithUpDirMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        VectorPort *m_in1;
 
        VectorPort *m_in2;
 
        VectorPort *m_in3;
 
        MatrixPort *m_out;
    };
 
    class ATOMSGRAPH_EXPORT SansScalingMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        SansScalingMatrixNode();
 
        virtual ~SansScalingMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        MatrixPort *m_in;
 
        MatrixPort *m_out;
    };
 
    class ATOMSGRAPH_EXPORT SansScalingAndShearMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        SansScalingAndShearMatrixNode();
 
        virtual ~SansScalingAndShearMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        MatrixPort *m_in;
 
        MatrixPort *m_out;
    };
 
    class ATOMSGRAPH_EXPORT VectorToMatrixNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        VectorToMatrixNode();
 
        virtual ~VectorToMatrixNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        VectorPort *m_in1;
 
        VectorPort *m_in2;
 
        VectorPort *m_in3;
 
        VectorPort *m_in4;
 
        MatrixPort *m_out;
    };
 
    class ATOMSGRAPH_EXPORT MatrixToVectorNode :
        public Node
    {
    public:
 
        NODE_STANDARD_MEMBERS
 
        MatrixToVectorNode();
 
        virtual ~MatrixToVectorNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
 
        VectorPort *m_out1;
 
        VectorPort *m_out2;
 
        VectorPort *m_out3;
 
        VectorPort *m_out4;
 
        MatrixPort *m_in;
    };
 
}