IfNodes.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 registerIfNodes();
 
    template <typename T>
    class IfNode : public Node
    {
    public:
 
        static unsigned int staticTypeId();
 
        unsigned int typeId() const { return IfNode<T>::staticTypeId(); };
 
        static std::string staticTypeStr();
 
        virtual std::string typeStr() const { return IfNode<T>::staticTypeStr(); };
 
        virtual Node* clone();
 
        static Node* creator() { return new IfNode<T>(); }
 
        IfNode();
 
        virtual ~IfNode();
 
        virtual bool compute(const ComputeData* computeData);
 
    private:
        PortTemplate<bool> *m_inB;
 
        PortTemplate<T> *m_in1;
        PortTemplate<T> *m_in2;
 
        PortTemplate<T> *m_out;
    };
 
    template <typename T>
    Node* IfNode<T>::clone() {
        Node* node = new IfNode<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 IfNode<T>::compute(const ComputeData* computeData)
    {
        if (m_inB->get())
        {
            m_out->set(m_in1->getRef());
        }
        else
        {
            m_out->set(m_in2->getRef());
        }
 
        return true;
    }
 
    template <typename T>
    IfNode<T>::~IfNode()
    {
    }
 
    template <typename T>
    IfNode<T>::IfNode()
    {
        m_inB = new PortTemplate<bool>("if");
        m_in1 = new PortTemplate<T>("in1");
        m_in2 = new PortTemplate<T>("in2");
        m_out = new PortTemplate<T>("out");
 
        addInputPort(m_inB);
        addInputPort(m_in1);
        addInputPort(m_in2);
        addOutputPort(m_out);
    }
 
    ATOMS_IMPLEMENT_NODE(IfNode<bool>, IfBool, IF_BOOL_NODE_ID)
    ATOMS_IMPLEMENT_NODE(IfNode<long>, IfLong, IF_LONG_NODE_ID)
    ATOMS_IMPLEMENT_NODE(IfNode<double>, IfDouble, IF_DOUBLE_NODE_ID)
    ATOMS_IMPLEMENT_NODE(IfNode<std::string>, IfString, IF_STRING_NODE_ID)
    ATOMS_IMPLEMENT_NODE(IfNode<AtomsMath::Matrix>, IfMatrix, IF_MATRIX_NODE_ID)
    ATOMS_IMPLEMENT_NODE(IfNode<AtomsMath::Vector3>, IfVector, IF_VECTOR_NODE_ID)
    ATOMS_IMPLEMENT_NODE(IfNode<AtomsMath::Quaternion>, IfQuaternion, IF_QUATERNION_NODE_ID)
    ATOMS_IMPLEMENT_NODE(IfNode<AtomsUtils::Curve>, IfCurve, IF_CURVE_NODE_ID)
}