Ticket #2324: ActorFormat.3.patch

source/graphics/UnitAnimation.h

@@ -1 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* Copyright (C) 2015 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -95 +95 @@
     struct SModelAnimState
     {
         CModel* model;
+        const CObjectEntry* object;
         std::vector<CSkeletonAnim*> anims;
+        CStr animName;
         size_t animIdx;
         float time;
         bool pastLoadPos;
@@ -111 +113 @@
      */
     bool m_AnimStatesAreStatic;
 
-    void AddModel(CModel* model, const CObjectEntry* object);
+    void AddModel(CModel* model, const CObjectEntry* object, bool useName = false, CStr* animName = NULL);
 
+    /**
+     * called in AddModel and Update.
+     * Will try to choose animations, fitting the animName if needed.
+     */
+    void pickAnim(SModelAnimState* state, const CStr& stateName, bool useName = false, CStr* animName = NULL, bool changeName = false);
+    
     entity_id_t m_Entity;
     CModel* m_Model;
     const CObjectEntry* m_Object;

source/graphics/UnitAnimation.cpp

@@ -1 @@
-/* Copyright (C) 2012 Wildfire Games.
+/* Copyright (C) 2015 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -52 +52 @@
     m_Entity = ent;
 }
 
-void CUnitAnimation::AddModel(CModel* model, const CObjectEntry* object)
+void CUnitAnimation::AddModel(CModel* model, const CObjectEntry* object, bool useName /* = false */, CStr* animName /* = NULL */)
 {
     SModelAnimState state;
 
-    state.anims = object->GetAnimations(m_State);
+    ENSURE(!object->GetStateAnimations("idle").empty()); // there must always be an idle animation
 
-    if (state.anims.empty())
-        state.anims = object->GetAnimations("idle");
-    ENSURE(!state.anims.empty()); // there must always be an idle animation
-
     state.model = model;
-    state.animIdx = rand(0, state.anims.size());
+    state.object = object;
     state.time = 0.f;
     state.pastLoadPos = false;
     state.pastActionPos = false;
     state.pastSoundPos = false;
 
+    this->pickAnim(&state, m_State, useName, animName);
+    
     m_AnimStates.push_back(state);
 
     model->SetAnimation(state.anims[state.animIdx], !m_Looping);
 
     // Detect if this unit has any non-static animations
-    for (size_t i = 0; i < state.anims.size(); i++)
-        if (state.anims[i]->m_AnimDef != NULL)
+    for (const CSkeletonAnim* animation : state.anims)
+        if (animation->m_AnimDef != NULL)
             m_AnimStatesAreStatic = false;
 
     // Recursively add all props
-    const std::vector<CModel::Prop>& props = model->GetProps();
-    for (std::vector<CModel::Prop>::const_iterator it = props.begin(); it != props.end(); ++it)
+    for (const CModel::Prop& prop : model->GetProps())
     {
-        CModel* propModel = it->m_Model->ToCModel();
+        CModel* propModel = prop.m_Model->ToCModel();
         if (propModel)
-            AddModel(propModel, it->m_ObjectEntry);
+            AddModel(propModel, prop.m_ObjectEntry, true, &state.animName);
     }
 }
 
