models.c File Reference

#include "shared/shared.h"
#include "shared/list.h"
#include "common/common.h"
#include "common/files.h"
#include "system/hunk.h"
#include "format/md2.h"
#include "format/sp2.h"
#include "refresh/images.h"
#include "refresh/models.h"

Go to the source code of this file.

Macros
#define	MAX_RMODELS   (MAX_MODELS * 2)

Functions
static model_t *	MOD_Alloc (void)
static model_t *	MOD_Find (const char *name)
static void	MOD_List_f (void)
void	MOD_FreeUnused (void)
void	MOD_FreeAll (void)
qerror_t	MOD_ValidateMD2 (dmd2header_t *header, size_t length)
static model_class_t	get_model_class (const char *name)
static qerror_t	MOD_LoadSP2 (model_t *model, const void *rawdata, size_t length)
qhandle_t	R_RegisterModel (const char *name)
model_t *	MOD_ForHandle (qhandle_t h)
void	MOD_Init (void)
void	MOD_Shutdown (void)

Variables
model_t	r_models [MAX_RMODELS]
int	r_numModels
cvar_t *	vid_rtx

Macro Definition Documentation

MAX_RMODELS

#define MAX_RMODELS   (MAX_MODELS * 2)

Definition at line 37 of file models.c.

Function Documentation

get_model_class()

static model_class_t get_model_class ( const char *  name )

static

Definition at line 209 of file models.c.

{
    if (!strcmp(name, "models/objects/explode/tris.md2"))
        return MCLASS_EXPLOSION;
    else if (!strcmp(name, "models/objects/r_explode/tris.md2"))
        return MCLASS_EXPLOSION;
    else if (!strcmp(name, "models/objects/flash/tris.md2"))
        return MCLASS_SMOKE;
    else if (!strcmp(name, "models/objects/smoke/tris.md2"))
        return MCLASS_SMOKE;
    else if (!strcmp(name, "models/objects/minelite/light2/tris.md2"))
        return MCLASS_STATIC_LIGHT;
    else if (!strcmp(name, "models/objects/flare/tris.md2"))
        return MCLASS_FLARE;
    else
        return MCLASS_REGULAR;
}

Referenced by R_RegisterModel().

MOD_Alloc()

static model_t* MOD_Alloc ( void  )

static

Definition at line 44 of file models.c.

{
    model_t *model;
    int i;
 
    for (i = 0, model = r_models; i < r_numModels; i++, model++) {
        if (!model->type) {
            break;
        }
    }
 
    if (i == r_numModels) {
        if (r_numModels == MAX_RMODELS) {
            return NULL;
        }
        r_numModels++;
    }
 
    return model;
}

Referenced by R_RegisterModel().

MOD_Find()

static model_t* MOD_Find ( const char *  name )

static

Definition at line 65 of file models.c.

{
    model_t *model;
    int i;
 
    for (i = 0, model = r_models; i < r_numModels; i++, model++) {
        if (!model->type) {
            continue;
        }
        if (!FS_pathcmp(model->name, name)) {
            return model;
        }
    }
 
    return NULL;
}

Referenced by R_RegisterModel().

MOD_ForHandle()

model_t* MOD_ForHandle

(

qhandle_t

h

)

Definition at line 430 of file models.c.

{
    model_t *model;
 
    if (!h) {
        return NULL;
    }
 
    if (h < 0 || h > r_numModels) {
        Com_Error(ERR_DROP, "%s: %d out of range", __func__, h);
    }
 
    model = &r_models[h - 1];
    if (!model->type) {
        return NULL;
    }
 
    return model;
}

Referenced by CL_AddPacketEntities(), CL_AddViewWeapon(), CL_PlainExplosion(), CL_RegisterTEntModels(), GL_DrawEntities(), prepare_entities(), R_DrawEntities(), update_transparency(), and write_sprite_geometry().

MOD_FreeAll()

void MOD_FreeAll

(

void

)

Definition at line 125 of file models.c.

{
    model_t *model;
    int i;
 
    for (i = 0, model = r_models; i < r_numModels; i++, model++) {
        if (!model->type) {
            continue;
        }
 
        Hunk_Free(&model->hunk);
        memset(model, 0, sizeof(*model));
    }
 
    r_numModels = 0;
}

Referenced by MOD_Shutdown().

