void* findAssetEverywhere(zoneInfo_t* info, int type, const char* name) { void* ret = getAsset(info, type, name); if(ret) return ret; return DB_FindXAssetHeader(type, name); }
snd_alias_list_t* FindSoundAliasHookFunc(assetType_t type, const char* name) { snd_alias_list_t* aliases = (snd_alias_list_t*)DB_FindXAssetHeader(type, name); // the most hated sound at this point if (!_stricmp(name, "music_mainmenu_mp")) { static snd_alias_list_t newList; static snd_alias_t newAlias; static StreamFile newFile; // duplicate the asset as we can't modify pointers memcpy(&newList, aliases, sizeof(newList)); memcpy(&newAlias, newList.aliases, sizeof(newAlias)); newList.aliases = &newAlias; memcpy(&newFile, newAlias.stream, sizeof(newFile)); newAlias.stream = &newFile; // and replace the filename. //newFile.file = "hz_boneyard_intro_LR_1.mp3"; newFile.file = "ui_lobby_answering_the_call.mp3"; // oh and this too aliases = &newList; } return aliases; }
void * addSoundAlias(zoneInfo_t* info, const char* name, char* data, int dataLen) { if (dataLen < 0) { SoundAliasList* lst = (SoundAliasList*)data; if (lst->head->soundFile->type == SAT_STREAMED || lst->head->soundFile->type == SAT_LOADED) { return data; // no fixups needed } Com_Error(false, "Unknown sound type %d!\n", lst->head->soundFile->type); return NULL; } // why the hell can't I f*****g do string parsing? string l = string(data); int slash = l.find_last_of('/'); bool hasfolder; string folder, file; if(slash == -1) { file = l; hasfolder = false; } else { folder = l.substr(0, slash); file = l.substr(slash + 1); hasfolder = true; } SoundAliasList* base = (SoundAliasList*)DB_FindXAssetHeader(ASSET_TYPE_SOUND, "AB_1mc_boost"); SoundAliasList* snd = new SoundAliasList; memcpy(snd, base, sizeof(SoundAliasList)); snd->name = strdup(name); snd->head->name = snd->name; if (hasfolder) { snd->head->soundFile->data.stream.dir = strdup((char*)folder.c_str()); } else { snd->head->soundFile->data.stream.dir = NULL; } snd->head->soundFile->data.stream.name = strdup((char*)file.c_str()); return snd; }
void StringTable_GetAsset(char* filename, stringTable_t** table) { if (!stringTables[filename]) { stringTables[filename] = StringTable_Load(filename); } // 1 = get from XAsset DB if ((int)stringTables[filename] == 1) { *table = (stringTable_t*)DB_FindXAssetHeader(ASSET_TYPE_STRINGTABLE, filename); } else { *table = stringTables[filename]; } }
const char* SEH_GetLocalizedString(const char* key) { google::dense_hash_map<std::string, std::string>::const_iterator iter = _localizedStrings.find(key); if (iter != _localizedStrings.end()) { return (*iter).second.c_str(); } localizedEntry_s* entry = (localizedEntry_s*)DB_FindXAssetHeader(ASSET_TYPE_LOCALIZE, key); if (entry) { return entry->value; } return NULL; }
stringTable_t* StringTable_Load_LoadObj(const char* filename, const char* buffer) { stringTable_t* origTable = (stringTable_t*)DB_FindXAssetHeader(ASSET_TYPE_STRINGTABLE, filename); strtk::token_grid::options options; options.set_row_delimiters("\r\n"); options.set_column_delimiters(","); options.set_column_split_option(strtk::split_options::default_mode); options.set_row_split_option(strtk::split_options::default_mode); strtk::token_grid grid(buffer, strlen(buffer), options); int columns = grid.max_column_count(); int rows = grid.row_count(); stringTable_t* newTable = (stringTable_t*)malloc(sizeof(stringTable_t)); newTable->fileName = (char*)filename; newTable->data = (char**)malloc(sizeof(char*) * rows * columns * 2); for (std::size_t ri = 0; ri < (std::size_t)rows; ri++) { strtk::token_grid::row_type r = grid.row(ri); for (std::size_t ci = 0; ci < r.size(); ci++) { std::string strSource = r.get<std::string>(ci); char* str = (char*)malloc(strSource.length() + 1); memcpy(str, strSource.c_str(), strSource.length() + 1); newTable->data[((ri * columns) + ci) * 2] = str; newTable->data[(((ri * columns) + ci) * 2) + 1] = (char*)StringTableHash(str); } } newTable->columns = columns; newTable->rows = rows; return newTable; }
void* addXModel(zoneInfo_t* info, const char* name, char* data, size_t dataLen) { if (data == NULL) return NULL; if(dataLen == 0) { XModel * model = (XModel*)data; short* boneNames = new short[model->numBones]; for(int i=0; i<model->numBones; i++) { boneNames[i] = addScriptString(info, SL_ConvertToString(model->boneNames[i])); } model->boneNames = boneNames; for(int i=0; i<model->numSurfaces; i++) { // allow material overriding void* file; void* asset; if(int len = FS_ReadFile(va("zonebuilder/materials/%s.txt", model->materials[i]->name), &file) > 0) { asset = addMaterial(info, model->materials[i]->name, (char*)file, len); FS_FreeFile(file); } else { asset = addMaterial(info, model->materials[i]->name, (char*)model->materials[i], 0); } addAsset(info, ASSET_TYPE_MATERIAL, model->materials[i]->name, asset); } return data; } // copy stuff over XModel * base = (XModel*)DB_FindXAssetHeader(ASSET_TYPE_XMODEL, "viewmodel_mp5k"); XModel * asset = new XModel; memcpy(asset, base, sizeof(XModel)); asset->lods[0].surfaces = new XModelSurfaces; memcpy(asset->lods[0].surfaces, base->lods[0].surfaces, sizeof(XModelSurfaces)); XModelSurfaces * surf = asset->lods[0].surfaces; surf->name = new char[strlen(name) + 6]; sprintf((char*)surf->name, "%s_surf", name); BUFFER * buf = new BUFFER(data, dataLen); asset->name = new char[128]; buf->readstr(asset->name, 128); buf->read(&asset->numBones, 4, 1); buf->read(&asset->numSubBones, 4, 1); buf->read(&asset->numSurfaces, 4, 1); surf->numSurfaces = asset->numSurfaces; asset->lods[0].numSurfs = surf->numSurfaces; asset->boneNames = new short[asset->numBones]; for(int i=0; i<asset->numBones; i++) { char bone[64]; buf->readstr(bone, 64); asset->boneNames[i] = addScriptString(info, bone); } // allocate stuff and load it if(asset->numBones - asset->numSubBones) { asset->parentList = new char[asset->numBones - asset->numSubBones]; asset->tagAngles = new XModelAngle[asset->numBones - asset->numSubBones]; asset->tagPositions = new XModelTagPos[asset->numBones - asset->numSubBones]; buf->read(asset->parentList, sizeof(char), asset->numBones - asset->numSubBones); buf->read(asset->tagAngles, sizeof(XModelAngle), asset->numBones - asset->numSubBones); buf->read(asset->tagPositions, sizeof(XModelTagPos), asset->numBones - asset->numSubBones); } if(asset->numBones) { asset->partClassification = new char[asset->numBones]; asset->animMatrix = new char[32 * asset->numBones]; buf->read(asset->partClassification, sizeof(char), asset->numBones); buf->read(asset->animMatrix, 32, asset->numBones); } surf->surfaces = new XSurface[surf->numSurfaces]; memset(surf->surfaces, 0, sizeof(XSurface) * surf->numSurfaces); for(int i=0; i<surf->numSurfaces; i++) { XSurface* s = &surf->surfaces[i]; buf->read(&s->numVertices, 4, 1); buf->read(&s->numPrimitives, 4, 1); buf->read(&s->blendNum1, 4, 1); buf->read(&s->blendNum2, 4, 1); buf->read(&s->blendNum3, 4, 1); buf->read(&s->blendNum4, 4, 1); int blendCount = (s->blendNum4 * 7) + (s->blendNum3 * 5) + (s->blendNum2 * 3) + s->blendNum1; if(blendCount) { s->blendInfo = new char[blendCount * 2]; buf->read(s->blendInfo, 2, blendCount); } else { s->blendInfo = NULL; } s->vertexBuffer = new GfxPackedVertex[s->numVertices]; buf->read(s->vertexBuffer, 32, s->numVertices); int ct = 0; buf->read(&ct, 4, 1); if(ct) { buf->read(&s->numCT, 4, 1); s->ct = new XSurfaceCT[s->numCT]; for(int j=0; j<s->numCT; j++) { XSurfaceCT* ct = &s->ct[j]; buf->read(&ct->pad, 4, 1); buf->read(&ct->pad2, 4, 1); ct->entry = new XSurfaceCTEntry; buf->read(ct->entry, 24, 1); buf->read(&ct->entry->numNode, 4, 1); buf->read(&ct->entry->numLeaf, 4, 1); if(ct->entry->numNode) { ct->entry->node = new char[ct->entry->numNode * 16]; buf->read(ct->entry->node, 16, ct->entry->numNode); } else { ct->entry->node = NULL; } if(ct->entry->numLeaf) { ct->entry->leaf = new short[ct->entry->numLeaf]; buf->read(ct->entry->leaf, 2, ct->entry->numLeaf); } else { ct->entry->node = NULL; } } } else { s->ct = NULL; s->numCT = 0; } s->indexBuffer = new Face[s->numPrimitives]; buf->read(s->indexBuffer, sizeof(Face), s->numPrimitives); } asset->materials = new Material*[asset->numSurfaces]; // read the material stuff and load a material if we need it for(int i=0; i<asset->numSurfaces; i++) { char matName[64] = { 0 }; char techName[64] = { 0 }; char matFileName[78] = { 0 }; buf->readstr(matName, 50); buf->readstr(techName, 64); char* filename = matName; // asset is already in db... dont re-add it if (containsAsset(info, ASSET_TYPE_MATERIAL, matName) > 0) { asset->materials[i] = (Material*)getAsset(info, ASSET_TYPE_MATERIAL, matName); continue; } if(!strncmp("mc/", matName, 3)) filename = matName + 3; _snprintf(matFileName, sizeof(matFileName), "materials/%s.txt", filename); void* matBuf; int len = FS_ReadFile(matFileName, &matBuf); if(len > 0) { asset->materials[i] = (Material*)addMaterial(info, matName, (char*)matBuf, len); FS_FreeFile(matBuf); } else { asset->materials[i] = (Material*)DB_FindXAssetHeader(ASSET_TYPE_MATERIAL, matName); addMaterial(info, matName, (char*)asset->materials[i], 0); } addAsset(info, ASSET_TYPE_MATERIAL, matName, asset->materials[i]); } int test = 0; buf->read(&test, 4, 1); if(test) Com_Error(false, "Cause NTA said so!"); buf->read(&test, 4, 1); if(!test) Com_Error(false, "Cause NTA said so!"); asset->unknowns = new char[asset->numBones * 28]; buf->read(asset->unknowns, 28, asset->numBones); return asset; }
void DumpRawFiles() { if (Cmd_Argc() != 2) { return; } rawFileNames[0] = Cmd_Argv(1); currentRawFile = 1; for (int i = 0; i < currentRawFile; i++) { const char* name = rawFileNames[i]; memset(rawFileBuffer, 0, RAWFILE_BUFSIZE); if (LoadRawFile(name, rawFileBuffer, RAWFILE_BUFSIZE)) { char filename[512]; char dir[512]; size_t length = strlen(rawFileBuffer); sprintf(filename, "%s/%s", "maw", name); GetCurrentDirectoryA(sizeof(dir), dir); strcat(dir, "/"); strcat(dir, filename); *(strrchr(dir, '/')) = '\0'; size_t strl = strlen(dir); for (size_t i = 0; i < strl; i++) { if (dir[i] == '/') dir[i] = '\\'; } SHCreateDirectoryExA(NULL, dir, NULL); FILE* file = fopen(filename, "wb"); if (file) { fwrite(rawFileBuffer, 1, length, file); fclose(file); } } } currentRawFile = 0; return; for (int i = 0; i < currentSTable; i++) { const char* name = sTableNames[i]; stringTable_t* stringTable; if (stringTable = (stringTable_t*)DB_FindXAssetHeader(37, name)) { char filename[512]; char dir[512]; sprintf(filename, "%s/%s", "raw", name); GetCurrentDirectoryA(sizeof(dir), dir); strcat(dir, "/"); strcat(dir, filename); *(strrchr(dir, '/')) = '\0'; size_t strl = strlen(dir); for (size_t i = 0; i < strl; i++) { if (dir[i] == '/') dir[i] = '\\'; } SHCreateDirectoryExA(NULL, dir, NULL); FILE* file = fopen(filename, "w"); if (file) { int currentColumn = 0; int currentRow = 0; int total = stringTable->columns * stringTable->rows; for (int i = 0; i < total; i++) { char* current = stringTable->data[i * 2]; fprintf(file, "%s", current); bool isNext = ((i + 1) % stringTable->columns) == 0; if (isNext) { fprintf(file, "\n"); } else { fprintf(file, ","); } fflush(file); } fclose(file); } } } currentSTable = 0; }
void BG_PatchWeaponDef(char* weapon, AttachmentDef* attachment) { Com_Printf(0, "Patching weapon %s using %s\n", *(char**)weapon, attachment->name); for (int i = 0; i < attachment->numPatches; i++) { AttachmentPatch* patch = &attachment->patches[i]; weaponEntry_t* entry = FindWeaponEntry(patch->fieldName); if (!entry) { Com_Error(1, "Unknown weapon field %s in %s.", patch->fieldName, attachment->name); } assetType_t assetType; switch (entry->type) { case 0: // string { char** string = (char**)(weapon + entry->offset); if (patch->operation == APO_ADD) { *string = strdup(va("%s%s", *string, patch->string)); } else { if (strchr(patch->string, ' ')) { char* oldName = *(char**)(weapon + entry->offset); // TODO: needs to be changed to SL? *string = DoStringParse(oldName, patch); //char* newStr = DoStringParse(oldName, patch); //free(newStr); } else { *string = (char*)patch->string; // ?! } } break; } case 1: // char[1024] case 2: // char[64] case 3: // char[256] { if (strchr(patch->string, ' ')) { char* oldName = (char*)(weapon + entry->offset); // TODO: needs to be changed to SL? char* str = DoStringParse(oldName, patch); sprintf((char*)(weapon + entry->offset), "%s", str); free(str); } else { sprintf((char*)(weapon + entry->offset), "%s", patch->string); } break; } #define DO_NUM_PATCH(variable, source) if (patch->operation == APO_ADD) \ { \ variable += source; \ } else if (patch->operation == APO_MULTIPLY) { \ variable *= source; \ } else { \ variable = source; \ } #define GET_NUM(patch) ((patch->type == APT_FLOAT) ? patch->value : ((patch->type == APT_INTEGER) ? patch->integer : atof(patch->string))) case 4: case 5: // bool-as-int { //*(int*)(weapon + entry->offset) = patch->integer; int oldNum = *(int*)(weapon + entry->offset); DO_NUM_PATCH(oldNum, GET_NUM(patch)); *(int*)(weapon + entry->offset) = oldNum; break; } case 6: { *(bool*)(weapon + entry->offset) = patch->integer; break; } case 7: { float oldNum = *(float*)(weapon + entry->offset); DO_NUM_PATCH(oldNum, GET_NUM(patch)); *(float*)(weapon + entry->offset) = oldNum; break; } case 8: { float oldNum = *(float*)(weapon + entry->offset) / 17.6f; DO_NUM_PATCH(oldNum, GET_NUM(patch)); *(float*)(weapon + entry->offset) = oldNum * 17.6f; // miles/hour - inch/sec break; } case 9: { float oldNum = *(float*)(weapon + entry->offset) / 1000.f; DO_NUM_PATCH(oldNum, GET_NUM(patch)); *(float*)(weapon + entry->offset) = oldNum * 1000.f; break; } #define WEAPON_DO_ARRAY(arr, count) \ { \ for (int i = 0; i < (count); i++) { \ if (patch->type == APT_STRING && !_stricmp(*(char**)(arr + (i * 4)), patch->string)) { \ *(int*)(weapon + entry->offset) = i; \ } \ } \ } case 16: WEAPON_DO_ARRAY(0x795DA0, 4) break; case 17: WEAPON_DO_ARRAY(0x795DB0, 12) break; case 18: WEAPON_DO_ARRAY(0x795E68, 2) break; case 19: WEAPON_DO_ARRAY(0x795E10, 4) break; case 20: WEAPON_DO_ARRAY(0x795E20, 11) break; case 21: WEAPON_DO_ARRAY(0x795E70, 3) break; case 22: WEAPON_DO_ARRAY(0x795E4C, 7) break; case 23: WEAPON_DO_ARRAY(0x795E7C, 6) break; case 24: WEAPON_DO_ARRAY(0x7BE928, *(int*)0x7BDDDC) break; case 25: WEAPON_DO_ARRAY(0x795E94, 3) break; case 26: WEAPON_DO_ARRAY(0x795EA0, 4) break; case 28: WEAPON_DO_ARRAY(0x795EB0, 6) break; case 29: WEAPON_DO_ARRAY(0x795EC8, 3) break; case 30: WEAPON_DO_ARRAY(0x795DE0, 6) break; case 31: WEAPON_DO_ARRAY(0x795DF8, 6) break; case 32: WEAPON_DO_ARRAY(0x795ED4, 7) break; case 33: WEAPON_DO_ARRAY(0x795EF0, 3) break; case 34: WEAPON_DO_ARRAY(0x795EF0, 3) // same as 33 break; case 35: WEAPON_DO_ARRAY(0x795EF0, 3) // same as 33 break; case 36: WEAPON_DO_ARRAY(0x795EF0, 3) // same as 33 break; case 37: WEAPON_DO_ARRAY(0x795EF0, 3) // same as 33 break; /*case 13: // phys collmap break;*/ case 10: // fx assetType = ASSET_TYPE_FX; goto loadThingAsset; case 11: // xmodel assetType = ASSET_TYPE_XMODEL; goto loadThingAsset; case 12: // material assetType = ASSET_TYPE_MATERIAL; goto loadThingAsset; case 14: // soundalias assetType = ASSET_TYPE_SOUND; goto loadThingAsset; case 15: // tracer assetType = ASSET_TYPE_TRACER; loadThingAsset: { if (strchr(patch->string, ' ')) { char* oldName = **(char***)(weapon + entry->offset); char* newStr = DoStringParse(oldName, patch); // and get the asset/free the string *(void**)(weapon + entry->offset) = DB_FindXAssetHeader(assetType, newStr); free(newStr); } else { *(void**)(weapon + entry->offset) = DB_FindXAssetHeader(assetType, patch->string); } break; } /*case 38: // hideTags { // hopefully we'll have useful shit here, as if we don't, we're screwed // for some reason this code made me go deja vu - seems like I've done SL_ConvertToString before. short* tags = (short*)data; for (int i = 0; i < 32; i++) { short tag = tags[i]; if (tag) { fprintf(file, "%s%s", SL_ConvertToString(tag), (i == 31 || tags[i + 1] == 0) ? "" : "\n"); // it seems like a newline is needed for all but the last tag } } break; } case 27: // bounceSound; surface sound { char*** dat = *(char****)data; if (dat != 0) { char bounceName[128]; strcpy(bounceName, **dat); strrchr(bounceName, '_')[0] = '\0'; fprintf(file, "%s", bounceName); } break; }*/ default: Com_Error(1, "Unhandled weapon field type %i in %s\n", entry->type, entry->name); break; } } }