+void CUnitAnimation::pickAnim(SModelAnimState* state, const CStr& stateName, bool useName /* = false */, CStr* animName /* = NULL */, bool changeName /* = false */)
+{
+    ENSURE(!(animName == NULL && useName));
+    
+        // get the proper animations.
+    if (useName)
+        state->anims = state->object->GetAnimations(stateName, *animName);
+    else
+        state->anims = state->object->GetStateAnimations(stateName);
+
+    // if empty and we used a specific anim name, try something more general
+    // else try the idle animation, there is at least one by construction.
+    if (state->anims.size() == 0)
+    {
+        if (useName)
+            state->anims = state->object->GetAnimations(stateName, *animName);
+        useName = false;
+        if (state->anims.size() == 0)
+            state->anims = state->object->GetStateAnimations("idle");
+    }
+
+    // choose an animation. This is done randomly, but we respect the frequencies defined.
+    // in case frequencies are all 0, we pick the first.
+    size_t total = 0;
+    if (useName)
+        total = state->object->GetStateAnimFrequency(stateName, *animName);
+    else
+        total = state->object->GetStateFrequency(stateName);
+    
+    size_t sum = 0;
+    size_t randv = 0;
+    if (total != 0)
+        randv = rand(1, total+1);
+    
+    for (size_t i = 0; i < state->anims.size(); ++i)
+    {
+        sum += state->anims[i]->m_Frequency;
+        if (sum < randv)
+            continue;
+
+        if (i != state->animIdx || state->anims[i]->m_AnimationName != state->animName)
+        {
+            state->animIdx = i;
+            state->animName = state->anims[i]->m_AnimationName;
+            state->model->SetAnimation(state->anims[state->animIdx], !m_Looping);
+        }
+        
+        if (changeName)
+            *animName = state->animName;
+        
+        break;
+    }
+}
+
+
 void CUnitAnimation::ReloadUnit(CModel* model, const CObjectEntry* object)
 {
     m_Model = model;
@@ -160 +212 @@
         return;
 
     // Advance all of the prop models independently
+    SModelAnimState* needLooping[m_AnimStates.size()];
+    size_t looped = 0;
+
     for (std::vector<SModelAnimState>::iterator it = m_AnimStates.begin(); it != m_AnimStates.end(); ++it)
     {
         CSkeletonAnimDef* animDef = it->anims[it->animIdx]->m_AnimDef;
@@ -228 +283 @@
         else if (m_Looping)
         {
             // If we've finished the current animation and want to loop...
-
+            needLooping[looped++] = &(*it);
+            
             // Wrap the timer around
             it->time = fmod(it->time + advance, duration);
-
-            // If there's a choice of multiple animations, pick a new random one
-            if (it->anims.size() > 1)
-            {
-                size_t newAnimIdx = rand(0, it->anims.size());
-                if (newAnimIdx != it->animIdx)
-                {
-                    it->animIdx = newAnimIdx;
-                    it->model->SetAnimation(it->anims[it->animIdx], !m_Looping);
-                }
-            }
-
+            
             it->pastActionPos = false;
             it->pastLoadPos = false;
             it->pastSoundPos = false;
-
-            it->model->UpdateTo(it->time);
         }
         else
         {
@@ -262 +305 @@
             }
         }
     }
+    
+    
+    if (looped == 0)
+        return;
+    
+    // to keep our props in synch (well those that can be)
+    // we'll update them separately.
+    CStr animName = "";
+    CStr& stateName = m_State;
+
+    // the first one is the initializer so out of the loop.
+    SModelAnimState* oState = needLooping[0];
+    this->pickAnim(oState, stateName, false, &animName, true);
+    oState->model->UpdateTo(oState->time);
+    
+    for (size_t i = 1; i < looped; ++i)
+    {
+        SModelAnimState* state = needLooping[i];
+        
+        this->pickAnim(state, stateName, true, &animName);
+        
+        state->model->UpdateTo(state->time);
+    }
 }

source/graphics/SkeletonAnim.h

