--- /dev/null
+/*
+======================================================================
+pntspols.c
+
+Point and polygon functions for an LWO2 reader.
+
+Ernie Wright 17 Sep 00
+====================================================================== */
+
+#include "../picointernal.h"
+#include "lwo2.h"
+
+
+/*
+======================================================================
+lwFreePoints()
+
+Free the memory used by an lwPointList.
+====================================================================== */
+
+void lwFreePoints( lwPointList *point )
+{
+ int i;
+
+ if ( point ) {
+ if ( point->pt ) {
+ for ( i = 0; i < point->count; i++ ) {
+ if ( point->pt[ i ].pol ) _pico_free( point->pt[ i ].pol );
+ if ( point->pt[ i ].vm ) _pico_free( point->pt[ i ].vm );
+ }
+ _pico_free( point->pt );
+ }
+ memset( point, 0, sizeof( lwPointList ));
+ }
+}
+
+
+/*
+======================================================================
+lwFreePolygons()
+
+Free the memory used by an lwPolygonList.
+====================================================================== */
+
+void lwFreePolygons( lwPolygonList *plist )
+{
+ int i, j;
+
+ if ( plist ) {
+ if ( plist->pol ) {
+ for ( i = 0; i < plist->count; i++ ) {
+ if ( plist->pol[ i ].v ) {
+ for ( j = 0; j < plist->pol[ i ].nverts; j++ )
+ if ( plist->pol[ i ].v[ j ].vm )
+ _pico_free( plist->pol[ i ].v[ j ].vm );
+ }
+ }
+ if ( plist->pol[ 0 ].v )
+ _pico_free( plist->pol[ 0 ].v );
+ _pico_free( plist->pol );
+ }
+ memset( plist, 0, sizeof( lwPolygonList ));
+ }
+}
+
+
+/*
+======================================================================
+lwGetPoints()
+
+Read point records from a PNTS chunk in an LWO2 file. The points are
+added to the array in the lwPointList.
+====================================================================== */
+
+int lwGetPoints( picoMemStream_t *fp, int cksize, lwPointList *point )
+{
+ float *f;
+ int np, i, j;
+
+ if ( cksize == 1 ) return 1;
+
+ /* extend the point array to hold the new points */
+
+ np = cksize / 12;
+ point->offset = point->count;
+ point->count += np;
+ if ( !_pico_realloc( (void *) &point->pt, (point->count - np) * sizeof( lwPoint ), point->count * sizeof( lwPoint )) )
+ return 0;
+ memset( &point->pt[ point->offset ], 0, np * sizeof( lwPoint ));
+
+ /* read the whole chunk */
+
+ f = ( float * ) getbytes( fp, cksize );
+ if ( !f ) return 0;
+ revbytes( f, 4, np * 3 );
+
+ /* assign position values */
+
+ for ( i = 0, j = 0; i < np; i++, j += 3 ) {
+ point->pt[ i ].pos[ 0 ] = f[ j ];
+ point->pt[ i ].pos[ 1 ] = f[ j + 1 ];
+ point->pt[ i ].pos[ 2 ] = f[ j + 2 ];
+ }
+
+ _pico_free( f );
+ return 1;
+}
+
+
+/*
+======================================================================
+lwGetBoundingBox()
+
+Calculate the bounding box for a point list, but only if the bounding
+box hasn't already been initialized.
+====================================================================== */
+
+void lwGetBoundingBox( lwPointList *point, float bbox[] )
+{
+ int i, j;
+
+ if ( point->count == 0 ) return;
+
+ for ( i = 0; i < 6; i++ )
+ if ( bbox[ i ] != 0.0f ) return;
+
+ bbox[ 0 ] = bbox[ 1 ] = bbox[ 2 ] = 1e20f;
+ bbox[ 3 ] = bbox[ 4 ] = bbox[ 5 ] = -1e20f;
+ for ( i = 0; i < point->count; i++ ) {
+ for ( j = 0; j < 3; j++ ) {
+ if ( bbox[ j ] > point->pt[ i ].pos[ j ] )
+ bbox[ j ] = point->pt[ i ].pos[ j ];
+ if ( bbox[ j + 3 ] < point->pt[ i ].pos[ j ] )
+ bbox[ j + 3 ] = point->pt[ i ].pos[ j ];
+ }
+ }
+}
+
+
+/*
+======================================================================
+lwAllocPolygons()
+
+Allocate or extend the polygon arrays to hold new records.
+====================================================================== */
+
+int lwAllocPolygons( lwPolygonList *plist, int npols, int nverts )
+{
+ int i;
+
+ plist->offset = plist->count;
+ plist->count += npols;
+ if ( !_pico_realloc( (void *) &plist->pol, (plist->count - npols) * sizeof( lwPolygon ), plist->count * sizeof( lwPolygon )) )
+ return 0;
+ memset( plist->pol + plist->offset, 0, npols * sizeof( lwPolygon ));
+
+ plist->voffset = plist->vcount;
+ plist->vcount += nverts;
+ if ( !_pico_realloc( (void *) &plist->pol[ 0 ].v, (plist->vcount - nverts) * sizeof( lwPolVert ), plist->vcount * sizeof( lwPolVert )) )
+ return 0;
+ memset( plist->pol[ 0 ].v + plist->voffset, 0, nverts * sizeof( lwPolVert ));
+
+ /* fix up the old vertex pointers */
+
+ for ( i = 1; i < plist->offset; i++ )
+ plist->pol[ i ].v = plist->pol[ i - 1 ].v + plist->pol[ i - 1 ].nverts;
+
+ return 1;
+}
+
+
+/*
+======================================================================
+lwGetPolygons()
+
+Read polygon records from a POLS chunk in an LWO2 file. The polygons
+are added to the array in the lwPolygonList.
+====================================================================== */
+
+int lwGetPolygons( picoMemStream_t *fp, int cksize, lwPolygonList *plist, int ptoffset )
+{
+ lwPolygon *pp;
+ lwPolVert *pv;
+ unsigned char *buf, *bp;
+ int i, j, flags, nv, nverts, npols;
+ unsigned int type;
+
+
+ if ( cksize == 0 ) return 1;
+
+ /* read the whole chunk */
+
+ set_flen( 0 );
+ type = getU4( fp );
+ buf = getbytes( fp, cksize - 4 );
+ if ( cksize != get_flen() ) goto Fail;
+
+ /* count the polygons and vertices */
+
+ nverts = 0;
+ npols = 0;
+ bp = buf;
+
+ while ( bp < buf + cksize - 4 ) {
+ nv = sgetU2( &bp );
+ nv &= 0x03FF;
+ nverts += nv;
+ npols++;
+ for ( i = 0; i < nv; i++ )
+ j = sgetVX( &bp );
+ }
+
+ if ( !lwAllocPolygons( plist, npols, nverts ))
+ goto Fail;
+
+ /* fill in the new polygons */
+
+ bp = buf;
+ pp = plist->pol + plist->offset;
+ pv = plist->pol[ 0 ].v + plist->voffset;
+
+ for ( i = 0; i < npols; i++ ) {
+ nv = sgetU2( &bp );
+ flags = nv & 0xFC00;
+ nv &= 0x03FF;
+
+ pp->nverts = nv;
+ pp->flags = flags;
+ pp->type = type;
+ if ( !pp->v ) pp->v = pv;
+ for ( j = 0; j < nv; j++ )
+ pp->v[ j ].index = sgetVX( &bp ) + ptoffset;
+
+ pp++;
+ pv += nv;
+ }
+
+ _pico_free( buf );
+ return 1;
+
+Fail:
+ if ( buf ) _pico_free( buf );
+ lwFreePolygons( plist );
+ return 0;
+}
+
+
+/*
+======================================================================
+lwGetPolyNormals()
+
+Calculate the polygon normals. By convention, LW's polygon normals
+are found as the cross product of the first and last edges. It's
+undefined for one- and two-point polygons.
+====================================================================== */
+
+void lwGetPolyNormals( lwPointList *point, lwPolygonList *polygon )
+{
+ int i, j;
+ float p1[ 3 ], p2[ 3 ], pn[ 3 ], v1[ 3 ], v2[ 3 ];
+
+ for ( i = 0; i < polygon->count; i++ ) {
+ if ( polygon->pol[ i ].nverts < 3 ) continue;
+ for ( j = 0; j < 3; j++ ) {
+ p1[ j ] = point->pt[ polygon->pol[ i ].v[ 0 ].index ].pos[ j ];
+ p2[ j ] = point->pt[ polygon->pol[ i ].v[ 1 ].index ].pos[ j ];
+ pn[ j ] = point->pt[ polygon->pol[ i ].v[
+ polygon->pol[ i ].nverts - 1 ].index ].pos[ j ];
+ }
+
+ for ( j = 0; j < 3; j++ ) {
+ v1[ j ] = p2[ j ] - p1[ j ];
+ v2[ j ] = pn[ j ] - p1[ j ];
+ }
+
+ cross( v1, v2, polygon->pol[ i ].norm );
+ normalize( polygon->pol[ i ].norm );
+ }
+}
+
+
+/*
+======================================================================
+lwGetPointPolygons()
+
+For each point, fill in the indexes of the polygons that share the
+point. Returns 0 if any of the memory allocations fail, otherwise
+returns 1.
+====================================================================== */
+
+int lwGetPointPolygons( lwPointList *point, lwPolygonList *polygon )
+{
+ int i, j, k;
+
+ /* count the number of polygons per point */
+
+ for ( i = 0; i < polygon->count; i++ )
+ for ( j = 0; j < polygon->pol[ i ].nverts; j++ )
+ ++point->pt[ polygon->pol[ i ].v[ j ].index ].npols;
+
+ /* alloc per-point polygon arrays */
+
+ for ( i = 0; i < point->count; i++ ) {
+ if ( point->pt[ i ].npols == 0 ) continue;
+ point->pt[ i ].pol = _pico_calloc( point->pt[ i ].npols, sizeof( int ));
+ if ( !point->pt[ i ].pol ) return 0;
+ point->pt[ i ].npols = 0;
+ }
+
+ /* fill in polygon array for each point */
+
+ for ( i = 0; i < polygon->count; i++ ) {
+ for ( j = 0; j < polygon->pol[ i ].nverts; j++ ) {
+ k = polygon->pol[ i ].v[ j ].index;
+ point->pt[ k ].pol[ point->pt[ k ].npols ] = i;
+ ++point->pt[ k ].npols;
+ }
+ }
+
+ return 1;
+}
+
+
+/*
+======================================================================
+lwResolvePolySurfaces()
+
+Convert tag indexes into actual lwSurface pointers. If any polygons
+point to tags for which no corresponding surface can be found, a
+default surface is created.
+====================================================================== */
+
+int lwResolvePolySurfaces( lwPolygonList *polygon, lwTagList *tlist,
+ lwSurface **surf, int *nsurfs )
+{
+ lwSurface **s, *st;
+ int i, index;
+
+ if ( tlist->count == 0 ) return 1;
+
+ s = _pico_calloc( tlist->count, sizeof( lwSurface * ));
+ if ( !s ) return 0;
+
+ for ( i = 0; i < tlist->count; i++ ) {
+ st = *surf;
+ while ( st ) {
+ if ( !strcmp( st->name, tlist->tag[ i ] )) {
+ s[ i ] = st;
+ break;
+ }
+ st = st->next;
+ }
+ }
+
+ for ( i = 0; i < polygon->count; i++ ) {
+ index = ( size_t ) polygon->pol[ i ].surf;
+ if ( index < 0 || index > tlist->count ) return 0;
+ if ( !s[ index ] ) {
+ s[ index ] = lwDefaultSurface();
+ if ( !s[ index ] ) return 0;
+ s[ index ]->name = _pico_alloc( strlen( tlist->tag[ index ] ) + 1 );
+ if ( !s[ index ]->name ) return 0;
+ strcpy( s[ index ]->name, tlist->tag[ index ] );
+ lwListAdd( (void *) surf, s[ index ] );
+ *nsurfs = *nsurfs + 1;
+ }
+ polygon->pol[ i ].surf = s[ index ];
+ }
+
+ _pico_free( s );
+ return 1;
+}
+
+
+/*
+======================================================================
+lwGetVertNormals()
+
+Calculate the vertex normals. For each polygon vertex, sum the
+normals of the polygons that share the point. If the normals of the
+current and adjacent polygons form an angle greater than the max
+smoothing angle for the current polygon's surface, the normal of the
+adjacent polygon is excluded from the sum. It's also excluded if the
+polygons aren't in the same smoothing group.
+
+Assumes that lwGetPointPolygons(), lwGetPolyNormals() and
+lwResolvePolySurfaces() have already been called.
+====================================================================== */
+
+void lwGetVertNormals( lwPointList *point, lwPolygonList *polygon )
+{
+ int j, k, n, g, h, p;
+ float a;
+
+ for ( j = 0; j < polygon->count; j++ ) {
+ for ( n = 0; n < polygon->pol[ j ].nverts; n++ ) {
+ for ( k = 0; k < 3; k++ )
+ polygon->pol[ j ].v[ n ].norm[ k ] = polygon->pol[ j ].norm[ k ];
+
+ if ( polygon->pol[ j ].surf->smooth <= 0 ) continue;
+
+ p = polygon->pol[ j ].v[ n ].index;
+
+ for ( g = 0; g < point->pt[ p ].npols; g++ ) {
+ h = point->pt[ p ].pol[ g ];
+ if ( h == j ) continue;
+
+ if ( polygon->pol[ j ].smoothgrp != polygon->pol[ h ].smoothgrp )
+ continue;
+ a = vecangle( polygon->pol[ j ].norm, polygon->pol[ h ].norm );
+ if ( a > polygon->pol[ j ].surf->smooth ) continue;
+
+ for ( k = 0; k < 3; k++ )
+ polygon->pol[ j ].v[ n ].norm[ k ] += polygon->pol[ h ].norm[ k ];
+ }
+
+ normalize( polygon->pol[ j ].v[ n ].norm );
+ }
+ }
+}
+
+
+/*
+======================================================================
+lwFreeTags()
+
+Free memory used by an lwTagList.
+====================================================================== */
+
+void lwFreeTags( lwTagList *tlist )
+{
+ int i;
+
+ if ( tlist ) {
+ if ( tlist->tag ) {
+ for ( i = 0; i < tlist->count; i++ )
+ if ( tlist->tag[ i ] ) _pico_free( tlist->tag[ i ] );
+ _pico_free( tlist->tag );
+ }
+ memset( tlist, 0, sizeof( lwTagList ));
+ }
+}
+
+
+/*
+======================================================================
+lwGetTags()
+
+Read tag strings from a TAGS chunk in an LWO2 file. The tags are
+added to the lwTagList array.
+====================================================================== */
+
+int lwGetTags( picoMemStream_t *fp, int cksize, lwTagList *tlist )
+{
+ char *buf, *bp;
+ int i, len, ntags;
+
+ if ( cksize == 0 ) return 1;
+
+ /* read the whole chunk */
+
+ set_flen( 0 );
+ buf = getbytes( fp, cksize );
+ if ( !buf ) return 0;
+
+ /* count the strings */
+
+ ntags = 0;
+ bp = buf;
+ while ( bp < buf + cksize ) {
+ len = strlen( bp ) + 1;
+ len += len & 1;
+ bp += len;
+ ++ntags;
+ }
+
+ /* expand the string array to hold the new tags */
+
+ tlist->offset = tlist->count;
+ tlist->count += ntags;
+ if ( !_pico_realloc( (void *) &tlist->tag, (tlist->count - ntags) * sizeof( char * ), tlist->count * sizeof( char * )) )
+ goto Fail;
+ memset( &tlist->tag[ tlist->offset ], 0, ntags * sizeof( char * ));
+
+ /* copy the new tags to the tag array */
+
+ bp = buf;
+ for ( i = 0; i < ntags; i++ )
+ tlist->tag[ i + tlist->offset ] = sgetS0( (unsigned char **) &bp );
+
+ _pico_free( buf );
+ return 1;
+
+Fail:
+ if ( buf ) _pico_free( buf );
+ return 0;
+}
+
+
+/*
+======================================================================
+lwGetPolygonTags()
+
+Read polygon tags from a PTAG chunk in an LWO2 file.
+====================================================================== */
+
+int lwGetPolygonTags( picoMemStream_t *fp, int cksize, lwTagList *tlist,
+ lwPolygonList *plist )
+{
+ unsigned int type;
+ int rlen = 0, i, j;
+
+ set_flen( 0 );
+ type = getU4( fp );
+ rlen = get_flen();
+ if ( rlen < 0 ) return 0;
+
+ if ( type != ID_SURF && type != ID_PART && type != ID_SMGP ) {
+ _pico_memstream_seek( fp, cksize - 4, PICO_SEEK_CUR );
+ return 1;
+ }
+
+ while ( rlen < cksize ) {
+ i = getVX( fp ) + plist->offset;
+ j = getVX( fp ) + tlist->offset;
+ rlen = get_flen();
+ if ( rlen < 0 || rlen > cksize ) return 0;
+
+ switch ( type ) {
+ case ID_SURF: plist->pol[ i ].surf = ( lwSurface * ) (size_t) j; break;
+ case ID_PART: plist->pol[ i ].part = j; break;
+ case ID_SMGP: plist->pol[ i ].smoothgrp = j; break;
+ }
+ }
+
+ return 1;
+}
projects / voretournament / voretournament.git / blobdiff