Ticket #2324: ActorModel.patch

source/graphics/Model.cpp

@@ -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)
         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;
     else

source/graphics/ObjectBase.cpp

@@ -96 +96 @@
 
     m_VariantGroups.clear();
 
+    int version = root.GetAttributes().Item(0).Value.ToInt();
+    
     m_Pathname = pathname;
     m_ShortName = pathname.Basename().string();
 
@@ -118 +120 @@
         for (size_t i = 0; i < variantGroupSizes.size(); ++i)
             m_VariantGroups[i].resize(variantGroupSizes[i]);
     }
-
-
+    
+    
     // (This XML-reading code is rather worryingly verbose...)
-
+    
     std::vector<std::vector<Variant> >::iterator currentGroup = m_VariantGroups.begin();
-
+    
     XERO_ITER_EL(root, child)
     {
         int child_name = child.GetNodeName();
-
+        
         if (child_name == el_group)
         {
             std::vector<Variant>::iterator currentVariant = currentGroup->begin();
@@ -137 +139 @@
                 XERO_ITER_ATTR(variant, attr)
                 {
                     if (attr.Name == at_name)
-                        currentVariant->m_VariantName = attr.Value.LowerCase();
-
+                    currentVariant->m_VariantName = attr.Value.LowerCase();
+                    
                     else if (attr.Name == at_frequency)
-                        currentVariant->m_Frequency = attr.Value.ToInt();
+                    currentVariant->m_Frequency = attr.Value.ToInt();
                 }
-
+                
                 XERO_ITER_EL(variant, option)
                 {
                     int option_name = option.GetNodeName();
-
+                    
                     if (option_name == el_mesh)
                     {
                         currentVariant->m_ModelFilename = VfsPath("art/meshes") / option.GetText().FromUTF8();
@@ -161 +163 @@
                             XERO_ITER_ATTR(textures_element, se)
                             {
                                 if (se.Name == at_file)
-                                    samp.m_SamplerFile = VfsPath("art/textures/skins") / se.Value.FromUTF8();
+                                samp.m_SamplerFile = VfsPath("art/textures/skins") / se.Value.FromUTF8();
                                 else if (se.Name == at_name)
-                                    samp.m_SamplerName = se.Value;
+                                samp.m_SamplerName = se.Value;
                             }
                             currentVariant->m_Samplers.push_back(samp);
                         }
@@ -184 +186 @@
                         XMBAttributeList attrs = option.GetAttributes();
                         VfsPath file = VfsPath("art/particles") / attrs.GetNamedItem(at_file).FromUTF8();
                         currentVariant->m_Particles = file;
-
+                        
                         // For particle hotloading, it's easiest to reload the entire actor,
                         // so remember the relevant particle file as a dependency for this actor
                         m_UsedFiles.insert(file);
@@ -195 +197 @@
                     }
                     else if (option_name == el_animations)
                     {
-                        XERO_ITER_EL(option, anim_element)
+                        if (version == 2)
                         {
-                            ENSURE(anim_element.GetNodeName() == el_animation);
-
-                            Anim anim;
-                            XERO_ITER_ATTR(anim_element, ae)
+                            XERO_ITER_EL(option, states)
                             {
-                                if (ae.Name == at_name)
+                                // because I want niceness, I'm not going to use el_XX
+                                // but get the (user chosen) name of the balise.
+                                std::string stateName = XeroFile.GetElementString(states.GetNodeName());
+                                
+                                XERO_ITER_EL(states, anim_element)
                                 {
-                                    anim.m_AnimName = ae.Value;
+                                    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 if (ae.Name == at_file)
+                            }
+                        }
+                        else
+                        {
+                            XERO_ITER_EL(option, anim_element)
+                            {
+                                Anim anim;
+                                ENSURE(anim_element.GetNodeName() == el_animation);
+                                
+                                anim.m_Frequency = 1;
+                                anim.m_AnimName = "";
+
+                                XERO_ITER_ATTR(anim_element, ae)
                                 {
-                                    anim.m_FileName = VfsPath("art/animation") / ae.Value.FromUTF8();
+                                    if (ae.Name == at_name)
+                                    {
+                                        anim.m_StateName = 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_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);
+                                    }
                                 }
-                                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_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);
                             }
-                            currentVariant->m_Anims.push_back(anim);
                         }
-
                     }
                     else if (option_name == el_props)
                     {
                         XERO_ITER_EL(option, prop_element)
                         {
                             ENSURE(prop_element.GetNodeName() == el_prop);
-
+                            
                             Prop prop;
                             XERO_ITER_ATTR(prop_element, pe)
                             {
                                 if (pe.Name == at_attachpoint)
-                                    prop.m_PropPointName = pe.Value;
+                                prop.m_PropPointName = pe.Value;
                                 else if (pe.Name == at_actor)
-                                    prop.m_ModelName = pe.Value.FromUTF8();
+                                prop.m_ModelName = pe.Value.FromUTF8();
                                 else if (pe.Name == at_minheight)
-                                    prop.m_minHeight = pe.Value.ToFloat();
+                                prop.m_minHeight = pe.Value.ToFloat();
                                 else if (pe.Name == at_maxheight)
-                                    prop.m_maxHeight = pe.Value.ToFloat();
+                                prop.m_maxHeight = pe.Value.ToFloat();
                             }
                             currentVariant->m_Props.push_back(prop);
                         }
                     }
                 }
