path: root/src/libparsec/obj_odt.cpp

/*
 * PARSEC - ODT File Functions
 *
 * $Author: uberlinuxguy $ - $Date: 2004/09/26 03:43:44 $
 *
 * Orginally written by:
 *   Copyright (c) Markus Hadwiger     <msh@parsec.org>   1996-2000
 *   Copyright (c) Clemens Beer        <cbx@parsec.org>   1999
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */ 

// C library
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// compilation flags/debug support
#include "config.h"
#include "debug.h"

// general definitions
#include "general.h"
#include "gd_heads.h"
#include "objstruc.h"
#include "od_odt.h"

// global externals
#include "globals.h"
#ifdef PARSEC_SERVER
	#include "e_world_trans.h"
#endif // PARSEC_SERVER

// mathematics header
#include "utl_math.h"

// local module header
#include "obj_odt.h"

// proprietary module headers
#ifdef PARSEC_SERVER
	#include "con_aux_sv.h"
#else // !PARSEC_SERVER
	#include "con_aux.h"
	#include "con_shad.h"
	#include "e_shader.h"
	//#include "e_supp.h"
	#include "obj_ctrl.h"
#endif // !PARSEC_SERVER

#include "obj_clas.h"
#include "obj_type.h"
#include "sys_file.h"
#include "sys_swap.h"


// flags
//#define OD2_BBOX_VALID



// string constants -----------------------------------------------------------
//
static char object_not_found[]	= "object \"%s\" not found";
static char object_readerror[]	= "object \"%s\" readerror";
static char corrupt_object[]	= "corrupt object file.";
static char corrupt_type[]		= "corrupt type definition.";
static char no_object_mem[] 	= "not enough mem for object class-data.";


// alignment to enforce for object geometry data ------------------------------
//
#define OBJ_GEOMETRY_ALIGNMENT_VAL		0x1f
#define OBJ_GEOMETRY_ALIGNMENT_MASK		(~OBJ_GEOMETRY_ALIGNMENT_VAL)


// default objload_xx flags ---------------------------------------------------
//
#define ODT_OBJLOAD_DEFAULT ( OBJLOAD_WEDGENORMALS | OBJLOAD_WEDGELIGHTED | OBJLOAD_POLYWEDGEINDEXES )
#define OD2_OBJLOAD_DEFAULT ( OBJLOAD_WEDGENORMALS | OBJLOAD_WEDGELIGHTED | OBJLOAD_POLYWEDGEINDEXES )


// map texture name to pointer ------------------------------------------------
//
PRIVATE
TextureMap *OBJODT_FetchTexture( char *texname )
{
#ifdef PARSEC_SERVER
	return NULL;
#else
	if ( texname == NULL ) {
		return NULL;
	}

	// make sure the texture name is all lower case since it is
	// not possible to specify upper case chars in the console
	strlwr( texname );

	TextureMap*	FetchTextureMap( const char *texname );
	TextureMap *tmap = FetchTextureMap( texname );

	// error if no texture of specified name could be found
	if ( tmap == NULL ) {

		// display error message
//		MSGOUT( "texture %s needed by object not found.", texname );

		// fall back on default texture if possible
		tmap = FetchTextureMap( "texinval" );
		if ( tmap == NULL ) {

			// hard exit if texture not found and default not available
			PERROR( "OBJODT_FetchTexture(): texture not found: \"%s\".", texname );
		}
	}

	return tmap;
#endif // !PARSEC_SERVER
}


// tables for corners and wedges ----------------------------------------------
//
#define MAX_AVERAGE_POLYS_PER_VTX	8

// linear array subrange
struct range_info_s {

	int start;
	int count;
};

// corner (vertex,poly)
struct corner_info_s {

	int vertid;
	int polyid;
};

static range_info_s*	corner_info_vtxrange = NULL;
static corner_info_s*	corner_info_corners  = NULL;
static int				corner_info_num_corners;

// wedge (set of corners)
struct wedge_info_s {

	int		cornerstart;
	int		cornercount;

	Vector3	normal;
};

static range_info_s*	wedge_info_vtxrange = NULL;
static wedge_info_s*	wedge_info_wedges   = NULL;
static int				wedge_info_num_wedges;


// generate corner info tables ------------------------------------------------
//
PRIVATE
void OBJODT_CreateVertexCornerInfo( GenObject *gobj )
{
	ASSERT( gobj != NULL );

	ASSERT( corner_info_vtxrange == NULL );
	ASSERT( corner_info_corners == NULL );

	int numverts   = gobj->NumPolyVerts;
	int maxpolyids = numverts * MAX_AVERAGE_POLYS_PER_VTX;

	// alloc tables
	corner_info_vtxrange = (range_info_s *) ALLOCMEM( numverts * sizeof( range_info_s ) );
	if ( corner_info_vtxrange == NULL )
		OUTOFMEM( 0 );
	corner_info_corners = (corner_info_s *) ALLOCMEM( maxpolyids * sizeof( corner_info_s ) );
	if ( corner_info_corners == NULL )
		OUTOFMEM( 0 );

	int cornerbase	= 0;
	int vidbase		= gobj->NumNormals;

	//NOTE:
	// sort order is on vertices. i.e., all corners incident
	// with a specific vertex will be stored consecutively.

	// scan all vertices
	for ( int vid = 0; vid < numverts; vid++ ) {

		corner_info_vtxrange[ vid ].start = cornerbase;
		corner_info_vtxrange[ vid ].count = 0;

		// scan all polys
		for ( unsigned int pid = 0; pid < gobj->NumPolys; pid++ ) {

			dword *vindxs = gobj->PolyList[ pid ].VertIndxs;
			for ( int indx = gobj->PolyList[ pid ].NumVerts; indx > 0; indx-- ) {
				if ( *vindxs++ == (dword)( vid + vidbase ) ) {
					ASSERT( cornerbase < maxpolyids );
					corner_info_corners[ cornerbase ].vertid = vid;
					corner_info_corners[ cornerbase ].polyid = pid;
					corner_info_vtxrange[ vid ].count++;
					cornerbase++;
				}
			}
		}
	}

	// store number of corners
	corner_info_num_corners = cornerbase;
}


// fetch normal corresponding to corner ---------------------------------------
//
PRIVATE
Vector3 *OBJODT_FetchCornerNormal( GenObject *gobj, int corner )
{
	ASSERT( gobj != NULL );
	ASSERT( (dword)corner < (dword)corner_info_num_corners );

	dword cornerpoly = corner_info_corners[ corner ].polyid;
	ASSERT( cornerpoly < gobj->NumPolys );

	dword cornerface = gobj->PolyList[ cornerpoly ].FaceIndx;
	ASSERT( cornerface < gobj->NumFaces );

	dword cornernorm = gobj->FaceList[ cornerface ].FaceNormalIndx;
	ASSERT( cornernorm < gobj->NumNormals );

	return &gobj->VertexList[ cornernorm ];
}


// additional configurable parameters for object loading ----------------------
//
PUBLIC
odt_loading_params_s odt_loading_params = {

	0,						// maximum number of face anims (0==default)
	0,						// maximum number of vertex anims (0==default)
	FLOAT_TO_GEOMV( 0.5f ),	// threshold for dot product of normals to merge
};


// generate wedge info tables (sets of corners) -------------------------------
//
PRIVATE
void OBJODT_CreateVertexWedgeInfo( GenObject *gobj )
{
	ASSERT( gobj != NULL );

	ASSERT( wedge_info_vtxrange == NULL );
	ASSERT( wedge_info_wedges == NULL );

	int numverts  = gobj->NumPolyVerts;
	int maxwedges = corner_info_num_corners;

	// alloc tables
	wedge_info_vtxrange = (range_info_s *) ALLOCMEM( numverts * sizeof( range_info_s ) );
	if ( wedge_info_vtxrange == NULL )
		OUTOFMEM( 0 );
	memset( wedge_info_vtxrange, 0, numverts * sizeof( range_info_s ) );

	wedge_info_wedges = (wedge_info_s *) ALLOCMEM( maxwedges * sizeof( wedge_info_s ) );
	if ( wedge_info_wedges == NULL )
		OUTOFMEM( 0 );
	memset( wedge_info_wedges, 0, maxwedges * sizeof( wedge_info_s ) );

	//NOTE:
	// sort order is on vertices. i.e., all wedges incident
	// with a specific vertex will be stored consecutively.

	// scan all vertices
	int wedgebase = 0;
	for ( int vid = 0; vid < numverts; vid++ ) {

		wedge_info_vtxrange[ vid ].start = wedgebase;
		wedge_info_vtxrange[ vid ].count = 0;

		// scan corners for this vertex
		int start  = corner_info_vtxrange[ vid ].start;
		int beyond = corner_info_vtxrange[ vid ].count + start;

		int runs[ 32 ];

		// bring corners into wedge-order, determine number of wedges
		int cbase = start;
		int numwedges = 0;
		for ( numwedges = 0; cbase < beyond; numwedges++ ) {

			int crun  = 1;
			int cstop = beyond;

			// try to grow run
			int cscan = 0;
			for ( cscan = cbase + 1; cscan < cstop; ) {

				// merging allowed if at least one normal within threshold
				Vector3 *norm = OBJODT_FetchCornerNormal( gobj, cscan );
				int ccmp = 0;
				for ( ccmp = cbase; ccmp < cbase + crun; ccmp++ ) {

					Vector3 *cmpnorm = OBJODT_FetchCornerNormal( gobj, ccmp );
					geomv_t ndiff = GEOMV_1 - DOT_PRODUCT( norm, cmpnorm );
					ABS_GEOMV( ndiff );
					if ( ndiff < odt_loading_params.merge_normals_threshold ) {

						// grow run, continue with next element
						crun++;
						cscan++;
						break;
					}
				}

				if ( ccmp == cbase + crun ) {

					// shorten test range
					cstop--;

					// swap non-mergeable corner beyond test range
					corner_info_s temp			 = corner_info_corners[ cstop ];
					corner_info_corners[ cstop ] = corner_info_corners[ cscan ];
					corner_info_corners[ cscan ] = temp;
				}
			}

			// store length of run (one wedge)
			ASSERT( numwedges < 32 );
			runs[ numwedges ] = crun;

			// base for next run
			cbase += crun;
		}

		// merge runs (corners) into wedges
		int cornerstart = start;
		for ( int wedge = 0; wedge < numwedges; wedge++ ) {

			wedge_info_wedges[ wedgebase ].cornerstart = cornerstart;
			wedge_info_wedges[ wedgebase ].cornercount = runs[ wedge ];

			wedge_info_wedges[ wedgebase ].normal.X = GEOMV_0;
			wedge_info_wedges[ wedgebase ].normal.Y = GEOMV_0;
			wedge_info_wedges[ wedgebase ].normal.Z = GEOMV_0;

			// sum all corner normals for this wedge
			int cornerbeyond = cornerstart + runs[ wedge ];
			for ( int corner = cornerstart; corner < cornerbeyond; corner++ ) {

				Vector3 *cornernorm = OBJODT_FetchCornerNormal( gobj, corner );
				wedge_info_wedges[ wedgebase ].normal.X += cornernorm->X;
				wedge_info_wedges[ wedgebase ].normal.Y += cornernorm->Y;
				wedge_info_wedges[ wedgebase ].normal.Z += cornernorm->Z;
			}

			// normalize resulting normal (averaging implicit)
			NormVctX( &wedge_info_wedges[ wedgebase ].normal );

			cornerstart = cornerbeyond;

			wedge_info_vtxrange[ vid ].count++;
			wedgebase++;
		}
	}

	// set total number of wedges
	wedge_info_num_wedges = wedgebase;
}