@@ -1 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2015 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -33 +33 @@
 {
 public:
     // the name of the action which uses this animation (e.g. "idle")
-    CStr m_Name;
+    CStr m_StateName;
+    // the name of the animation ("" is default, and you can then specify)
+    CStr m_AnimationName;
     // the raw animation frame data; may be NULL if this is a static 'animation'
     CSkeletonAnimDef* m_AnimDef;
     // speed at which this animation runs, as a factor of the AnimDef default speed
     // (treated as 0 if m_AnimDef == NULL)
     float m_Speed;
+    // how often this animation will be played.
+    size_t m_Frequency;
     // Times during the animation at which the interesting bits happen,
     // as msec times in the range [0, AnimDef->GetDuration],
     // or special value -1 if unspecified.

source/graphics/ObjectEntry.h

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2015 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -63 +63 @@
 
     std::wstring m_ProjectileModelName;
 
-    // Returns a randomly-chosen animation matching the given name.
+    // Returns a randomly-chosen animation from a given state
     // If none is found, returns NULL.
-    CSkeletonAnim* GetRandomAnimation(const CStr& animationName) const;
+    CSkeletonAnim* GetRandomAnimation(const CStr& stateName) const;
 
-    // Returns all the animations matching the given name.
-    std::vector<CSkeletonAnim*> GetAnimations(const CStr& animationName) const;
+    // Returns all the animations for a given state and name
+    std::vector<CSkeletonAnim*> GetAnimations(const CStr& stateName, const CStr& animationName) const;
+    
+    // Returns all the animations for a given state.
+    std::vector<CSkeletonAnim*> GetStateAnimations(const CStr& stateName) const;
 
+    // Returns total frequencies for a state and anim name
+    size_t GetStateAnimFrequency(const CStr& stateName, const CStr& animationName) const;
+
+    // Returns total frequencies for a state
+    size_t GetStateFrequency(const CStr& stateName) const;
+
     // corresponding model
     CModelAbstract* m_Model;
 
@@ -80 +89 @@
 private:
     CSimulation2& m_Simulation;
 
-    typedef std::multimap<CStr, CSkeletonAnim*> SkeletonAnimMap;
-    SkeletonAnimMap m_Animations;
+    // stores animations for each state. We'll iterate if we need to find a specific one.
+    // TODO: maybe someday if we have lots of anims use something cleverer.
+    typedef std::multimap<CStr, CSkeletonAnim*> SkeletonStateAnimMap;
+    SkeletonStateAnimMap m_StateAnimations;
+    typedef std::map<CStr, size_t> SkeletonStateFrequencies;
+    SkeletonStateFrequencies m_StateFrequencies;
         // TODO: something more memory-efficient than storing loads of similar strings for each unit?
 };
 

source/graphics/ObjectEntry.cpp

@@ -46 +46 @@
 
 CObjectEntry::~CObjectEntry()
 {
-    for (const std::pair<CStr, CSkeletonAnim*>& anim : m_Animations)
+    for (const std::pair<CStr, CSkeletonAnim*>& anim : m_StateAnimations)
         delete anim.second;
 
     delete m_Model;
@@ -145 +145 @@
         model->GetMaterial().AddSampler(CMaterial::TextureSampler(samp.m_SamplerName, texture));
     }
 
-    const std::vector<CStrIntern>& requiredSamplers = model->GetMaterial().GetRequiredSampler();
-    for (const auto& requSampName : requiredSamplers)
+    for (const auto& requSampName : model->GetMaterial().GetRequiredSampler())
     {
         if (std::find_if(m_Samplers.begin(), m_Samplers.end(),
                          [&](CObjectBase::Samp sampler) { return sampler.m_SamplerName == requSampName; }) == m_Samplers.end())
@@ -159 +158 @@
     // load the animations
     for (std::multimap<CStr, CObjectBase::Anim>::iterator it = variation.anims.begin(); it != variation.anims.end(); ++it)
     {
-        CStr name = it->first.LowerCase();
+        CStr stateName = it->first.LowerCase();
 
-        if (!it->second.m_FileName.empty())
-        {
-            CSkeletonAnim* anim = model->BuildAnimation(it->second.m_FileName, name, it->second.m_Speed, it->second.m_ActionPos, it->second.m_ActionPos2, it->second.m_SoundPos);
-            if (anim)
-                m_Animations.insert(std::make_pair(name, anim));
+        if (it->second.m_FileName.empty())
+            continue;
+
+        CSkeletonAnim* anim = model->BuildAnimation(it->second.m_FileName, stateName, it->second.m_AnimName, it->second.m_Speed,
+                                                    it->second.m_Frequency, it->second.m_ActionPos, it->second.m_ActionPos2, it->second.m_SoundPos);
+        if (!anim)
+            continue;
+
+        m_StateAnimations.insert(std::make_pair(stateName, anim));
+        SkeletonStateFrequencies::const_iterator idx = m_StateFrequencies.find(stateName);
+        if (idx == m_StateFrequencies.end())
+            m_StateFrequencies[stateName] = it->second.m_Frequency;
+        else
+            m_StateFrequencies[stateName] += it->second.m_Frequency;
         }
-    }
 
     // ensure there's always an idle animation
-    if (m_Animations.find("idle") == m_Animations.end())
+    if (m_StateAnimations.find("idle") == m_StateAnimations.end())
     {
         CSkeletonAnim* anim = new CSkeletonAnim();
-        anim->m_Name = "idle";
+        anim->m_StateName = "idle";
+        anim->m_AnimationName = "";
         anim->m_AnimDef = NULL;
+        anim->m_Frequency = 1;
         anim->m_Speed = 0.f;
         anim->m_ActionPos = 0.f;
         anim->m_ActionPos2 = 0.f;
         anim->m_SoundPos = 0.f;
-        m_Animations.insert(std::make_pair("idle", anim));
 
+        m_StateAnimations.insert(std::make_pair("idle", anim));
+        m_StateFrequencies["idle"] = 1;
+
         // Ignore errors, since they're probably saying this is a non-animated model
         model->SetAnimation(anim);
     }
@@ -250 +261 @@
     return true;
 }
 