-
+                
                 ++currentVariant;
             }
-
+            
             if (currentGroup->size() == 0)
             {
                 LOGERROR(L"Actor group has zero variants ('%ls')", pathname.string().c_str());
             }
-
+            
             ++currentGroup;
         }
         else if (child_name == el_castshadow)
@@ -281 +344 @@
             m_Material = VfsPath("art/materials") / child.GetText().FromUTF8();
         }
     }
-
+    
     if (m_Material.empty())
-        m_Material = VfsPath("art/materials/default.xml");
-
+    m_Material = VfsPath("art/materials/default.xml");
+    
     return true;
 }
 
@@ -302 +365 @@
 {
     // (TODO: see CObjectManager::FindObjectVariation for an opportunity to
     // call this function a bit less frequently)
-
+    
     // Calculate a complete list of choices, one per group, based on the
     // supposedly-complete selections (i.e. not making random choices at this
     // stage).
@@ -310 +373 @@
     // first 'selections', set use that one.
     // Otherwise, try with the next (lower priority) selections set, and repeat.
     // Otherwise, choose the first variant (arbitrarily).
-
+    
     std::vector<u8> choices;
-
+    
     std::multimap<CStr, CStrW> chosenProps;
-
+    
     for (std::vector<std::vector<CObjectBase::Variant> >::iterator grp = m_VariantGroups.begin();
-        grp != m_VariantGroups.end();
-        ++grp)
+         grp != m_VariantGroups.end();
+         ++grp)
     {
         // Ignore groups with nothing inside. (A warning will have been
         // emitted by the loading code.)
         if (grp->size() == 0)
-            continue;
-
+        continue;
+        
         int match = -1; // -1 => none found yet
-
+        
         // If there's only a single variant, choose that one
         if (grp->size() == 1)
         {
@@ -335 +398 @@
         {
             // Determine the first variant that matches the provided strings,
             // starting with the highest priority selections set:
-
+            
             for (std::vector<std::set<CStr> >::const_iterator selset = selections.begin(); selset < selections.end(); ++selset)
             {
                 ENSURE(grp->size() < 256); // else they won't fit in 'choices'
-
+                
                 for (size_t i = 0; i < grp->size(); ++i)
                 {
                     if (selset->count((*grp)[i].m_VariantName))
@@ -348 +411 @@
                         break;
                     }
                 }
-
+                
                 // Stop after finding the first match
                 if (match != -1)
-                    break;
+                break;
             }
-
+            
             // If no match, just choose the first
             if (match == -1)
-                match = 0;
+            match = 0;
         }
-
+        
         choices.push_back(match);
-
+        
         // Remember which props were chosen, so we can call CalculateVariationKey on them
         // at the end.
         Variant& var ((*grp)[match]);
@@ -368 +431 @@
         {
             // Erase all existing props which are overridden by this variant:
             for (std::vector<Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
-                chosenProps.erase(it->m_PropPointName);
+            chosenProps.erase(it->m_PropPointName);
             // and then insert the new ones:
             for (std::vector<Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
-                if (! it->m_ModelName.empty())
-                    chosenProps.insert(make_pair(it->m_PropPointName, it->m_ModelName));
+            if (! it->m_ModelName.empty())
+            chosenProps.insert(make_pair(it->m_PropPointName, it->m_ModelName));
         }
     }
-
+    
     // Load each prop, and add their CalculateVariationKey to our key:
     for (std::multimap<CStr, CStrW>::iterator it = chosenProps.begin(); it != chosenProps.end(); ++it)
     {
@@ -386 +449 @@
             choices.insert(choices.end(), propChoices.begin(), propChoices.end());
         }
     }
-
+    
     return choices;
 }
 
 const CObjectBase::Variation CObjectBase::BuildVariation(const std::vector<u8>& variationKey)
 {
     Variation variation;
-
+    
     // variationKey should correspond with m_Variants, giving the id of the
     // chosen variant from each group. (Except variationKey has some bits stuck
     // on the end for props, but we don't care about those in here.)
-
+    
     std::vector<std::vector<CObjectBase::Variant> >::iterator grp = m_VariantGroups.begin();
     std::vector<u8>::const_iterator match = variationKey.begin();
     for ( ;
-        grp != m_VariantGroups.end() && match != variationKey.end();
-        ++grp, ++match)
+         grp != m_VariantGroups.end() && match != variationKey.end();
+         ++grp, ++match)
     {
         // Ignore groups with nothing inside. (A warning will have been
         // emitted by the loading code.)
         if (grp->size() == 0)
-            continue;
-
+        continue;
+        
         size_t id = *match;
         if (id >= grp->size())
         {
@@ -416 +479 @@
             debug_warn(L"BuildVariation: invalid variant id");
             continue;
         }
-
+        
         // Get the matched variant
         CObjectBase::Variant& var ((*grp)[id]);
-
+        
         // Apply its data:
-
+        
         if (! var.m_ModelFilename.empty())
-            variation.model = var.m_ModelFilename;
-
+        variation.model = var.m_ModelFilename;
+        
         if (var.m_Decal.m_SizeX && var.m_Decal.m_SizeZ)
-            variation.decal = var.m_Decal;
-
+        variation.decal = var.m_Decal;
+        
         if (! var.m_Particles.empty())
-            variation.particles = var.m_Particles;
-
+        variation.particles = var.m_Particles;
+        
         if (! var.m_Color.empty())
-            variation.color = var.m_Color;
-
+        variation.color = var.m_Color;
+        
         // If one variant defines one prop attached to e.g. "root", and this
         // variant defines two different props with the same attachpoint, the one
         // original should be erased, and replaced by the two new ones.
         //
         // So, erase all existing props which are overridden by this variant:
         for (std::vector<CObjectBase::Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
-            variation.props.erase(it->m_PropPointName);
+        variation.props.erase(it->m_PropPointName);
         // and then insert the new ones:
         for (std::vector<CObjectBase::Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
-            if (! it->m_ModelName.empty()) // if the name is empty then the overridden prop is just deleted
-                variation.props.insert(make_pair(it->m_PropPointName, *it));
-
+        if (! it->m_ModelName.empty()) // if the name is empty then the overridden prop is just deleted
+        variation.props.insert(make_pair(it->m_PropPointName, *it));
+        
         // 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)
-            variation.samplers.erase(it->m_SamplerName);
+        variation.samplers.erase(it->m_SamplerName);
         for (std::vector<CObjectBase::Samp>::iterator it = var.m_Samplers.begin(); it != var.m_Samplers.end(); ++it)
-            variation.samplers.insert(make_pair(it->m_SamplerName, *it));
+        variation.samplers.insert(make_pair(it->m_SamplerName, *it));
     }
-
+    
     return variation;
 }
 
@@ -468 +531 @@
 {
     rng_t rng;
     rng.seed(seed);
-
+    
     std::set<CStr> remainingSelections = CalculateRandomRemainingSelections(rng, std::vector<std::set<CStr> >(1, initialSelections));
     remainingSelections.insert(initialSelections.begin(), initialSelections.end());
-
+    
     return remainingSelections; // now actually a complete set of selections
 }
 
@@ -486 +549 @@
 {
     std::set<CStr> remainingSelections;
     std::multimap<CStr, CStrW> chosenProps;
-
+    
     // Calculate a complete list of selections, so there is at least one
     // (and in most cases only one) per group.
     // In each group, if one of the variants has a name matching a string in
@@ -496 +559 @@
     //
     // When choosing randomly, make use of each variant's frequency. If all
     // variants have frequency 0, treat them as if they were 1.
-
+    
     for (std::vector<std::vector<Variant> >::iterator grp = m_VariantGroups.begin();
-        grp != m_VariantGroups.end();
-        ++grp)
+         grp != m_VariantGroups.end();
+         ++grp)
     {
         // Ignore groups with nothing inside. (A warning will have been
         // emitted by the loading code.)
         if (grp->size() == 0)
-            continue;
-
+        continue;
+        
         int match = -1; // -1 => none found yet
-
+        
         // If there's only a single variant, choose that one
         if (grp->size() == 1)
         {
@@ -518 +581 @@
             // See if a variant (or several, but we only care about the first)
             // is already matched by the selections we've made, keeping their
             // priority order into account
-
+            
             for (size_t s = 0; s < initialSelections.size(); ++s)
             {
                 for (size_t i = 0; i < grp->size(); ++i)
@@ -529 +592 @@
                         break;
                     }
                 }
-
+                
                 if (match >= 0)
-                    break;
+                break;
             }
-
+            
             // If there was one, we don't need to do anything now because there's
             // already something to choose. Otherwise, choose randomly from the others.
             if (match == -1)
@@ -541 +604 @@
                 // Sum the frequencies
                 int totalFreq = 0;
                 for (size_t i = 0; i < grp->size(); ++i)
-                    totalFreq += (*grp)[i].m_Frequency;
-
+                totalFreq += (*grp)[i].m_Frequency;
+                
                 // Someone might be silly and set all variants to have freq==0, in
                 // which case we just pretend they're all 1
                 bool allZero = (totalFreq == 0);
                 if (allZero) totalFreq = (int)grp->size();
-
+                
                 // Choose a random number in the interval [0..totalFreq)
                 int randNum = boost::uniform_int<>(0, totalFreq-1)(rng);
-
+                
                 // and use that to choose one of the variants
                 for (size_t i = 0; i < grp->size(); ++i)
                 {
@@ -558 +621 @@
                     if (randNum < 0)
                     {
                         remainingSelections.insert((*grp)[i].m_VariantName);
-                        // (If this change to 'remainingSelections' interferes with earlier choices, then 
+                        // (If this change to 'remainingSelections' interferes with earlier choices, then
                         // we'll get some non-fatal inconsistencies that just break the randomness. But that
                         // shouldn't happen, much.)
                         // (As an example, suppose you have a group with variants "a" and "b", and another
@@ -574 +637 @@
                 // wouldn't have chosen any of the variants.
             }
         }
-
+        
         // Remember which props were chosen, so we can call CalculateRandomVariation on them
         // at the end.
         Variant& var ((*grp)[match]);
@@ -582 +645 @@
         {
             // Erase all existing props which are overridden by this variant:
             for (std::vector<Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
-                chosenProps.erase(it->m_PropPointName);
+            chosenProps.erase(it->m_PropPointName);
             // and then insert the new ones:
             for (std::vector<Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
-                if (! it->m_ModelName.empty())
-                    chosenProps.insert(make_pair(it->m_PropPointName, it->m_ModelName));
+            if (! it->m_ModelName.empty())
+            chosenProps.insert(make_pair(it->m_PropPointName, it->m_ModelName));
         }
     }
-
+    
     // Load each prop, and add their required selections to ours:
     for (std::multimap<CStr, CStrW>::iterator it = chosenProps.begin(); it != chosenProps.end(); ++it)
     {
@@ -598 +661 @@
         {
             std::vector<std::set<CStr> > propInitialSelections = initialSelections;
             if (!remainingSelections.empty())
-                propInitialSelections.push_back(remainingSelections);
-
+            propInitialSelections.push_back(remainingSelections);
+            
             std::set<CStr> propRemainingSelections = prop->CalculateRandomRemainingSelections(rng, propInitialSelections);
             remainingSelections.insert(propRemainingSelections.begin(), propRemainingSelections.end());
-
+            
             // Add the prop's used files to our own (recursively) so we can hotload
             // when any prop is changed
             m_UsedFiles.insert(prop->m_UsedFiles.begin(), prop->m_UsedFiles.end());
         }
     }
-
+    
     return remainingSelections;
 }
 
 std::vector<std::vector<CStr> > CObjectBase::GetVariantGroups() const
 {
     std::vector<std::vector<CStr> > groups;
-
+    
     // Queue of objects (main actor plus props (recursively)) to be processed
     std::queue<const CObjectBase*> objectsQueue;
     objectsQueue.push(this);
-
+    
     // Set of objects already processed, so we don't do them more than once
     std::set<const CObjectBase*> objectsProcessed;
-
+    
     while (!objectsQueue.empty())
     {
         const CObjectBase* obj = objectsQueue.front();
         objectsQueue.pop();
         // Ignore repeated objects (likely to be props)
         if (objectsProcessed.find(obj) != objectsProcessed.end())
-            continue;
-
+        continue;
+        
         objectsProcessed.insert(obj);
-
+        
         // Iterate through the list of groups
         for (size_t i = 0; i < obj->m_VariantGroups.size(); ++i)
         {
@@ -640 +703 @@
             std::vector<CStr> group;
             group.reserve(obj->m_VariantGroups[i].size());
             for (size_t j = 0; j < obj->m_VariantGroups[i].size(); ++j)
-                group.push_back(obj->m_VariantGroups[i][j].m_VariantName);
-
+            group.push_back(obj->m_VariantGroups[i][j].m_VariantName);
+            
             // If this group is identical to one elsewhere, don't bother listing
             // it twice.
             // Linear search is theoretically not very efficient, but hopefully
@@ -656 +719 @@
                 }
             }
             if (dupe)
-                continue;
-
+            continue;
+            
             // Add non-trivial groups (i.e. not just one entry) to the returned list
             if (obj->m_VariantGroups[i].size() > 1)
-                groups.push_back(group);
-
+            groups.push_back(group);
+            
             // Add all props onto the queue to be considered
             for (size_t j = 0; j < obj->m_VariantGroups[i].size(); ++j)
             {
@@ -672 +735 @@
                     {
                         CObjectBase* prop = m_ObjectManager.FindObjectBase(props[k].m_ModelName.c_str());
                         if (prop)
-                            objectsQueue.push(prop);
+                        objectsQueue.push(prop);
                     }
                 }
             }
         }
     }