MOD_FreeUnused()

void MOD_FreeUnused

(

void

)

Definition at line 105 of file models.c.

{
    model_t *model;
    int i;
 
    for (i = 0, model = r_models; i < r_numModels; i++, model++) {
        if (!model->type) {
            continue;
        }
        if (model->registration_sequence == registration_sequence) {
            // make sure it is paged in
            Com_PageInMemory(model->hunk.base, model->hunk.cursize);
        } else {
            // don't need this model
            Hunk_Free(&model->hunk);
            memset(model, 0, sizeof(*model));
        }
    }
}

Referenced by R_EndRegistration(), R_EndRegistration_GL(), and R_EndRegistration_RTX().

MOD_Init()

void MOD_Init

(

void

)

Definition at line 450 of file models.c.

{
    if (r_numModels) {
        Com_Error(ERR_FATAL, "%s: %d models not freed", __func__, r_numModels);
    }
 
    Cmd_AddCommand("modellist", MOD_List_f);
}

Referenced by GL_PostInit(), R_Init(), and R_Init_RTX().

MOD_List_f()

static void MOD_List_f ( void  )

static

Definition at line 82 of file models.c.

{
    static const char types[4] = "FASE";
    int     i, count;
    model_t *model;
    size_t  bytes;
 
    Com_Printf("------------------\n");
    bytes = count = 0;
 
    for (i = 0, model = r_models; i < r_numModels; i++, model++) {
        if (!model->type) {
            continue;
        }
        Com_Printf("%c %8"PRIz" : %s\n", types[model->type],
                   model->hunk.mapped, model->name);
        bytes += model->hunk.mapped;
        count++;
    }
    Com_Printf("Total models: %d (out of %d slots)\n", count, r_numModels);
    Com_Printf("Total resident: %"PRIz"\n", bytes);
}

Referenced by MOD_Init().

MOD_LoadSP2()

static qerror_t MOD_LoadSP2 ( model_t *  model, const void *  rawdata, size_t  length  )

static

Definition at line 227 of file models.c.

{
    dsp2header_t header;
    dsp2frame_t *src_frame;
    mspriteframe_t *dst_frame;
    unsigned w, h, x, y;
    char buffer[SP2_MAX_FRAMENAME];
    int i;
 
    if (length < sizeof(header))
        return Q_ERR_FILE_TOO_SMALL;
 
    // byte swap the header
    header = *(dsp2header_t *)rawdata;
    for (i = 0; i < sizeof(header) / 4; i++) {
        ((uint32_t *)&header)[i] = LittleLong(((uint32_t *)&header)[i]);
    }
 
    if (header.ident != SP2_IDENT)
        return Q_ERR_UNKNOWN_FORMAT;
    if (header.version != SP2_VERSION)
        return Q_ERR_UNKNOWN_FORMAT;
    if (header.numframes < 1) {
        // empty models draw nothing
        model->type = MOD_EMPTY;
        return Q_ERR_SUCCESS;
    }
    if (header.numframes > SP2_MAX_FRAMES)
        return Q_ERR_TOO_MANY;
    if (sizeof(dsp2header_t) + sizeof(dsp2frame_t) * header.numframes > length)
        return Q_ERR_BAD_EXTENT;
 
    Hunk_Begin(&model->hunk, 0x10000);
    model->type = MOD_SPRITE;
 
    model->spriteframes = MOD_Malloc(sizeof(mspriteframe_t) * header.numframes);
    model->numframes = header.numframes;
 
    src_frame = (dsp2frame_t *)((byte *)rawdata + sizeof(dsp2header_t));
    dst_frame = model->spriteframes;
    for (i = 0; i < header.numframes; i++) {
        w = LittleLong(src_frame->width);
        h = LittleLong(src_frame->height);
        if (w < 1 || h < 1 || w > MAX_TEXTURE_SIZE || h > MAX_TEXTURE_SIZE) {
            Com_WPrintf("%s has bad frame dimensions\n", model->name);
            w = 1;
            h = 1;
        }
        dst_frame->width = w;
        dst_frame->height = h;
 
        // FIXME: are these signed?
        x = LittleLong(src_frame->origin_x);
        y = LittleLong(src_frame->origin_y);
        if (x > 8192 || y > 8192) {
            Com_WPrintf("%s has bad frame origin\n", model->name);
            x = y = 0;
        }
        dst_frame->origin_x = x;
        dst_frame->origin_y = y;
 
        if (!Q_memccpy(buffer, src_frame->name, 0, sizeof(buffer))) {
            Com_WPrintf("%s has bad frame name\n", model->name);
            dst_frame->image = R_NOTEXTURE;
        } else {
            FS_NormalizePath(buffer, buffer);
            dst_frame->image = IMG_Find(buffer, IT_SPRITE, IF_SRGB);
        }
 
        src_frame++;
        dst_frame++;
    }
 
    Hunk_End(&model->hunk);
 
    return Q_ERR_SUCCESS;
}