-CSkeletonAnim* CObjectEntry::GetRandomAnimation(const CStr& animationName) const
+CSkeletonAnim* CObjectEntry::GetRandomAnimation(const CStr& stateName) const
 {
-    SkeletonAnimMap::const_iterator lower = m_Animations.lower_bound(animationName);
-    SkeletonAnimMap::const_iterator upper = m_Animations.upper_bound(animationName);
+    SkeletonStateAnimMap::const_iterator lower = m_StateAnimations.lower_bound(stateName);
+    SkeletonStateAnimMap::const_iterator upper = m_StateAnimations.upper_bound(stateName);
     size_t count = std::distance(lower, upper);
     if (count == 0)
         return NULL;
 
+    // TODO: make this use frequencies.
     size_t id = rand(0, count);
     std::advance(lower, id);
     return lower->second;
 }
 
-std::vector<CSkeletonAnim*> CObjectEntry::GetAnimations(const CStr& animationName) const
+std::vector<CSkeletonAnim*> CObjectEntry::GetAnimations(const CStr& stateName, const CStr& animationName) const
 {
     std::vector<CSkeletonAnim*> anims;
+    
+    SkeletonStateAnimMap::const_iterator lower = m_StateAnimations.lower_bound(stateName);
+    SkeletonStateAnimMap::const_iterator upper = m_StateAnimations.upper_bound(stateName);
+    for (SkeletonStateAnimMap::const_iterator it = lower; it != upper; ++it)
+    {
+        if (it->second->m_AnimationName == animationName)
+            anims.push_back(it->second);
+    }
+    return anims;
+}
 
-    SkeletonAnimMap::const_iterator lower = m_Animations.lower_bound(animationName);
-    SkeletonAnimMap::const_iterator upper = m_Animations.upper_bound(animationName);
-    for (SkeletonAnimMap::const_iterator it = lower; it != upper; ++it)
+std::vector<CSkeletonAnim*> CObjectEntry::GetStateAnimations(const CStr& stateName) const
+{
+    std::vector<CSkeletonAnim*> anims;
+
+    SkeletonStateAnimMap::const_iterator lower = m_StateAnimations.lower_bound(stateName);
+    SkeletonStateAnimMap::const_iterator upper = m_StateAnimations.upper_bound(stateName);
+    for (SkeletonStateAnimMap::const_iterator it = lower; it != upper; ++it)
         anims.push_back(it->second);
     return anims;
 }