-
+    
     return groups;
 }

source/graphics/Model.h

@@ -201 +201 @@
      * 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/UnitAnimation.h

@@ -95 +95 @@
     struct SModelAnimState
     {
         CModel* model;
+        const CObjectEntry* object;
         std::vector<CSkeletonAnim*> anims;
+        CStr animName;
         size_t animIdx;
         float time;
         bool pastLoadPos;
@@ -105 +107 @@
 
     std::vector<SModelAnimState> m_AnimStates;
 
-    void AddModel(CModel* model, const CObjectEntry* object);
+    void AddModel(CModel* model, const CObjectEntry* object, bool useName = false, const CStr& animName = "");
 
     entity_id_t m_Entity;
     CModel* m_Model;

source/graphics/ObjectEntry.cpp

@@ -48 +48 @@
 
 CObjectEntry::~CObjectEntry()
 {
-    std::for_each(m_Animations.begin(), m_Animations.end(), delete_pair_2nd<CStr, CSkeletonAnim*>);
+    std::for_each(m_StateAnimations.begin(), m_StateAnimations.end(), delete_pair_2nd<CStr, CSkeletonAnim*>);
 
     delete m_Model;
 }
@@ -155 +155 @@
     // 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();
 
         // TODO: Use consistent names everywhere, then remove this translation section.
         // (It's just mapping the names used in actors onto the names used by code.)
-        if (name == "attack") name = "melee";
-        else if (name == "chop") name = "gather";
-        else if (name == "decay") name = "corpse";
+        if (stateName == "attack") stateName = "melee";
+        else if (stateName == "chop") stateName = "gather";
+        else if (stateName == "decay") stateName = "corpse";
 
         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);
