ControllerMixer.h

#pragma once


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

/*
        Slouzi k michani controlleru\n
        CntType         = typ controlleru\n
        ParamType       = typ parametru\n
*/

template<class CntType, class ParamType>
class CControllerMixer : public CController {
protected:
        std::vector<std::pair<float*,CntType*>> m_controllers;  
        ParamType                         m_accumulated_param;                          

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

        void Normalize();

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

        CNTRL_CLASS_NAME(CControllerMixer);
};

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

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

template<class CntType, class ParamType>
void CControllerMixer<CntType, ParamType>::RegisterController(CntType* cnt, float* weight)
{
        if(!m_controllers.empty()) {
                if(cnt->GetParameter() != m_controllers[0]->GetParameter()) {
                        LOGErr("CControllerMixer::RegisterController - parameters don't match");
                        return;
                }
        }
        cnt->SetPassive(true);
        m_controllers.push_back(std::make_pair(weight, cnt));
}
template<class CntType, class ParamType>
void CControllerMixer<CntType, ParamType>::UnRegisterController(CntType* cnt)
{
        for(size_t i = 0; i < m_controllers.size(); i++) {
                if(m_controllers[i].second == cnt) {
                        cnt->SetPassive(false);
                        m_controllers.erase(m_controllers.begin() + i);
                        break;
                }
        }
}

template<class CntType, class ParamType>
void CControllerMixer<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 CControllerMixer<CntType, ParamType>::IsEmpty() 
{
        return m_controllers.empty();
}

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

/*
        Inherited
*/
template<class CntType, class ParamType>
void CControllerMixer<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;

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

                std::pair<float*,CntType*>& curr = m_controllers[i];

                // celkova vaha nesmi prekrocit 1
                if(weight_remaining - *curr.first < 0.0f) {
                        curr_weight = weight_remaining;
                } else {
                        curr_weight = *curr.first;
                }
                weight_remaining -= *curr.first;
                //

                if((*curr.first) <= 0.0f) continue;
                curr.second->Update(dt);
                


                if(first) {     
                        m_accumulated_param = (*curr.second->GetParameter()) * (*curr.first);
                        first = false;
                } else {
                        m_accumulated_param += (*curr.second->GetParameter()) * (*curr.first);
                }

        }
        if(!m_controllers.empty() && first == false) {
                *m_controllers[0].second->GetParameter() = m_accumulated_param;
        }
}



/*
        Private
*/