// free storage for corner and wedge info tables ------------------------------
//
PRIVATE
void OBJODT_FreeVertexCornerWedgeInfo()
{
	// free corner info
	if ( corner_info_vtxrange != NULL ) {
		FREEMEM( corner_info_vtxrange );
		corner_info_vtxrange = NULL;
	}
	if ( corner_info_corners != NULL ) {
		FREEMEM( corner_info_corners );
		corner_info_corners = NULL;
	}

	// free wedge info
	if ( wedge_info_vtxrange != NULL ) {
		FREEMEM( wedge_info_vtxrange );
		wedge_info_vtxrange = NULL;
	}
	if ( wedge_info_wedges != NULL ) {
		FREEMEM( wedge_info_wedges );
		wedge_info_wedges = NULL;
	}
}


// pointer correction macro ---------------------------------------------------
//
#define CORRECT_POINTER(p)	( ( (p) != NULL ) ? ( (char*)(p) + pdiff ) : NULL )


// correct data pointers contained in lod object to new object base -----------
//
PRIVATE
void OBJODT_CorrectPointersLodObject( GenLodObject *lodobj, ptrdiff_t pdiff, int postcorrect )
{
	ASSERT( lodobj != NULL );

	Poly *polylist = lodobj->PolyList;
	Face *facelist = lodobj->FaceList;

	lodobj->VertexList		= (Vertex3 *)	 CORRECT_POINTER( lodobj->VertexList );
	lodobj->X_VertexList	= (Vertex3 *)	 CORRECT_POINTER( lodobj->X_VertexList );
	lodobj->S_VertexList	= (SPoint *)	 CORRECT_POINTER( lodobj->S_VertexList );
	lodobj->PolyList		= (Poly *)		 CORRECT_POINTER( lodobj->PolyList );
	lodobj->FaceList		= (Face *)		 CORRECT_POINTER( lodobj->FaceList );
	lodobj->VisPolyList		= (dword *)		 CORRECT_POINTER( lodobj->VisPolyList );
	lodobj->SortedPolyList	= (dword *)		 CORRECT_POINTER( lodobj->SortedPolyList );
	lodobj->AuxList			= (void *)		 CORRECT_POINTER( lodobj->AuxList );
	lodobj->BSPTree			= (BSPNode *)	 CORRECT_POINTER( lodobj->BSPTree );
	lodobj->AuxBSPTree		= (CullBSPNode*) CORRECT_POINTER( lodobj->AuxBSPTree );
	lodobj->AuxObject		= (void *)		 CORRECT_POINTER( lodobj->AuxObject );
	lodobj->WedgeVertIndxs	= (dword *)		 CORRECT_POINTER( lodobj->WedgeVertIndxs );
	lodobj->WedgeNormals	= (Vector3 *)	 CORRECT_POINTER( lodobj->WedgeNormals );
	lodobj->WedgeColors		= (colrgba_s *)	 CORRECT_POINTER( lodobj->WedgeColors );
	lodobj->WedgeTexCoords	= (TexCoord2 *)	 CORRECT_POINTER( lodobj->WedgeTexCoords );
	lodobj->WedgeLighted	= (colrgba_s *)	 CORRECT_POINTER( lodobj->WedgeLighted );
	lodobj->WedgeSpecular	= (colrgba_s *)	 CORRECT_POINTER( lodobj->WedgeSpecular );
	lodobj->WedgeFogged		= (colrgba_s *)	 CORRECT_POINTER( lodobj->WedgeFogged );

	// if correction takes place after relocation
	// the lists are already at their new positions
	if ( postcorrect ) {
		polylist = lodobj->PolyList;
		facelist = lodobj->FaceList;
	}

	// correct pointers contained in poly structures
	for ( unsigned int pid = 0; pid < lodobj->NumPolys; pid++ ) {
		if (&polylist[pid] != NULL)
			polylist[ pid ].VertIndxs = (dword *) CORRECT_POINTER( polylist[ pid ].VertIndxs );
	}

	// correct pointers contained in face structures
	for ( unsigned int fid = 0; fid < lodobj->NumFaces; fid++ ) {
		if (&facelist[fid] != NULL)
			facelist[ fid ].ExtInfo = (FaceExtInfo *) CORRECT_POINTER( facelist[ fid ].ExtInfo );
	}
}


// correct data pointers to new object base (base data) -----------------------
//
PRIVATE
void OBJODT_CorrectPointersBaseData( GenObject *obj, ptrdiff_t pdiff, int postcorrect )
{
	ASSERT( obj != NULL );

	GenLodInfo *lodinfo = obj->LodObjects;

	obj->LodObjects		= (GenLodInfo *)	CORRECT_POINTER( obj->LodObjects );
	obj->FaceAnimStates	= (FaceAnimState *) CORRECT_POINTER( obj->FaceAnimStates );
	obj->VtxAnimStates	= (VtxAnimState *)  CORRECT_POINTER( obj->VtxAnimStates );

	// if correction takes place after relocation
	// the lod infos are already at their new positions
	if ( postcorrect ) {

		lodinfo = obj->LodObjects;

		// correct pointers contained in lod infos
		for ( int lod = 0; lod < obj->NumLodObjects; lod++ ) {
			if (&lodinfo[lod] != NULL) {
				lodinfo[ lod ].LodObject = (GenLodObject *) CORRECT_POINTER( lodinfo[ lod ].LodObject );
				OBJODT_CorrectPointersLodObject( lodinfo[ lod ].LodObject, pdiff, TRUE );
			}
		}

	} else {

		// correct pointers contained in lod infos
		for ( int lod = 0; lod < obj->NumLodObjects; lod++ ) {
			OBJODT_CorrectPointersLodObject( lodinfo[ lod ].LodObject, pdiff, FALSE );
			lodinfo[ lod ].LodObject = (GenLodObject *) CORRECT_POINTER( lodinfo[ lod ].LodObject );
		}
	}
}


// correct data pointers to new object base (geometry data) -------------------
//
PRIVATE
void OBJODT_CorrectPointersGeomData( GenObject *obj, ptrdiff_t pdiff, int postcorrect )
{
	ASSERT( obj != NULL );

	Poly *polylist = obj->PolyList;
	Face *facelist = obj->FaceList;

	obj->VertexList		= (Vertex3 *)		CORRECT_POINTER( obj->VertexList );
	obj->X_VertexList	= (Vertex3 *)		CORRECT_POINTER( obj->X_VertexList );
	obj->S_VertexList	= (SPoint *)		CORRECT_POINTER( obj->S_VertexList );
	obj->PolyList		= (Poly *)			CORRECT_POINTER( obj->PolyList );
	obj->FaceList		= (Face *)			CORRECT_POINTER( obj->FaceList );
	obj->VisPolyList	= (dword *)			CORRECT_POINTER( obj->VisPolyList );
	obj->SortedPolyList	= (dword *)			CORRECT_POINTER( obj->SortedPolyList );
	obj->AuxList		= (void *)			CORRECT_POINTER( obj->AuxList );
	obj->BSPTree		= (BSPNode *)		CORRECT_POINTER( obj->BSPTree );
	obj->AuxBSPTree		= (CullBSPNode*)	CORRECT_POINTER( obj->AuxBSPTree );
	obj->AuxObject		= (void *)			CORRECT_POINTER( obj->AuxObject );
	obj->WedgeVertIndxs	= (dword *)			CORRECT_POINTER( obj->WedgeVertIndxs );
	obj->WedgeNormals	= (Vector3 *)		CORRECT_POINTER( obj->WedgeNormals );
	obj->WedgeColors	= (colrgba_s *)		CORRECT_POINTER( obj->WedgeColors );
	obj->WedgeTexCoords	= (TexCoord2 *)		CORRECT_POINTER( obj->WedgeTexCoords );
	obj->WedgeLighted	= (colrgba_s *)		CORRECT_POINTER( obj->WedgeLighted );
	obj->WedgeSpecular	= (colrgba_s *)		CORRECT_POINTER( obj->WedgeSpecular );
	obj->WedgeFogged	= (colrgba_s *)		CORRECT_POINTER( obj->WedgeFogged );

	// if correction takes place after relocation
	// the lists are already at their new positions
	if ( postcorrect ) {
		polylist = obj->PolyList;
		facelist = obj->FaceList;
	}

	// correct pointers contained in poly structures
	for ( unsigned int pid = 0; pid < obj->NumPolys; pid++ ) {
		if (&polylist[pid] != NULL)
			polylist[ pid ].VertIndxs = (dword *) CORRECT_POINTER( polylist[ pid ].VertIndxs );
	}

	// correct pointers contained in face structures
	for ( unsigned int fid = 0; fid < obj->NumFaces; fid++ ) {
		if (&facelist[fid] != NULL)
			facelist[ fid ].ExtInfo = (FaceExtInfo *) CORRECT_POINTER( facelist[ fid ].ExtInfo );
	}
}


