Ejemplo n.º 1
0
/*
=================
R_LoadIQM

Load an IQM model and compute the joint matrices for every frame.
=================
*/
qboolean R_LoadIQM(model_t* mod, void* buffer, int filesize, const char* mod_name) {
    iqmHeader_t*     header;
    iqmVertexArray_t*    vertexarray;
    iqmTriangle_t*       triangle;
    iqmMesh_t*       mesh;
    iqmJoint_t*      joint;
    iqmPose_t*       pose;
    iqmBounds_t*     bounds;
    unsigned short*      framedata;
    char*            str;
    int         i, j;
    float           jointMats[IQM_MAX_JOINTS * 2 * 12];
    float*           mat;
    size_t          size, joint_names;
    iqmData_t*       iqmData;
    srfIQModel_t*        surface;

    if (filesize < sizeof(iqmHeader_t)) {
        return qfalse;
    }

    header = (iqmHeader_t*)buffer;
    if (Q_strncmp(header->magic, IQM_MAGIC, sizeof(header->magic))) {
        return qfalse;
    }

    LL(header->version);
    if (header->version != IQM_VERSION) {
        ri.Printf(PRINT_WARNING, "R_LoadIQM: %s is a unsupported IQM version (%d), only version %d is supported.\n",
                  mod_name, header->version, IQM_VERSION);
        return qfalse;
    }

    LL(header->filesize);
    if (header->filesize > filesize || header->filesize > 16 << 20) {
        return qfalse;
    }

    LL(header->flags);
    LL(header->num_text);
    LL(header->ofs_text);
    LL(header->num_meshes);
    LL(header->ofs_meshes);
    LL(header->num_vertexarrays);
    LL(header->num_vertexes);
    LL(header->ofs_vertexarrays);
    LL(header->num_triangles);
    LL(header->ofs_triangles);
    LL(header->ofs_adjacency);
    LL(header->num_joints);
    LL(header->ofs_joints);
    LL(header->num_poses);
    LL(header->ofs_poses);
    LL(header->num_anims);
    LL(header->ofs_anims);
    LL(header->num_frames);
    LL(header->num_framechannels);
    LL(header->ofs_frames);
    LL(header->ofs_bounds);
    LL(header->num_comment);
    LL(header->ofs_comment);
    LL(header->num_extensions);
    LL(header->ofs_extensions);

    // check ioq3 joint limit
    if (header->num_joints > IQM_MAX_JOINTS) {
        ri.Printf(PRINT_WARNING, "R_LoadIQM: %s has more than %d joints (%d).\n",
                  mod_name, IQM_MAX_JOINTS, header->num_joints);
        return qfalse;
    }

    // check and swap vertex arrays
    if (IQM_CheckRange(header, header->ofs_vertexarrays,
                       header->num_vertexarrays,
                       sizeof(iqmVertexArray_t))) {
        return qfalse;
    }
    vertexarray = (iqmVertexArray_t*)((byte*)header + header->ofs_vertexarrays);
    for (i = 0; i < header->num_vertexarrays; i++, vertexarray++) {
        int j, n, *intPtr;

        if (vertexarray->size <= 0 || vertexarray->size > 4) {
            return qfalse;
        }

        // total number of values
        n = header->num_vertexes * vertexarray->size;

        switch (vertexarray->format) {
            case IQM_BYTE:
            case IQM_UBYTE:
                // 1 byte, no swapping necessary
                if (IQM_CheckRange(header, vertexarray->offset,
                                   n, sizeof(byte))) {
                    return qfalse;
                }
                break;
            case IQM_INT:
            case IQM_UINT:
            case IQM_FLOAT:
                // 4-byte swap
                if (IQM_CheckRange(header, vertexarray->offset,
                                   n, sizeof(float))) {
                    return qfalse;
                }
                intPtr = (int*)((byte*)header + vertexarray->offset);
                for (j = 0; j < n; j++, intPtr++) {
                    LL(*intPtr);
                }
                break;
            default:
                // not supported
                return qfalse;
                break;
        }

        switch (vertexarray->type) {
            case IQM_POSITION:
            case IQM_NORMAL:
                if (vertexarray->format != IQM_FLOAT ||
                        vertexarray->size != 3) {
                    return qfalse;
                }
                break;
            case IQM_TANGENT:
                if (vertexarray->format != IQM_FLOAT ||
                        vertexarray->size != 4) {
                    return qfalse;
                }
                break;
            case IQM_TEXCOORD:
                if (vertexarray->format != IQM_FLOAT ||
                        vertexarray->size != 2) {
                    return qfalse;
                }
                break;
            case IQM_BLENDINDEXES:
            case IQM_BLENDWEIGHTS:
                if (vertexarray->format != IQM_UBYTE ||
                        vertexarray->size != 4) {
                    return qfalse;
                }
                break;
            case IQM_COLOR:
                if (vertexarray->format != IQM_UBYTE ||
                        vertexarray->size != 4) {
                    return qfalse;
                }
                break;
        }
    }

    // check and swap triangles
    if (IQM_CheckRange(header, header->ofs_triangles,
                       header->num_triangles, sizeof(iqmTriangle_t))) {
        return qfalse;
    }
    triangle = (iqmTriangle_t*)((byte*)header + header->ofs_triangles);
    for (i = 0; i < header->num_triangles; i++, triangle++) {
        LL(triangle->vertex[0]);
        LL(triangle->vertex[1]);
        LL(triangle->vertex[2]);

        if (triangle->vertex[0] > header->num_vertexes ||
                triangle->vertex[1] > header->num_vertexes ||
                triangle->vertex[2] > header->num_vertexes) {
            return qfalse;
        }
    }

    // check and swap meshes
    if (IQM_CheckRange(header, header->ofs_meshes,
                       header->num_meshes, sizeof(iqmMesh_t))) {
        return qfalse;
    }
    mesh = (iqmMesh_t*)((byte*)header + header->ofs_meshes);
    for (i = 0; i < header->num_meshes; i++, mesh++) {
        LL(mesh->name);
        LL(mesh->material);
        LL(mesh->first_vertex);
        LL(mesh->num_vertexes);
        LL(mesh->first_triangle);
        LL(mesh->num_triangles);

        // check ioq3 limits
        if (mesh->num_vertexes > SHADER_MAX_VERTEXES) {
            ri.Printf(PRINT_WARNING, "R_LoadIQM: %s has more than %i verts on a surface (%i).\n",
                      mod_name, SHADER_MAX_VERTEXES, mesh->num_vertexes);
            return qfalse;
        }
        if (mesh->num_triangles * 3 > SHADER_MAX_INDEXES) {
            ri.Printf(PRINT_WARNING, "R_LoadIQM: %s has more than %i triangles on a surface (%i).\n",
                      mod_name, SHADER_MAX_INDEXES / 3, mesh->num_triangles);
            return qfalse;
        }

        if (mesh->first_vertex >= header->num_vertexes ||
                mesh->first_vertex + mesh->num_vertexes > header->num_vertexes ||
                mesh->first_triangle >= header->num_triangles ||
                mesh->first_triangle + mesh->num_triangles > header->num_triangles ||
                mesh->name >= header->num_text ||
                mesh->material >= header->num_text) {
            return qfalse;
        }
    }

    // check and swap joints
    if (IQM_CheckRange(header, header->ofs_joints,
                       header->num_joints, sizeof(iqmJoint_t))) {
        return qfalse;
    }
    joint = (iqmJoint_t*)((byte*)header + header->ofs_joints);
    joint_names = 0;
    for (i = 0; i < header->num_joints; i++, joint++) {
        LL(joint->name);
        LL(joint->parent);
        LL(joint->translate[0]);
        LL(joint->translate[1]);
        LL(joint->translate[2]);
        LL(joint->rotate[0]);
        LL(joint->rotate[1]);
        LL(joint->rotate[2]);
        LL(joint->rotate[3]);
        LL(joint->scale[0]);
        LL(joint->scale[1]);
        LL(joint->scale[2]);

        if (joint->parent < -1 ||
                joint->parent >= (int)header->num_joints ||
                joint->name >= (int)header->num_text) {
            return qfalse;
        }
        joint_names += strlen((char*)header + header->ofs_text +
                              joint->name) + 1;
    }

    // check and swap poses
    if (header->num_poses != header->num_joints) {
        return qfalse;
    }
    if (IQM_CheckRange(header, header->ofs_poses,
                       header->num_poses, sizeof(iqmPose_t))) {
        return qfalse;
    }
    pose = (iqmPose_t*)((byte*)header + header->ofs_poses);
    for (i = 0; i < header->num_poses; i++, pose++) {
        LL(pose->parent);
        LL(pose->mask);
        LL(pose->channeloffset[0]);
        LL(pose->channeloffset[1]);
        LL(pose->channeloffset[2]);
        LL(pose->channeloffset[3]);
        LL(pose->channeloffset[4]);
        LL(pose->channeloffset[5]);
        LL(pose->channeloffset[6]);
        LL(pose->channeloffset[7]);
        LL(pose->channeloffset[8]);
        LL(pose->channeloffset[9]);
        LL(pose->channelscale[0]);
        LL(pose->channelscale[1]);
        LL(pose->channelscale[2]);
        LL(pose->channelscale[3]);
        LL(pose->channelscale[4]);
        LL(pose->channelscale[5]);
        LL(pose->channelscale[6]);
        LL(pose->channelscale[7]);
        LL(pose->channelscale[8]);
        LL(pose->channelscale[9]);
    }

    if (header->ofs_bounds) {
        // check and swap model bounds
        if (IQM_CheckRange(header, header->ofs_bounds,
                           header->num_frames, sizeof(*bounds))) {
            return qfalse;
        }
        bounds = (iqmBounds_t*)((byte*) header + header->ofs_bounds);
        for (i = 0; i < header->num_frames; i++) {
            LL(bounds->bbmin[0]);
            LL(bounds->bbmin[1]);
            LL(bounds->bbmin[2]);
            LL(bounds->bbmax[0]);
            LL(bounds->bbmax[1]);
            LL(bounds->bbmax[2]);

            bounds++;
        }
    }

    // allocate the model and copy the data
    size = sizeof(iqmData_t);
    size += header->num_meshes * sizeof(srfIQModel_t);
    size += header->num_joints * header->num_frames * 12 * sizeof(float);
    if (header->ofs_bounds)
        size += header->num_frames * 6 * sizeof(float); // model bounds
    size += header->num_vertexes * 3 * sizeof(float);   // positions
    size += header->num_vertexes * 2 * sizeof(float);   // texcoords
    size += header->num_vertexes * 3 * sizeof(float);   // normals
    size += header->num_vertexes * 4 * sizeof(float);   // tangents
    size += header->num_vertexes * 4 * sizeof(byte);    // blendIndexes
    size += header->num_vertexes * 4 * sizeof(byte);    // blendWeights
    size += header->num_vertexes * 4 * sizeof(byte);    // colors
    size += header->num_joints * sizeof(int);       // parents
    size += header->num_triangles * 3 * sizeof(int);    // triangles
    size += joint_names;                    // joint names

    mod->type = MOD_IQM;
    iqmData = (iqmData_t*)ri.Hunk_Alloc(size, h_low);
    mod->modelData = iqmData;

    // fill header
    iqmData->num_vertexes = header->num_vertexes;
    iqmData->num_triangles = header->num_triangles;
    iqmData->num_frames   = header->num_frames;
    iqmData->num_surfaces = header->num_meshes;
    iqmData->num_joints   = header->num_joints;
    iqmData->surfaces     = (srfIQModel_t*)(iqmData + 1);
    iqmData->poseMats     = (float*)(iqmData->surfaces + iqmData->num_surfaces);
    if (header->ofs_bounds) {
        iqmData->bounds       = iqmData->poseMats + 12 * header->num_joints * header->num_frames;
        iqmData->positions    = iqmData->bounds + 6 * header->num_frames;
    } else
        iqmData->positions    = iqmData->poseMats + 12 * header->num_joints * header->num_frames;
    iqmData->texcoords    = iqmData->positions + 3 * header->num_vertexes;
    iqmData->normals      = iqmData->texcoords + 2 * header->num_vertexes;
    iqmData->tangents     = iqmData->normals + 3 * header->num_vertexes;
    iqmData->blendIndexes = (byte*)(iqmData->tangents + 4 * header->num_vertexes);
    iqmData->blendWeights = iqmData->blendIndexes + 4 * header->num_vertexes;
    iqmData->colors       = iqmData->blendWeights + 4 * header->num_vertexes;
    iqmData->jointParents = (int*)(iqmData->colors + 4 * header->num_vertexes);
    iqmData->triangles    = iqmData->jointParents + header->num_joints;
    iqmData->names        = (char*)(iqmData->triangles + 3 * header->num_triangles);

    // calculate joint matrices and their inverses
    // they are needed only until the pose matrices are calculated
    mat = jointMats;
    joint = (iqmJoint_t*)((byte*)header + header->ofs_joints);
    for (i = 0; i < header->num_joints; i++, joint++) {
        float baseFrame[12], invBaseFrame[12];

        JointToMatrix(joint->rotate, joint->scale, joint->translate, baseFrame);
        Matrix34Invert(baseFrame, invBaseFrame);

        if (joint->parent >= 0) {
            Matrix34Multiply(jointMats + 2 * 12 * joint->parent, baseFrame, mat);
            mat += 12;
            Matrix34Multiply(invBaseFrame, jointMats + 2 * 12 * joint->parent + 12, mat);
            mat += 12;
        } else {
            Com_Memcpy(mat, baseFrame,    sizeof(baseFrame));
            mat += 12;
            Com_Memcpy(mat, invBaseFrame, sizeof(invBaseFrame));
            mat += 12;
        }
    }

    // calculate pose matrices
    framedata = (unsigned short*)((byte*)header + header->ofs_frames);
    mat = iqmData->poseMats;
    for (i = 0; i < header->num_frames; i++) {
        pose = (iqmPose_t*)((byte*)header + header->ofs_poses);
        for (j = 0; j < header->num_poses; j++, pose++) {
            vec3_t  translate;
            vec4_t  rotate;
            vec3_t  scale;
            float   mat1[12], mat2[12];

            translate[0] = pose->channeloffset[0];
            if (pose->mask & 0x001)
                translate[0] += *framedata++ * pose->channelscale[0];
            translate[1] = pose->channeloffset[1];
            if (pose->mask & 0x002)
                translate[1] += *framedata++ * pose->channelscale[1];
            translate[2] = pose->channeloffset[2];
            if (pose->mask & 0x004)
                translate[2] += *framedata++ * pose->channelscale[2];

            rotate[0] = pose->channeloffset[3];
            if (pose->mask & 0x008)
                rotate[0] += *framedata++ * pose->channelscale[3];
            rotate[1] = pose->channeloffset[4];
            if (pose->mask & 0x010)
                rotate[1] += *framedata++ * pose->channelscale[4];
            rotate[2] = pose->channeloffset[5];
            if (pose->mask & 0x020)
                rotate[2] += *framedata++ * pose->channelscale[5];
            rotate[3] = pose->channeloffset[6];
            if (pose->mask & 0x040)
                rotate[3] += *framedata++ * pose->channelscale[6];

            scale[0] = pose->channeloffset[7];
            if (pose->mask & 0x080)
                scale[0] += *framedata++ * pose->channelscale[7];
            scale[1] = pose->channeloffset[8];
            if (pose->mask & 0x100)
                scale[1] += *framedata++ * pose->channelscale[8];
            scale[2] = pose->channeloffset[9];
            if (pose->mask & 0x200)
                scale[2] += *framedata++ * pose->channelscale[9];

            // construct transformation matrix
            JointToMatrix(rotate, scale, translate, mat1);

            if (pose->parent >= 0) {
                Matrix34Multiply(jointMats + 12 * 2 * pose->parent,
                                 mat1, mat2);
            } else {
                Com_Memcpy(mat2, mat1, sizeof(mat1));
            }

            Matrix34Multiply(mat2, jointMats + 12 * (2 * j + 1), mat);
            mat += 12;
        }
    }

    // register shaders
    // overwrite the material offset with the shader index
    mesh = (iqmMesh_t*)((byte*)header + header->ofs_meshes);
    surface = iqmData->surfaces;
    str = (char*)header + header->ofs_text;
    for (i = 0; i < header->num_meshes; i++, mesh++, surface++) {
        surface->surfaceType = SF_IQM;
        Q_strncpyz(surface->name, str + mesh->name, sizeof(surface->name));
        Q_strlwr(surface->name); // lowercase the surface name so skin compares are faster
        surface->shader = R_FindShader(str + mesh->material, LIGHTMAP_NONE, qtrue);
        if (surface->shader->defaultShader)
            surface->shader = tr.defaultShader;
        surface->data = iqmData;
        surface->first_vertex = mesh->first_vertex;
        surface->num_vertexes = mesh->num_vertexes;
        surface->first_triangle = mesh->first_triangle;
        surface->num_triangles = mesh->num_triangles;
    }

    // copy vertexarrays and indexes
    vertexarray = (iqmVertexArray_t*)((byte*)header + header->ofs_vertexarrays);
    for (i = 0; i < header->num_vertexarrays; i++, vertexarray++) {
        int n;

        // total number of values
        n = header->num_vertexes * vertexarray->size;

        switch (vertexarray->type) {
            case IQM_POSITION:
                Com_Memcpy(iqmData->positions,
                           (byte*)header + vertexarray->offset,
                           n * sizeof(float));
                break;
            case IQM_NORMAL:
                Com_Memcpy(iqmData->normals,
                           (byte*)header + vertexarray->offset,
                           n * sizeof(float));
                break;
            case IQM_TANGENT:
                Com_Memcpy(iqmData->tangents,
                           (byte*)header + vertexarray->offset,
                           n * sizeof(float));
                break;
            case IQM_TEXCOORD:
                Com_Memcpy(iqmData->texcoords,
                           (byte*)header + vertexarray->offset,
                           n * sizeof(float));
                break;
            case IQM_BLENDINDEXES:
                Com_Memcpy(iqmData->blendIndexes,
                           (byte*)header + vertexarray->offset,
                           n * sizeof(byte));
                break;
            case IQM_BLENDWEIGHTS:
                Com_Memcpy(iqmData->blendWeights,
                           (byte*)header + vertexarray->offset,
                           n * sizeof(byte));
                break;
            case IQM_COLOR:
                Com_Memcpy(iqmData->colors,
                           (byte*)header + vertexarray->offset,
                           n * sizeof(byte));
                break;
        }
    }

    // copy joint parents
    joint = (iqmJoint_t*)((byte*)header + header->ofs_joints);
    for (i = 0; i < header->num_joints; i++, joint++) {
        iqmData->jointParents[i] = joint->parent;
    }

    // copy triangles
    triangle = (iqmTriangle_t*)((byte*)header + header->ofs_triangles);
    for (i = 0; i < header->num_triangles; i++, triangle++) {
        iqmData->triangles[3 * i + 0] = triangle->vertex[0];
        iqmData->triangles[3 * i + 1] = triangle->vertex[1];
        iqmData->triangles[3 * i + 2] = triangle->vertex[2];
    }

    // copy joint names
    str = iqmData->names;
    joint = (iqmJoint_t*)((byte*)header + header->ofs_joints);
    for (i = 0; i < header->num_joints; i++, joint++) {
        char* name = (char*)header + header->ofs_text +
                     joint->name;
        int len = strlen(name) + 1;
        Com_Memcpy(str, name, len);
        str += len;
    }

    // copy model bounds
    if (header->ofs_bounds) {
        mat = iqmData->bounds;
        bounds = (iqmBounds_t*)((byte*) header + header->ofs_bounds);
        for (i = 0; i < header->num_frames; i++) {
            mat[0] = bounds->bbmin[0];
            mat[1] = bounds->bbmin[1];
            mat[2] = bounds->bbmin[2];
            mat[3] = bounds->bbmax[0];
            mat[4] = bounds->bbmax[1];
            mat[5] = bounds->bbmax[2];

            mat += 6;
            bounds++;
        }
    }

    return qtrue;
}
Ejemplo n.º 2
0
static bool LoadIQMFile( void *buffer, unsigned filesize, const char *mod_name,
			     size_t *len_names )
{
	iqmHeader_t		*header;
	iqmVertexArray_t	*vertexarray;
	iqmTriangle_t		*triangle;
	iqmMesh_t		*mesh;
	iqmJoint_t		*joint;
	iqmPose_t		*pose;
	iqmBounds_t		*bounds;
	iqmAnim_t		*anim;

	if( filesize < sizeof(iqmHeader_t) ) {
		Log::Warn("R_LoadIQModel: file size of %s is too small.",
			  mod_name );
		return false;
	}

	header = (iqmHeader_t *)buffer;
	if( Q_strncmp( header->magic, IQM_MAGIC, sizeof(header->magic) ) ) {
		Log::Warn("R_LoadIQModel: file %s doesn't contain an IQM header.",
			  mod_name );
		return false;
	}

	LL( header->version );
	if( header->version != IQM_VERSION ) {
		Log::Warn("R_LoadIQM: %s is a unsupported IQM version (%d), only version %d is supported.",
			  mod_name, header->version, IQM_VERSION);
		return false;
	}

	LL( header->filesize );
	if( header->filesize > filesize || header->filesize > 1<<24 ) {
		Log::Warn("R_LoadIQM: %s has an invalid file size %d.",
			  mod_name, header->filesize );
		return false;
	}

	LL( header->flags );
	LL( header->num_text );
	LL( header->ofs_text );
	LL( header->num_meshes );
	LL( header->ofs_meshes );
	LL( header->num_vertexarrays );
	LL( header->num_vertexes );
	LL( header->ofs_vertexarrays );
	LL( header->num_triangles );
	LL( header->ofs_triangles );
	LL( header->ofs_adjacency );
	LL( header->num_joints );
	LL( header->ofs_joints );
	LL( header->num_poses );
	LL( header->ofs_poses );
	LL( header->num_anims );
	LL( header->ofs_anims );
	LL( header->num_frames );
	LL( header->num_framechannels );
	LL( header->ofs_frames );
	LL( header->ofs_bounds );
	LL( header->num_comment );
	LL( header->ofs_comment );
	LL( header->num_extensions );
	LL( header->ofs_extensions );

	// check and swap vertex arrays
	if( IQM_CheckRange( header, header->ofs_vertexarrays,
			    header->num_vertexarrays,
			    sizeof(iqmVertexArray_t),
			    mod_name, "vertexarray" ) ) {
		return false;
	}
	vertexarray = ( iqmVertexArray_t* )IQMPtr( header, header->ofs_vertexarrays );
	for(unsigned i = 0; i < header->num_vertexarrays; i++, vertexarray++ ) {
		int	j, n, *intPtr;

		if( vertexarray->size <= 0 || vertexarray->size > 4 ) {
			Log::Warn("R_LoadIQM: %s contains an invalid vertexarray size.",
				  mod_name );
			return false;
		}

		// total number of values
		n = header->num_vertexes * vertexarray->size;

		switch( vertexarray->format ) {
		case IQM_BYTE:
		case IQM_UBYTE:
			// 1 byte, no swapping necessary
			if( IQM_CheckRange( header, vertexarray->offset, n,
					    sizeof(byte), mod_name, "vertexarray" ) ) {
				return false;
			}
			break;
		case IQM_INT:
		case IQM_UINT:
		case IQM_FLOAT:
			// 4-byte swap
			if( IQM_CheckRange( header, vertexarray->offset, n,
					    sizeof(float), mod_name, "vertexarray" ) ) {
				return false;
			}
			intPtr = ( int* )IQMPtr( header, vertexarray->offset );
			for( j = 0; j < n; j++, intPtr++ ) {
				LL( *intPtr );
			}
			break;
		default:
			// not supported
			Log::Warn("R_LoadIQM: file %s uses an unsupported vertex format.",
				  mod_name );
			return false;
			break;
		}

		switch( vertexarray->type ) {
		case IQM_POSITION:
		case IQM_NORMAL:
			if( vertexarray->format != IQM_FLOAT ||
			    vertexarray->size != 3 ) {
				Log::Warn("R_LoadIQM: file %s uses an unsupported vertex format.",
					  mod_name );
				return false;
			}
			break;
		case IQM_TANGENT:
			if( vertexarray->format != IQM_FLOAT ||
			    vertexarray->size != 4 ) {
				Log::Warn("R_LoadIQM: file %s uses an unsupported vertex format.",
					  mod_name );
				return false;
			}
			break;
		case IQM_TEXCOORD:
			if( vertexarray->format != IQM_FLOAT ||
			    vertexarray->size != 2 ) {
				Log::Warn("R_LoadIQM: file %s uses an unsupported vertex format.",
					  mod_name );
				return false;
			}
			break;
		case IQM_BLENDINDEXES:
		case IQM_BLENDWEIGHTS:
			if( vertexarray->format != IQM_UBYTE ||
			    vertexarray->size != 4 ) {
				Log::Warn("R_LoadIQM: file %s uses an unsupported vertex format.",
					  mod_name );
				return false;
			}
			break;
		case IQM_COLOR:
			if( vertexarray->format != IQM_UBYTE ||
			    vertexarray->size != 4 ) {
				Log::Warn("R_LoadIQM: file %s uses an unsupported vertex format.",
					  mod_name );
				return false;
			}
			break;
		}
	}

	// check and swap triangles
	if( IQM_CheckRange( header, header->ofs_triangles,
			    header->num_triangles, sizeof(iqmTriangle_t),
			    mod_name, "triangle" ) ) {
		return false;
	}
	triangle = ( iqmTriangle_t* )IQMPtr( header, header->ofs_triangles );
	for(unsigned i = 0; i < header->num_triangles; i++, triangle++ ) {
		LL( triangle->vertex[0] );
		LL( triangle->vertex[1] );
		LL( triangle->vertex[2] );

		if( triangle->vertex[0] > header->num_vertexes ||
		    triangle->vertex[1] > header->num_vertexes ||
		    triangle->vertex[2] > header->num_vertexes ) {
			return false;
		}
	}

	*len_names = 0;

	// check and swap meshes
	if( IQM_CheckRange( header, header->ofs_meshes,
			    header->num_meshes, sizeof(iqmMesh_t),
			    mod_name, "mesh" ) ) {
		return false;
	}
	mesh = ( iqmMesh_t* )IQMPtr( header, header->ofs_meshes );
	for(unsigned i = 0; i < header->num_meshes; i++, mesh++) {
		LL( mesh->name );
		LL( mesh->material );
		LL( mesh->first_vertex );
		LL( mesh->num_vertexes );
		LL( mesh->first_triangle );
		LL( mesh->num_triangles );

		if( mesh->first_vertex >= header->num_vertexes ||
		    mesh->first_vertex + mesh->num_vertexes > header->num_vertexes ||
		    mesh->first_triangle >= header->num_triangles ||
		    mesh->first_triangle + mesh->num_triangles > header->num_triangles ||
		    mesh->name >= header->num_text ||
		    mesh->material >= header->num_text ) {
			Log::Warn("R_LoadIQM: file %s contains an invalid mesh.",
				  mod_name );
			return false;
		}
		*len_names += strlen( ( char* )IQMPtr( header, header->ofs_text
					      + mesh->name ) ) + 1;
	}

	// check and swap joints
	if( header->num_joints != 0 &&
	    IQM_CheckRange( header, header->ofs_joints,
			    header->num_joints, sizeof(iqmJoint_t),
			    mod_name, "joint" ) ) {
		return false;
	}
	joint = ( iqmJoint_t* )IQMPtr( header, header->ofs_joints );
	for(unsigned i = 0; i < header->num_joints; i++, joint++ ) {
		LL( joint->name );
		LL( joint->parent );
		LL( joint->translate[0] );
		LL( joint->translate[1] );
		LL( joint->translate[2] );
		LL( joint->rotate[0] );
		LL( joint->rotate[1] );
		LL( joint->rotate[2] );
		LL( joint->rotate[3] );
		LL( joint->scale[0] );
		LL( joint->scale[1] );
		LL( joint->scale[2] );

		if( joint->parent < -1 ||
		    joint->parent >= (int)header->num_joints ||
		    joint->name >= header->num_text ) {
			Log::Warn("R_LoadIQM: file %s contains an invalid joint.",
				  mod_name );
			return false;
		}
		if( joint->scale[0] < 0.0f ||
			(int)( joint->scale[0] - joint->scale[1] ) ||
			(int)( joint->scale[1] - joint->scale[2] ) ) {
			Log::Warn("R_LoadIQM: file %s contains an invalid scale: %f %f %f",
				  mod_name, joint->scale[0], joint->scale[1], joint->scale[2] );
			return false;
		}
		*len_names += strlen( ( char* )IQMPtr( header, header->ofs_text
					      + joint->name ) ) + 1;
	}

	// check and swap poses
	if( header->ofs_poses > 0 ) {
		if( IQM_CheckRange( header, header->ofs_poses,
				    header->num_poses, sizeof(iqmPose_t),
				    mod_name, "pose" ) ) {
			return false;
		}
		pose = ( iqmPose_t* )IQMPtr( header, header->ofs_poses );
		for(unsigned i = 0; i < header->num_poses; i++, pose++ ) {
			LL( pose->parent );
			LL( pose->mask );
			LL( pose->channeloffset[0] );
			LL( pose->channeloffset[1] );
			LL( pose->channeloffset[2] );
			LL( pose->channeloffset[3] );
			LL( pose->channeloffset[4] );
			LL( pose->channeloffset[5] );
			LL( pose->channeloffset[6] );
			LL( pose->channeloffset[7] );
			LL( pose->channeloffset[8] );
			LL( pose->channeloffset[9] );
			LL( pose->channelscale[0] );
			LL( pose->channelscale[1] );
			LL( pose->channelscale[2] );
			LL( pose->channelscale[3] );
			LL( pose->channelscale[4] );
			LL( pose->channelscale[5] );
			LL( pose->channelscale[6] );
			LL( pose->channelscale[7] );
			LL( pose->channelscale[8] );
			LL( pose->channelscale[9] );
		}
	}

	if( header->ofs_bounds )
	{
		// check and swap model bounds
		if(IQM_CheckRange(header, header->ofs_bounds,
				  header->num_frames, sizeof(*bounds),
				  mod_name, "bounds" ))
		{
			return false;
		}
		bounds = ( iqmBounds_t* )IQMPtr( header, header->ofs_bounds );
		for(unsigned i = 0; i < header->num_poses; i++)
		{
			LL(bounds->bbmin[0]);
			LL(bounds->bbmin[1]);
			LL(bounds->bbmin[2]);
			LL(bounds->bbmax[0]);
			LL(bounds->bbmax[1]);
			LL(bounds->bbmax[2]);

			bounds++;
		}
	}

	// check and swap animations
	if( header->ofs_anims ) {
		if( IQM_CheckRange( header, header->ofs_anims,
				    header->num_anims, sizeof(iqmAnim_t),
				    mod_name, "animation" ) ) {
			return false;
		}
		anim = ( iqmAnim_t* )IQMPtr( header, header->ofs_anims );
		for(unsigned i = 0; i < header->num_anims; i++, anim++ ) {
			LL( anim->name );
			LL( anim->first_frame );
			LL( anim->num_frames );
			LL( anim->framerate );
			LL( anim->flags );

			*len_names += strlen( ( char* )IQMPtr( header, header->ofs_text
							       + anim->name ) ) + 1;
		}
	}

	return true;
}