+
+size_t CObjectEntry::GetStateFrequency(const CStr& stateName) const
+{
+    SkeletonStateFrequencies::const_iterator idx =  m_StateFrequencies.find(stateName);
+    if (idx != m_StateFrequencies.end())
+        return idx->second;
+    return 0;
+}
+
+size_t CObjectEntry::GetStateAnimFrequency(const CStr& stateName, const CStr& animationName) const
+{
+    size_t total = 0;
+    
+    SkeletonStateAnimMap::const_iterator lower = m_StateAnimations.lower_bound(stateName);
+    SkeletonStateAnimMap::const_iterator upper = m_StateAnimations.upper_bound(stateName);
+    for (SkeletonStateAnimMap::const_iterator it = lower; it != upper; ++it)
+        if (it->second->m_AnimationName == animationName)
+            total += it->second->m_Frequency;
+    
+    return total;
+}
+

source/graphics/ObjectBase.h

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2015 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -41 +41 @@
     {
         // constructor
         Anim() : m_Speed(1.f), m_ActionPos(-1.f), m_ActionPos2(-1.f), m_SoundPos(-1.f) {}
-        // name of the animation - "Idle", "Run", etc
+        // unit State the animation is used for — "Idle", "Run",…
+        CStr m_StateName;
+        // ctual Name of the animation
         CStr m_AnimName;
         // filename of the animation - manidle.psa, manrun.psa, etc
         VfsPath m_FileName;
         // animation speed, as specified in XML actor file
         float m_Speed;
+        // how often the animation will be chosen (if several are possible).
+        size_t m_Frequency;
         // fraction [0.0, 1.0] of the way through the animation that the interesting bit(s)
         // happens, or -1.0 if unspecified
         float m_ActionPos;

source/graphics/ObjectBase.cpp

@@ -100 +100 @@
     m_Pathname = pathname;
     m_ShortName = pathname.Basename().string();
 
+    int version = root.GetAttributes()[0].Value.ToInt();
 
     // Set up the vector<vector<T>> m_Variants to contain the right number
     // of elements, to avoid wasteful copying/reallocation later.
@@ -194 +195 @@
                     }
                     else if (option_name == el_animations)
                     {
+                        if (version == 2)
+                        {
+                            XERO_ITER_EL(option, states)
+                            {
+                                std::string stateName = XeroFile.GetElementString(states.GetNodeName());
+                                
+                                XERO_ITER_EL(states, anim_element)
+                                {
+                                    Anim anim;
+                                    ENSURE(anim_element.GetNodeName() == el_animation);
+                                    
+                                    anim.m_StateName = stateName;
+                                    anim.m_Frequency = 1;
+                                    anim.m_AnimName = "";
+                                    
+                                    XERO_ITER_ATTR(anim_element, ae)
+                                    {
+                                        if (ae.Name == at_name)
+                                        {
+                                            anim.m_AnimName = ae.Value;
+                                        }
+                                        else if (ae.Name == at_file)
+                                        {
+                                            anim.m_FileName = VfsPath("art/animation") / ae.Value.FromUTF8();
+                                        }
+                                        else if (ae.Name == at_speed)
+                                        {
+                                            anim.m_Speed = ae.Value.ToInt() / 100.f;
+                                            if (anim.m_Speed <= 0.0) anim.m_Speed = 1.0f;
+                                        }
+                                        else if (ae.Name == at_frequency)
+                                        {
+                                            anim.m_Frequency = ae.Value.ToUInt();
+                                        }
+                                        else if (ae.Name == at_event)
+                                        {
+                                            float pos = ae.Value.ToFloat();
+                                            anim.m_ActionPos = clamp(pos, 0.f, 1.f);
+                                        }
+                                        else if (ae.Name == at_load)
+                                        {
+                                            float pos = ae.Value.ToFloat();
+                                            anim.m_ActionPos2 = clamp(pos, 0.f, 1.f);
+                                        }
+                                        else if (ae.Name == at_sound)
+                                        {
+                                            float pos = ae.Value.ToFloat();
+                                            anim.m_SoundPos = clamp(pos, 0.f, 1.f);
+                                        }
+                                    }
+                                    currentVariant->m_Anims.push_back(anim);
+                                }
+                            }
+                        }
+                        else
+                        {
                         XERO_ITER_EL(option, anim_element)
                         {
                             ENSURE(anim_element.GetNodeName() == el_animation);
 
                             Anim anim;
+                                
+                                anim.m_Frequency = 1;
+                                anim.m_AnimName = "";
+                                
                             XERO_ITER_ATTR(anim_element, ae)
                             {
                                 if (ae.Name == at_name)
                                 {
-                                    anim.m_AnimName = ae.Value;
+                                        anim.m_StateName = ae.Value;
                                 }
                                 else if (ae.Name == at_file)
                                 {
@@ -232 +293 @@
                             }
                             currentVariant->m_Anims.push_back(anim);
                         }
-
                     }
+                    }
                     else if (option_name == el_props)
                     {
                         XERO_ITER_EL(option, prop_element)
@@ -450 +511 @@
         // Same idea applies for animations.
         // So, erase all existing animations which are overridden by this variant:
         for (std::vector<CObjectBase::Anim>::iterator it = var.m_Anims.begin(); it != var.m_Anims.end(); ++it)
-            variation.anims.erase(it->m_AnimName);
+            variation.anims.erase(it->m_StateName);
         // and then insert the new ones:
         for (std::vector<CObjectBase::Anim>::iterator it = var.m_Anims.begin(); it != var.m_Anims.end(); ++it)
-            variation.anims.insert(make_pair(it->m_AnimName, *it));
+            variation.anims.insert(make_pair(it->m_StateName, *it));
         
         // Same for samplers, though perhaps not strictly necessary:
         for (std::vector<CObjectBase::Samp>::iterator it = var.m_Samplers.begin(); it != var.m_Samplers.end(); ++it)

source/graphics/Model.h

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2015 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -200 +200 @@
      * Load raw animation frame animation from given file, and build an
      * animation specific to this model.
      * @param pathname animation file to load
-     * @param name animation name (e.g. "idle")
+     * @param stateName state name (e.g. "idle")
+     * @param animName animation name (default is "")
      * @param speed animation speed as a factor of the default animation speed
+     * @param frequency how often the animation will be chosen
      * @param actionpos offset of 'action' event, in range [0, 1]
      * @param actionpos2 offset of 'action2' event, in range [0, 1]
      * @param sound offset of 'sound' event, in range [0, 1]
      * @return new animation, or NULL on error
      */
-    CSkeletonAnim* BuildAnimation(const VfsPath& pathname, const CStr& name, float speed, float actionpos, float actionpos2, float soundpos);
+    CSkeletonAnim* BuildAnimation(const VfsPath& pathname, const CStr& stateName, const CStr& animName, float speed, int frequency, float actionpos, float actionpos2, float soundpos);
 
     /**
      * Add a prop to the model on the given point.

source/graphics/Model.cpp

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2015 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -255 +255 @@
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // BuildAnimation: load raw animation frame animation from given file, and build a 
 // animation specific to this model
-CSkeletonAnim* CModel::BuildAnimation(const VfsPath& pathname, const CStr& name, float speed, float actionpos, float actionpos2, float soundpos)
+CSkeletonAnim* CModel::BuildAnimation(const VfsPath& pathname, const CStr& stateName, const CStr& animName, float speed, int frequency, float actionpos, float actionpos2, float soundpos)
 {
     CSkeletonAnimDef* def = m_SkeletonAnimManager.GetAnimation(pathname);
     if (!def)
@@ -262 +262 @@
         return NULL;
 
     CSkeletonAnim* anim = new CSkeletonAnim();
-    anim->m_Name = name;
+    anim->m_StateName = stateName;
+    anim->m_AnimationName = animName;
     anim->m_AnimDef = def;
     anim->m_Speed = speed;
+    anim->m_Frequency = frequency;
 
     if (actionpos == -1.f)
         anim->m_ActionPos = -1.f;