// store wedge indexes as poly corner info ------------------------------------
//
PRIVATE
void OBJODT_StorePolyWedgeIndexes( GenObject *gobj, dword flags )
{
	ASSERT( gobj != NULL );

	if ( ( flags & OBJLOAD_POLYWEDGEINDEXES ) == 0 )
		return;

	// determine where wedge indexes should be stored
	dword wbase = 1;
	if ( flags & OBJLOAD_POLYCORNERCOLORS )
		wbase++;

	// augment polys with wedge indexes
	for ( unsigned int pid = 0; pid < gobj->NumPolys; pid++ ) {

		dword *vertindxs  = gobj->PolyList[ pid ].VertIndxs;
		dword *indxbeyond = &vertindxs[ gobj->PolyList[ pid ].NumVerts ];
		dword *wedgeindxs = &vertindxs[ gobj->PolyList[ pid ].NumVerts * wbase ];

		// map all vertex indexes
		for ( ; vertindxs < indxbeyond; vertindxs++ ) {

			int windx = -1;
			int vindx = *vertindxs - gobj->NumNormals;

			// check all wedges of this vertex
			int wstart  = wedge_info_vtxrange[ vindx ].start;
			int wbeyond = wedge_info_vtxrange[ vindx ].count + wstart;
			for ( ; wstart < wbeyond; wstart++ ) {

				// check all corners of this wedge
				int cstart  = wedge_info_wedges[ wstart ].cornerstart;
				int cbeyond = wedge_info_wedges[ wstart ].cornercount + cstart;
				for ( ; cstart < cbeyond; cstart++ ) {

					if ( (dword)corner_info_corners[ cstart ].polyid == pid ) {
						windx  = wstart;
						cstart = cbeyond;
						wstart = wbeyond;
					}
				}
			}

			// store corresponding wedge index
			ASSERT( windx != -1 );
			*wedgeindxs++ = windx;
		}

		// specify that wedge index array is present
		gobj->PolyList[ pid ].Flags = POLYFLAG_WEDGEINDEXES;
	}
}


// create wedge data structures -----------------------------------------------
//
PRIVATE
GenObject *OBJODT_CreateWedgeData( GenObject *gobj, size_t *objmemsize, dword flags )
{
	ASSERT( gobj != NULL );
	ASSERT( objmemsize != NULL );

	if ( ( flags & OBJLOAD_WEDGE_INFO ) == 0 )
		return gobj;

	// don't override wedges from file
	// (always 0 right now)
	if ( gobj->NumWedges > 0 ) {
		return gobj;
	}

	size_t basesize = *objmemsize;

	// create corner and wedge info,
	// determine number of wedges
	OBJODT_CreateVertexCornerInfo( gobj );
	OBJODT_CreateVertexWedgeInfo( gobj );
	dword numwedges = wedge_info_num_wedges;

	// GenObject::WedgeVertIndxs
	*objmemsize += sizeof( dword ) * numwedges;

	// GenObject::WedgeNormals
	if ( flags & OBJLOAD_WEDGENORMALS ) {
		*objmemsize += sizeof( Vector3 ) * numwedges;
	}

	// GenObject::WedgeColors
	if ( flags & OBJLOAD_WEDGECOLORS ) {
		*objmemsize += sizeof( colrgba_s ) * numwedges;
	}

	// GenObject::WedgeTexCoords
	if ( flags & OBJLOAD_WEDGETEXCOORDS ) {
		*objmemsize += sizeof( TexCoord2 ) * numwedges;
	}

	// GenObject::WedgeLighted
	if ( flags & OBJLOAD_WEDGELIGHTED ) {
		*objmemsize += sizeof( colrgba_s ) * numwedges;
	}

	// GenObject::WedgeSpecular
	if ( flags & OBJLOAD_WEDGESPECULAR ) {
		*objmemsize += sizeof( colrgba_s ) * numwedges;
	}

	// GenObject::WedgeFogged
	if ( flags & OBJLOAD_WEDGEFOGGED ) {
		*objmemsize += sizeof( colrgba_s ) * numwedges;
	}

	// allocate memory for expanded object
	char *curobjmem = (char *) ALLOCMEM( *objmemsize );
	if ( curobjmem == NULL )
		OUTOFMEM( no_object_mem );

	// copy original data
	memset( curobjmem, 0, *objmemsize );
	memcpy( curobjmem, gobj, basesize );

	GenObject *cobj = gobj;
	gobj = (GenObject *) curobjmem;

	// correct pointers
	ptrdiff_t pdiff = (char*)gobj - (char*)cobj;
	OBJODT_CorrectPointersBaseData( gobj, pdiff, TRUE );
	OBJODT_CorrectPointersGeomData( gobj, pdiff, TRUE );

	// free old object
	FREEMEM( cobj );
	char *heappos = curobjmem + basesize;

	// store number of wedges
	gobj->NumWedges = numwedges;

	// store pointers to wedge data
	gobj->WedgeVertIndxs = (dword *) heappos;
	heappos += sizeof( dword ) * numwedges;

	if ( flags & OBJLOAD_WEDGENORMALS ) {
		gobj->WedgeNormals = (Vector3 *) heappos;
		heappos += sizeof( Vector3 ) * numwedges;
	}
	if ( flags & OBJLOAD_WEDGECOLORS ) {
		gobj->WedgeColors = (colrgba_s *) heappos;
		heappos += sizeof( colrgba_s ) * numwedges;
	}
	if ( flags & OBJLOAD_WEDGETEXCOORDS ) {
		gobj->WedgeTexCoords = (TexCoord2 *) heappos;
		heappos += sizeof( TexCoord2 ) * numwedges;
	}
	if ( flags & OBJLOAD_WEDGELIGHTED ) {
		gobj->WedgeLighted = (colrgba_s *) heappos;
		heappos += sizeof( colrgba_s ) * numwedges;
	}
	if ( flags & OBJLOAD_WEDGESPECULAR ) {
		gobj->WedgeSpecular = (colrgba_s *) heappos;
		heappos += sizeof( colrgba_s ) * numwedges;
	}
	if ( flags & OBJLOAD_WEDGEFOGGED ) {
		gobj->WedgeFogged = (colrgba_s *) heappos;
		heappos += sizeof( colrgba_s ) * numwedges;
	}

	// store wedge data
	for ( unsigned int wedge = 0; wedge < numwedges; wedge++ ) {

		int vid = corner_info_corners[ wedge_info_wedges[ wedge ].cornerstart ].vertid;
		gobj->WedgeVertIndxs[ wedge ] = vid + gobj->NumNormals;

		if ( flags & OBJLOAD_WEDGENORMALS ) {
			gobj->WedgeNormals[ wedge ] = wedge_info_wedges[ wedge ].normal;
		}
		if ( flags & OBJLOAD_WEDGECOLORS ) {
			//TODO:
		}
		if ( flags & OBJLOAD_WEDGETEXCOORDS ) {
			//TODO:
		}
	}

	// store wedge indexes as poly corner info
	OBJODT_StorePolyWedgeIndexes( gobj, flags );

	// free temporary tables
	OBJODT_FreeVertexCornerWedgeInfo();

	return gobj;
}


// determine if face is texture mapped ----------------------------------------
//
PRIVATE
int ODT_FaceTextured( ODT_Face *face )
{
	return ( ( face->Shading == ODT_afftex_shad   ) ||
			 ( face->Shading == ODT_ipol1tex_shad ) ||
			 ( face->Shading == ODT_ipol2tex_shad ) ||
			 ( face->Shading == ODT_persptex_shad ) );
}


// these are global to reduce automatic variables in recursive traversal ------
//
static ODT_BSPNode	*odt_tree;
static BSPNode		*gen_tree;
static CullBSPNode	*aux_tree;
static GenObject	*base_obj;

static int			odt_numnodes;
static int			odt_numcontained;
static int			odt_maxnodeid;


// recursively swap bsp tree and determine number of nodes --------------------
//
PRIVATE
void ODT_SwapBSPTree( int node, int inlist )
{
	if ( node == 0 )
		return;

	if ( node > odt_maxnodeid )
		odt_maxnodeid = node;

	odt_tree[ node ].Polygon   = SWAP_32( odt_tree[ node ].Polygon );
	odt_tree[ node ].Contained = SWAP_32( odt_tree[ node ].Contained );
	odt_tree[ node ].FrontTree = SWAP_32( odt_tree[ node ].FrontTree );
	odt_tree[ node ].BackTree  = SWAP_32( odt_tree[ node ].BackTree );

	if ( odt_tree[ node ].BackTree > 0 ) {
		ASSERT( !inlist );
		ODT_SwapBSPTree( odt_tree[ node ].BackTree, FALSE );
	}

	if ( odt_tree[ node ].FrontTree > 0 ) {
		ASSERT( !inlist );
		ODT_SwapBSPTree( odt_tree[ node ].FrontTree, FALSE );
	}

	if ( odt_tree[ node ].Contained > 0 ) {
		ODT_SwapBSPTree( odt_tree[ node ].Contained, TRUE );
	}

	if ( inlist ) {
		odt_numcontained++;
	} else {
		odt_numnodes++;
	}
}


// recursively build bsp tree -------------------------------------------------
//
PRIVATE
void ODT_BuildBSPTree( int node )
{
	if ( node == 0 )
		return;

	ASSERT( (dword)node <= (dword)odt_maxnodeid );

	gen_tree[ node ].Polygon   = odt_tree[ node ].Polygon;
	gen_tree[ node ].Contained = odt_tree[ node ].Contained;
	gen_tree[ node ].FrontTree = odt_tree[ node ].FrontTree;
	gen_tree[ node ].BackTree  = odt_tree[ node ].BackTree;

	if ( odt_tree[ node ].BackTree > 0 ) {
		ODT_BuildBSPTree( odt_tree[ node ].BackTree );
	}

	if ( odt_tree[ node ].FrontTree > 0 ) {
		ODT_BuildBSPTree( odt_tree[ node ].FrontTree );
	}

	if ( odt_tree[ node ].Contained > 0 ) {
		ODT_BuildBSPTree( odt_tree[ node ].Contained );
	}
}


// recursively build aux bsp tree ---------------------------------------------
//
PRIVATE
void ODT_BuildBSPTreeAux( int node )
{
	if ( node == 0 )
		return;

	ASSERT( (dword)node <= (dword)odt_maxnodeid );

	dword polyid = odt_tree[ node ].Polygon;
	ASSERT( polyid < 32768 );

	aux_tree[ node ].polygons[ 0 ]	= 0;
	aux_tree[ node ].polygons[ 1 ]	= (short) polyid;
	aux_tree[ node ].numpolys[ 0 ]	= 0;
	aux_tree[ node ].numpolys[ 1 ]	= 1;

	// node polygon
	ASSERT( polyid < base_obj->NumPolys );
	Poly *poly = &base_obj->PolyList[ polyid ];

	// dot node normal with first polygon vertex
	dword normalindx	= base_obj->FaceList[ poly->FaceIndx ].FaceNormalIndx;
	geomv_t planeoffset	= DOT_PRODUCT( &base_obj->VertexList[ normalindx ],
									   &base_obj->VertexList[ *poly->VertIndxs ] );
	// set explicit plane spec
	aux_tree[ node ].plane.X		= base_obj->VertexList[ normalindx ].X;
	aux_tree[ node ].plane.Y		= base_obj->VertexList[ normalindx ].Y;
	aux_tree[ node ].plane.Z		= base_obj->VertexList[ normalindx ].Z;
	aux_tree[ node ].plane.D		= planeoffset;

//	aux_tree[ node ].minmax			= ?;

	aux_tree[ node ].flags			= 0;
	aux_tree[ node ].visframe		= 0;
	aux_tree[ node ].subtrees[ 0 ]	= odt_tree[ node ].BackTree;
	aux_tree[ node ].subtrees[ 1 ]	= odt_tree[ node ].FrontTree;

	if ( odt_tree[ node ].BackTree > 0 ) {
		ODT_BuildBSPTreeAux( odt_tree[ node ].BackTree );
	}

	if ( odt_tree[ node ].FrontTree > 0 ) {
		ODT_BuildBSPTreeAux( odt_tree[ node ].FrontTree );
	}

//FIXME:
// strip contained list
//	if ( odt_tree[ node ].Contained > 0 ) {
//		ODT_BuildBSPTreeAux( odt_tree[ node ].Contained );
//	}

}


