unsigned int CCategoryHandler::GetCategory(std::string name) { StringTrimInPlace(name); StringToLowerInPlace(name); if (name.empty()) return 0; // the empty category unsigned int cat = 0; GML_STDMUTEX_LOCK(cat); // GetCategory if (categories.find(name) == categories.end()) { // this category is yet unknown if (firstUnused >= CCategoryHandler::GetMaxCategories()) { // skip this category LOG_L(L_WARNING, "too many unit categories (%i), skipping %s", firstUnused, name.c_str()); cat = 0; } else { // create the category (bit field value) cat = (1 << firstUnused); //LOG_L(L_DEBUG, "New unit-category %s #%i", name.c_str(), firstUnused); } // if (cat == 0), this will prevent further warnings for this category categories[name] = cat; firstUnused++; } else { // this category is already known cat = categories[name]; } return cat; }
C3DOTextureHandler::UnitTexture* C3DOParser::GetTexture(S3DOPiece* obj, _Primitive* p, const std::vector<unsigned char>& fileBuf) const { std::string texName; if (p->OffsetToTextureName != 0) { int unused; texName = GET_TEXT(p->OffsetToTextureName, fileBuf, unused); StringToLowerInPlace(texName); if (teamtex.find(texName) == teamtex.end()) { texName += "00"; } } else { texName = "ta_color" + IntToString(p->PaletteEntry, "%i"); } auto tex = texturehandler3DO->Get3DOTexture(texName); if (tex != nullptr) return tex; LOG_L(L_WARNING, "[%s] unknown 3DO texture \"%s\" for piece \"%s\"", __FUNCTION__, texName.c_str(), obj->name.c_str()); // assign a dummy texture (the entire atlas) return texturehandler3DO->Get3DOTexture("___dummy___"); }
static void RegisterAssimpModelParsers(C3DModelLoader::ParserMap& parsers, CAssParser* assParser) { std::string extension; std::string extensions; Assimp::Importer importer; // get a ";" separated list of format extensions ("*.3ds;*.lwo;*.mesh.xml;...") importer.GetExtensionList(extensions); // do not ignore the last extension extensions += ";"; LOG("[%s] supported Assimp model formats: %s", __FUNCTION__, extensions.c_str()); size_t i = 0; size_t j = 0; // split the list, strip off the "*." extension prefixes while ((j = extensions.find(";", i)) != std::string::npos) { extension = extensions.substr(i, j - i); extension = extension.substr(extension.find("*.") + 2); StringToLowerInPlace(extension); if (parsers.find(extension) == parsers.end()) { parsers[extension] = assParser; } i = j + 1; } }
void CArchiveScanner::ReadCacheData(const std::string& filename) { if (!FileSystem::FileExists(filename)) { LOG_L(L_INFO, "Archive cache doesn't exist: %s", filename.c_str()); return; } LuaParser p(filename, SPRING_VFS_RAW, SPRING_VFS_BASE); if (!p.Execute()) { LOG_L(L_ERROR, "Failed to parse archive cache: %s", p.GetErrorLog().c_str()); return; } const LuaTable archiveCache = p.GetRoot(); // Do not load old version caches const int ver = archiveCache.GetInt("internalVer", (INTERNAL_VER + 1)); if (ver != INTERNAL_VER) { return; } const LuaTable archives = archiveCache.SubTable("archives"); for (int i = 1; archives.KeyExists(i); ++i) { const LuaTable curArchive = archives.SubTable(i); const LuaTable archived = curArchive.SubTable("archivedata"); std::string name = curArchive.GetString("name", ""); ArchiveInfo& ai = archiveInfos[StringToLower(name)]; ai.origName = name; ai.path = curArchive.GetString("path", ""); // do not use LuaTable.GetInt() for 32-bit integers, the Spring lua // library uses 32-bit floats to represent numbers, which can only // represent 2^24 consecutive integers ai.modified = strtoul(curArchive.GetString("modified", "0").c_str(), 0, 10); ai.checksum = strtoul(curArchive.GetString("checksum", "0").c_str(), 0, 10); ai.updated = false; ai.archiveData = CArchiveScanner::ArchiveData(archived, true); if (ai.archiveData.GetModType() == modtype::map) { AddDependency(ai.archiveData.GetDependencies(), "Map Helper v1"); } else if (ai.archiveData.GetModType() == modtype::primary) { AddDependency(ai.archiveData.GetDependencies(), "Spring content v1"); } } const LuaTable brokenArchives = archiveCache.SubTable("brokenArchives"); for (int i = 1; brokenArchives.KeyExists(i); ++i) { const LuaTable curArchive = brokenArchives.SubTable(i); std::string name = curArchive.GetString("name", ""); StringToLowerInPlace(name); BrokenArchive& ba = this->brokenArchives[name]; ba.path = curArchive.GetString("path", ""); ba.modified = strtoul(curArchive.GetString("modified", "0").c_str(), 0, 10); ba.updated = false; ba.problem = curArchive.GetString("problem", "unknown"); } isDirty = false; }
unsigned int CCategoryHandler::GetCategory(std::string name) { StringToLowerInPlace(name); while(!name.empty() && *name.begin()==' ') name.erase(name.begin()); if(name.empty()) return 0; // Remove some categories that we don't think we need since we have too few of them. if (categories.find(name) == categories.end()) { if (name.find("ctrl") != std::string::npos || name.find("arm") != std::string::npos || name.find("core") != std::string::npos || name.find("level") != std::string::npos || name.find("energy") != std::string::npos || name.find("storage") != std::string::npos || name.find("defensive") != std::string::npos || name.find("extractor") != std::string::npos || name.find("metal") != std::string::npos || name.find("torp") != std::string::npos) return 0; if(firstUnused > 31) { logOutput.Print("WARNING: too many unit categories %i missed %s", firstUnused + 1, name.c_str()); return 0; } categories[name] = (1 << (firstUnused++)); // logOutput.Print("New cat %s #%i",name.c_str(),firstUnused); } return categories[name]; }
void CUnitDefHandler::CreateYardMap(UnitDef* def, std::string yardmapStr) { StringToLowerInPlace(yardmapStr); const int mw = def->xsize; const int mh = def->zsize; const int maxIdx = mw * mh; // create the yardmaps for each build-facing for (int u = 0; u < 4; u++) { def->yardmaps[u] = new unsigned char[maxIdx]; } // Spring resolution's is double that of TA's (so 4 times as much area) unsigned char* originalMap = new unsigned char[maxIdx / 4]; memset(originalMap, 255, maxIdx / 4); if (!yardmapStr.empty()) { std::string::iterator si = yardmapStr.begin(); for (int y = 0; y < mh / 2; y++) { for (int x = 0; x < mw / 2; x++) { if (*si == 'g') def->needGeo = true; else if (*si == 'c') originalMap[x + y * mw / 2] = 1; // blocking else if (*si == 'y') originalMap[x + y * mw / 2] = 0; // non-blocking // advance one non-space character (matching the column // <x> we have just advanced) in this row, and skip any // spaces do { si++; } while (si != yardmapStr.end() && *si == ' '); if (si == yardmapStr.end()) { // no more chars for remaining colums in this row break; } } if (si == yardmapStr.end()) { // no more chars for any remaining rows break; } } } for (int y = 0; y < mh; y++) { for (int x = 0; x < mw; x++) { int orgIdx = x / 2 + y / 2 * mw / 2; char orgMapChar = originalMap[orgIdx]; def->yardmaps[0][ (x + y * mw) ] = orgMapChar; def->yardmaps[1][maxIdx - (mh * (x + 1) - (y + 1) + 1)] = orgMapChar; def->yardmaps[2][maxIdx - (x + y * mw + 1) ] = orgMapChar; def->yardmaps[3][ mh * (x + 1) - (y + 1) ] = orgMapChar; } } }
unsigned int CCategoryHandler::GetCategory(std::string name) { unsigned int cat = 0; StringToLowerInPlace(name); // remove leading spaces while (!name.empty() && (*name.begin() == ' ')) { name.erase(name.begin()); } if (name.empty()) { // the empty category cat = 0; } else if (categories.find(name) == categories.end()) { // this category is yet unknown if (firstUnused >= CCategoryHandler::GetMaxCategories()) { // skip this category logOutput.Print("WARNING: too many unit categories (%i), skipping %s", firstUnused, name.c_str()); cat = 0; } else { // create the category (bit field value) cat = (1 << firstUnused); // logOutput.Print("New cat %s #%i", name.c_str(), firstUnused); } // if (cat == 0), this will prevent further warnings for this category categories[name] = cat; firstUnused++; } else { // this category is already known cat = categories[name]; } return cat; }
int CDamageArrayHandler::GetTypeFromName(std::string name) { StringToLowerInPlace(name); if(name2type.find(name)!=name2type.end()) return name2type[name]; return 0; }
bool CglList::Filter(bool reset) { std::string current = (*filteredItems)[place]; std::vector<std::string>* destination = filteredItems == &temp1 ? &temp2 : &temp1; destination->clear(); if (reset) filteredItems = &items; // reset filter for (std::vector<std::string>::const_iterator it = filteredItems->begin(); it != filteredItems->end(); ++it) { std::string lcitem(*it, 0, query.length()); StringToLowerInPlace(lcitem); if (lcitem == query) { if (*it == current) place = destination->size(); destination->push_back(*it); } } if (destination->empty()) { query = query.substr(0, query.length() - 1); return false; } else { filteredItems = destination; if(place>=(int)filteredItems->size()) place=filteredItems->size()-1; if(place<0) place=0; return true; } }
int CTextureAtlas::AddTexFromFile(std::string name, std::string file) { StringToLowerInPlace(name); // if the file is already loaded, use that instead std::string lcFile = StringToLower(file); std::map<std::string, MemTex*>::iterator it = files.find(lcFile); if (it != files.end()) { MemTex* memtex = it->second; memtex->names.push_back(name); return 1; } CBitmap bitmap; if (!bitmap.Load(file)) { throw content_error("Could not load texture from file " + file); } if (bitmap.channels != 4 || bitmap.compressed) { // only suport RGBA for now throw content_error("Unsupported bitmap format in file " + file); } const int ret = AddTexFromMem(name, bitmap.xsize, bitmap.ysize, RGBA32, bitmap.mem); if (ret == 1) { files[lcFile] = memtextures.back(); } return ret; }
int CTextureAtlas::AddTexFromFile(std::string name, std::string file) { StringToLowerInPlace(name); //if the file already loaded, use that instead std::string lcfile = StringToLower(file); std::map<std::string, MemTex*>::iterator it = files.find(lcfile); if(it != files.end()) { MemTex *memtex = it->second; memtex->names.push_back(name); return 1; } CBitmap bitmap; if (!bitmap.Load(file)) throw content_error("Could not load texture from file " + file); if(bitmap.type != CBitmap::BitmapTypeStandardRGBA) //only suport rgba for now throw content_error("Unsupported bitmap format in file " + file); int ret = AddTexFromMem(name, bitmap.xsize, bitmap.ysize, RGBA32, bitmap.mem); if (ret == 1) files[lcfile] = memtextures.back(); return ret; }
void LuaMatUniforms::Parse(lua_State* L, const int tableIdx) { auto uniformAndNames = GetUniformsAndPossibleNames(); decltype(uniformAndNames) uniformAndNamesLower; for (auto& p: uniformAndNames) { uniformAndNamesLower[StringToLower(p.first)] = p.second; } for (lua_pushnil(L); lua_next(L, tableIdx) != 0; lua_pop(L, 1)) { if (!lua_israwstring(L, -2) || !lua_isnumber(L, -1)) continue; // get the lua table key // and remove the "loc" at the end (cameraPosLoc -> camerapos) std::string uniformLocStr = luaL_tosstring(L, -2); StringToLowerInPlace(uniformLocStr); if (StringEndsWith(uniformLocStr, "loc")) { uniformLocStr.resize(uniformLocStr.size() - 3); } const auto uniformLocIt = uniformAndNamesLower.find(uniformLocStr); if (uniformLocIt == uniformAndNamesLower.end()) { LOG_L(L_WARNING, "LuaMaterial: unknown uniform \"%s\"", lua_tostring(L, -2)); continue; } uniformLocIt->second->loc = static_cast<GLint>(lua_tonumber(L, -1)); } }
S3DOModel* C3DModelParser::Load3DO(string name,float scale,int side,const float3& offsets) { StringToLowerInPlace(name); if(name.find(".s3o")!=string::npos) return units3oparser->LoadS3O(name,scale,side); else return unit3doparser->Load3DO(name,scale,side,offsets); }
/** * Initializes variables in CGlobalUnsyncedStuff */ CGlobalUnsyncedStuff::CGlobalUnsyncedStuff() { boost::uint64_t randnum; randnum = SDL_GetTicks(); usRandSeed = randnum&0xffffffff; modGameTime = 0; gameTime = 0; lastFrameTime = 0; drawFrame = 1; viewSizeX = 100; viewSizeY = 100; pixelX = 0.01f; pixelY = 0.01f; aspectRatio = 1.0f; myPlayerNum = 0; myTeam = 1; myAllyTeam = 1; spectating = false; spectatingFullView = false; spectatingFullSelect = false; drawdebug = false; active = true; viewRange = MAX_VIEW_RANGE; timeOffset = 0; drawFog = true; teamNanospray = false; autoQuit = false; quitTime = 0; #ifdef DIRECT_CONTROL_ALLOWED directControl = 0; #endif compressTextures = false; atiHacks = false; supportNPOTs = GLEW_ARB_texture_non_power_of_two; { std::string vendor = std::string((char*)glGetString(GL_VENDOR)); StringToLowerInPlace(vendor); bool isATi = (vendor.find("ati ") != string::npos); if (isATi) { std::string renderer = std::string((char*)glGetString(GL_RENDERER)); StringToLowerInPlace(renderer); supportNPOTs = (renderer.find(" x") == string::npos && renderer.find(" 9") == string::npos); //! x-series doesn't support NPOTs } } }
S3DOModel* C3DModelParser::Load3DModel(std::string name, float scale, int side) { // TODO: abstract this StringToLowerInPlace(name); if (name.find(".s3o") != std::string::npos) return units3oparser->LoadS3O(name, scale, side); else return unit3doparser->Load3DO(name, scale, side); }
C3DOTextureHandler::UnitTexture* C3DOTextureHandler::Get3DOTexture(std::string name) { StringToLowerInPlace(name); std::map<std::string,UnitTexture*>::iterator tti; if((tti=textures.find(name))!=textures.end()){ return tti->second; } LogObject() << "Unknown texture " << name.c_str() << "\n"; return textures[" "]; }
CModel* C3DModelParser::Load3DO(string name,float scale,int side) { CModel *mdl; StringToLowerInPlace(name); if(name.find(".s3o")!=string::npos) mdl = units3oparser->Load3DO(name,scale,side); else mdl = unit3doparser->Load3DO(name,scale,side); return mdl; }
const UnitDef* CUnitDefHandler::GetUnitDefByName(std::string name) { StringToLowerInPlace(name); std::map<std::string, int>::iterator it = unitDefIDsByName.find(name); if (it == unitDefIDsByName.end()) { return NULL; } const int defid = it->second; return unitDefs[defid]; }
/** * Get CRC of the data in the specified archive. * Returns 0 if file could not be opened. */ unsigned int CArchiveScanner::GetCRC(const std::string& arcName) { CRC crc; CArchiveBase* ar; std::list<std::string> files; //! Try to open an archive ar = CArchiveFactory::OpenArchive(arcName); if (!ar) { return 0; // It wasn't an archive } //! Load ignore list. IFileFilter* ignore = CreateIgnoreFilter(ar); for (unsigned fid = 0; fid != ar->NumFiles(); ++fid) { std::string name; int size; ar->FileInfo(fid, name, size); if (ignore->Match(name)) { continue; } StringToLowerInPlace(name); //! case insensitive hash files.push_back(name); } files.sort(); //! Add all files in sorted order for (std::list<std::string>::iterator i = files.begin(); i != files.end(); ++i) { const unsigned int nameCRC = CRC().Update(i->data(), i->size()).GetDigest(); const unsigned fid = ar->FindFile(*i); const unsigned int dataCRC = ar->GetCrc32(fid); crc.Update(nameCRC); crc.Update(dataCRC); } delete ignore; delete ar; unsigned int digest = crc.GetDigest(); //! A value of 0 is used to indicate no crc.. so never return that //! Shouldn't happen all that often if (digest == 0) { return 4711; } else { return digest; } }
unsigned int CArchiveScanner::GetSingleArchiveChecksum(const std::string& name) const { std::string lcname = filesystem.GetFilename(name); StringToLowerInPlace(lcname); std::map<std::string, ArchiveInfo>::const_iterator aii = archiveInfo.find(lcname); if (aii == archiveInfo.end()) { logOutput.Print(LOG_ARCHIVESCANNER, "%s checksum: not found (0)\n", name.c_str()); return 0; } logOutput.Print(LOG_ARCHIVESCANNER, "%s checksum: %d/%u\n", name.c_str(), aii->second.checksum, aii->second.checksum); return aii->second.checksum; }
unsigned int CArchiveScanner::GetSingleArchiveChecksum(const std::string& name) const { std::string lcname = FileSystem::GetFilename(name); StringToLowerInPlace(lcname); std::map<std::string, ArchiveInfo>::const_iterator aii = archiveInfos.find(lcname); if (aii == archiveInfos.end()) { LOG_SL(LOG_SECTION_ARCHIVESCANNER, L_WARNING, "%s checksum: not found (0)", name.c_str()); return 0; } LOG_S(LOG_SECTION_ARCHIVESCANNER,"%s checksum: %d/%u", name.c_str(), aii->second.checksum, aii->second.checksum); return aii->second.checksum; }
S3DOPiece* C3DOParser::LoadPiece(S3DModel* model, int pos, S3DOPiece* parent, int* numobj, const std::vector<unsigned char>& fileBuf) { (*numobj)++; _3DObject me; int curOffset = pos; READ_3DOBJECT(me, fileBuf, curOffset); std::string s = GET_TEXT(me.OffsetToObjectName, fileBuf, curOffset); StringToLowerInPlace(s); S3DOPiece* piece = new S3DOPiece(); piece->name = s; piece->parent = parent; piece->offset.x = me.XFromParent * SCALE_FACTOR_3DO; piece->offset.y = me.YFromParent * SCALE_FACTOR_3DO; piece->offset.z = -me.ZFromParent * SCALE_FACTOR_3DO; piece->goffset = piece->offset + ((parent != NULL)? parent->goffset: ZeroVector); GetVertexes(&me, piece, fileBuf); GetPrimitives(piece, me.OffsetToPrimitiveArray, me.NumberOfPrimitives, ((pos == 0)? me.SelectionPrimitive: -1), fileBuf); piece->CalcNormals(); piece->SetMinMaxExtends(); piece->emitPos = ZeroVector; piece->emitDir = FwdVector; if (piece->vertexPos.size() >= 2) { piece->emitPos = piece->vertexPos[0]; piece->emitDir = piece->vertexPos[1] - piece->vertexPos[0]; } else if (piece->vertexPos.size() == 1) { piece->emitDir = piece->vertexPos[0]; } model->mins = float3::min(piece->goffset + piece->mins, model->mins); model->maxs = float3::max(piece->goffset + piece->maxs, model->maxs); piece->SetCollisionVolume(CollisionVolume("box", piece->maxs - piece->mins, (piece->maxs + piece->mins) * 0.5f)); if (me.OffsetToChildObject > 0) { piece->children.push_back(LoadPiece(model, me.OffsetToChildObject, piece, numobj, fileBuf)); } if (me.OffsetToSiblingObject > 0) { parent->children.push_back(LoadPiece(model, me.OffsetToSiblingObject, parent, numobj, fileBuf)); } return piece; }
const UnitDef* CUnitDefHandler::GetUnitByName(std::string name) { StringToLowerInPlace(name); std::map<std::string, int>::iterator it = unitID.find(name); if (it == unitID.end()) { return NULL; } const int id = it->second; if (!unitDefs[id].valid) { return NULL; // should not happen } return &unitDefs[id]; }
int CTextureAtlas::AddTexFromMem(std::string name, int xsize, int ysize, TextureType texType, void *data) { int gpp = GetBPP(texType); MemTex *memtex = SAFE_NEW MemTex; memtex->xsize = xsize; memtex->ysize = ysize; memtex->xpos = 0; memtex->ypos = 0; memtex->texType = texType; memtex->data = SAFE_NEW char[xsize*ysize*gpp/8]; StringToLowerInPlace(name); memtex->names.push_back(name); memcpy(memtex->data, data, xsize*ysize*gpp/8); memtextures.push_back(memtex); return 1; }
unsigned int CCategoryHandler::GetCategories(std::string names) { unsigned int ret = 0; StringToLowerInPlace(names); // split on ' ' std::stringstream namesStream(names); std::string name; while (std::getline(namesStream, name, ' ')) { if (!name.empty()) { ret |= GetCategory(name); } } return ret; }
void* CTextureAtlas::AddTex(std::string name, int xsize, int ysize, TextureType texType) { const int gpp = GetBPP(texType); const size_t data_size = xsize * ysize * gpp / 8; MemTex* memtex = new MemTex; memtex->xsize = xsize; memtex->ysize = ysize; memtex->texType = texType; memtex->data = new char[data_size]; StringToLowerInPlace(name); memtex->names.push_back(name); memtextures.push_back(memtex); atlasAllocator->AddEntry(name, int2(xsize, ysize)); return memtex->data; }
CColorMap* CColorMap::LoadFromBitmapFile(std::string filename) { std::string lowfilename = filename; StringToLowerInPlace(lowfilename); CColorMap *map; if(colorMapsMap.find(lowfilename)==colorMapsMap.end()) { map = new CColorMap(filename); colorMapsMap[lowfilename] = map; colorMaps.push_back(map); } else { map = colorMapsMap.find(lowfilename)->second; } return map; }
CArchive7Zip::CArchive7Zip(const std::string& name): CArchiveBuffered(name), curSearchHandle(1), isOpen(false) { SZ_RESULT res; archiveStream.File = fopen(name.c_str(), "rb"); if (archiveStream.File == 0) return; archiveStream.InStream.Read = SzFileReadImp; archiveStream.InStream.Seek = SzFileSeekImp; allocImp.Alloc = SzAlloc; allocImp.Free = SzFree; allocTempImp.Alloc = SzAllocTemp; allocTempImp.Free = SzFreeTemp; InitCrcTable(); SzArDbExInit(&db); res = SzArchiveOpen(&archiveStream.InStream, &db, &allocImp, &allocTempImp); if (res != SZ_OK) return; isOpen = true; // Get contents of archive and store name->int mapping for (unsigned i = 0; i < db.Database.NumFiles; ++i) { CFileItem* fi = db.Database.Files + i; if ((fi->Size >= 0) && !fi->IsDirectory) { std::string name = fi->Name; //SetSlashesForwardToBack(name); FileData fd; fd.origName = name; fd.fp = i; fd.size = fi->Size; fd.crc = (fi->Size > 0) ? fi->FileCRC : 0; StringToLowerInPlace(name); fileData[name] = fd; } } }
CTextureHandler::UnitTexture* CTextureHandler::GetTATexture(std::string name, int team, int teamTex) { if(teamTex){ char c[50]; sprintf(c,"team%d_",team); name=string(c)+name; } StringToLowerInPlace(name); std::map<std::string,UnitTexture*>::iterator tti; if((tti=textures.find(name))!=textures.end()){ return tti->second; } logOutput << "Unknown texture " << name.c_str() << "\n"; return textures[" "]; }
size_t CTextureAtlas::AddTex(std::string name, int xsize, int ysize, TextureType texType) { memTextures.emplace_back(); MemTex& tex = memTextures.back(); tex.xsize = xsize; tex.ysize = ysize; tex.texType = texType; tex.mem.resize((xsize * ysize * GetBPP(texType)) / 8, 0); StringToLowerInPlace(name); tex.names.emplace_back(std::move(name)); atlasAllocator->AddEntry(tex.names.back(), int2(xsize, ysize)); return (memTextures.size() - 1); }