Referenced by R_RegisterModel().

MOD_Shutdown()

void MOD_Shutdown

(

void

)

Definition at line 459 of file models.c.

{
    MOD_FreeAll();
    Cmd_RemoveCommand("modellist");
}

Referenced by R_Shutdown(), R_Shutdown_GL(), and R_Shutdown_RTX().

MOD_ValidateMD2()

qerror_t MOD_ValidateMD2	(	dmd2header_t *	header,
		size_t	length
	)

Definition at line 142 of file models.c.

{
    size_t end;
 
    // check ident and version
    if (header->ident != MD2_IDENT)
        return Q_ERR_UNKNOWN_FORMAT;
    if (header->version != MD2_VERSION)
        return Q_ERR_UNKNOWN_FORMAT;
 
    // check triangles
    if (header->num_tris < 1)
        return Q_ERR_TOO_FEW;
    if (header->num_tris > MD2_MAX_TRIANGLES)
        return Q_ERR_TOO_MANY;
 
    end = header->ofs_tris + sizeof(dmd2triangle_t) * header->num_tris;
    if (header->ofs_tris < sizeof(header) || end < header->ofs_tris || end > length)
        return Q_ERR_BAD_EXTENT;
 
    // check st
    if (header->num_st < 3)
        return Q_ERR_TOO_FEW;
    if (header->num_st > MAX_ALIAS_VERTS)
        return Q_ERR_TOO_MANY;
 
    end = header->ofs_st + sizeof(dmd2stvert_t) * header->num_st;
    if (header->ofs_st < sizeof(header) || end < header->ofs_st || end > length)
        return Q_ERR_BAD_EXTENT;
 
    // check xyz and frames
    if (header->num_xyz < 3)
        return Q_ERR_TOO_FEW;
    if (header->num_xyz > MAX_ALIAS_VERTS)
        return Q_ERR_TOO_MANY;
    if (header->num_frames < 1)
        return Q_ERR_TOO_FEW;
    if (header->num_frames > MD2_MAX_FRAMES)
        return Q_ERR_TOO_MANY;
 
    end = sizeof(dmd2frame_t) + (header->num_xyz - 1) * sizeof(dmd2trivertx_t);
    if (header->framesize < end || header->framesize > MD2_MAX_FRAMESIZE)
        return Q_ERR_BAD_EXTENT;
 
    end = header->ofs_frames + (size_t)header->framesize * header->num_frames;
    if (header->ofs_frames < sizeof(header) || end < header->ofs_frames || end > length)
        return Q_ERR_BAD_EXTENT;
 
    // check skins
    if (header->num_skins) {
        if (header->num_skins > MAX_ALIAS_SKINS)
            return Q_ERR_TOO_MANY;
 
        end = header->ofs_skins + (size_t)MD2_MAX_SKINNAME * header->num_skins;
        if (header->ofs_skins < sizeof(header) || end < header->ofs_skins || end > length)
            return Q_ERR_BAD_EXTENT;
    }
 
    if (header->skinwidth < 1 || header->skinwidth > MD2_MAX_SKINWIDTH)
        return Q_ERR_INVALID_FORMAT;
    if (header->skinheight < 1 || header->skinheight > MD2_MAX_SKINHEIGHT)
        return Q_ERR_INVALID_FORMAT;
 
    return Q_ERR_SUCCESS;
}

Referenced by MOD_LoadMD2(), MOD_LoadMD2_GL(), and MOD_LoadMD2_RTX().

R_RegisterModel()

qhandle_t R_RegisterModel

(

const char *

name

)

Definition at line 305 of file models.c.