// convert odt shading spec into internal shader spec -------------------------
//
PRIVATE
void ODT_ConvertShading( GenObject *gobj, dword faceid, ODT_Face *odtface, shader_s *shader )
{
#ifdef PARSEC_CLIENT

	ASSERT( gobj != NULL );
	ASSERT( faceid < gobj->NumFaces );
	ASSERT( odtface != NULL );

	// allow overriding shader specified in file
	if ( SetFaceShader( gobj, ACTIVE_LOD, faceid, shader ) )
		return;

	Face *face = &gobj->FaceList[ faceid ];

	switch ( odtface->Shading ) {

		case ODT_no_shad:
		case ODT_flat_shad:
		case ODT_gouraud_shad:
			face->ShadingIter  = iter_rgb | iter_overwrite;
			face->ShadingFlags = FACE_SHADING_USECOLORINDEX;
			break;

		case ODT_afftex_shad:
		case ODT_ipol1tex_shad:
		case ODT_ipol2tex_shad:
			face->ShadingIter  = iter_texrgb | iter_overwrite;
			face->ShadingFlags = FACE_SHADING_ENABLETEXTURE | FACE_SHADING_TEXIPOLATE;
			break;

		case ODT_persptex_shad:
			face->ShadingIter  = iter_texrgb | iter_overwrite;
			face->ShadingFlags = FACE_SHADING_ENABLETEXTURE;
			break;

//		case ODT_material_shad:
//		case ODT_texmat_shad:

		default:
			PANIC( "invalid ODT shading specification." );
	}

#endif // PARSEC_CLIENT
}


// create (internal) object from (external) odt object ------------------------
//
PRIVATE
size_t ODT_CreateObject( ODT_GenObject *cobj, dword flags, shader_s *shader )
{
	ASSERT( cobj != NULL );

	// default flags may be requested
	if ( flags == OBJLOAD_DEFAULT ) {
		flags = ODT_OBJLOAD_DEFAULT;
	}

	// swap important header fields
	cobj->InstanceSize	= SWAP_32( cobj->InstanceSize );
	cobj->NumVerts 		= SWAP_32( cobj->NumVerts );
	cobj->NumPolyVerts 	= SWAP_32( cobj->NumPolyVerts );
	cobj->NumNormals 	= SWAP_32( cobj->NumNormals );
	cobj->NumPolys		= SWAP_32( cobj->NumPolys );
	cobj->NumFaces		= SWAP_32( cobj->NumFaces );

	//NOTE:
	// some very old ODT files have an invalid InstanceSize field.
	// never mind, we recalculate it anyway.

	ASSERT( cobj->NumVerts == cobj->NumPolyVerts + cobj->NumNormals );
	ASSERT( cobj->NumPolys >= cobj->NumFaces );

	// new base address for object data
	size_t newdatabase = (size_t) cobj;

	// correct header relative pointers in object header to absolute pointers
	cobj->VertexList	= (ODT_Vertex3 *)	( SWAP_32( (size_t)cobj->VertexList )   + newdatabase );
	cobj->X_VertexList	= (ODT_Vertex3 *)	( SWAP_32( (size_t)cobj->X_VertexList ) + newdatabase );
	cobj->P_VertexList	= (ODT_ProjPoint *)	( SWAP_32( (size_t)cobj->P_VertexList ) + newdatabase );
	cobj->S_VertexList	= (ODT_SPoint *)	( SWAP_32( (size_t)cobj->S_VertexList ) + newdatabase );
	cobj->PolyList		= (ODT_Poly *)		( SWAP_32( (size_t)cobj->PolyList )     + newdatabase );
	cobj->FaceList		= (ODT_Face *)		( SWAP_32( (size_t)cobj->FaceList )     + newdatabase );
	cobj->VisPolyList	= (ODT_VisPolys *)	( SWAP_32( (size_t)cobj->VisPolyList )  + newdatabase );
	cobj->BSPTree		= (ODT_BSPNode *)	( SWAP_32( (size_t)cobj->BSPTree )      + newdatabase );

	// size of generic header plus size of type specific header
	size_t instancesize = OBJ_FetchTypeSize( cobj->ObjectType );

	// face anim state array may be included at end of instance data
	int       numfaceanimstates = 0;
	ptrdiff_t faceanimstatebase = 0;
	if ( flags & OBJLOAD_FACEANIMS ) {

		// default is simply a fixed number of anim states,
		// since we do not know the number of textures
		numfaceanimstates = ( odt_loading_params.max_face_anim_states > 0 ) ?
			odt_loading_params.max_face_anim_states : 16;

		// safeguard
		if ( numfaceanimstates > 256 ) {
			numfaceanimstates = 256;
		}

		size_t alignmentpadding  = ( ( instancesize + 3 ) & ~0x03 ) - instancesize;
		size_t sz_faceanimstates = numfaceanimstates * sizeof( FaceAnimState );

		faceanimstatebase = instancesize + alignmentpadding;
		instancesize += sz_faceanimstates + alignmentpadding;
	}

	// calc necessary alignment padding for data (area behind header)
	size_t alignmentpadding = ( ( instancesize + OBJ_GEOMETRY_ALIGNMENT_VAL )
								& OBJ_GEOMETRY_ALIGNMENT_MASK ) - instancesize;
	ASSERT( alignmentpadding <= OBJ_GEOMETRY_ALIGNMENT_VAL );

	// swap bsp tree and count number of nodes
	odt_numnodes	 = 0;
	odt_numcontained = 0;
	odt_maxnodeid	 = 0;
	odt_tree		 = cobj->BSPTree;

	ODT_SwapBSPTree( 1, FALSE );
//	ASSERT( odt_maxnodeid == odt_numnodes + odt_numcontained ); //FIXME:

	//NOTE:
	// apparently some ODT files contain bsp trees where there
	// are unused nodes in the interior of the array. therefore,
	// the above assertion may indeed fail. should look into this.

	// calc some numbers not available in header
	int numpolyvindexs = ( (size_t)cobj->FaceList - (size_t)cobj->PolyList -
							cobj->NumPolys * sizeof( ODT_Poly ) ) / sizeof( dword );
	int numodtbspnodes = odt_maxnodeid + 1;

	// reserve an extended face info for every face
	int numfaceexinfos = ( numfaceanimstates > 0 ) ? cobj->NumFaces : 0;

	// determine how many dwords to reserve
	// for each corner in a polygon
	size_t cornersize = 1;
	if ( flags & OBJLOAD_POLYCORNERCOLORS )
		cornersize++;
	if ( flags & OBJLOAD_POLYWEDGEINDEXES )
		cornersize++;

	// determine sizes of data areas
	size_t sz_vertexlist	 = cobj->NumVerts * sizeof( Vertex3 );
	size_t sz_xvertexlist	 = cobj->NumVerts * sizeof( Vertex3 );
	size_t sz_svertexlist	 = cobj->NumVerts * sizeof( SPoint );
	size_t sz_polylist		 = cobj->NumPolys * sizeof( Poly );
	size_t sz_polyindexes	 = numpolyvindexs * sizeof( dword ) * cornersize;
	size_t sz_facelist		 = cobj->NumFaces * sizeof( Face );
	size_t sz_faceextinfo	 = numfaceexinfos * sizeof( FaceExtInfo );
	size_t sz_vispolylist	 = cobj->NumPolys * sizeof( dword );
	size_t sz_bsptree		 = numodtbspnodes * sizeof( BSPNode );
	size_t sz_auxbsptree	 = numodtbspnodes * sizeof( CullBSPNode );

	// calc data size
	size_t datasize = 0;
	datasize += sz_vertexlist;		// VertexList
	datasize += sz_xvertexlist;		// X_VertexList
	datasize += sz_svertexlist;		// S_VertexList
	datasize += sz_polylist;		// PolyList
	datasize += sz_polyindexes;		// +poly vertex/wedge indexes
	datasize += sz_facelist;		// FaceList
	datasize += sz_faceextinfo;		// +extended face infos
	datasize += sz_vispolylist;		// VisPolyList
	datasize += sz_bsptree;			// BSPTree
	datasize += sz_auxbsptree;		// AuxBSPTree

	// calc size of memory block the object will occupy
	size_t objmemsize = instancesize + alignmentpadding + datasize;

	// allocate memory for object
	char *curobjmem = (char *) ALLOCMEM( objmemsize );
	if ( curobjmem == NULL )
		OUTOFMEM( no_object_mem );

	// preclear memory
	memset( curobjmem, 0, objmemsize );

	// init pointer to new class
	GenObject *gobj = (GenObject *) curobjmem;

	// init header fields
	gobj->NextObj			= NULL;
	gobj->PrevObj			= NULL;
	gobj->NextVisObj		= NULL;

	gobj->ObjectNumber		= 0;
	gobj->HostObjNumber 	= 0;
	gobj->ObjectType		= cobj->ObjectType;
	gobj->ObjectClass		= cobj->ObjectClass;
	gobj->InstanceSize		= instancesize;

	gobj->NumVerts 			= cobj->NumVerts;
	gobj->NumPolyVerts 		= cobj->NumPolyVerts;
	gobj->NumNormals 		= cobj->NumNormals;
	gobj->NumPolys			= cobj->NumPolys;
	gobj->NumFaces			= cobj->NumFaces;

	gobj->VertexList		= (Vertex3 *)	( (char*)gobj				+ instancesize + alignmentpadding );
	gobj->X_VertexList		= (Vertex3 *)	( (char*)gobj->VertexList	+ sz_vertexlist );
	gobj->S_VertexList		= (SPoint *)	( (char*)gobj->X_VertexList	+ sz_xvertexlist );
	gobj->PolyList			= (Poly *)		( (char*)gobj->S_VertexList	+ sz_svertexlist );
	gobj->FaceList			= (Face *)		( (char*)gobj->PolyList		+ sz_polylist + sz_polyindexes );
	gobj->VisPolyList		= (dword *)		( (char*)gobj->FaceList		+ sz_facelist + sz_faceextinfo );
	gobj->SortedPolyList	= NULL;
	gobj->AuxList			= NULL;
	gobj->BSPTree			= (BSPNode *)	( (char*)gobj->VisPolyList	+ sz_vispolylist );
	gobj->AuxBSPTree		= (CullBSPNode*)( (char*)gobj->BSPTree		+ sz_bsptree );
	//						= ( *)			( (char*)gobj->AuxBSPTree	+ sz_auxbsptree );

	gobj->NumFaceAnims		= numfaceanimstates;
	gobj->ActiveFaceAnims	= 0;
	gobj->FaceAnimStates	= ( flags & OBJLOAD_FACEANIMS ) ?
		(FaceAnimState *) ( (char*)gobj + faceanimstatebase ) : NULL;

	gobj->NumVtxAnims		= 0;
	gobj->ActiveVtxAnims	= 0;
	gobj->VtxAnimStates		= NULL;

	gobj->BoundingSphere 	= FIXED_TO_GEOMV( SWAP_32( DW32( cobj->BoundingSphere ) ) );
	gobj->BoundingSphere2 	= FIXED_TO_GEOMV( SWAP_32( DW32( cobj->BoundingSphere2 ) ) );

	// axial bounding box
	geomv_t mins[ 3 ];
	geomv_t maxs[ 3 ];

	// init to swapped maximum extents
	for ( int dim = 0; dim < 3; dim++ ) {
		mins[ dim ] =  gobj->BoundingSphere;
		maxs[ dim ] = -gobj->BoundingSphere;
	}

	// init list of vertices
	ODT_Vertex3 *odtvtxs = cobj->VertexList;
	Vertex3     *genvtxs = gobj->VertexList;

	for ( int vct = gobj->NumVerts; vct > 0; vct--, odtvtxs++, genvtxs++ ) {

		genvtxs->X = FIXED_TO_GEOMV( SWAP_32( DW32( odtvtxs->X ) ) );
		genvtxs->Y = FIXED_TO_GEOMV( SWAP_32( DW32( odtvtxs->Y ) ) );
		genvtxs->Z = FIXED_TO_GEOMV( SWAP_32( DW32( odtvtxs->Z ) ) );
		genvtxs->VisibleFrame = 0;

		// determine min-max coordinates in each dimension for bounding box
		mins[ 0 ] = min( mins[ 0 ], genvtxs->X );
		maxs[ 0 ] = max( maxs[ 0 ], genvtxs->X );

		mins[ 1 ] = min( mins[ 1 ], genvtxs->Y );
		maxs[ 1 ] = max( maxs[ 1 ], genvtxs->Y );

		mins[ 2 ] = min( mins[ 2 ], genvtxs->Z );
		maxs[ 2 ] = max( maxs[ 2 ], genvtxs->Z );
	}

	// store bounding box via min-max vertices
	gobj->BoundingBox[ 0 ].X = mins[ 0 ];
	gobj->BoundingBox[ 0 ].Y = mins[ 1 ];
	gobj->BoundingBox[ 0 ].Z = mins[ 2 ];

	gobj->BoundingBox[ 1 ].X = maxs[ 0 ];
	gobj->BoundingBox[ 1 ].Y = maxs[ 1 ];
	gobj->BoundingBox[ 1 ].Z = maxs[ 2 ];

	// init list of polygons
	ODT_Poly *odtpolys = cobj->PolyList;
	Poly     *genpolys = gobj->PolyList;
	dword    *genindxs = (dword *) ( (char*)gobj->PolyList + sz_polylist );

	int numindxs  = 0;
	for ( int pct = gobj->NumPolys; pct > 0; pct--, odtpolys++, genpolys++ ) {

		genpolys->NumVerts  = SWAP_32( odtpolys->NumVerts );
		genpolys->FaceIndx  = SWAP_32( odtpolys->FaceIndx );
		genpolys->VertIndxs = genindxs;
		genpolys->Flags		= POLYFLAG_DEFAULT;
		odtpolys->VertIndxs = (dword *) ( SWAP_32( (size_t)odtpolys->VertIndxs ) + newdatabase );

		// grab all vertex indexes
		dword *odtindxs = odtpolys->VertIndxs;
		for ( int vict = genpolys->NumVerts; vict > 0; vict--, numindxs++ ) {
			ASSERT( numindxs < numpolyvindexs );
			*genindxs++ = SWAP_32( *odtindxs );
			odtindxs++;
		}

		// skip area reserved for additional corner info
		genindxs += genpolys->NumVerts * ( cornersize - 1 );
	}
	ASSERT( numindxs == numpolyvindexs );

	// init list of faces
	ODT_Face *odtfaces = cobj->FaceList;

	for ( dword faceid = 0; faceid < gobj->NumFaces; faceid++, odtfaces++ ) {

		Face *face = &gobj->FaceList[ faceid ];

		// swap shading and texname fields
		odtfaces->Shading = SWAP_32( odtfaces->Shading );
		odtfaces->TexMap  = ODT_FaceTextured( odtfaces ) ?
			(char *) ( SWAP_32( (size_t)odtfaces->TexMap ) + newdatabase ) : NULL;

		face->TexMap		  = OBJODT_FetchTexture( odtfaces->TexMap );
		ODT_ConvertShading( gobj, faceid, odtfaces, shader );

		face->ExtInfo		  = NULL;

		face->ColorRGB		  = SWAP_32( odtfaces->ColorRGB );
		// set unspecified color to white
		if ( face->ColorRGB == 0 )
			face->ColorRGB = 0xffffffff;

		face->ColorIndx		  = SWAP_32( odtfaces->ColorIndx );
		face->FaceNormalIndx  = SWAP_32( odtfaces->FaceNormalIndx );
		face->VisibleFrame	  = VISFRAME_NEVER;

		face->TexXmatrx[0][0] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[0][0] ) ) );
		face->TexXmatrx[0][1] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[0][1] ) ) );
		face->TexXmatrx[0][2] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[0][2] ) ) );
		face->TexXmatrx[0][3] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[0][3] ) ) );
		face->TexXmatrx[1][0] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[1][0] ) ) );
		face->TexXmatrx[1][1] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[1][1] ) ) );
		face->TexXmatrx[1][2] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[1][2] ) ) );
		face->TexXmatrx[1][3] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[1][3] ) ) );
		face->TexXmatrx[2][0] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[2][0] ) ) );
		face->TexXmatrx[2][1] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[2][1] ) ) );
		face->TexXmatrx[2][2] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[2][2] ) ) );
		face->TexXmatrx[2][3] = FIXED_TO_GEOMV( SWAP_32( DW32( odtfaces->TexXmatrx[2][3] ) ) );
	}

	// init bsp tree
	odt_tree = cobj->BSPTree;
	gen_tree = gobj->BSPTree;
	aux_tree = gobj->AuxBSPTree;
	base_obj = gobj;

	ODT_BuildBSPTree( 1 );
	ODT_BuildBSPTreeAux( 1 );

	// create wedge data structures
	gobj = OBJODT_CreateWedgeData( gobj, &objmemsize, flags );

	// enter object into class array
	ObjClasses[ gobj->ObjectClass ] = gobj;

	// init class and type data of object
	OBJ_InitClass( gobj->ObjectClass );

	// return mem size of object
	return objmemsize;
}


