CompareNodes.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/NodeIds.h>
#include <AtomsGraph/Node.h>
#include <AtomsGraph/Ports.h>
#include <AtomsUtils/AtomsMath.h>
#include <cmath>
#include <algorithm>
 
namespace AtomsGraph
{
    ATOMSGRAPH_EXPORT void registerCompareNodes();
 
    template <typename T>   
    class CompareNode : public Node                                                     
    {                                                               
    public: 
 
        inline bool compareValues(const T& A, const T& B, int op);
        
        static unsigned int staticTypeId();                         
        
        unsigned int typeId() const { return CompareNode<T>::staticTypeId(); };
        
        static std::string staticTypeStr();                                 
        
        virtual std::string typeStr() const { return CompareNode<T>::staticTypeStr(); };
        
        virtual Node* clone();
        
        static Node* creator() { return new CompareNode<T>(); }
        
        CompareNode();
        
        virtual ~CompareNode();
        
        virtual bool compute(const ComputeData* computeData);
        
    private:                                                        
        
        PortTemplate<T> *m_in1;
        
        PortTemplate<T> *m_in2;
 
        LongPort* m_compType;
        
        PortTemplate<bool> *m_out;                                      
    };                  
 
    template <typename T>
    inline  bool CompareNode<T>::compareValues(const T& A, const T& B, int op)
    {
        switch (op)
        {
        case 0:
            return A == B;
        case 1:
            return A != B;
        case 2:
            return A < B;
        case 3:
            return A > B;
        case 4:
            return A <= B;
        case 5:
            return A >= B;
        default:
            return A == B;
        }
    }
 
    template<>
    inline  bool CompareNode<AtomsMath::Vector3>::compareValues(const AtomsMath::Vector3& A, const AtomsMath::Vector3& B, int op)
    {
        switch (op)
        {
        case 0:
            return A == B;
        case 1:
            return A != B;
        default:
            return false;
        }
    }
 
    template<>
    inline  bool CompareNode<AtomsMath::Vector2>::compareValues(const AtomsMath::Vector2& A, const AtomsMath::Vector2& B, int op)
    {
        switch (op)
        {
        case 0:
            return A == B;
        case 1:
            return A != B;
        default:
            return false;
        }
    }
 
    template<>
    inline bool CompareNode<AtomsMath::Quaternion>::compareValues(const AtomsMath::Quaternion& A, const AtomsMath::Quaternion& B, int op)
    {
        switch (op)
        {
        case 0:
            return A == B;
        case 1:
            return A != B;
        default:
            return false;
        }
    }
 
    template<>
    inline bool CompareNode<AtomsMath::Matrix>::compareValues(const AtomsMath::Matrix& A, const AtomsMath::Matrix& B, int op)
    {
        switch (op)
        {
        case 0:
            return A == B;
        case 1:
            return A != B;
        default:
            return false;
        }
    }
 
    template <typename T>
    Node* CompareNode<T>::clone() {
        Node* node = new CompareNode<T>();
        if (!node)
            return nullptr;
        node->setName(name());
 
        for (auto portIt = inputPortCBegin(); portIt != inputPortCEnd(); ++portIt)
        {
            if ((*portIt)->numConnections() > 0)
                continue;
            Port *port = node->getInputPort((*portIt)->name());
            port->copyValue(*portIt);
        }
        return node;
    };
 
    template <typename T>   
    bool CompareNode<T>::compute(const ComputeData* computeData)
    {   
 
        m_out->set(compareValues(m_in1->getRef(), m_in2->getRef(), m_compType->get()));
        return true;                                                        
    }           
 
    template <typename T>
    CompareNode<T>::~CompareNode()
    {
    }
            
    template <typename T>   
    CompareNode<T>::CompareNode()
    {                                                                       
        m_in1 = new PortTemplate<T>("in1");                         
        m_in2 = new PortTemplate<T>("in2");
        m_compType = new LongPort("operation");
        m_out = new PortTemplate<bool>("out");                          
        
        m_compType->set(0);
            
        addInputPort(m_in1);                            
        addInputPort(m_in2);                    
        addInputPort(m_compType);
        addOutputPort(m_out);                           
    }
        
    ATOMS_IMPLEMENT_NODE(CompareNode<bool>, CompareBool, COMPARE_BOOL_NODE_ID)
    ATOMS_IMPLEMENT_NODE(CompareNode<long>, CompareLong, COMPARE_LONG_NODE_ID)
    ATOMS_IMPLEMENT_NODE(CompareNode<double>, CompareDouble, COMPARE_DOUBLE_NODE_ID)
    ATOMS_IMPLEMENT_NODE(CompareNode<std::string>, CompareString, COMPARE_STRING_NODE_ID)
    ATOMS_IMPLEMENT_NODE(CompareNode<AtomsMath::Matrix>, CompareMatrix, COMPARE_MATRIX_NODE_ID)
    ATOMS_IMPLEMENT_NODE(CompareNode<AtomsMath::Vector3>, CompareVector, COMPARE_VECTOR_NODE_ID)
    ATOMS_IMPLEMENT_NODE(CompareNode<AtomsMath::Quaternion>, CompareQuaternion, COMPARE_QUATERNION_NODE_ID)
}