janwas
c0ed950657
this snowballed into a massive search+destroy of the hodgepodge of mostly equivalent types we had in use (int, uint, unsigned, unsigned int, i32, u32, ulong, uintN). it is more efficient to use 64-bit types in 64-bit mode, so the preferred default is size_t (for anything remotely resembling a size or index). tile coordinates are ssize_t to allow more efficient conversion to/from floating point. flags are int because we almost never need more than 15 distinct bits, bit test/set is not slower and int is fastest to type. finally, some data that is pretty much directly passed to OpenGL is now typed accordingly. after several hours, the code now requires fewer casts and less guesswork. other changes: - unit and player IDs now have an "invalid id" constant in the respective class to avoid casting and -1 - fix some endian/64-bit bugs in the map (un)packing. added a convenience function to write/read a size_t. - ia32: change CPUID interface to allow passing in ecx (required for cache topology detection, which I need at work). remove some unneeded functions from asm, replace with intrinsics where possible. This was SVN commit r5942.
237 lines
7.3 KiB
C++
237 lines
7.3 KiB
C++
#include "precompiled.h"
|
|
|
|
#include "ObjectEntry.h"
|
|
#include "ObjectManager.h"
|
|
#include "ObjectBase.h"
|
|
#include "Model.h"
|
|
#include "ModelDef.h"
|
|
#include "ps/CLogger.h"
|
|
#include "MaterialManager.h"
|
|
#include "MeshManager.h"
|
|
#include "SkeletonAnim.h"
|
|
|
|
#include "UnitManager.h"
|
|
#include "Unit.h"
|
|
|
|
#include "ps/XML/Xeromyces.h"
|
|
#include "ps/XML/XMLWriter.h"
|
|
|
|
#include "lib/rand.h"
|
|
|
|
#include <sstream>
|
|
|
|
#define LOG_CATEGORY "graphics"
|
|
|
|
CObjectEntry::CObjectEntry(CObjectBase* base)
|
|
: m_Base(base), m_Color(1.0f, 1.0f, 1.0f, 1.0f),
|
|
m_ProjectileModel(NULL), m_AmmunitionModel(NULL), m_AmmunitionPoint(NULL), m_Model(NULL)
|
|
{
|
|
}
|
|
|
|
template<typename T, typename S> static void delete_pair_2nd(std::pair<T,S> v) { delete v.second; }
|
|
|
|
CObjectEntry::~CObjectEntry()
|
|
{
|
|
std::for_each(m_Animations.begin(), m_Animations.end(), delete_pair_2nd<CStr, CSkeletonAnim*>);
|
|
|
|
delete m_Model;
|
|
}
|
|
|
|
|
|
bool CObjectEntry::BuildVariation(const std::vector<std::set<CStr> >& selections,
|
|
const std::vector<u8>& variationKey,
|
|
CObjectManager& objectManager)
|
|
{
|
|
CObjectBase::Variation variation = m_Base->BuildVariation(variationKey);
|
|
|
|
// Copy the chosen data onto this model:
|
|
|
|
m_TextureName = variation.texture;
|
|
m_ModelName = variation.model;
|
|
|
|
if (! variation.color.empty())
|
|
{
|
|
std::stringstream str;
|
|
str << variation.color;
|
|
int r, g, b;
|
|
if (! (str >> r >> g >> b)) // Any trailing data is ignored
|
|
LOG(CLogger::Error, LOG_CATEGORY, "Invalid RGB colour '%s'", variation.color.c_str());
|
|
else
|
|
m_Color = CColor(r/255.0f, g/255.0f, b/255.0f, 1.0f);
|
|
}
|
|
|
|
std::vector<CObjectBase::Prop> props;
|
|
|
|
for (std::map<CStr, CObjectBase::Prop>::iterator it = variation.props.begin(); it != variation.props.end(); ++it)
|
|
props.push_back(it->second);
|
|
|
|
// Build the model:
|
|
|
|
/*
|
|
// remember the old model so we can replace any models using it later on
|
|
CModelDefPtr oldmodeldef = m_Model ? m_Model->GetModelDef() : CModelDefPtr();
|
|
*/
|
|
|
|
// try and create a model
|
|
CModelDefPtr modeldef (objectManager.GetMeshManager().GetMesh(m_ModelName));
|
|
if (!modeldef)
|
|
{
|
|
LOG(CLogger::Error, LOG_CATEGORY, "CObjectEntry::BuildModel(): Model %s failed to load", m_ModelName.c_str());
|
|
return false;
|
|
}
|
|
|
|
// delete old model, create new
|
|
delete m_Model;
|
|
m_Model = new CModel(objectManager.GetSkeletonAnimManager());
|
|
m_Model->SetTexture((const char*) m_TextureName);
|
|
m_Model->SetMaterial(g_MaterialManager.LoadMaterial(m_Base->m_Material));
|
|
m_Model->InitModel(modeldef);
|
|
m_Model->SetPlayerColor(m_Color);
|
|
|
|
// calculate initial object space bounds, based on vertex positions
|
|
m_Model->CalcObjectBounds();
|
|
|
|
// load the animations
|
|
for (std::multimap<CStr, CObjectBase::Anim>::iterator it = variation.anims.begin(); it != variation.anims.end(); ++it)
|
|
{
|
|
CStr name = 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 (! it->second.m_FileName.empty())
|
|
{
|
|
CSkeletonAnim* anim = m_Model->BuildAnimation(it->second.m_FileName, name, it->second.m_Speed, it->second.m_ActionPos, it->second.m_ActionPos2);
|
|
if (anim)
|
|
m_Animations.insert(std::make_pair(name, anim));
|
|
}
|
|
}
|
|
|
|
// ensure there's always an idle animation
|
|
if (m_Animations.find("idle") == m_Animations.end())
|
|
{
|
|
CSkeletonAnim* anim = new CSkeletonAnim();
|
|
anim->m_Name = "idle";
|
|
anim->m_AnimDef = NULL;
|
|
anim->m_Speed = 0.f;
|
|
anim->m_ActionPos = 0.f;
|
|
anim->m_ActionPos2 = 0.f;
|
|
m_Animations.insert(std::make_pair("idle", anim));
|
|
|
|
// Ignore errors, since they're probably saying this is a non-animated model
|
|
m_Model->SetAnimation(anim);
|
|
}
|
|
else
|
|
{
|
|
// start up idling
|
|
if (! m_Model->SetAnimation(GetRandomAnimation("idle")))
|
|
LOG(CLogger::Error, LOG_CATEGORY, "Failed to set idle animation in model \"%s\"", m_ModelName.c_str());
|
|
}
|
|
|
|
// build props - TODO, RC - need to fix up bounds here
|
|
// TODO: Make sure random variations get handled correctly when a prop fails
|
|
for (size_t p = 0; p < props.size(); p++)
|
|
{
|
|
const CObjectBase::Prop& prop = props[p];
|
|
|
|
CObjectEntry* oe = objectManager.FindObjectVariation(prop.m_ModelName, selections);
|
|
if (!oe)
|
|
{
|
|
LOG(CLogger::Error, LOG_CATEGORY, "Failed to build prop model \"%s\" on actor \"%s\"", (const char*)prop.m_ModelName, (const char*)m_Base->m_ShortName);
|
|
continue;
|
|
}
|
|
|
|
// Pluck out the special attachpoint 'projectile'
|
|
if (prop.m_PropPointName == "projectile")
|
|
{
|
|
m_ProjectileModel = oe->m_Model;
|
|
}
|
|
// Also the other special attachpoint 'loaded-<proppoint>'
|
|
else if (prop.m_PropPointName.length() > 7 && prop.m_PropPointName.Left(7) == "loaded-")
|
|
{
|
|
CStr ppn = prop.m_PropPointName.substr(7);
|
|
m_AmmunitionModel = oe->m_Model;
|
|
m_AmmunitionPoint = modeldef->FindPropPoint((const char*)ppn );
|
|
if (! m_AmmunitionPoint)
|
|
LOG(CLogger::Error, LOG_CATEGORY, "Failed to find matching prop point called \"%s\" in model \"%s\" on actor \"%s\"", (const char*)ppn, (const char*)m_ModelName, (const char*)prop.m_ModelName);
|
|
}
|
|
else
|
|
{
|
|
SPropPoint* proppoint = modeldef->FindPropPoint((const char*) prop.m_PropPointName);
|
|
if (proppoint)
|
|
{
|
|
CModel* propmodel = oe->m_Model->Clone();
|
|
m_Model->AddProp(proppoint, propmodel, oe);
|
|
propmodel->SetAnimation(oe->GetRandomAnimation("idle"));
|
|
}
|
|
else
|
|
LOG(CLogger::Error, LOG_CATEGORY, "Failed to find matching prop point called \"%s\" in model \"%s\" on actor \"%s\"", (const char*)prop.m_PropPointName, (const char*)m_ModelName, (const char*)prop.m_ModelName);
|
|
}
|
|
}
|
|
|
|
// setup flags
|
|
if (m_Base->m_Properties.m_CastShadows)
|
|
{
|
|
m_Model->SetFlags(m_Model->GetFlags()|MODELFLAG_CASTSHADOWS);
|
|
}
|
|
|
|
// replace any units using old model to now use new model; also reprop models, if necessary
|
|
// FIXME, RC - ugh, doesn't recurse correctly through props
|
|
/*
|
|
// (PT: Removed this, since I'm not entirely sure what it's useful for, and it
|
|
// gets a bit confusing with randomised actors)
|
|
|
|
const std::vector<CUnit*>& units = g_UnitMan.GetUnits();
|
|
for (size_t i = 0; i < units.size(); ++i)
|
|
{
|
|
CModel* unitmodel=units[i]->GetModel();
|
|
if (unitmodel->GetModelDef() == oldmodeldef)
|
|
{
|
|
unitmodel->InitModel(m_Model->GetModelDef());
|
|
unitmodel->SetFlags(m_Model->GetFlags());
|
|
|
|
const std::vector<CModel::Prop>& newprops = m_Model->GetProps();
|
|
for (size_t j = 0; j < newprops.size(); j++)
|
|
unitmodel->AddProp(newprops[j].m_Point, newprops[j].m_Model->Clone());
|
|
}
|
|
|
|
std::vector<CModel::Prop>& mdlprops = unitmodel->GetProps();
|
|
for (size_t j = 0; j < mdlprops.size(); j++)
|
|
{
|
|
CModel::Prop& prop = mdlprops[j];
|
|
if (prop.m_Model)
|
|
{
|
|
if (prop.m_Model->GetModelDef() == oldmodeldef)
|
|
{
|
|
delete prop.m_Model;
|
|
prop.m_Model = m_Model->Clone();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
return true;
|
|
}
|
|
|
|
CSkeletonAnim* CObjectEntry::GetRandomAnimation(const CStr& animationName)
|
|
{
|
|
SkeletonAnimMap::iterator lower = m_Animations.lower_bound(animationName);
|
|
SkeletonAnimMap::iterator upper = m_Animations.upper_bound(animationName);
|
|
size_t count = std::distance(lower, upper);
|
|
if (count == 0)
|
|
{
|
|
// LOG(CLogger::Warning, LOG_CATEGORY, "Failed to find animation '%s' for actor '%s'", animationName.c_str(), m_ModelName.c_str());
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
// TODO: Do we care about network synchronisation of random animations?
|
|
size_t id = rand(0, count);
|
|
std::advance(lower, id);
|
|
return lower->second;
|
|
}
|
|
}
|