// table of textures used by an object ----------------------------------------
//
struct texused_s {

	dword			num;
	TextureMap**	table;

} textures_used;


// presort object faces on certain attributes ---------------------------------
//
PRIVATE
void OD2_PreSortAttributes( GenObject *obj )
{
	ASSERT( obj != NULL );

#ifndef PARSEC_SERVER
	// sort polygons on texture
	if ( AUX_OBJ_SORT_POLYS_ON_TEXTURE ) 
	{

		dword *sortedindexes = obj->SortedPolyList;

		// sort textured faces
		for ( unsigned int tid = 0; tid < textures_used.num; tid++ ) {

			// map to compare with
			TextureMap *curmap = textures_used.table[ tid ];

			// process polygon list
			Poly *plist = obj->PolyList;
			for ( unsigned int pid = 0; pid < obj->NumPolys; pid++, plist++ ) {

				// store index if same texture
				if ( obj->FaceList[ plist->FaceIndx ].TexMap == curmap ) {
					*sortedindexes++ = pid;
				}
				ASSERT( ( sortedindexes - obj->SortedPolyList ) <= (int)obj->NumPolys );
			}
		}

		// append faces without textures
		Poly *plist = obj->PolyList;
		for ( unsigned int pid = 0; pid < obj->NumPolys; pid++, plist++ ) {

			// store index if no texture
			if ( obj->FaceList[ plist->FaceIndx ].TexMap == NULL ) {
				*sortedindexes++ = pid;
			}
			ASSERT( ( sortedindexes - obj->SortedPolyList ) <= (int)obj->NumPolys );
		}

		ASSERT( ( sortedindexes - obj->SortedPolyList ) == (int)obj->NumPolys );

	} 
	else 
#endif // !PARSEC_SERVER
	{
		// ensure the uninitialized list won't be used
		obj->SortedPolyList = NULL;
	}
}


// determine if face is texture mapped ----------------------------------------
//
PRIVATE
int OD2_FaceTextured( OD2_Face *face )
{
	return ( ( face->Shading == ( OD2_shad_afftex   & OD2_shadmask_base ) ) ||
			 ( face->Shading == ( OD2_shad_ipol1tex & OD2_shadmask_base ) ) ||
			 ( face->Shading == ( OD2_shad_ipol2tex & OD2_shadmask_base ) ) ||
			 ( face->Shading == ( OD2_shad_persptex & OD2_shadmask_base ) ) );
}


// convert od2 shading spec into internal shader spec -------------------------
//
PRIVATE
void OD2_ConvertShading( GenObject *gobj, dword faceid, OD2_Face *odtface, shader_s *shader )
{
#ifdef PARSEC_CLIENT

	ASSERT( gobj != NULL );
	ASSERT( faceid < gobj->NumFaces );
	ASSERT( odtface != NULL );

	// allow overriding shader specified in file
	if ( SetFaceShader( gobj, ACTIVE_LOD, faceid, shader ) )
		return;

	Face *face = &gobj->FaceList[ faceid ];

	switch ( odtface->Shading ) {

		case ( OD2_shad_ambient  & OD2_shadmask_base ):
		case ( OD2_shad_flat     & OD2_shadmask_base ):
		case ( OD2_shad_gouraud  & OD2_shadmask_base ):
			face->ShadingIter  = iter_rgb | iter_overwrite;
			face->ShadingFlags = FACE_SHADING_USECOLORINDEX;
			break;

		case ( OD2_shad_afftex   & OD2_shadmask_base ):
		case ( OD2_shad_ipol1tex & OD2_shadmask_base ):
		case ( OD2_shad_ipol2tex & OD2_shadmask_base ):
			face->ShadingIter  = iter_texrgb | iter_overwrite;
			face->ShadingFlags = FACE_SHADING_ENABLETEXTURE | FACE_SHADING_TEXIPOLATE;
			break;

		case ( OD2_shad_persptex & OD2_shadmask_base ):
			face->ShadingIter  = iter_texrgb | iter_overwrite;
			face->ShadingFlags = FACE_SHADING_ENABLETEXTURE;
			break;

//		case ( OD2_shad_material & OD2_shadmask_base ):
//		case ( OD2_shad_texmat   & OD2_shadmask_base ):

		default:
			PANIC( "invalid OD2 shading specification." );
	}
#endif // PARSEC_CLIENT
}


