/**
* @brief Loads in a model for the given name
* @param[in] filename Filename relative to base dir and with extension (models/model.md2)
* @param[inout] mod Structure to initialize
* @return True if the loading was succeed. True or false structure mod was edited.
*/
static bool R_LoadModel (model_t *mod, const char *filename)
{
byte *buf;
int modfilelen;
char animname[MAX_QPATH];
if (filename[0] == '\0')
Com_Error(ERR_FATAL, "R_ModForName: NULL name");
/* load the file */
modfilelen = FS_LoadFile(filename, &buf);
if (!buf)
return false;
OBJZERO(*mod);
Q_strncpyz(mod->name, filename, sizeof(mod->name));
/* call the appropriate loader */
switch (LittleLong(*(unsigned *) buf)) {
case IDALIASHEADER:
/* MD2 header */
R_ModLoadAliasMD2Model(mod, buf, modfilelen, true);
break;
case DPMHEADER:
R_ModLoadAliasDPMModel(mod, buf, modfilelen);
break;
case IDMD3HEADER:
/* MD3 header */
R_ModLoadAliasMD3Model(mod, buf, modfilelen);
break;
case IDBSPHEADER:
Com_Error(ERR_FATAL, "R_ModForName: don't load BSPs with this function");
break;
default:
{
const char* ext = Com_GetExtension(filename);
if (ext != NULL && !Q_strcasecmp(ext, "obj"))
R_LoadObjModel(mod, buf, modfilelen);
else
Com_Error(ERR_FATAL, "R_ModForName: unknown fileid for %s", mod->name);
}
}
/* load the animations */
Com_StripExtension(mod->name, animname, sizeof(animname));
Com_DefaultExtension(animname, sizeof(animname), ".anm");
/* try to load the animation file */
if (FS_CheckFile("%s", animname) != -1) {
R_ModLoadAnims(&mod->alias, animname);
}
FS_FreeFile(buf);
return true;
}
int main (int argc, char **argv)
{
char bspFilename[MAX_OSPATH];
if (argc < 2) {
Usage();
}
com_genericPool = Mem_CreatePool("slicer");
com_fileSysPool = Mem_CreatePool("slicer filesys");
Swap_Init();
Mem_Init();
SL_Parameter(argc, argv);
Com_StripExtension(config.filename, bspFilename, sizeof(bspFilename));
Com_DefaultExtension(bspFilename, sizeof(bspFilename), ".bsp");
FS_InitFilesystem(false);
SL_BSPSlice(LoadBSPFile(bspFilename), config.thickness, config.scale, config.singleContour, config.multipleContour);
Mem_Shutdown();
return EXIT_SUCCESS;
}
/**
* @brief Write the config file to a specific name
*/
static void Com_WriteConfig_f (void)
{
char filename[MAX_QPATH];
if (Cmd_Argc() != 2) {
Com_Printf("Usage: %s <filename>\n", Cmd_Argv(0));
return;
}
Q_strncpyz(filename, Cmd_Argv(1), sizeof(filename));
Com_DefaultExtension(filename, sizeof(filename), ".cfg");
Com_WriteConfigToFile(filename);
}
/*
=================
S_CodecOpenStream
=================
*/
snd_stream_t *S_CodecOpenStream(const char *filename)
{
snd_codec_t *codec;
char fn[MAX_QPATH];
codec = S_FindCodecForFile(filename);
if(!codec)
{
Com_Printf("Unknown extension for %s\n", filename);
return NULL;
}
strncpy(fn, filename, sizeof(fn));
Com_DefaultExtension(fn, sizeof(fn), codec->ext);
return codec->open(fn);
}
/*
=================
S_CodecLoad
=================
*/
void *S_CodecLoad(const char *filename, snd_info_t * info)
{
snd_codec_t *codec;
char fn[MAX_QPATH];
codec = S_FindCodecForFile(filename);
if(!codec)
{
Com_Printf("Unknown extension for %s\n", filename);
return NULL;
}
strncpy(fn, filename, sizeof(fn));
Com_DefaultExtension(fn, sizeof(fn), codec->ext);
return codec->load(fn, info);
}
/*
=================
S_FindCodecForFile
Select an appropriate codec for a file based on its extension
=================
*/
static snd_codec_t *S_FindCodecForFile(const char *filename)
{
char *ext = S_FileExtension(filename);
snd_codec_t *codec = codecs;
if(!ext)
{
// No extension - auto-detect
while(codec)
{
char fn[MAX_QPATH];
// there is no extension so we do not need to subtract 4 chars
Q_strncpyz(fn, filename, MAX_QPATH);
Com_DefaultExtension(fn, MAX_QPATH, codec->ext);
// Check it exists
if(FS_ReadFile(fn, NULL) != -1)
return codec;
// Nope. Next!
codec = codec->next;
}
// Nothin'
return NULL;
}
while(codec)
{
if(!Q_stricmp(ext, codec->ext))
return codec;
codec = codec->next;
}
return NULL;
}
/**
* @brief Tries to load a mdx file that contains the normals and the tangents for a model.
* @sa R_ModCalcNormalsAndTangents
* @sa R_ModCalcUniqueNormalsAndTangents
* @param mod The model to load the mdx file for
*/
qboolean R_ModLoadMDX (model_t *mod)
{
int i;
for (i = 0; i < mod->alias.num_meshes; i++) {
mAliasMesh_t *mesh = &mod->alias.meshes[i];
char mdxFileName[MAX_QPATH];
byte *buffer = NULL, *buf;
const int32_t *intbuf;
uint32_t version;
int sharedTris[MAX_ALIAS_VERTS];
Com_StripExtension(mod->name, mdxFileName, sizeof(mdxFileName));
Com_DefaultExtension(mdxFileName, sizeof(mdxFileName), ".mdx");
if (FS_LoadFile(mdxFileName, &buffer) == -1)
return qfalse;
buf = buffer;
if (strncmp((const char *) buf, IDMDXHEADER, strlen(IDMDXHEADER)))
Com_Error(ERR_DROP, "No mdx file buffer given");
buffer += strlen(IDMDXHEADER) * sizeof(char);
version = LittleLong(*(uint32_t*) buffer);
if (version != MDX_VERSION)
Com_Error(ERR_DROP, "Invalid version of the mdx file, expected %i, found %i",
MDX_VERSION, version);
buffer += sizeof(uint32_t);
intbuf = (const int32_t *) buffer;
mesh->num_verts = LittleLong(*intbuf);
if (mesh->num_verts <= 0 || mesh->num_verts > MAX_ALIAS_VERTS)
Com_Error(ERR_DROP, "mdx file for %s has to many (or no) vertices: %i", mod->name, mesh->num_verts);
intbuf++;
mesh->num_indexes = LittleLong(*intbuf);
intbuf++;
mesh->indexes = (int32_t *)Mem_PoolAlloc(sizeof(int32_t) * mesh->num_indexes, vid_modelPool, 0);
mesh->revIndexes = (mIndexList_t *)Mem_PoolAlloc(sizeof(mIndexList_t) * mesh->num_verts, vid_modelPool, 0);
mesh->vertexes = (mAliasVertex_t *)Mem_PoolAlloc(sizeof(mAliasVertex_t) * mod->alias.num_frames * mesh->num_verts, vid_modelPool, 0);
/* load index that maps triangle verts to Vertex objects */
for (i = 0; i < mesh->num_indexes; i++) {
mesh->indexes[i] = LittleLong(*intbuf);
intbuf++;
}
for (i = 0; i < mesh->num_verts; i++)
sharedTris[i] = 0;
/* set up reverse-index that maps Vertex objects to a list of triangle verts */
for (i = 0; i < mesh->num_indexes; i++)
sharedTris[mesh->indexes[i]]++;
for (i = 0; i < mesh->num_verts; i++) {
mesh->revIndexes[i].length = 0;
mesh->revIndexes[i].list = (int32_t *)Mem_PoolAlloc(sizeof(int32_t) * sharedTris[i], vid_modelPool, 0);
}
for (i = 0; i < mesh->num_indexes; i++)
mesh->revIndexes[mesh->indexes[i]].list[mesh->revIndexes[mesh->indexes[i]].length++] = i;
FS_FreeFile(buf);
}
return qtrue;
}
void SP_target_speaker(gentity_t * ent)
{
char buffer[MAX_QPATH];
char *s;
if(G_SpawnString("s_sound", "NOSOUND", &s))
{
G_SpawnBoolean("s_looping", "0", &ent->soundLooping);
G_SpawnBoolean("s_waitfortrigger", "0", &ent->soundWaitForTrigger);
G_SpawnBoolean("s_global", "0", &ent->soundGlobal);
G_SpawnBoolean("s_activator", "0", &ent->soundActivator);
G_SpawnFloat("wait", "0", &ent->wait);
G_SpawnFloat("random", "0", &ent->random);
}
else if(G_SpawnString("s_shader", "NOSOUND", &s))
{
// Doom3 compatibility mode
G_SpawnBoolean("s_looping", "0", &ent->soundLooping);
G_SpawnBoolean("s_waitfortrigger", "0", &ent->soundWaitForTrigger);
G_SpawnBoolean("s_global", "0", &ent->soundGlobal);
G_SpawnBoolean("s_activator", "0", &ent->soundActivator);
G_SpawnFloat("wait", "0", &ent->wait);
G_SpawnFloat("random", "0", &ent->random);
}
else if(G_SpawnString("noise", "NOSOUND", &s))
{
// Q3A compatibility mode
ent->soundLooping = ent->spawnflags & 1 ? qtrue : qfalse;
ent->soundWaitForTrigger = ent->spawnflags & 2 ? qtrue : qfalse;
ent->soundGlobal = ent->spawnflags & 4 ? qtrue : qfalse;
ent->soundActivator = ent->spawnflags & 8 ? qtrue : qfalse;
}
else
{
//G_Error("speaker without a noise key at %s", vtos(ent->s.origin));
G_Printf(S_COLOR_YELLOW "WARNING: speaker '%s' without a noise key at %s", ent->name, vtos(ent->s.origin));
}
// force all client reletive sounds to be "activator" speakers that
// play on the entity that activates it
if(s[0] == '*')
{
ent->soundActivator = qtrue;
}
Q_strncpyz(buffer, s, sizeof(buffer));
Com_DefaultExtension(buffer, sizeof(buffer), ".wav");
ent->soundIndex = G_SoundIndex(buffer);
// a repeating speaker can be done completely client side
ent->s.eType = ET_SPEAKER;
ent->s.eventParm = ent->soundIndex;
ent->s.frame = ent->wait * 10;
ent->s.clientNum = ent->random * 10;
// check for prestarted looping sound
if(ent->soundLooping && !ent->soundWaitForTrigger)
{
ent->s.loopSound = ent->soundIndex;
}
ent->use = Use_Target_Speaker;
if(ent->soundGlobal)
{
ent->r.svFlags |= SVF_BROADCAST;
}
VectorCopy(ent->s.origin, ent->s.pos.trBase);
// must link the entity so we get areas and clusters so
// the server can determine who to send updates to
trap_LinkEntity(ent);
}