{
    char normalized[MAX_QPATH];
    qhandle_t index;
    size_t namelen;
    ssize_t filelen;
    model_t *model;
    byte *rawdata = NULL;
    uint32_t ident;
    mod_load_t load;
    qerror_t ret;
 
    // empty names are legal, silently ignore them
    if (!*name)
        return 0;
 
    if (*name == '*') {
        // inline bsp model
        index = atoi(name + 1);
        return ~index;
    }
 
    // normalize the path
    namelen = FS_NormalizePathBuffer(normalized, name, MAX_QPATH);
 
    // this should never happen
    if (namelen >= MAX_QPATH)
        Com_Error(ERR_DROP, "%s: oversize name", __func__);
 
    // normalized to empty name?
    if (namelen == 0) {
        Com_DPrintf("%s: empty name\n", __func__);
        return 0;
    }
 
    // see if it's already loaded
    model = MOD_Find(normalized);
    if (model) {
        MOD_Reference(model);
        goto done;
    }
 
    char* extension = normalized + namelen - 4;
    if (namelen > 4 && (strcmp(extension, ".md2") == 0) && vid_rtx->integer)
    {
        memcpy(extension, ".md3", 4);
 
        filelen = FS_LoadFile(normalized, (void **)&rawdata);
 
        memcpy(extension, ".md2", 4);
    }
 
    if (!rawdata)
    {
        filelen = FS_LoadFile(normalized, (void **)&rawdata);
        if (!rawdata) {
            // don't spam about missing models
            if (filelen == Q_ERR_NOENT) {
                return 0;
            }
 
            ret = filelen;
            goto fail1;
        }
    }
 
    if (filelen < 4) {
        ret = Q_ERR_FILE_TOO_SMALL;
        goto fail2;
    }
 
    // check ident
    ident = LittleLong(*(uint32_t *)rawdata);
    switch (ident) {
    case MD2_IDENT:
        load = MOD_LoadMD2;
        break;
#if USE_MD3
    case MD3_IDENT:
        load = MOD_LoadMD3;
        break;
#endif
    case SP2_IDENT:
        load = MOD_LoadSP2;
        break;
    default:
        ret = Q_ERR_UNKNOWN_FORMAT;
        goto fail2;
    }
 
    model = MOD_Alloc();
    if (!model) {
        ret = Q_ERR_OUT_OF_SLOTS;
        goto fail2;
    }
 
    memcpy(model->name, normalized, namelen + 1);
    model->registration_sequence = registration_sequence;
 
    ret = load(model, rawdata, filelen);
 
    FS_FreeFile(rawdata);
 
    if (ret) {
        memset(model, 0, sizeof(*model));
        goto fail1;
    }
 
    model->model_class = get_model_class(model->name);
 
done:
    index = (model - r_models) + 1;
#if USE_REF == REF_VKPT
    extern int register_model_dirty;
    register_model_dirty = 1;
#endif
    return index;
 
fail2:
    FS_FreeFile(rawdata);
fail1:
    Com_EPrintf("Couldn't load %s: %s\n", normalized, Q_ErrorString(ret));
    return 0;
}

Referenced by CL_LoadClientinfo(), CL_PrepRefresh(), CL_RegisterTEntModels(), CL_UpdateConfigstring(), LOC_AddLocationsToScene(), ReloadMedia(), and V_Gun_Model_f().

Variable Documentation

r_models

model_t r_models[MAX_RMODELS]

Definition at line 39 of file models.c.

Referenced by MOD_Alloc(), MOD_Find(), MOD_ForHandle(), MOD_FreeAll(), MOD_FreeUnused(), MOD_List_f(), R_RegisterModel(), and vkpt_vertex_buffer_upload_models_to_staging().

r_numModels

int r_numModels

Definition at line 40 of file models.c.

Referenced by MOD_Alloc(), MOD_Find(), MOD_ForHandle(), MOD_FreeAll(), MOD_FreeUnused(), MOD_Init(), and MOD_List_f().

vid_rtx

cvar_t* vid_rtx

Definition at line 30 of file refresh.c.

Referenced by CL_AddExplosions(), CL_AddPacketEntities(), CL_AddViewWeapon(), CL_InitRefresh(), CL_MuzzleFlash(), CL_PrepRefresh(), R_RegisterModel(), and SCR_DrawFPS().