// converts a float as contained in odt2 file into native geomv_t -----------
//
INLINE
geomv_t OD2_Geomv_in( float value )
{
	dword tmp = SWAP_32( DW32( value ) );
	return FLOAT_TO_GEOMV( *(float *)&tmp );
}


// create (internal) object from (external) odt2 object -----------------------
//
PRIVATE
size_t OD2_CreateObject( OD2_Root *cobj, dword flags, shader_s *shader )
{
	ASSERT( cobj != NULL );

	// default flags may be requested
	if ( flags == OBJLOAD_DEFAULT ) {
		flags = OD2_OBJLOAD_DEFAULT;
	}

	// currently only version 1.0 valid
	if ( ( cobj->major != 1 ) || ( cobj->minor != 0 ) ) {
		return FALSE;
	}

	// swap important header fields
	cobj->rootflags			= SWAP_32( cobj->rootflags );
	cobj->rootflags2		= SWAP_32( cobj->rootflags2 );
	cobj->InstanceSize		= SWAP_32( cobj->InstanceSize );
	cobj->NumVerts 			= SWAP_32( cobj->NumVerts );
	cobj->NumPolyVerts 		= SWAP_32( cobj->NumPolyVerts );
	cobj->NumNormals 		= SWAP_32( cobj->NumNormals );
	cobj->NumPolys			= SWAP_32( cobj->NumPolys );
	cobj->NumFaces			= SWAP_32( cobj->NumFaces );
	cobj->NumTextures		= SWAP_32( cobj->NumTextures );

	ASSERT( cobj->InstanceSize == sizeof( OD2_Root ) );
	ASSERT( cobj->NumVerts >= cobj->NumPolyVerts + cobj->NumNormals );
	ASSERT( cobj->NumPolys >= cobj->NumFaces );

	// new base address for object data
	size_t newdatabase = (size_t) cobj;

	// correct header relative pointers in object header to absolute pointers
	cobj->NodeList		= (OD2_Node *)		( SWAP_32( (size_t)cobj->NodeList )		+ newdatabase );
	cobj->Children[ 0 ]	= (OD2_Child *)		( SWAP_32( (size_t)cobj->Children[ 0 ] )+ newdatabase );
	cobj->Children[ 1 ]	= (OD2_Child *)		( SWAP_32( (size_t)cobj->Children[ 1 ] )+ newdatabase );
	cobj->VertexList	= (OD2_Vertex3 *)	( SWAP_32( (size_t)cobj->VertexList )	+ newdatabase );
	cobj->PolyList		= (OD2_Poly *)		( SWAP_32( (size_t)cobj->PolyList )		+ newdatabase );
	cobj->FaceList		= (OD2_Face *)		( SWAP_32( (size_t)cobj->FaceList )		+ newdatabase );

	// size of generic header plus size of type specific header
	size_t instancesize = OBJ_FetchTypeSize( cobj->ObjectType );

	// face anim state array may be included at end of instance data
	int       numfaceanimstates = 0;
	ptrdiff_t faceanimstatebase = 0;
	if ( flags & OBJLOAD_FACEANIMS ) {

		// default is the number of textures
		numfaceanimstates = ( odt_loading_params.max_face_anim_states > 0 ) ?
			odt_loading_params.max_face_anim_states : cobj->NumTextures;

		// safeguard
		if ( numfaceanimstates > 256 ) {
			numfaceanimstates = 256;
		}

		size_t alignmentpadding  = ( ( instancesize + 3 ) & ~0x03 ) - instancesize;
		size_t sz_faceanimstates = numfaceanimstates * sizeof( FaceAnimState );

		faceanimstatebase = instancesize + alignmentpadding;
		instancesize += sz_faceanimstates + alignmentpadding;
	}

	// vertex anim state array may be included at end of instance data
	int       numvtxanimstates = 0;
	ptrdiff_t vtxanimstatebase = 0;
	if ( flags & OBJLOAD_VTXANIMS ) {

		// default is simply a fixed number
		numvtxanimstates = ( odt_loading_params.max_vtx_anim_states > 0 ) ?
			odt_loading_params.max_vtx_anim_states : 4;

		// safeguard
		if ( numvtxanimstates > 64 ) {
			numvtxanimstates = 64;
		}

		// number of additional base object info states
		int numbases = 1;

		// need space for every lod (instance data will be taken from lod 0)
		lodinfo_s *lodinfo = ObjectInfo[ cobj->ObjectClass ].lodinfo;
		if ( lodinfo != NULL ) {
			ASSERT( lodinfo->numlods > 0 );
			numvtxanimstates *= lodinfo->numlods;
			numbases = lodinfo->numlods;
		}

		// reserve additional anim states for base object infos (beyond)
		size_t alignmentpadding = ( ( instancesize + 3 ) & ~0x03 ) - instancesize;
		size_t sz_vtxanimstates = ( numvtxanimstates + numbases ) * sizeof( VtxAnimState );

		vtxanimstatebase = instancesize + alignmentpadding;
		instancesize += sz_vtxanimstates + alignmentpadding;
	}

	// calc necessary alignment padding for data (area behind header)
	size_t alignmentpadding = ( ( instancesize + OBJ_GEOMETRY_ALIGNMENT_VAL )
								& OBJ_GEOMETRY_ALIGNMENT_MASK ) - instancesize;
	ASSERT( alignmentpadding <= OBJ_GEOMETRY_ALIGNMENT_VAL );

	// calc some numbers not available in header
	int numpolyvindexs = ( (size_t)cobj->FaceList - (size_t)cobj->PolyList -
							cobj->NumPolys * sizeof( OD2_Poly ) ) / sizeof( dword );

	// reserve an extended face info for every face
	int numfaceexinfos = ( numfaceanimstates > 0 ) ? cobj->NumFaces : 0;

	// determine how many dwords to reserve
	// for each corner in a polygon
	size_t cornersize = 1;
	if ( flags & OBJLOAD_POLYCORNERCOLORS )
		cornersize++;
	if ( flags & OBJLOAD_POLYWEDGEINDEXES )
		cornersize++;

	// determine sizes of data areas
	size_t sz_vertexlist	 = cobj->NumVerts * sizeof( Vertex3 );
	size_t sz_xvertexlist	 = cobj->NumVerts * sizeof( Vertex3 );
	size_t sz_svertexlist	 = cobj->NumVerts * sizeof( SPoint );
	size_t sz_sortedpolylist = cobj->NumPolys * sizeof( dword );
	size_t sz_polylist		 = cobj->NumPolys * sizeof( Poly );
	size_t sz_polyindexes	 = numpolyvindexs * sizeof( dword ) * cornersize;
	size_t sz_facelist		 = cobj->NumFaces * sizeof( Face );
	size_t sz_faceextinfo	 = numfaceexinfos * sizeof( FaceExtInfo );
	size_t sz_vispolylist	 = cobj->NumPolys * sizeof( dword );

	// calc data size
	size_t datasize = 0;
	datasize += sz_vertexlist;		// VertexList
	datasize += sz_xvertexlist;		// X_VertexList
	datasize += sz_svertexlist;		// S_VertexList
	datasize += sz_sortedpolylist;	// SortedPolyList
	datasize += sz_polylist;		// PolyList
	datasize += sz_polyindexes;		// +poly vertex/wedge indexes
	datasize += sz_facelist;		// FaceList
	datasize += sz_faceextinfo;		// +extended face infos
	datasize += sz_vispolylist;		// VisPolyList

	// calc size of memory block the object will occupy
	size_t objmemsize = instancesize + alignmentpadding + datasize;

	// allocate memory for object
	char *curobjmem = (char *) ALLOCMEM( objmemsize );
	if ( curobjmem == NULL )
		OUTOFMEM( no_object_mem );

	// preclear memory
	memset( curobjmem, 0, objmemsize );

	// init pointer to new class
	GenObject *gobj = (GenObject *) curobjmem;

	// init header fields
	gobj->NextObj			= NULL;
	gobj->PrevObj			= NULL;
	gobj->NextVisObj		= NULL;

	gobj->ObjectNumber		= 0;
	gobj->HostObjNumber 	= 0;
	gobj->ObjectType		= cobj->ObjectType;
	gobj->ObjectClass		= cobj->ObjectClass;
	gobj->InstanceSize		= instancesize;

	gobj->NumVerts 			= cobj->NumVerts;
	gobj->NumPolyVerts 		= cobj->NumPolyVerts;
	gobj->NumNormals 		= cobj->NumNormals;
	gobj->NumPolys			= cobj->NumPolys;
	gobj->NumFaces			= cobj->NumFaces;

	gobj->VertexList		= (Vertex3 *)	( (char*)gobj					+ instancesize + alignmentpadding );
	gobj->X_VertexList		= (Vertex3 *)	( (char*)gobj->VertexList		+ sz_vertexlist );
	gobj->S_VertexList		= (SPoint *)	( (char*)gobj->X_VertexList		+ sz_xvertexlist );
	gobj->SortedPolyList	= (dword *)		( (char*)gobj->S_VertexList		+ sz_svertexlist );
	gobj->PolyList			= (Poly *)		( (char*)gobj->SortedPolyList	+ sz_sortedpolylist );
	gobj->FaceList			= (Face *)		( (char*)gobj->PolyList			+ sz_polylist + sz_polyindexes );
	gobj->VisPolyList		= (dword *)		( (char*)gobj->FaceList			+ sz_facelist + sz_faceextinfo );
	//						= ( *)			( (char*)gobj->VisPolyList		+ sz_vispolylist );
	gobj->AuxList			= NULL;
	gobj->BSPTree			= NULL;
	gobj->AuxBSPTree		= NULL;

	gobj->NumFaceAnims		= numfaceanimstates;
	gobj->ActiveFaceAnims	= 0;
	gobj->FaceAnimStates	= ( flags & OBJLOAD_FACEANIMS ) ?
		(FaceAnimState *) ( (char*)gobj + faceanimstatebase ) : NULL;

	gobj->NumVtxAnims		= numvtxanimstates;
	gobj->ActiveVtxAnims	= 0;
	gobj->VtxAnimStates		= ( flags & OBJLOAD_VTXANIMS ) ?
		(VtxAnimState *) ( (char*)gobj + vtxanimstatebase ) : NULL;

	dword tmp				= SWAP_32( DW32( cobj->BoundingSphere ) );
	float boundrad		= *(float *)&tmp;
	gobj->BoundingSphere 	= FLOAT_TO_GEOMV( boundrad );
	gobj->BoundingSphere2 	= FLOAT_TO_GEOMV( boundrad * boundrad );

	// axial bounding box
	geomv_t mins[ 3 ];
	geomv_t maxs[ 3 ];

#ifdef OD2_BBOX_VALID

	// take bbox from file
	for ( int dim = 0; dim < 3; dim++ ) {
		mins[ dim ] = FLOAT_TO_GEOMV( cobj->BoundingBox.mins[ dim ] );
		maxs[ dim ] = FLOAT_TO_GEOMV( cobj->BoundingBox.maxs[ dim ] );
	}

#else

	// init bbox to swapped maximum extents
	for ( int dim = 0; dim < 3; dim++ ) {
		mins[ dim ] =  gobj->BoundingSphere;
		maxs[ dim ] = -gobj->BoundingSphere;
	}

#endif

	// init list of vertices
	OD2_Vertex3 *odtvtxs = cobj->VertexList;
	Vertex3     *genvtxs = gobj->VertexList;

	for ( int vct = gobj->NumVerts; vct > 0; vct--, odtvtxs++, genvtxs++ ) {

		genvtxs->X = OD2_Geomv_in( odtvtxs->X );
		genvtxs->Y = OD2_Geomv_in( odtvtxs->Y );
		genvtxs->Z = OD2_Geomv_in( odtvtxs->Z );
		genvtxs->VisibleFrame = 0;

#ifndef OD2_BBOX_VALID

		mins[ 0 ] = min( mins[ 0 ], genvtxs->X );
		maxs[ 0 ] = max( maxs[ 0 ], genvtxs->X );

		mins[ 1 ] = min( mins[ 1 ], genvtxs->Y );
		maxs[ 1 ] = max( maxs[ 1 ], genvtxs->Y );

		mins[ 2 ] = min( mins[ 2 ], genvtxs->Z );
		maxs[ 2 ] = max( maxs[ 2 ], genvtxs->Z );
#endif

	}

	// store bounding box via min-max vertices
	gobj->BoundingBox[ 0 ].X = mins[ 0 ];
	gobj->BoundingBox[ 0 ].Y = mins[ 1 ];
	gobj->BoundingBox[ 0 ].Z = mins[ 2 ];

	gobj->BoundingBox[ 1 ].X = maxs[ 0 ];
	gobj->BoundingBox[ 1 ].Y = maxs[ 1 ];
	gobj->BoundingBox[ 1 ].Z = maxs[ 2 ];

	// init list of polygons
	OD2_Poly *odtpolys = cobj->PolyList;
	Poly     *genpolys = gobj->PolyList;
	dword    *genindxs = (dword *) ( (char*)gobj->PolyList + sz_polylist );

	int numindxs  = 0;
	for ( int pct = gobj->NumPolys; pct > 0; pct--, odtpolys++, genpolys++ ) {

		genpolys->NumVerts  = SWAP_32( odtpolys->NumVerts );
		genpolys->FaceIndx  = SWAP_32( odtpolys->FaceIndx );
		genpolys->VertIndxs = genindxs;
		genpolys->Flags		= POLYFLAG_DEFAULT;
		odtpolys->VertIndxs = (dword *) ( SWAP_32( (size_t)odtpolys->VertIndxs ) + newdatabase );

		// grab all vertex indexes
		dword *odtindxs = odtpolys->VertIndxs;
		for ( int vict = genpolys->NumVerts; vict > 0; vict--, numindxs++ ) {
			ASSERT( numindxs < numpolyvindexs );
			*genindxs++ = SWAP_32( *odtindxs );
			odtindxs++;
		}

		// skip area reserved for additional corner info
		genindxs += genpolys->NumVerts * ( cornersize - 1 );
	}
	ASSERT( numindxs == numpolyvindexs );

	// create temporary texture table
	textures_used.num	= cobj->NumTextures;
	textures_used.table	= ( textures_used.num > 0 ) ? (TextureMap **)
		ALLOCMEM( textures_used.num * sizeof( TextureMap* ) ) : NULL;

	// init list of faces
	OD2_Face *odtfaces = cobj->FaceList;

	unsigned int numtexturesused = 0;
	for ( dword faceid = 0; faceid < gobj->NumFaces; faceid++, odtfaces++ ) {

		Face *face = &gobj->FaceList[ faceid ];

		// swap shading and texname fields
		odtfaces->Shading = SWAP_32( odtfaces->Shading );
		odtfaces->TexMap  = OD2_FaceTextured( odtfaces ) ? (char *)
			( SWAP_32( (size_t)odtfaces->TexMap ) + newdatabase ) : NULL;

		face->TexMap		  = OBJODT_FetchTexture( odtfaces->TexMap );
		OD2_ConvertShading( gobj, faceid, odtfaces, shader );

		face->ExtInfo		  = NULL;

		face->ColorRGB		  = SWAP_32( odtfaces->ColorRGB );
		// set unspecified color to white
		if ( face->ColorRGB == 0 )
			face->ColorRGB = 0xffffffff;

		face->ColorIndx		  = SWAP_32( odtfaces->ColorIndx );
		face->FaceNormalIndx  = SWAP_32( odtfaces->FaceNormalIndx );
		face->VisibleFrame	  = VISFRAME_NEVER;

		face->TexXmatrx[0][0] = OD2_Geomv_in( odtfaces->TexXmatrx[0][0] );
		face->TexXmatrx[0][1] = OD2_Geomv_in( odtfaces->TexXmatrx[0][1] );
		face->TexXmatrx[0][2] = OD2_Geomv_in( odtfaces->TexXmatrx[0][2] );
		face->TexXmatrx[0][3] = OD2_Geomv_in( odtfaces->TexXmatrx[0][3] );
		face->TexXmatrx[1][0] = OD2_Geomv_in( odtfaces->TexXmatrx[1][0] );
		face->TexXmatrx[1][1] = OD2_Geomv_in( odtfaces->TexXmatrx[1][1] );
		face->TexXmatrx[1][2] = OD2_Geomv_in( odtfaces->TexXmatrx[1][2] );
		face->TexXmatrx[1][3] = OD2_Geomv_in( odtfaces->TexXmatrx[1][3] );
		face->TexXmatrx[2][0] = OD2_Geomv_in( odtfaces->TexXmatrx[2][0] );
		face->TexXmatrx[2][1] = OD2_Geomv_in( odtfaces->TexXmatrx[2][1] );
		face->TexXmatrx[2][2] = OD2_Geomv_in( odtfaces->TexXmatrx[2][2] );
		face->TexXmatrx[2][3] = OD2_Geomv_in( odtfaces->TexXmatrx[2][3] );

		if ( face->TexMap != NULL ) {

			// enter texture into list if not used before
			ASSERT( textures_used.table != NULL );	
			unsigned int tid = 0;
			for ( tid = 0; tid < numtexturesused; tid++ )
				if ( textures_used.table[ tid ] == face->TexMap )
					break;
			if ( tid == numtexturesused ) {
				ASSERT( numtexturesused < textures_used.num );
				textures_used.table[ tid ] = face->TexMap;
				numtexturesused++;
			}
		}
	}

#ifdef PARSEC_CLIENT

	// this will only fire if at least two textures are missing (the first
	// missing texture will count texinvalid and therefore not change the count)
	if ( numtexturesused != textures_used.num ) {
		MSGOUT( "using %d fewer textures for object than specified.", ( textures_used.num - numtexturesused ) );
	}

#endif // PARSEC_CLIENT

	// create wedge data structures
	gobj = OBJODT_CreateWedgeData( gobj, &objmemsize, flags );

	// perform presorting for face attributes
	OD2_PreSortAttributes( gobj );

	// free temporary texture table
	if ( textures_used.table != NULL ) {
		FREEMEM( textures_used.table );
		textures_used.table = NULL;
	}

	// enter object into class array
	ObjClasses[ gobj->ObjectClass ] = gobj;

	// init class and type data of object
	OBJ_InitClass( gobj->ObjectClass );

	// return mem size of object
	return objmemsize;
}


