int addAsset(zoneInfo_t* info, int type, const char* name, void* data)
{
if(info->assetCount >= MAX_ASSET_COUNT) Com_Error(true, "Tell Apadayo to increase MAX_ASSET_COUNT!");
int a = containsAsset(info, type, name);
if(a >= 0) return a;
// force data to have correct name
const char* assetName = getAssetName(type, data);
if (strcmp(assetName, name))
{
setAssetName(type, data, name);
}
info->assets[info->assetCount].name = R_HashString(name);
info->assets[info->assetCount].type = type;
info->assets[info->assetCount].data = data;
#if ZB_DEBUG
info->assets[info->assetCount].debugName = name;
info->assets[info->assetCount].verified = false;
#endif
return info->assetCount++;
}
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 addMaterial(zoneInfo_t* info, const char* name, char* data, size_t dataLen)
{
if(parseMatFile(data, dataLen) < 0) return;
// load up the techset
char techsetfname [128];
_snprintf(techsetfname, 128, "techsets/%s.techset", techsetName);
loadAsset(info, ASSET_TYPE_TECHSET, techsetfname, techsetName);
int asset = addAsset(info, ASSET_TYPE_MATERIAL, name, NULL, 0);
BUFFER* buf = new BUFFER(4096);
Material* mat = new Material;
memset(mat, 0, sizeof(Material));
mat->name = (char*)0xFFFFFFFF;
if(materialUsage == MATERIAL_USAGE_UI)
{
mat->flags = 0x2F;
mat->animationX = 1;
mat->animationY = 1;
mat->unknown2 = 0xFFFFFFFF;
mat->unknown3 = 0xFFFFFF00;
memset(mat->unknown4, 0xFF, sizeof(mat->unknown4));
mat->numMaps = materialMapCount;
mat->stateMapCount = 1;
mat->unknown6 = 3;
mat->unknown7 = 4;
}
// null dem pointers!
mat->techniqueSet = (MaterialTechniqueSet*)0x0;//0xFFFFFFFF;
mat->maps = (MaterialTextureDef*)0xFFFFFFFF;
mat->stateMap = (void*)0xFFFFFFFF;
buf->write(mat, sizeof(Material), 1);
buf->write((void*)name, strlen(name) + 1, 1);
// techset
int assetPatchTo = containsAsset(info, ASSET_TYPE_TECHSET, techsetName);
addFixup(info, asset, 80, assetPatchTo);
// maps
for(int i=0; i<materialMapCount; i++)
{
MaterialTextureDef* tex = new MaterialTextureDef;
memset(tex, 0, sizeof(MaterialTextureDef));
tex->firstCharacter = materialMaps[i][0];
tex->secondLastCharacter = materialMaps[i][strlen(materialMaps[i])];
tex->typeHash = R_HashString(materialMaps[i]);
tex->image = (GfxImage*)0xFFFFFFFF;
tex->textureType = 0xE2;
buf->write(tex, sizeof(MaterialTextureDef), 1);
GfxImage* img = new GfxImage;
memset(img, 0, sizeof(GfxImage));
img->depth = 1;
img->textureType = 3; // 2d texture
img->textureType2 = 3;
img->texture = (GfxImageLoadDef*)0xFFFFFFFF;
img->name = (char*)0xFFFFFFFF;
img->width = iwiHeaders[i].xsize;
img->height = iwiHeaders[i].ysize;
buf->write(img, sizeof(GfxImage), 1);
buf->write((void*)materialTextureNames[i], strlen(materialTextureNames[i]) + 1, 1);
GfxImageLoadDef * def = new GfxImageLoadDef;
memset(def, 0, sizeof(GfxImageLoadDef));
int format = 0;
switch(iwiHeaders[i].format)
{
case IWI_ARGB:
format = 21;
break;
case IWI_RGB8:
format = 20;
break;
case IWI_DXT1:
format = 0x31545844;
break;
case IWI_DXT3:
format = 0x33545844;
break;
case IWI_DXT5:
format = 0x35545844;
break;
}
def->format = format;
def->mipLevels = 1;
buf->write(def, sizeof(GfxImageLoadDef), 1);
}
// unknown 8 goes here whenever we use it
// statemap
if(materialUsage == MATERIAL_USAGE_UI)
{
char statemap[] = {0x65, 0x51, 0x12, 0x18, 0x02, 0x00, 0x0E, 0xE0 };
buf->write(statemap, 8, 1);
}
buf->resize(-1);
// fix the data
setAssetData(info, asset, buf->data(), buf->getsize());
}
