void nsCollect::ProcessData::SetFiles(int runIndex)
{
ConcatInt(runIndex, "_S", processID, 2, 40);
if (rangeOutputDesc.writeFile)
ReplaceExtension(rngFile, rangeOutputFile.fileName, processID, ".nRng");
if (optOutputDesc.writeFile)
ReplaceExtension(optFile, optOutputFile.fileName, processID, ".nOpt");
if (xyForwardOutputDesc.writeFile)
ReplaceExtension(xyFile, xyForwardOutputFile.fileName, processID, ".nXYSim");
}
void AAI::InitAI(IGlobalAICallback* callback, int team)
{
aicb = callback;
cb = callback->GetAICallback();
// open log file
char filename[1000];
char buffer[60];
char team_number[3];
#ifdef WIN32
itoa(team, team_number, 10);
#else
snprintf(team_number,10,"%d",team);
#endif
strcpy(buffer, AILOG_PATH);
strcat(buffer, "AAI_log_team_");
strcat(buffer, team_number);
strcat(buffer, ".txt");
ReplaceExtension (buffer, filename, sizeof(filename), ".txt");
cb->GetValue(AIVAL_LOCATE_FILE_W, filename);
file = fopen(filename,"w");
fprintf(file, "AAI %s running mod %s\n \n", AAI_VERSION, cb->GetModName());
// load config file first
cfg->LoadConfig(this);
if(!cfg->initialized)
{
cb->SendTextMsg("Error: Could not load mod and/or general config file, see .../log/AILog.txt for further information",0);
return;
}
// create buildtable
bt = new AAIBuildTable(cb, this);
bt->Init();
// init unit table
ut = new AAIUnitTable(this, bt);
// init map
map = new AAIMap(this);
map->Init();
// init brain
brain = new AAIBrain(this);
// init executer
execute = new AAIExecute(this, brain);
// create unit groups
group_list = new list<AAIGroup*>[SEA_BUILDER+1];
// init airforce manager
af = new AAIAirForceManager(this, cb, bt);
cb->SendTextMsg("AAI loaded",0);
}
bool Texture2D::BeginLoad(Deserializer& source)
{
// In headless mode, do not actually load the texture, just return success
if (!graphics_)
return true;
// If device is lost, retry later
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Texture load while device is lost");
dataPending_ = true;
return true;
}
// Load the image data for EndLoad()
loadImage_ = new Image(context_);
if (!loadImage_->Load(source))
{
loadImage_.Reset();
return false;
}
// Precalculate mip levels if async loading
if (GetAsyncLoadState() == ASYNC_LOADING)
loadImage_->PrecalculateLevels();
// Load the optional parameters file
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
loadParameters_ = cache->GetTempResource<XMLFile>(xmlName, false);
return true;
}
void CExportDlg::OnSelchangeFormatoptions()
{
UpdateData();
// check exporter has a file extension
if (m_mgrImportExport.ExporterHasFileExtension(s_nFormatOption))
{
// enable path edit
m_eExportPath.EnableWindow(TRUE);
// check file extension is correct
m_eExportPath.SetFilter(m_mgrImportExport.GetExporterFileFilter(s_nFormatOption));
if (m_nExportOption == ACTIVETASKLIST || m_bExportOneFile)
{
if (m_sExportPath.IsEmpty())
{
m_sExportPath = m_sOrgFilePath;
}
ReplaceExtension(m_sExportPath, s_nFormatOption);
UpdateData(FALSE);
}
else if (m_sExportPath.IsEmpty())
{
m_sExportPath = m_sOrgFolderPath;
}
}
else // disable path edit and remove file path
{
m_eExportPath.SetWindowText(_T(""));
m_eExportPath.EnableWindow(FALSE);
}
}
void CExportDlg::OnSelchangeTasklistoptions()
{
UpdateData();
// can't do all tasklists and selected item
if (m_taskSel.GetWantSelectedTasks() && m_nExportOption == ALLTASKLISTS)
{
m_taskSel.SetWantWhatTasks(TSDT_ALL);
}
// only process this notification if something's _really_ changed
if (!(m_nExportOption == ALLTASKLISTS && m_bExportOneFile))
{
BOOL bFolder = (m_nExportOption == ALLTASKLISTS && !m_bExportOneFile);
m_eExportPath.EnableStyle(FES_FOLDERS, bFolder);
m_sPathLabel.LoadString(bFolder ? IDS_ED_FOLDER : IDS_ED_FILEPATH);
// check file extension is correct
if (m_nExportOption == ALLTASKLISTS && !m_bExportOneFile)
{
m_sExportPath = m_sFolderPath;
}
else
{
m_sExportPath = m_sFilePath;
ReplaceExtension(m_sExportPath, s_nFormatOption);
}
}
GetDlgItem(IDC_EXPORTONEFILE)->EnableWindow(!m_bSingleTaskList && m_nExportOption == ALLTASKLISTS);
UpdateData(FALSE);
}
void Font::LoadParameters()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
SharedPtr<XMLFile> xml = cache->GetTempResource<XMLFile>(xmlName, false);
if (!xml)
return;
XMLElement rootElem = xml->GetRoot();
XMLElement absoluteElem = rootElem.GetChild("absoluteoffset");
if (!absoluteElem)
absoluteElem = rootElem.GetChild("absolute");
if (absoluteElem)
{
absoluteOffset_.x_ = absoluteElem.GetInt("x");
absoluteOffset_.y_ = absoluteElem.GetInt("y");
}
XMLElement scaledElem = rootElem.GetChild("scaledoffset");
if (!scaledElem)
scaledElem = rootElem.GetChild("scaled");
if (scaledElem)
{
scaledOffset_.x_ = scaledElem.GetFloat("x");
scaledOffset_.y_ = scaledElem.GetFloat("y");
}
}
bool Animation::Save(Serializer& dest) const
{
// Write ID, name and length
dest.WriteFileID("UANI");
dest.WriteString(animationName_);
dest.WriteFloat(length_);
// Write tracks
dest.WriteUInt(tracks_.Size());
for (HashMap<StringHash, AnimationTrack>::ConstIterator i = tracks_.Begin(); i != tracks_.End(); ++i)
{
const AnimationTrack& track = i->second_;
dest.WriteString(track.name_);
dest.WriteUByte(track.channelMask_);
dest.WriteUInt(track.keyFrames_.Size());
// Write keyframes of the track
for (unsigned j = 0; j < track.keyFrames_.Size(); ++j)
{
const AnimationKeyFrame& keyFrame = track.keyFrames_[j];
dest.WriteFloat(keyFrame.time_);
if (track.channelMask_ & CHANNEL_POSITION)
dest.WriteVector3(keyFrame.position_);
if (track.channelMask_ & CHANNEL_ROTATION)
dest.WriteQuaternion(keyFrame.rotation_);
if (track.channelMask_ & CHANNEL_SCALE)
dest.WriteVector3(keyFrame.scale_);
}
}
// If triggers have been defined, write an XML file for them
if (!triggers_.Empty() || HasMetadata())
{
File* destFile = dynamic_cast<File*>(&dest);
if (destFile)
{
String xmlName = ReplaceExtension(destFile->GetName(), ".xml");
SharedPtr<XMLFile> xml(new XMLFile(context_));
XMLElement rootElem = xml->CreateRoot("animation");
for (unsigned i = 0; i < triggers_.Size(); ++i)
{
XMLElement triggerElem = rootElem.CreateChild("trigger");
triggerElem.SetFloat("time", triggers_[i].time_);
triggerElem.SetVariant(triggers_[i].data_);
}
SaveMetadataToXML(rootElem);
File xmlFile(context_, xmlName, FILE_WRITE);
xml->Save(xmlFile);
}
else
ATOMIC_LOGWARNING("Can not save animation trigger data when not saving into a file");
}
return true;
}
//
// DeleteGwaFile
//
void DeleteGwaFile(const char *base_wad_name)
{
char *gwa_file = ReplaceExtension(base_wad_name, "gwa");
if (remove(gwa_file) == 0)
PrintMsg("Deleted GWA file: %s\n", gwa_file);
UtilFree(gwa_file);
}
void Texture::LoadParameters()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
XMLFile* file = cache->GetResource<XMLFile>(xmlName, false);
if (file)
LoadParameters(file);
}
void CResourceCompilerHelper::GetInputFilename(
const char* filename,
const unsigned int index,
char* inputFilename,
size_t inputFilenameSizeInBytes)
{
if (inputFilename == 0 || inputFilenameSizeInBytes < sizeof(inputFilename[0]))
{
return;
}
const char *ext = GetExtension(filename);
if (ext && stricmp(ext, "dds") == 0)
{
switch(index)
{
case 0:
ReplaceExtension(filename, "tif", inputFilename, inputFilenameSizeInBytes);
return;
case 1:
ReplaceExtension(filename, "srf", inputFilename, inputFilenameSizeInBytes);
return;
default:
inputFilename[0] = 0;
return;
}
}
if (index > 0)
{
inputFilename[0] = 0;
return;
}
strncpy_s(inputFilename, inputFilenameSizeInBytes, filename, _TRUNCATE);
}
void CResourceCompilerHelper::GetOutputFilename(const char* szFilePath, char* buffer, size_t bufferSizeInBytes)
{
const char* const ext = GetExtension(szFilePath);
if (ext)
{
if (stricmp(ext, "tif") == 0 ||
stricmp(ext, "hdr") == 0)
{
ReplaceExtension(szFilePath, "dds", buffer, bufferSizeInBytes);
return;
}
}
cry_strcpy(buffer, bufferSizeInBytes, szFilePath);
}
bool FileMisc::LogText(LPCTSTR szLine, bool bWantDateTime)
{
CString sLogFile = GetAppFileName();
ReplaceExtension(sLogFile, _T(".log"));
CString sLogLine(szLine);
if (bWantDateTime)
{
sLogLine += _T(" (");
sLogLine += COleDateTime::GetCurrentTime().Format();
sLogLine += _T(")");
}
return AppendLineToFile(sLogFile, sLogLine);
}
void Sound::LoadParameters()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
if (!cache->Exists(xmlName))
return;
XMLFile* file = cache->GetResource<XMLFile>(xmlName);
if (!file)
return;
XMLElement rootElem = file->GetRoot();
XMLElement paramElem = rootElem.GetChild();
while (paramElem)
{
String name = paramElem.GetName();
if (name == "format" && !compressed_)
{
if (paramElem.HasAttribute("frequency"))
frequency_ = paramElem.GetInt("frequency");
if (paramElem.HasAttribute("sixteenbit"))
sixteenBit_ = paramElem.GetBool("sixteenbit");
if (paramElem.HasAttribute("16bit"))
sixteenBit_ = paramElem.GetBool("16bit");
if (paramElem.HasAttribute("stereo"))
stereo_ = paramElem.GetBool("stereo");
}
if (name == "loop")
{
if (paramElem.HasAttribute("enable"))
SetLooped(paramElem.GetBool("enable"));
if (paramElem.HasAttribute("start") && paramElem.HasAttribute("end"))
SetLoop(paramElem.GetInt("start"), paramElem.GetInt("end"));
}
paramElem = paramElem.GetNext();
}
}
void StaticModel::ApplyMaterialList(const String& fileName)
{
String useFileName = fileName;
if (useFileName.Trimmed().Empty() && model_)
useFileName = ReplaceExtension(model_->GetName(), ".txt");
ResourceCache* cache = GetSubsystem<ResourceCache>();
SharedPtr<File> file = cache->GetFile(useFileName, false);
if (!file)
return;
unsigned index = 0;
while (!file->IsEof() && index < batches_.Size())
{
Material* material = cache->GetResource<Material>(file->ReadLine());
if (material)
SetMaterial(index, material);
++index;
}
}
bool ModConfig::Load (IGlobalAICallback *cb)
{
char file[64];
const char *mod = cb->GetAICallback()->GetModName ();
ReplaceExtension (mod, file, 64, "cfg");
// register the build options type:
CfgValue::AddValueClass (&cfg_BuildOptionsType);
// load config
root = CfgValue::LoadFile (file);
if (!root)
{
ChatMsgPrintf (cb->GetAICallback(), "Error loading mod config: %s", file);
return false;
}
unitTypesInfo.Load (root, &buildTable);
return true;
}
libDHStandard<T, B, S>::libDHStandard(struct libDHBase<T>::SPParameters* params) {
DHParams = params;
NumFeatures = 0;
isMyGraph = true;
isMyObs = true;
phi = new struct Sample<GRAPH_TYPE>;
phi->x = new std::vector<GRAPH_TYPE>;
y = new std::vector<std::vector<size_t> >(DHParams->FeatureFiles.size(), std::vector<size_t>());
T (*conversion)(T) = NULL;//&convFunc;
for(std::vector<std::string>::iterator f=DHParams->FeatureFiles.begin(),f_e=DHParams->FeatureFiles.end();f!=f_e;++f) {
GRAPH_TYPE tmp;
if(DHParams->ReadBinary==1) {
ReadRegionFileBinary(f->c_str(), tmp, true, conversion);
} else {
ReadRegionFile(f->c_str(), tmp, true, conversion);
}
phi->x->push_back(tmp);
ReadObservationFile(ReplaceExtension(*f, std::string(".observation")).c_str(), y->at(f-DHParams->FeatureFiles.begin()));
}
for(size_t x=0,x_e=phi->x->size();x!=x_e;++x) {
GRAPH_TYPE* ptr = &phi->x->at(x);
for(typename GRAPH_TYPE::iterator rit=ptr->begin(),rit_e=ptr->end();rit!=rit_e;++rit) {
typename S::MPNode* r = *rit;
size_t maxEl = *std::max_element(r->featureIDs.begin(), r->featureIDs.end());
NumFeatures = (maxEl>NumFeatures) ? maxEl : NumFeatures;
}
}
++NumFeatures;
for(size_t x=0,x_e=phi->x->size();x!=x_e;++x) {
GRAPH_TYPE* ptr = &phi->x->at(x);
rBP.push_back(new S(ptr, DHParams->epsilon));
rBP.back()->Initialize();
}
}
void CExportDlg::OnExportonefile()
{
UpdateData();
m_eExportPath.EnableStyle(FES_FOLDERS, (m_nExportOption == ALLTASKLISTS && !m_bExportOneFile));
if (m_nExportOption == ALLTASKLISTS && !m_bExportOneFile)
{
m_sExportPath = m_sFolderPath;
}
else
{
m_sExportPath = m_sFilePath;
}
if (m_nExportOption == ACTIVETASKLIST || m_bExportOneFile)
{
ReplaceExtension(m_sExportPath, s_nFormatOption);
}
UpdateData(FALSE);
}
tstring CResourceCompilerHelper::GetInputFilename( const TCHAR *szFilePath, const unsigned int dwIndex ) const
{
const TCHAR *ext = GetExtension(szFilePath);
if(ext)
{
if(_tcsicmp(ext,_T("dds"))==0)
{
switch(dwIndex)
{
case 0: return ReplaceExtension(szFilePath,_T("tif")); // index 0
// case 1: return ReplaceExtension(szFilePath,".srf"); // index 1
default: return _T(""); // last one
}
}
}
if(dwIndex)
return _T(""); // last one
return szFilePath; // index 0
}
void StaticModel::ApplyMaterialList(const ea::string& fileName)
{
ea::string useFileName = fileName;
useFileName.trim();
if (useFileName.empty() && model_)
useFileName = ReplaceExtension(model_->GetName(), ".txt");
auto* cache = GetSubsystem<ResourceCache>();
ea::shared_ptr<File> file = cache->GetFile(useFileName, false);
if (!file)
return;
unsigned index = 0;
while (!file->IsEof() && index < batches_.size())
{
auto* material = cache->GetResource<Material>(file->ReadLine());
if (material)
SetMaterial(index, material);
++index;
}
}
void Sound::LoadParameters()
{
auto* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
SharedPtr<XMLFile> file(cache->GetTempResource<XMLFile>(xmlName, false));
if (!file)
return;
XMLElement rootElem = file->GetRoot();
LoadMetadataFromXML(rootElem);
for (XMLElement paramElem = rootElem.GetChild(); paramElem; paramElem = paramElem.GetNext())
{
String name = paramElem.GetName();
if (name == "format" && !compressed_)
{
if (paramElem.HasAttribute("frequency"))
frequency_ = (unsigned)paramElem.GetInt("frequency");
if (paramElem.HasAttribute("sixteenbit"))
sixteenBit_ = paramElem.GetBool("sixteenbit");
if (paramElem.HasAttribute("16bit"))
sixteenBit_ = paramElem.GetBool("16bit");
if (paramElem.HasAttribute("stereo"))
stereo_ = paramElem.GetBool("stereo");
}
if (name == "loop")
{
if (paramElem.HasAttribute("enable"))
SetLooped(paramElem.GetBool("enable"));
if (paramElem.HasAttribute("start") && paramElem.HasAttribute("end"))
SetLoop((unsigned)paramElem.GetInt("start"), (unsigned)paramElem.GetInt("end"));
}
}
}
void MeshCompiler::CompileMaterial( TiXmlElement* Material )
{
SMaterial NewMaterial = { 0 };
TiXmlAttribute* MatAttr = Material->FirstAttribute();
const char* pTypeName = MatAttr->Value();
if( strcmp( pTypeName, "Diffuse" ) == 0 )
{
NewMaterial.m_Type = EMT_DIFFUSE;
}
else if( strcmp( pTypeName, "Normal" ) == 0 )
{
NewMaterial.m_Type = EMT_NORMAL;
}
MatAttr = MatAttr->Next();
const char* pFilename = MatAttr->Value();
CleanStrncpy( NewMaterial.m_Filename, FileUtil::StripLeadingUpFolders( pFilename ), MAT_FILENAME_LENGTH );
SimpleString FilenameAsString( NewMaterial.m_Filename );
FilenameAsString.Replace( '\\', '/' );
CleanStrncpy( NewMaterial.m_Filename, FilenameAsString.CStr(), MAT_FILENAME_LENGTH );
if( FilenameAsString.Contains( "NODXT" ) )
{
// Leave the extension alone
}
else
{
ReplaceExtension( NewMaterial.m_Filename, ".tga", ".dds" );
}
m_Materials.PushBack( NewMaterial );
++m_Header.m_NumMaterials;
}
FIMULTIBITMAP * DLL_CALLCONV
FreeImage_OpenMultiBitmap(FREE_IMAGE_FORMAT fif, const char *filename, BOOL create_new, BOOL read_only, BOOL keep_cache_in_memory, int flags) {
// sanity check on the parameters
if (create_new)
read_only = FALSE;
// retrieve the plugin list to find the node belonging to this plugin
PluginList *list = FreeImage_GetPluginList();
if (list) {
PluginNode *node = list->FindNodeFromFIF(fif);
if (node) {
FreeImageIO *io = new FreeImageIO;
if (io) {
SetDefaultIO(io);
BOOL cont = TRUE;
FILE *handle = NULL;
if (!create_new) {
handle = fopen(filename, "rb");
if (handle == NULL) {
cont = FALSE;
}
}
if (cont) {
FIMULTIBITMAP *bitmap = new FIMULTIBITMAP;
if (bitmap) {
MULTIBITMAPHEADER *header = new MULTIBITMAPHEADER;
header->m_filename = new char[strlen(filename) + 1];
strcpy(header->m_filename, filename);
header->node = node;
header->fif = fif;
header->io = io;
header->handle = handle;
header->changed = FALSE;
header->read_only = read_only;
header->m_cachefile = NULL;
header->cache_fif = fif;
header->load_flags = flags;
if (header) {
// store the MULTIBITMAPHEADER in the surrounding FIMULTIBITMAP structure
bitmap->data = header;
// cache the page count
header->page_count = FreeImage_InternalGetPageCount(bitmap);
// allocate a continueus block to describe the bitmap
if (!create_new)
header->m_blocks.push_back((BlockTypeS *)new BlockContinueus(0, header->page_count - 1));
// set up the cache
if (!read_only) {
char cache_name[256];
ReplaceExtension(cache_name, filename, "ficache");
CacheFile *cache_file = new CacheFile(cache_name, keep_cache_in_memory);
if (cache_file->open()) {
header->m_cachefile = cache_file;
// return the multibitmap
return bitmap;
}
delete cache_file;
delete header;
}
return bitmap;
}
return NULL;
}
}
}
delete io;
}
}
return NULL;
}
bool Animation::BeginLoad(Deserializer& source)
{
unsigned memoryUse = sizeof(Animation);
// Check ID
if (source.ReadFileID() != "UANI")
{
URHO3D_LOGERROR(source.GetName() + " is not a valid animation file");
return false;
}
// Read name and length
animationName_ = source.ReadString();
animationNameHash_ = animationName_;
length_ = source.ReadFloat();
tracks_.Clear();
unsigned tracks = source.ReadUInt();
memoryUse += tracks * sizeof(AnimationTrack);
// Read tracks
for (unsigned i = 0; i < tracks; ++i)
{
AnimationTrack* newTrack = CreateTrack(source.ReadString());
newTrack->channelMask_ = source.ReadUByte();
unsigned keyFrames = source.ReadUInt();
newTrack->keyFrames_.Resize(keyFrames);
memoryUse += keyFrames * sizeof(AnimationKeyFrame);
// Read keyframes of the track
for (unsigned j = 0; j < keyFrames; ++j)
{
AnimationKeyFrame& newKeyFrame = newTrack->keyFrames_[j];
newKeyFrame.time_ = source.ReadFloat();
if (newTrack->channelMask_ & CHANNEL_POSITION)
newKeyFrame.position_ = source.ReadVector3();
if (newTrack->channelMask_ & CHANNEL_ROTATION)
newKeyFrame.rotation_ = source.ReadQuaternion();
if (newTrack->channelMask_ & CHANNEL_SCALE)
newKeyFrame.scale_ = source.ReadVector3();
}
}
// Optionally read triggers from an XML file
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
SharedPtr<XMLFile> file(cache->GetTempResource<XMLFile>(xmlName, false));
if (file)
{
XMLElement rootElem = file->GetRoot();
XMLElement triggerElem = rootElem.GetChild("trigger");
while (triggerElem)
{
if (triggerElem.HasAttribute("normalizedtime"))
AddTrigger(triggerElem.GetFloat("normalizedtime"), true, triggerElem.GetVariant());
else if (triggerElem.HasAttribute("time"))
AddTrigger(triggerElem.GetFloat("time"), false, triggerElem.GetVariant());
triggerElem = triggerElem.GetNext("trigger");
}
memoryUse += triggers_.Size() * sizeof(AnimationTriggerPoint);
SetMemoryUse(memoryUse);
return true;
}
// Optionally read triggers from a JSON file
String jsonName = ReplaceExtension(GetName(), ".json");
SharedPtr<JSONFile> jsonFile(cache->GetTempResource<JSONFile>(jsonName, false));
if (jsonFile)
{
const JSONValue& rootVal = jsonFile->GetRoot();
JSONArray triggerArray = rootVal.Get("triggers").GetArray();
for (unsigned i = 0; i < triggerArray.Size(); i++)
{
const JSONValue& triggerValue = triggerArray.At(i);
JSONValue normalizedTimeValue = triggerValue.Get("normalizedTime");
if (!normalizedTimeValue.IsNull())
AddTrigger(normalizedTimeValue.GetFloat(), true, triggerValue.GetVariant());
else
{
JSONValue timeVal = triggerValue.Get("time");
if (!timeVal.IsNull())
AddTrigger(timeVal.GetFloat(), false, triggerValue.GetVariant());
}
}
memoryUse += triggers_.Size() * sizeof(AnimationTriggerPoint);
SetMemoryUse(memoryUse);
return true;
}
SetMemoryUse(memoryUse);
return true;
}
BOOL DLL_CALLCONV
FreeImage_CloseMultiBitmap(FIMULTIBITMAP *bitmap, int flags) {
if (bitmap) {
BOOL success = TRUE;
if (bitmap->data) {
MULTIBITMAPHEADER *header = FreeImage_GetMultiBitmapHeader(bitmap);
// saves changes only of images loaded directly from a file
if (header->changed && header->m_filename) {
try {
// open a temp file
std::string spool_name;
ReplaceExtension(spool_name, header->m_filename, "fispool");
// open the spool file and the source file
FILE *f = fopen(spool_name.c_str(), "w+b");
// saves changes
if (f == NULL) {
FreeImage_OutputMessageProc(header->fif, "Failed to open %s, %s", spool_name.c_str(), strerror(errno));
success = FALSE;
} else {
success = FreeImage_SaveMultiBitmapToHandle(header->fif, bitmap, header->io, (fi_handle)f, flags);
// close the files
if (fclose(f) != 0) {
success = FALSE;
FreeImage_OutputMessageProc(header->fif, "Failed to close %s, %s", spool_name.c_str(), strerror(errno));
}
}
if (header->handle) {
fclose((FILE *)header->handle);
}
// applies changes to the destination file
if (success) {
remove(header->m_filename);
success = (rename(spool_name.c_str(), header->m_filename) == 0) ? TRUE:FALSE;
if(!success) {
FreeImage_OutputMessageProc(header->fif, "Failed to rename %s to %s", spool_name.c_str(), header->m_filename);
}
} else {
remove(spool_name.c_str());
}
} catch (std::bad_alloc &) {
success = FALSE;
}
} else {
if (header->handle && header->m_filename) {
fclose((FILE *)header->handle);
}
}
// clear the blocks list
for (BlockListIterator i = header->m_blocks.begin(); i != header->m_blocks.end(); ++i) {
delete *i;
}
// flush and dispose the cache
if (header->m_cachefile) {
header->m_cachefile->close();
delete header->m_cachefile;
}
// delete the last open bitmaps
while (!header->locked_pages.empty()) {
FreeImage_Unload(header->locked_pages.begin()->first);
header->locked_pages.erase(header->locked_pages.begin()->first);
}
// get rid of the IO structure
delete header->io;
// delete the filename
if(header->m_filename) {
delete[] header->m_filename;
}
// delete the FIMULTIBITMAPHEADER
delete header;
}
delete bitmap;
return success;
}
return FALSE;
}
FIMULTIBITMAP * DLL_CALLCONV
FreeImage_OpenMultiBitmap(FREE_IMAGE_FORMAT fif, const char *filename, BOOL create_new, BOOL read_only, BOOL keep_cache_in_memory, int flags) {
FILE *handle = NULL;
try {
// sanity check on the parameters
if (create_new) {
read_only = FALSE;
}
// retrieve the plugin list to find the node belonging to this plugin
PluginList *list = FreeImage_GetPluginList();
if (list) {
PluginNode *node = list->FindNodeFromFIF(fif);
if (node) {
std::auto_ptr<FreeImageIO> io (new FreeImageIO);
SetDefaultIO(io.get());
if (!create_new) {
handle = fopen(filename, "rb");
if (handle == NULL) {
return NULL;
}
}
std::auto_ptr<FIMULTIBITMAP> bitmap (new FIMULTIBITMAP);
std::auto_ptr<MULTIBITMAPHEADER> header (new MULTIBITMAPHEADER);
header->m_filename = new char[strlen(filename) + 1];
strcpy(header->m_filename, filename);
header->node = node;
header->fif = fif;
header->io = io.get ();
header->handle = handle;
header->changed = FALSE;
header->read_only = read_only;
header->m_cachefile = NULL;
header->cache_fif = fif;
header->load_flags = flags;
// store the MULTIBITMAPHEADER in the surrounding FIMULTIBITMAP structure
bitmap->data = header.get();
// cache the page count
header->page_count = FreeImage_InternalGetPageCount(bitmap.get());
// allocate a continueus block to describe the bitmap
if (!create_new) {
header->m_blocks.push_back((BlockTypeS *)new BlockContinueus(0, header->page_count - 1));
}
// set up the cache
if (!read_only) {
std::string cache_name;
ReplaceExtension(cache_name, filename, "ficache");
std::auto_ptr<CacheFile> cache_file (new CacheFile(cache_name, keep_cache_in_memory));
if (cache_file->open()) {
// we can use release() as std::bad_alloc won't be thrown from here on
header->m_cachefile = cache_file.release();
} else {
// an error occured ...
fclose(handle);
return NULL;
}
}
// return the multibitmap
// std::bad_alloc won't be thrown from here on
header.release(); // now owned by bitmap
io.release(); // now owned by bitmap
return bitmap.release(); // now owned by caller
}
}
} catch (std::bad_alloc &) {
/** @todo report error */
}
if (handle)
fclose(handle);
return NULL;
}
void WriteOutput(const String& outputFileName, bool exportAnimations, bool rotationsOnly, bool saveMaterialList)
{
// Begin serialization
{
File dest(context_);
if (!dest.Open(outputFileName, FILE_WRITE))
ErrorExit("Could not open output file " + outputFileName);
// ID
dest.WriteFileID("UMDL");
// Vertexbuffers
dest.WriteUInt(vertexBuffers_.Size());
for (unsigned i = 0; i < vertexBuffers_.Size(); ++i)
vertexBuffers_[i].WriteData(dest);
// Indexbuffers
dest.WriteUInt(indexBuffers_.Size());
for (unsigned i = 0; i < indexBuffers_.Size(); ++i)
indexBuffers_[i].WriteData(dest);
// Subgeometries
dest.WriteUInt(subGeometries_.Size());
for (unsigned i = 0; i < subGeometries_.Size(); ++i)
{
// Write bone mapping info from the first LOD level. It does not change for further LODs
dest.WriteUInt(subGeometries_[i][0].boneMapping_.Size());
for (unsigned k = 0; k < subGeometries_[i][0].boneMapping_.Size(); ++k)
dest.WriteUInt(subGeometries_[i][0].boneMapping_[k]);
// Lod levels for this subgeometry
dest.WriteUInt(subGeometries_[i].Size());
for (unsigned j = 0; j < subGeometries_[i].Size(); ++j)
{
dest.WriteFloat(subGeometries_[i][j].distance_);
dest.WriteUInt((unsigned)subGeometries_[i][j].primitiveType_);
dest.WriteUInt(subGeometries_[i][j].vertexBuffer_);
dest.WriteUInt(subGeometries_[i][j].indexBuffer_);
dest.WriteUInt(subGeometries_[i][j].indexStart_);
dest.WriteUInt(subGeometries_[i][j].indexCount_);
}
}
// Morphs
dest.WriteUInt(morphs_.Size());
for (unsigned i = 0; i < morphs_.Size(); ++i)
morphs_[i].WriteData(dest);
// Skeleton
dest.WriteUInt(bones_.Size());
for (unsigned i = 0; i < bones_.Size(); ++i)
{
dest.WriteString(bones_[i].name_);
dest.WriteUInt(bones_[i].parentIndex_);
dest.WriteVector3(bones_[i].bindPosition_);
dest.WriteQuaternion(bones_[i].bindRotation_);
dest.WriteVector3(bones_[i].bindScale_);
Matrix3x4 offsetMatrix(bones_[i].derivedPosition_, bones_[i].derivedRotation_, bones_[i].derivedScale_);
offsetMatrix = offsetMatrix.Inverse();
dest.Write(offsetMatrix.Data(), sizeof(Matrix3x4));
dest.WriteUByte(bones_[i].collisionMask_);
if (bones_[i].collisionMask_ & 1)
dest.WriteFloat(bones_[i].radius_);
if (bones_[i].collisionMask_ & 2)
dest.WriteBoundingBox(bones_[i].boundingBox_);
}
// Bounding box
dest.WriteBoundingBox(boundingBox_);
// Geometry centers
for (unsigned i = 0; i < subGeometryCenters_.Size(); ++i)
dest.WriteVector3(subGeometryCenters_[i]);
}
if (saveMaterialList)
{
String materialListName = ReplaceExtension(outputFileName, ".txt");
File listFile(context_);
if (listFile.Open(materialListName, FILE_WRITE))
{
for (unsigned i = 0; i < materialNames_.Size(); ++i)
{
// Assume the materials will be located inside the standard Materials subdirectory
listFile.WriteLine("Materials/" + ReplaceExtension(SanitateAssetName(materialNames_[i]), ".xml"));
}
}
else
PrintLine("Warning: could not write material list file " + materialListName);
}
XMLElement skeletonRoot = skelFile_->GetRoot("skeleton");
if (skeletonRoot && exportAnimations)
{
// Go through animations
XMLElement animationsRoot = skeletonRoot.GetChild("animations");
if (animationsRoot)
{
XMLElement animation = animationsRoot.GetChild("animation");
while (animation)
{
ModelAnimation newAnimation;
newAnimation.name_ = animation.GetAttribute("name");
newAnimation.length_ = animation.GetFloat("length");
XMLElement tracksRoot = animation.GetChild("tracks");
XMLElement track = tracksRoot.GetChild("track");
while (track)
{
String trackName = track.GetAttribute("bone");
ModelBone* bone = 0;
for (unsigned i = 0; i < bones_.Size(); ++i)
{
if (bones_[i].name_ == trackName)
{
bone = &bones_[i];
break;
}
}
if (!bone)
ErrorExit("Found animation track for unknown bone " + trackName);
AnimationTrack newAnimationTrack;
newAnimationTrack.name_ = trackName;
if (!rotationsOnly)
newAnimationTrack.channelMask_ = CHANNEL_POSITION | CHANNEL_ROTATION;
else
newAnimationTrack.channelMask_ = CHANNEL_ROTATION;
XMLElement keyFramesRoot = track.GetChild("keyframes");
XMLElement keyFrame = keyFramesRoot.GetChild("keyframe");
while (keyFrame)
{
AnimationKeyFrame newKeyFrame;
// Convert from right- to left-handed
XMLElement position = keyFrame.GetChild("translate");
float x = position.GetFloat("x");
float y = position.GetFloat("y");
float z = position.GetFloat("z");
Vector3 pos(x, y, -z);
XMLElement rotation = keyFrame.GetChild("rotate");
XMLElement axis = rotation.GetChild("axis");
float angle = -rotation.GetFloat("angle") * M_RADTODEG;
x = axis.GetFloat("x");
y = axis.GetFloat("y");
z = axis.GetFloat("z");
Vector3 axisVec(x, y, -z);
Quaternion rot(angle, axisVec);
// Transform from bind-pose relative into absolute
pos = bone->bindPosition_ + bone->bindRotation_ * pos;
rot = bone->bindRotation_ * rot;
newKeyFrame.time_ = keyFrame.GetFloat("time");
newKeyFrame.position_ = pos;
newKeyFrame.rotation_ = rot;
newAnimationTrack.keyFrames_.Push(newKeyFrame);
keyFrame = keyFrame.GetNext("keyframe");
}
// Make sure keyframes are sorted from beginning to end
Sort(newAnimationTrack.keyFrames_.Begin(), newAnimationTrack.keyFrames_.End(), CompareKeyFrames);
// Do not add tracks with no keyframes
if (newAnimationTrack.keyFrames_.Size())
newAnimation.tracks_.Push(newAnimationTrack);
track = track.GetNext("track");
}
// Write each animation into a separate file
String animationFileName = outputFileName.Replaced(".mdl", "");
animationFileName += "_" + newAnimation.name_ + ".ani";
File dest(context_);
if (!dest.Open(animationFileName, FILE_WRITE))
ErrorExit("Could not open output file " + animationFileName);
dest.WriteFileID("UANI");
dest.WriteString(newAnimation.name_);
dest.WriteFloat(newAnimation.length_);
dest.WriteUInt(newAnimation.tracks_.Size());
for (unsigned i = 0; i < newAnimation.tracks_.Size(); ++i)
{
AnimationTrack& track = newAnimation.tracks_[i];
dest.WriteString(track.name_);
dest.WriteUByte(track.channelMask_);
dest.WriteUInt(track.keyFrames_.Size());
for (unsigned j = 0; j < track.keyFrames_.Size(); ++j)
{
AnimationKeyFrame& keyFrame = track.keyFrames_[j];
dest.WriteFloat(keyFrame.time_);
if (track.channelMask_ & CHANNEL_POSITION)
dest.WriteVector3(keyFrame.position_);
if (track.channelMask_ & CHANNEL_ROTATION)
dest.WriteQuaternion(keyFrame.rotation_);
if (track.channelMask_ & CHANNEL_SCALE)
dest.WriteVector3(keyFrame.scale_);
}
}
animation = animation.GetNext("animation");
PrintLine("Processed animation " + newAnimation.name_);
}
}
}
}
bool Animation::Load(Deserializer& source)
{
PROFILE(LoadAnimation);
unsigned memoryUse = sizeof(Animation);
// Check ID
if (source.ReadFileID() != "UANI")
{
LOGERROR(source.GetName() + " is not a valid animation file");
return false;
}
// Read name and length
animationName_ = source.ReadString();
animationNameHash_ = animationName_;
length_ = source.ReadFloat();
tracks_.Clear();
unsigned tracks = source.ReadUInt();
tracks_.Resize(tracks);
memoryUse += tracks * sizeof(AnimationTrack);
// Read tracks
for (unsigned i = 0; i < tracks; ++i)
{
AnimationTrack& newTrack = tracks_[i];
newTrack.name_ = source.ReadString();
newTrack.nameHash_ = newTrack.name_;
newTrack.channelMask_ = source.ReadUByte();
unsigned keyFrames = source.ReadUInt();
newTrack.keyFrames_.Resize(keyFrames);
memoryUse += keyFrames * sizeof(AnimationKeyFrame);
// Read keyframes of the track
for (unsigned j = 0; j < keyFrames; ++j)
{
AnimationKeyFrame& newKeyFrame = newTrack.keyFrames_[j];
newKeyFrame.time_ = source.ReadFloat();
if (newTrack.channelMask_ & CHANNEL_POSITION)
newKeyFrame.position_ = source.ReadVector3();
if (newTrack.channelMask_ & CHANNEL_ROTATION)
newKeyFrame.rotation_ = source.ReadQuaternion();
if (newTrack.channelMask_ & CHANNEL_SCALE)
newKeyFrame.scale_ = source.ReadVector3();
}
}
// Optionally read triggers from an XML file
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
if (cache->Exists(xmlName))
{
XMLFile* file = cache->GetResource<XMLFile>(xmlName);
if (file)
{
XMLElement rootElem = file->GetRoot();
XMLElement triggerElem = rootElem.GetChild("trigger");
while (triggerElem)
{
if (triggerElem.HasAttribute("normalizedtime"))
AddTrigger(triggerElem.GetFloat("normalizedtime"), true, triggerElem.GetVariant());
else if (triggerElem.HasAttribute("time"))
AddTrigger(triggerElem.GetFloat("time"), false, triggerElem.GetVariant());
triggerElem = triggerElem.GetNext("trigger");
}
memoryUse += triggers_.Size() * sizeof(AnimationTriggerPoint);
}
}
SetMemoryUse(memoryUse);
return true;
}
BOOL DLL_CALLCONV
FreeImage_CloseMultiBitmap(FIMULTIBITMAP *bitmap, int flags) {
if (bitmap) {
BOOL success = TRUE;
if (bitmap->data) {
MULTIBITMAPHEADER *header = FreeImage_GetMultiBitmapHeader(bitmap);
if (header->changed) {
// open a temp file
char spool_name[256];
ReplaceExtension(spool_name, header->m_filename, "fispool");
// open the spool file and the source file
FILE *f = fopen(spool_name, "w+b");
void *data = FreeImage_Open(header->node, header->io, (fi_handle)f, FALSE);
void *data_read = NULL;
if (header->handle) {
header->io->seek_proc(header->handle, 0, SEEK_SET);
data_read = FreeImage_Open(header->node, header->io, header->handle, TRUE);
}
// write all the pages to the temp file
int count = 0;
for (BlockListIterator i = header->m_blocks.begin(); i != header->m_blocks.end(); i++) {
if (success) {
switch((*i)->m_type) {
case BLOCK_CONTINUEUS :
{
BlockContinueus *block = (BlockContinueus *)(*i);
for (int j = block->m_start; j <= block->m_end; j++) {
FIBITMAP *dib = header->node->m_plugin->load_proc(header->io, header->handle, j, header->load_flags, data_read);
success = header->node->m_plugin->save_proc(header->io, dib, (fi_handle)f, count, flags, data);
count++;
FreeImage_Unload(dib);
}
break;
}
case BLOCK_REFERENCE :
{
BlockReference *ref = (BlockReference *)(*i);
// read the compressed data
BYTE *compressed_data = (BYTE*)malloc(ref->m_size * sizeof(BYTE));
header->m_cachefile->readFile((BYTE *)compressed_data, ref->m_reference, ref->m_size);
// uncompress the data
FIMEMORY *hmem = FreeImage_OpenMemory(compressed_data, ref->m_size);
FIBITMAP *dib = FreeImage_LoadFromMemory(header->cache_fif, hmem, 0);
FreeImage_CloseMemory(hmem);
// get rid of the buffer
free(compressed_data);
// save the data
success = header->node->m_plugin->save_proc(header->io, dib, (fi_handle)f, count, flags, data);
count++;
// unload the dib
FreeImage_Unload(dib);
break;
}
}
} else {
break;
}
}
// close the files
FreeImage_Close(header->node, header->io, (fi_handle)f, data);
fclose(f);
if (header->handle) {
FreeImage_Close(header->node, header->io, header->handle, data_read);
fclose((FILE *)header->handle);
}
if (success) {
remove(header->m_filename);
rename(spool_name, header->m_filename);
} else {
remove(spool_name);
}
} else {
if (header->handle && header->m_filename) {
fclose((FILE *)header->handle);
}
}
// clear the blocks list
for (BlockListIterator i = header->m_blocks.begin(); i != header->m_blocks.end(); ++i)
delete *i;
// flush and dispose the cache
if (header->m_cachefile) {
header->m_cachefile->close();
delete header->m_cachefile;
}
// delete the last open bitmaps
while (!header->locked_pages.empty()) {
FreeImage_Unload(header->locked_pages.begin()->first);
header->locked_pages.erase(header->locked_pages.begin()->first);
}
// get rid of the IO structure
delete header->io;
// delete the filename
if(header->m_filename)
delete[] header->m_filename;
// delete the FIMULTIBITMAPHEADER
delete header;
}
delete bitmap;
return success;
}
return FALSE;
}
bool Model::Save(Serializer& dest) const
{
// Write ID
if (!dest.WriteFileID("UMD2"))
return false;
// Write vertex buffers
dest.WriteUInt(vertexBuffers_.Size());
for (unsigned i = 0; i < vertexBuffers_.Size(); ++i)
{
VertexBuffer* buffer = vertexBuffers_[i];
dest.WriteUInt(buffer->GetVertexCount());
const PODVector<VertexElement>& elements = buffer->GetElements();
dest.WriteUInt(elements.Size());
for (unsigned j = 0; j < elements.Size(); ++j)
{
unsigned elementDesc = ((unsigned)elements[j].type_) |
(((unsigned)elements[j].semantic_) << 8) |
(((unsigned)elements[j].index_) << 16);
dest.WriteUInt(elementDesc);
}
dest.WriteUInt(morphRangeStarts_[i]);
dest.WriteUInt(morphRangeCounts_[i]);
dest.Write(buffer->GetShadowData(), buffer->GetVertexCount() * buffer->GetVertexSize());
}
// Write index buffers
dest.WriteUInt(indexBuffers_.Size());
for (unsigned i = 0; i < indexBuffers_.Size(); ++i)
{
IndexBuffer* buffer = indexBuffers_[i];
dest.WriteUInt(buffer->GetIndexCount());
dest.WriteUInt(buffer->GetIndexSize());
dest.Write(buffer->GetShadowData(), buffer->GetIndexCount() * buffer->GetIndexSize());
}
// Write geometries
dest.WriteUInt(geometries_.Size());
for (unsigned i = 0; i < geometries_.Size(); ++i)
{
// Write bone mappings
dest.WriteUInt(geometryBoneMappings_[i].Size());
for (unsigned j = 0; j < geometryBoneMappings_[i].Size(); ++j)
dest.WriteUInt(geometryBoneMappings_[i][j]);
// Write the LOD levels
dest.WriteUInt(geometries_[i].Size());
for (unsigned j = 0; j < geometries_[i].Size(); ++j)
{
Geometry* geometry = geometries_[i][j];
dest.WriteFloat(geometry->GetLodDistance());
dest.WriteUInt(geometry->GetPrimitiveType());
dest.WriteUInt(LookupVertexBuffer(geometry->GetVertexBuffer(0), vertexBuffers_));
dest.WriteUInt(LookupIndexBuffer(geometry->GetIndexBuffer(), indexBuffers_));
dest.WriteUInt(geometry->GetIndexStart());
dest.WriteUInt(geometry->GetIndexCount());
}
}
// Write morphs
dest.WriteUInt(morphs_.Size());
for (unsigned i = 0; i < morphs_.Size(); ++i)
{
dest.WriteString(morphs_[i].name_);
dest.WriteUInt(morphs_[i].buffers_.Size());
// Write morph vertex buffers
for (HashMap<unsigned, VertexBufferMorph>::ConstIterator j = morphs_[i].buffers_.Begin();
j != morphs_[i].buffers_.End(); ++j)
{
dest.WriteUInt(j->first_);
dest.WriteUInt(j->second_.elementMask_);
dest.WriteUInt(j->second_.vertexCount_);
// Base size: size of each vertex index
unsigned vertexSize = sizeof(unsigned);
// Add size of individual elements
if (j->second_.elementMask_ & MASK_POSITION)
vertexSize += sizeof(Vector3);
if (j->second_.elementMask_ & MASK_NORMAL)
vertexSize += sizeof(Vector3);
if (j->second_.elementMask_ & MASK_TANGENT)
vertexSize += sizeof(Vector3);
dest.Write(j->second_.morphData_.Get(), vertexSize * j->second_.vertexCount_);
}
}
// Write skeleton
skeleton_.Save(dest);
// Write bounding box
dest.WriteBoundingBox(boundingBox_);
// Write geometry centers
for (unsigned i = 0; i < geometryCenters_.Size(); ++i)
dest.WriteVector3(geometryCenters_[i]);
// Write metadata
if (HasMetadata())
{
File* destFile = dynamic_cast<File*>(&dest);
if (destFile)
{
String xmlName = ReplaceExtension(destFile->GetName(), ".xml");
SharedPtr<XMLFile> xml(new XMLFile(context_));
XMLElement rootElem = xml->CreateRoot("model");
SaveMetadataToXML(rootElem);
File xmlFile(context_, xmlName, FILE_WRITE);
xml->Save(xmlFile);
}
else
URHO3D_LOGWARNING("Can not save model metadata when not saving into a file");
}
return true;
}
void BuildTable::Init (IAICallback *callback, bool cache)
{
cb = callback;
char cachefn[80];
ReplaceExtension (cb->GetModName (), cachefn, sizeof(cachefn), "modcache");
if (cache) {
if (LoadCache (cachefn))
return;
}
// this is what makes loading times long, because spring will load unit defs only when they're needed.
// meaning, GetUnitDefs() will make spring load all the unit defs at once.
numDefs = cb->GetNumUnitDefs();
deflist = new UDef[numDefs];
const UnitDef** templist=new const UnitDef*[numDefs];
cb->GetUnitDefList (templist);
for (int a=0;a<numDefs;a++)
{
UDef& d = deflist[a];
d.def = templist[a];
d.cost.energy = d.def->energyCost;
d.cost.metal = d.def->metalCost;
d.make.energy = d.def->energyMake;
d.make.metal = d.def->metalMake;
if (d.def->activateWhenBuilt)
{ // Solars have negative energy upkeep so they can be disabled
d.make.energy -= d.def->energyUpkeep;
d.make.metal += d.def->makesMetal;
d.make.metal -= d.def->metalUpkeep;
}
d.storage.energy = d.def->energyStorage;
d.storage.metal = d.def->metalStorage;
d.metalExtractDepth = d.def->extractsMetal;
d.buildTime = d.def->buildTime;
d.energyUse = d.def->energyUpkeep;
d.buildSpeed = d.def->buildSpeed;
d.numBuildOptions = d.def->buildOptions.size();
d.flags = 0;
if (!d.def->buildOptions.empty ()) d.flags |= CUD_Builder;
if (d.def->type == "Building" || d.def->type == "Factory" || d.def->type == "MetalExtractor")
d.flags |= CUD_Building;
if (d.def->windGenerator) d.flags |= CUD_WindGen;
if (d.def->movedata) {
d.moveType = d.def->movedata->moveType;
d.flags |= CUD_MoveType;
}
deflist[a].def = templist[a];
deflist[a].name = templist[a]->name;
d.weaponDamage = 0.0f;
d.weaponRange = 0.0f;
for (int b=0;b<d.def->weapons.size();b++)
{
const WeaponDef* w = d.def->weapons[b].def;
if (d.weaponRange < w->range)
d.weaponRange = w->range;
d.weaponDamage += CalcAverageDamage (&w->damages);
}
}
delete[] templist;
table.alloc(numDefs);
logPrintf ("Calculating build table for %d build types...\n", numDefs);
// convert all string'ed identifiers to id's, which can be used for indexing directly
buildby = new std::vector<int>[numDefs];
for (int a=0;a<numDefs;a++)
{
const UnitDef *def=deflist[a].def;
for (map<int,string>::const_iterator i=def->buildOptions.begin();i!=def->buildOptions.end();++i)
{
const UnitDef *bdef = cb->GetUnitDef (i->second.c_str());
if (bdef)
buildby[bdef->id-1].push_back(a);
}
deflist[a].buildby = &buildby [a];
}
for (int a=0;a<numDefs;a++)
CalcBuildTable (a, a, 0, ResInfo());
SaveCache (cachefn);
/* for (int a=0;a<numDefs;a++)
{
logPrintf ("%s builds:", deflist[a].name.c_str());
for (int b=0;b<numDefs;b++)
{
BuildTable::Table::ent& e=table.get(a,b);
if (e.id>=0)
logPrintf ("%s by building %s (%d), ", deflist[b].name.c_str(), deflist[e.id].name.c_str(), e.depth);
}
logPrintf ("\n");
}*/
}