// temporary tables to store info about object lods ---------------------------
//
static GenObject*	object_lod_classes[ MAX_OBJECT_LODS ];
static size_t		object_lod_sizes[ MAX_OBJECT_LODS ];


#ifdef PARSEC_SERVER
//FIXME: HACK: this function must be moved from OBJ_CTRL to a shared module

// switch object detail level -------------------------------------------------
//
void OBJ_SwitchObjectLod( GenObject *obj, dword lod )
{
	ASSERT( obj != NULL );
	ASSERT( lod < obj->NumLodObjects );

	// store active lod
	obj->CurrentLod = lod;

	// retrieve source geometry
	ASSERT( obj->LodObjects != NULL );
	GenLodObject *lodobj = obj->LodObjects[ lod ].LodObject;

	// switch geometry
	ASSERT( lodobj != NULL );
	obj->NumVerts			= lodobj->NumVerts;
	obj->NumPolyVerts		= lodobj->NumPolyVerts;
	obj->NumNormals			= lodobj->NumNormals;
	obj->VertexList			= lodobj->VertexList;
	obj->X_VertexList		= lodobj->X_VertexList;
	obj->S_VertexList		= lodobj->S_VertexList;
	obj->NumPolys			= lodobj->NumPolys;
	obj->PolyList			= lodobj->PolyList;
	obj->NumFaces			= lodobj->NumFaces;
	obj->FaceList			= lodobj->FaceList;
	obj->VisPolyList		= lodobj->VisPolyList;
	obj->SortedPolyList		= lodobj->SortedPolyList;
	obj->AuxList			= lodobj->AuxList;
	obj->BSPTree			= lodobj->BSPTree;
	obj->AuxBSPTree			= lodobj->AuxBSPTree;
	obj->AuxObject			= lodobj->AuxObject;
	obj->NumWedges			= lodobj->NumWedges;
	obj->NumLayers			= lodobj->NumLayers;
	obj->WedgeFlags			= lodobj->WedgeFlags;
	obj->WedgeVertIndxs		= lodobj->WedgeVertIndxs;
	obj->WedgeNormals		= lodobj->WedgeNormals;
	obj->WedgeColors		= lodobj->WedgeColors;
	obj->WedgeTexCoords		= lodobj->WedgeTexCoords;
	obj->WedgeLighted		= lodobj->WedgeLighted;
	obj->WedgeSpecular		= lodobj->WedgeSpecular;
	obj->WedgeFogged		= lodobj->WedgeFogged;
	obj->ActiveFaceAnims	= lodobj->ActiveFaceAnims;
	obj->ActiveVtxAnims		= lodobj->ActiveVtxAnims;
}
#endif // PARSEC_SERVER