+            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)
-                m_Animations.insert(std::make_pair(name, anim));
+            {
+                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_Speed = 0.f;
+        anim->m_Frequency = 1;
         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);
@@ -252 +262 @@
     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/ObjectEntry.h

@@ -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
+    size_t GetStateFrequency(const CStr& stateName) const;
+    
+    // Returns total frequencies for a state and anim name
+    size_t GetStateAnimFrequency(const CStr& stateName, const CStr& animationName) const;
+
     // corresponding model
     CModelAbstract* m_Model;
 
@@ -80 +89 @@
 private:
     CSimulation2& m_Simulation;
 
-    typedef std::multimap<CStr, CSkeletonAnim*> SkeletonAnimMap;
-    SkeletonAnimMap m_Animations;
-        // TODO: something more memory-efficient than storing loads of similar strings for each unit?
+    // 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/UnitAnimation.cpp

@@ -52 +52 @@
     m_Entity = ent;
 }
 
-void CUnitAnimation::AddModel(CModel* model, const CObjectEntry* object)
+void CUnitAnimation::AddModel(CModel* model, const CObjectEntry* object, bool useName, const CStr& animName)
 {
     SModelAnimState state;
 
-    state.anims = object->GetAnimations(m_State);
+    CStr &name = m_State;
+    
+    if (useName)
+        state.anims = object->GetAnimations(name,animName);
+    else
+        state.anims = object->GetStateAnimations(name);
 
     if (state.anims.empty())
-        state.anims = object->GetAnimations("idle");
+    {
+        if (useName)
+        {
+            state.anims = object->GetStateAnimations(name);
+            useName = false;
+        }
+        if (state.anims.empty())
+        {
+            state.anims = object->GetStateAnimations("idle");
+            name = "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;
+    
+    // picking the animation
+    size_t total = 0;
+    if (useName)
+        total = object->GetStateAnimFrequency(name, animName);
+    else
+        total = object->GetStateFrequency(name);
+    
+    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)
+        {
+            state.animIdx = i;
+            state.animName = state.anims[i]->m_AnimationName;
+            break;
+        }
+    }
+    
     state.time = 0.f;
     state.pastLoadPos = false;
     state.pastActionPos = false;
     state.pastSoundPos = false;
-
+    
     m_AnimStates.push_back(state);
-
+    
     model->SetAnimation(state.anims[state.animIdx], !m_Looping);
-
+    
     // 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)
     {
         CModel* propModel = it->m_Model->ToCModel();
         if (propModel)
-            AddModel(propModel, it->m_ObjectEntry);
+            AddModel(propModel, it->m_ObjectEntry, true, state.animName);
     }
 }
 
