ControllerPriorityMixer.h

#pragma once


#include "Controller.h"
#include <vector>
#include <utility>
#include <algorithm>

template<class CntType, class ParamType>
class CControllerPriorityMixer : public CController {
protected:
        struct MIX_NODE {
                CntType* controller;    
                float*   weight;                
                char     priority;              

                bool operator>(const MIX_NODE& rNode) const 
                {
                        return priority > rNode.priority;
                }
                bool operator<(const MIX_NODE& rNode) const 
                {
                        return priority < rNode.priority;
                }
                bool operator==(const MIX_NODE& rNode) const 
                {
                        return priority == rNode.priority;
                }
        };

        std::vector<MIX_NODE> m_controllers;                    
        ParamType                         m_accumulated_param;          
                        

        
public:
        CControllerPriorityMixer(const std::string& name);
        virtual ~CControllerPriorityMixer(void);
        inline bool IsEmpty();
        void RegisterController(CntType* cnt, float* weight, char priority);
        void UnRegisterController(CntType* cnt);
        void Normalize();

        inline ParamType* GetParameter();
        virtual void Update(float dt);

        CNTRL_CLASS_NAME(CControllerMixer);
};

template<class CntType, class ParamType>
CControllerPriorityMixer<CntType, ParamType>::CControllerPriorityMixer(const std::string& name) : CController(name)
{
}

template<class CntType, class ParamType>
CControllerPriorityMixer<CntType, ParamType>::~CControllerPriorityMixer()
{
}

template<class CntType, class ParamType>
void CControllerPriorityMixer<CntType, ParamType>::RegisterController(CntType* cnt, float* weight, char priority)
{
        if(!m_controllers.empty()) {
                if(cnt->GetParameter() != m_controllers[0].controller->GetParameter()) {
                        LOGErr("CControllerPriorityMixer::RegisterController - parameters don't match");
                        return;
                }
        }

        MIX_NODE new_node;
        cnt->SetPassive(true);
        new_node.controller = cnt;
        new_node.weight         = weight;
        new_node.priority       = priority;

        m_controllers.push_back(new_node);

        std::sort(m_controllers.begin(), m_controllers.end(), std::greater<MIX_NODE>());
}
template<class CntType, class ParamType>
void CControllerPriorityMixer<CntType, ParamType>::UnRegisterController(CntType* cnt)
{
        for(size_t i = 0; i < m_controllers.size(); i++) {
                if(m_controllers[i].controller == cnt) {
                        cnt->SetPassive(false);
                        m_controllers.erase(m_controllers.begin() + i);
                        break;
                }
        }
}

template<class CntType, class ParamType>
void CControllerPriorityMixer<CntType, ParamType>::Normalize() 
{
        float nTotalWeight = 0.0f;
        for(size_t i = 0; i < m_controllers.size(); i++) {
                nTotalWeight += *m_controllers[i].first;
        }

        // Normalize
        for(size_t i = 0; i < m_controllers.size(); i++) {
                *m_controllers[i].first /= nTotalWeight;
        }
}

template<class CntType, class ParamType>
bool CControllerPriorityMixer<CntType, ParamType>::IsEmpty() 
{
        return m_controllers.empty();
}

template<class CntType, class ParamType>
ParamType* CControllerPriorityMixer<CntType, ParamType>::GetParameter()
{
        return &m_accumulated_param;
}

/*
        Inherited
*/
template<class CntType, class ParamType>
void CControllerPriorityMixer<CntType, ParamType>::Update(float dt)
{
        float weight_remaining = 1.0f;  // zbyvajici vaha, pokud nektery controller vypotrebuje vsechno (z 1.0f), na ostatni se jiz nedostane
        bool first = true;
        float curr_weight;
        

        for(size_t i = 0; i < m_controllers.size(); i++) {
                if(weight_remaining < 0.0f) break;

                MIX_NODE& curr = m_controllers[i];

                // celkova vaha nesmi prekrocit 1
                if(weight_remaining - *curr.weight < 0.0f) {
                        curr_weight = weight_remaining;
                } else {
                        curr_weight = *curr.weight;
                }
                weight_remaining -= *curr.weight;
                //
                
                if((*curr.weight) <= 0.0f) continue;
        
                curr.controller->Update(dt);
                
                if(first) {     
                        m_accumulated_param = (*curr.controller->GetParameter()) * (curr_weight);
                        first = false;
                } else {
                        m_accumulated_param += (*curr.controller->GetParameter()) * (curr_weight);
                }
        }
        if(!m_controllers.empty() && first == false) {
                *m_controllers[0].controller->GetParameter() = m_accumulated_param;
        }
}