// merge lod objects into single object ---------------------------------------
//
PRIVATE
size_t InitClassFromODTLods( dword classid )
{
	ASSERT( classid < MAX_DISTINCT_OBJCLASSES );

	lodinfo_s *lodinfo = ObjectInfo[ classid ].lodinfo;
	ASSERT( lodinfo != NULL );

	int numlods = lodinfo->numlods;
	ASSERT( (dword)numlods <= MAX_OBJECT_LODS );

	// determine resulting size
	size_t objmemsize = 0;

	size_t baseinstancesize	= object_lod_classes[ 0 ]->InstanceSize;
	size_t lodspecsize		= numlods * ( sizeof( GenLodInfo ) + sizeof( GenLodObject ) );
	objmemsize += baseinstancesize + lodspecsize;
	int lod = 0;
	for ( lod = 0; lod < numlods; lod++ ) {

		GenObject *curobj = object_lod_classes[ lod ];
		ASSERT( curobj != NULL );

		ASSERT( curobj->NumLodObjects == 0 );
		ASSERT( curobj->LodObjects == NULL );

		size_t alignmentpadding = ( ( objmemsize + OBJ_GEOMETRY_ALIGNMENT_VAL )
									& OBJ_GEOMETRY_ALIGNMENT_MASK ) - objmemsize;
		objmemsize += alignmentpadding;

		size_t instancesize = curobj->InstanceSize;
		alignmentpadding = ( ( instancesize + OBJ_GEOMETRY_ALIGNMENT_VAL )
							 & OBJ_GEOMETRY_ALIGNMENT_MASK ) - instancesize;

		objmemsize += object_lod_sizes[ lod ] - instancesize - alignmentpadding;
	}

	// allocate memory for object
	char *curobjmem = (char *) ALLOCMEM( objmemsize );
	if ( curobjmem == NULL )
		OUTOFMEM( no_object_mem );
	memset( curobjmem, 0, objmemsize );

	GenObject*    gobj         = (GenObject *)		curobjmem;
	GenLodInfo*   genlodinfo   = (GenLodInfo *)   ( curobjmem + baseinstancesize );
	GenLodObject* genlodobject = (GenLodObject *) ( curobjmem + baseinstancesize + numlods * sizeof( GenLodInfo ) );

	// initialize object
	memcpy( gobj, object_lod_classes[ 0 ], baseinstancesize );

	ptrdiff_t pdiff = (char*)gobj - (char*)object_lod_classes[ 0 ];
	OBJODT_CorrectPointersBaseData( gobj, pdiff, TRUE );

	gobj->NumLodObjects	= numlods;
	gobj->LodObjects	= genlodinfo;

	size_t curfillofs = baseinstancesize + lodspecsize;
	for ( lod = 0; lod < numlods; lod++ ) {

		GenObject *curobj = object_lod_classes[ lod ];
		ASSERT( curobj != NULL );

		size_t alignmentpadding = ( ( curfillofs + OBJ_GEOMETRY_ALIGNMENT_VAL )
									& OBJ_GEOMETRY_ALIGNMENT_MASK ) - curfillofs;
		curfillofs += alignmentpadding;

		size_t instancesize = curobj->InstanceSize;
		alignmentpadding = ( ( instancesize + OBJ_GEOMETRY_ALIGNMENT_VAL )
							 & OBJ_GEOMETRY_ALIGNMENT_MASK ) - instancesize;
		// correct pointers
		pdiff = (char*)gobj - (char*)curobj;
		pdiff += curfillofs - instancesize - alignmentpadding;
		OBJODT_CorrectPointersGeomData( curobj, pdiff, FALSE );

		// copy pointers
		GenLodObject *lodobj = &genlodobject[ lod ];

		lodobj->NumVerts		= curobj->NumVerts;
		lodobj->NumPolyVerts	= curobj->NumPolyVerts;
		lodobj->NumNormals		= curobj->NumNormals;
		lodobj->VertexList		= curobj->VertexList;
		lodobj->X_VertexList	= curobj->X_VertexList;
		lodobj->S_VertexList	= curobj->S_VertexList;
		lodobj->NumPolys		= curobj->NumPolys;
		lodobj->PolyList		= curobj->PolyList;
		lodobj->NumFaces		= curobj->NumFaces;
		lodobj->FaceList		= curobj->FaceList;
		lodobj->VisPolyList		= curobj->VisPolyList;
		lodobj->SortedPolyList	= curobj->SortedPolyList;
		lodobj->AuxList			= curobj->AuxList;
		lodobj->BSPTree			= curobj->BSPTree;
		lodobj->AuxBSPTree		= curobj->AuxBSPTree;
		lodobj->AuxObject		= curobj->AuxObject;
		lodobj->NumWedges		= curobj->NumWedges;
		lodobj->NumLayers		= curobj->NumLayers;
		lodobj->WedgeFlags		= curobj->WedgeFlags;
		lodobj->WedgeVertIndxs	= curobj->WedgeVertIndxs;
		lodobj->WedgeNormals	= curobj->WedgeNormals;
		lodobj->WedgeColors		= curobj->WedgeColors;
		lodobj->WedgeTexCoords	= curobj->WedgeTexCoords;
		lodobj->WedgeLighted	= curobj->WedgeLighted;
		lodobj->WedgeSpecular	= curobj->WedgeSpecular;
		lodobj->WedgeFogged		= curobj->WedgeFogged;
		lodobj->ActiveFaceAnims	= curobj->ActiveFaceAnims;
		lodobj->ActiveVtxAnims	= curobj->ActiveVtxAnims;

		// copy data
		size_t datasize = object_lod_sizes[ lod ] - instancesize - alignmentpadding;
		memcpy( curobjmem + curfillofs, (char*)curobj + instancesize + alignmentpadding, datasize );
		curfillofs += datasize;

		// store info
		genlodinfo[ lod ].Flags		  = 0x0000;
		genlodinfo[ lod ].MagTreshold = lodinfo->lodmags[ lod ];
		genlodinfo[ lod ].MinTreshold = lodinfo->lodmins[ lod ];
		genlodinfo[ lod ].LodObject	  = lodobj;
	}

	// init base to lod 0
	// (mandatory due to pointer correction)
	OBJ_SwitchObjectLod( gobj, 0 );

	// set new class pointer
	ObjClasses[ classid ] = gobj;

	// return mem size of object
	return objmemsize;
}


// load a single object from an odt file, insert into global class table ------
//
PRIVATE
size_t InitClassFromODT( dword classid, dword flags, shader_s *shader )
{
	ASSERT( classid < MAX_DISTINCT_OBJCLASSES );

	// determine file size
	size_t odtobjsize = SYS_GetFileLength( ObjectInfo[ classid ].file );
	if ( odtobjsize == (dword)-1 )
		FERROR( object_not_found, ObjectInfo[ classid ].file );
	if ( odtobjsize < sizeof( ODT_GenObject ) )
		PERROR( corrupt_object );

	// allocate temporary memory for odt object
	char *odtobjmem = (char *) ALLOCMEM( odtobjsize );
	if ( odtobjmem == NULL )
		OUTOFMEM( no_object_mem );

	FILE *fp = SYS_fopen( ObjectInfo[ classid ].file, "rb" );
	if ( fp == NULL )
		FERROR( object_not_found, ObjectInfo[ classid ].file );

	// read odt data in one chunk
	if ( SYS_fread( odtobjmem, 1, odtobjsize, fp ) != odtobjsize )
		FERROR( object_readerror, ObjectInfo[ classid ].file );

	if ( SYS_fclose( fp ) != 0 )
		FERROR( object_readerror, ObjectInfo[ classid ].file );

	// determine whether file is ODT2
	int isodt2 = ( strcmp( odtobjmem, "ODT2" ) == 0 );

	// actual object mem size
	size_t objmemsize = 0;

	if ( isodt2 ) {

		// init important header fields
		OD2_Root *cobj = (OD2_Root *) odtobjmem;

		cobj->ObjectType	= ObjectInfo[ classid ].type;
		cobj->ObjectClass	= classid;

		// convert odt2 to internal object format
		objmemsize = OD2_CreateObject( cobj, flags, shader );

	} else {

		// init important header fields
		ODT_GenObject *cobj = (ODT_GenObject *) odtobjmem;

		cobj->ObjectNumber	= 0;
		cobj->HostObjNumber = 0;
		cobj->ObjectType	= ObjectInfo[ classid ].type;
		cobj->ObjectClass	= classid;

		// convert odt to internal object format
		objmemsize = ODT_CreateObject( cobj, flags, shader );
	}

	// memory for loaded data is temporary
	FREEMEM( odtobjmem );

	// return actual object mem size
	return objmemsize;
}


// load object from odt file --------------------------------------------------
//
int OBJ_LoadODT( dword classid, dword flags, shader_s *shader )
{
	ASSERT( classid < MAX_DISTINCT_OBJCLASSES );

	//NOTE:
	// object type of specified object class must already
	// be valid in the global ObjectInfo[] table before
	// calling this function.

	if ( ObjectInfo[ classid ].lodinfo == NULL ) {

		// simply load one object class
		return ( InitClassFromODT( classid, flags, shader ) > 0 );

	} else {

		// fetch info table
		lodinfo_s *lodinfo = ObjectInfo[ classid ].lodinfo;
		int numlods = lodinfo->numlods;
		if ( numlods > MAX_OBJECT_LODS ) {
			ASSERT( 0 );
			numlods = MAX_OBJECT_LODS;
		}

		// save base filename
		char *savebase = ObjectInfo[ classid ].file;

		// load object classes for all lods
		int lod = 0;
		for ( lod = 0; lod < numlods; lod++ ) {

			// read lod file, init class
			ObjectInfo[ classid ].file = lodinfo->filetab[ lod ];
			size_t objmemsize = InitClassFromODT( classid, flags, shader );
			if ( objmemsize == 0 ) {
				// return which lod failed
				return -lod;
			}

			object_lod_classes[ lod ] = ObjClasses[ classid ];
			object_lod_sizes[ lod ]   = objmemsize;
		}

		// restore base filename
		ObjectInfo[ classid ].file = savebase;

		// merge lod objects into single object
		size_t objmemsize = InitClassFromODTLods( classid );

		// free single objects
		for ( lod = 0; lod < numlods; lod++ ) {
			FREEMEM( object_lod_classes[ lod ] );
		}

		return ( objmemsize > 0 );
	}
}