@@ -148 +188 @@
 void CUnitAnimation::Update(float time)
 {
     // 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;
@@ -216 +259 @@
         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
         {
@@ -250 +281 @@
             }
         }
     }
+    
+    if (looped == 0)
+        return;
+    
+    // to keep our props in synch (well those that can be)
+    // we'll update them separately.
+    CStr animName = "";
+    bool useName = false;
+    
+    CStr &name = m_State;
+
+    // the first one is the initializer so out of the loop.
+    SModelAnimState* state = needLooping[0];
+    
+    state->anims = state->object->GetStateAnimations(m_State);
+    if (state->anims.size() == 0)
+    {
+        name = "idle";
+        state->anims = state->object->GetStateAnimations("idle");
+    }
+    
+    if (state->anims.size() > 1)
+    {
+        // picking the animation
+        size_t total = state->object->GetStateFrequency(name);
+        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)
+            {
+                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);
+                }
+                animName = state->animName;
+                break;
+            }
+        }
+    } else
+        animName = state->animName;
+
+    state->model->UpdateTo(state->time);
+    
+    if (looped == 1)
+        return;
+    
+    for (size_t i = 1; i < looped; ++i)
+    {
+        SModelAnimState* state = needLooping[i];
+        useName = true;
+        
+        state->anims = state->object->GetAnimations(name, animName);
+        if (state->anims.size() == 0)
+        {
+            useName = false;
+            if (state->anims.size() == 0)
+            {
+                name = "idle";
+                state->anims = state->object->GetStateAnimations("idle");
+            }
+        }
+        // picking the animation
+        size_t total = 0;
+        if (useName)
+            total = state->object->GetStateAnimFrequency(name, animName);
+        else
+            total = state->object->GetStateFrequency(name);
+
+        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)
+            {
+                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);
+                }
+                break;
+            }
+        }
+        
+        state->model->UpdateTo(state->time);
+    }
 }

source/graphics/ObjectBase.h

@@ -40 +40 @@
     {
         // 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
+        // State the animation is used for — "Idle", "Run",…
+        CStr m_StateName;
+        // name of the animation, used for synching with props
         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/SkeletonAnim.h

@@ -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.