Variations.impl.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.
// ===========================================================================
 
namespace Atoms
{
    bool Variations::removeAgentTypeVariation(const std::string &agentTypeName)
    {
        std::map<std::string, AgentTypeVariation>::iterator it = m_agentTypeVariations.find(agentTypeName);
        if (it != m_agentTypeVariations.end())
        {
            m_agentTypeVariations.erase(it);
            return true;
        }
        return false;
    }
 
    std::vector<std::string> Variations::getAgentTypeNames() const
    {
        std::vector<std::string> names;
        names.reserve(m_agentTypeVariations.size());
        for (auto it = m_agentTypeVariations.cbegin(); it != m_agentTypeVariations.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    AgentTypeVariationCPtr Variations::getAgentTypeVariationPtr(const std::string &agentTypeName) const
    {
        std::map<std::string, AgentTypeVariation>::const_iterator it = m_agentTypeVariations.find(agentTypeName);
        if (it != m_agentTypeVariations.cend())
            return &it->second;
        return nullptr;
    }
 
    inline VariationGeometryCPtr AgentTypeVariation::getGeometryPtr(const std::string &name) const
    {
        std::map<std::string, VariationGeometry>::const_iterator it = m_geos.find(name);
        if (it != m_geos.cend())
            return &it->second;
        return nullptr;
    }
 
    inline VariationMaterialCPtr AgentTypeVariation::getMaterialPtr(const std::string &name) const
    {
        std::map<std::string, VariationMaterial>::const_iterator it = m_mats.find(name);
        if (it != m_mats.cend())
            return &it->second;
        return nullptr;
    }
 
    inline VariationGroupCPtr AgentTypeVariation::getGroupPtr(const std::string &name) const
    {
        std::map<std::string, VariationGroup>::const_iterator it = m_groups.find(name);
        if (it != m_groups.cend())
            return &it->second;
        return nullptr;
    }
 
    inline VariationOverrideCPtr AgentTypeVariation::getOverridePtr(const std::string& name) const
    {
        std::map<std::string, VariationOverride>::const_iterator it = m_overrides.find(name);
        if (it != m_overrides.cend())
            return &it->second;
        return nullptr;
    }
 
    void AgentTypeVariation::clear()
    {
        m_geos.clear();
        m_mats.clear();
        m_groups.clear();
        m_overrides.clear();
        m_variationTree = VariationTree(this);
    }
 
    std::vector<std::string> AgentTypeVariation::getGeometryNames()  const
    {
        std::vector<std::string> names;
        names.reserve(m_geos.size());
        for (auto it = m_geos.cbegin(); it != m_geos.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    std::vector<std::string> AgentTypeVariation::getMaterialNames()  const
    {
        std::vector<std::string> names;
        names.reserve(m_mats.size());
        for (auto it = m_mats.cbegin(); it != m_mats.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    std::vector<std::string> AgentTypeVariation::getGroupNames()  const
    {
        std::vector<std::string> names;
        names.reserve(m_groups.size());
        for (auto it = m_groups.cbegin(); it != m_groups.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    std::vector<std::string> AgentTypeVariation::getOverrideNames()  const
    {
        std::vector<std::string> names;
        names.reserve(m_overrides.size());
        for (auto it = m_overrides.cbegin(); it != m_overrides.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    bool AgentTypeVariation::removeGeometry(const std::string &name)
    {
        std::map<std::string, VariationGeometry>::iterator it = m_geos.find(name);
        if (it != m_geos.end())
        {
            m_geos.erase(it);
            return true;
        }
        return false;
    }
 
    bool AgentTypeVariation::removeMaterial(const std::string &name)
    {
        std::map<std::string, VariationMaterial>::iterator it = m_mats.find(name);
        if (it != m_mats.end())
        {
            m_mats.erase(it);
            return true;
        }
        return false;
    }
 
    bool AgentTypeVariation::removeGroup(const std::string &name)
    {
        std::map<std::string, VariationGroup>::iterator it = m_groups.find(name);
        if (it != m_groups.end())
        {
            m_groups.erase(it);
            return true;
        }
        return false;
    }
 
    bool AgentTypeVariation::removeAllGroups()
    {
        m_groups.clear();
        return true;
    }
 
    bool AgentTypeVariation::removeOverride(const std::string& name)
    {
        std::map<std::string, VariationOverride>::iterator it = m_overrides.find(name);
        if (it != m_overrides.end())
        {
            m_overrides.erase(it);
            return true;
        }
        return false;
    }
 
    bool AgentTypeVariation::removeAllOverrides()
    {
        m_overrides.clear();
        return true;
    }
 
    inline VariationGroupLodCPtr VariationGroup::getLodPtr(const std::string &name) const
    {
        std::map<std::string, VariationGroupLod>::const_iterator it = m_lods.find(name);
        if (it != m_lods.cend())
            return &it->second;
        return nullptr;
    }
 
    inline bool BaseVariationGroup::hasCombination(const std::string &geometryName, const std::string &materialName)
    {
        return std::find(m_combinations.begin(), m_combinations.end(), std::pair<std::string, std::string>(geometryName, materialName)) != m_combinations.end();
    }
 
    bool VariationGroup::removeLod(const std::string &name)
    {
        std::map<std::string, VariationGroupLod>::iterator it = m_lods.find(name);
        if (it != m_lods.end())
        {
            m_lods.erase(it);
            return true;
        }
        return false;
    }
 
    const std::pair<std::string, std::string>& BaseVariationGroup::getCombinationAtIndex(unsigned int index) const
    {
        if (index < m_combinations.size())
            return m_combinations[index];
        return m_emptyPair;
    }
 
    bool BaseVariationGroup::removeCombinationAtIndex(unsigned int index)
    {
        if (index < m_combinations.size())
        {
            m_combinations.erase(m_combinations.begin() + index);
            return true;
        }
        return false;
    }
 
    std::vector<std::string> VariationGroup::getLodNames()  const
    {
        std::vector<std::string> names;
        names.reserve(m_lods.size());
        for (auto it = m_lods.cbegin(); it != m_lods.cend(); it++)
            names.push_back(it->first);
        return names;
    }
 
    size_t Variations::size() const
    {
        return m_agentTypeVariations.size();
    }
 
    bool VariationOverride::hasGeometryFilter(const std::string& geometryName) const
    {
        return std::find(m_geometryFilter.begin(), m_geometryFilter.end(), geometryName) != m_geometryFilter.end();
    }
 
    const std::string& VariationOverride::getGeometryFilterAtIndex(unsigned int index) const
    {
        if (index < m_geometryFilter.size())
            return m_geometryFilter[index];
        return m_emptyString;
    }
 
    bool VariationOverride::removeGeometryFilterAtIndex(unsigned int index)
    {
        if (index < m_geometryFilter.size())
        {
            m_geometryFilter.erase(m_geometryFilter.begin() + index);
            return true;
        }
        return false;
    }
 
    void VariationTree::clear()
    {
        m_variationTypes.clear();
        m_extraGeos.clear();
        m_materialConstraints.clear();
        m_geoMatAlias.clear();
        m_geoMatSuffixRepl.first = "";
        m_geoMatSuffixRepl.second = "";
        m_materialPrefix = "";
    }
 
    void VariationTree::addVariationType(const std::string& name, const VariationTreeGeo& vg)
    {
        m_variationTypes.insert({ name, vg });
    }
 
    void VariationTree::addExtraGeo(const std::string& name, const VariationTreeGeo& vg)
    {   
        m_extraGeos.insert({ name, vg });
    }
 
    void VariationTree::addMaterialConstraint(const std::string& name, const MaterialConstraint& mc)
    {
        m_materialConstraints.insert({ name, mc });
    }
 
    void VariationTree::addExcludeGeometry(const std::string &name, const ExcludeGeometry& eg)
    {
        if (!m_atVariation->hasGeometry(eg.getSourceGeometry()))
        {
            AtomsUtils::Logger::error() << "Can't add exclude geometry " << name << ". Geometry " << eg.getSourceGeometry() << " does not exist";
            return;
        }
 
        if (!m_atVariation->hasGeometry(eg.getDestinationGeometry()))
        {
            AtomsUtils::Logger::error() << "Can't add exclude geometry " << name << ". Geometry " << eg.getDestinationGeometry() << " does not exist";
            return;
        }
 
        m_excludeGeometries.insert({ name, eg });
    }
 
    bool MaterialOverride::hasMaterial(const std::string& materialName) const
    {
        return std::find(m_materialNames.begin(), m_materialNames.end(), materialName) != m_materialNames.end();
    }
 
    void MaterialOverride::addMaterial(const std::string& materialName, const double weight)
    {
        m_materialNames.push_back(materialName);
        m_materialWeights.push_back(weight);
    }
 
    const std::string& MaterialOverride::getMaterialNameAtIndex(unsigned int index) const
    {
        if (index >= 0 && index < m_materialNames.size())
            return m_materialNames[index];
        return m_emptyString;
    }
 
    const double MaterialOverride::getMaterialWeightAtIndex(unsigned int index) const
    {
        if (index >= 0 && index < m_materialWeights.size())
            return m_materialWeights[index];
        return 0;
    }
 
    bool MaterialOverride::removeMaterialAtIndex(unsigned int index)
    {
        if (index >= 0 && index < m_materialNames.size())
        {
            m_materialNames.erase(m_materialNames.begin() + index);
            m_materialWeights.erase(m_materialWeights.begin() + index);
            return true;
        }
        return false;
    }
 
}