another way to do 265c42d
[xonotic/netradiant.git] / tools / quake3 / q3data / 3dslib.c
1 /*
2    Copyright (C) 1999-2007 id Software, Inc. and contributors.
3    For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5    This file is part of GtkRadiant.
6
7    GtkRadiant is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    GtkRadiant is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GtkRadiant; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #include <assert.h>
23 #include "q3data.h"
24
25 static void Load3DS( const char *filename, _3DS_t *p3DS, qboolean verbose );
26
27 static qboolean s_verbose;
28
29 #define MAX_MATERIALS 100
30 #define MAX_NAMED_OBJECTS 100
31 #define MAX_MESH_MATERIAL_GROUPS 100
32 #define MAX_TRI_OBJECTS 512
33
34 static char s_buffer[1000000];
35
36 static int ReadString( FILE *fp, char *buffer ){
37         int i = 0;
38         int bytesRead = 0;
39
40         do
41         {
42                 fread( &buffer[i], 1, sizeof( char ), fp );
43                 bytesRead++;
44         } while ( buffer[i++] != 0 );
45         buffer[i] = 0;
46
47         return bytesRead;
48 }
49
50 static int ReadChunkAndLength( FILE *fp, unsigned short *chunk, long *len ){
51         if ( fread( chunk, sizeof( short ), 1, fp ) != 1 ) {
52                 return 0;
53         }
54         if ( fread( len, sizeof( long ), 1, fp ) != 1 ) {
55                 Error( "Unexpected EOF found" );
56         }
57         return 1;
58 }
59
60 static void LoadMapName( FILE *fp, char *buffer, int thisChunkLen ){
61         unsigned short chunkID;
62         long chunkLen;
63         long bytesRead = 0;
64
65         while ( ReadChunkAndLength( fp, &chunkID, &chunkLen ) )
66         {
67                 switch ( chunkID )
68                 {
69                 case _3DS_CHUNK_MAT_MAPNAME:
70                         fread( buffer, chunkLen - 6, 1, fp );
71                         break;
72                 default:
73                         fread( s_buffer, chunkLen - 6, 1, fp );
74                         break;
75                 }
76                 bytesRead += chunkLen;
77                 if ( bytesRead >= thisChunkLen ) {
78                         return;
79                 }
80         }
81 }
82
83 static void LoadMaterialList( FILE *fp, long thisChunkLen, _3DSMaterial_t *pMat ){
84         long chunkLen;
85         unsigned short chunkID;
86         long bytesRead = 0;
87         _3DSMaterial_t mat;
88         char curdir[1024];
89         char buffer[2048];
90
91         memset( &mat, 0, sizeof( mat ) );
92
93         if ( s_verbose ) {
94                 printf( "    >>> MATERIAL LIST\n" );
95         }
96
97         while ( ReadChunkAndLength( fp, &chunkID, &chunkLen ) )
98         {
99                 switch ( chunkID )
100                 {
101                 case _3DS_CHUNK_MAT_NAME:
102                         fread( mat.name, chunkLen - 6, 1, fp );
103                         if ( s_verbose ) {
104                                 printf( "        found mat name '%s'\n", mat.name );
105                         }
106                         break;
107                 case _3DS_CHUNK_TEXMAP:
108                         LoadMapName( fp, mat.texture, chunkLen - 6 );
109                         if ( s_verbose ) {
110                                 printf( "        found texture '%s'\n", mat.texture );
111                         }
112                         break;
113                 case _3DS_CHUNK_SPECMAP:
114                         LoadMapName( fp, mat.specular, chunkLen - 6 );
115                         if ( s_verbose ) {
116                                 printf( "        found specular map '%s'\n", mat.specular );
117                         }
118                         break;
119                 case _3DS_CHUNK_OPACMAP:
120                         LoadMapName( fp, mat.opacity, chunkLen - 6 );
121                         if ( s_verbose ) {
122                                 printf( "        found opacity map '%s'\n", mat.opacity );
123                         }
124                         break;
125                 case _3DS_CHUNK_REFLMAP:
126                         LoadMapName( fp, mat.reflection, chunkLen - 6 );
127                         if ( s_verbose ) {
128                                 printf( "        found reflection map '%s'\n", mat.reflection );
129                         }
130                         break;
131                 case _3DS_CHUNK_BUMPMAP:
132                         LoadMapName( fp, mat.bump, chunkLen - 6 );
133                         if ( s_verbose ) {
134                                 printf( "        found bump map '%s'\n", mat.bump );
135                         }
136                         break;
137                 default:
138                         fread( s_buffer, chunkLen - 6, 1, fp );
139                         break;
140                 }
141
142                 bytesRead += chunkLen;
143
144                 if ( bytesRead >= thisChunkLen ) {
145                         break;
146                 }
147         }
148
149         Q_getwd( curdir );
150
151         if ( mat.texture[0] ) {
152                 sprintf( buffer, "%s%s", curdir, mat.texture );
153                 if ( strstr( buffer, gamedir + 1 ) ) {
154                         strcpy( mat.texture, strstr( buffer, gamedir + 1 ) + strlen( gamedir ) - 1 );
155                 }
156                 else{
157                         strcpy( mat.texture, buffer );
158                 }
159         }
160
161         if ( mat.specular[0] ) {
162                 sprintf( buffer, "%s%s", curdir, mat.specular );
163                 if ( strstr( buffer, gamedir + 1 ) ) {
164                         strcpy( mat.specular, strstr( buffer, gamedir + 1 ) + strlen( gamedir ) - 1 );
165                 }
166                 else{
167                         strcpy( mat.specular, buffer );
168                 }
169         }
170
171         if ( mat.bump[0] ) {
172                 sprintf( buffer, "%s%s", curdir, mat.bump );
173                 if ( strstr( buffer, gamedir + 1 ) ) {
174                         strcpy( mat.bump, strstr( buffer, gamedir + 1 ) + strlen( gamedir ) - 1 );
175                 }
176                 else{
177                         strcpy( mat.bump, buffer );
178                 }
179         }
180
181         if ( mat.reflection[0] ) {
182                 sprintf( buffer, "%s%s", curdir, mat.reflection );
183                 if ( strstr( buffer, gamedir + 1 ) ) {
184                         strcpy( mat.reflection, strstr( buffer, gamedir + 1 ) + strlen( gamedir ) - 1 );
185                 }
186                 else{
187                         strcpy( mat.reflection, buffer );
188                 }
189         }
190
191         if ( mat.opacity[0] ) {
192                 sprintf( buffer, "%s%s", curdir, mat.opacity );
193                 if ( strstr( buffer, gamedir + 1 ) ) {
194                         strcpy( mat.opacity, strstr( buffer, gamedir + 1 ) + strlen( gamedir ) - 1 );
195                 }
196                 else{
197                         strcpy( mat.opacity, buffer );
198                 }
199         }
200
201         *pMat = mat;
202 }
203
204 static void LoadMeshMaterialGroup( FILE *fp, long thisChunkLen, _3DSMeshMaterialGroup_t *pMMG ){
205         _3DSMeshMaterialGroup_t mmg;
206
207         memset( &mmg, 0, sizeof( mmg ) );
208
209         ReadString( fp, mmg.name );
210
211         fread( &mmg.numFaces, sizeof( mmg.numFaces ), 1, fp );
212         mmg.pFaces = malloc( sizeof( mmg.pFaces[0] ) * mmg.numFaces );
213         fread( mmg.pFaces, sizeof( mmg.pFaces[0] ), mmg.numFaces, fp );
214
215         if ( s_verbose ) {
216                 printf( "    >>> MESH MATERIAL GROUP '%s' (%d faces)\n", mmg.name, mmg.numFaces );
217
218                 {
219                         int i;
220
221                         for ( i = 0; i < mmg.numFaces; i++ )
222                         {
223                                 printf( "        %d\n", mmg.pFaces[i] );
224                         }
225                 }
226         }
227
228         *pMMG = mmg;
229 }
230
231 static void LoadNamedTriObject( FILE *fp, long thisChunkLen, _3DSTriObject_t *pTO ){
232         long chunkLen;
233         unsigned short chunkID;
234         int i = 0;
235         long bytesRead = 0;
236         _3DSTriObject_t triObj;
237         _3DSMeshMaterialGroup_t meshMaterialGroups[MAX_MESH_MATERIAL_GROUPS];
238         int numMeshMaterialGroups = 0;
239
240         memset( &triObj, 0, sizeof( triObj ) );
241
242         if ( s_verbose ) {
243                 printf( "        >>> NAMED TRI OBJECT\n" );
244         }
245
246         while ( ReadChunkAndLength( fp, &chunkID, &chunkLen ) )
247         {
248                 switch ( chunkID )
249                 {
250                 case _3DS_CHUNK_MSH_MAT_GROUP:
251                         LoadMeshMaterialGroup( fp, chunkLen - 6, &meshMaterialGroups[numMeshMaterialGroups] );
252                         bytesRead += chunkLen;
253                         numMeshMaterialGroups++;
254                         break;
255                 case _3DS_CHUNK_FACE_ARRAY:
256                         fread( &triObj.numFaces, sizeof( triObj.numFaces ), 1, fp );
257                         assert( triObj.pFaces == 0 );
258
259                         triObj.pFaces = malloc( sizeof( triObj.pFaces[0] ) * triObj.numFaces );
260                         fread( triObj.pFaces, sizeof( triObj.pFaces[0] ), triObj.numFaces, fp );
261                         bytesRead += sizeof( triObj.numFaces ) + triObj.numFaces * sizeof( triObj.pFaces[0] ) + 6;
262
263                         if ( s_verbose ) {
264                                 printf( "            found face array with %d faces\n", triObj.numFaces );
265                                 for ( i = 0; i < triObj.numFaces; i++ )
266                                 {
267                                         printf( "                %d: %d,%d,%d\n", i, triObj.pFaces[i].a, triObj.pFaces[i].b, triObj.pFaces[i].c );
268                                 }
269                         }
270
271                         break;
272                 case _3DS_CHUNK_POINT_ARRAY:
273                         fread( &triObj.numPoints, sizeof( triObj.numPoints ), 1, fp );
274                         triObj.pPoints = malloc( sizeof( triObj.pPoints[0] ) * triObj.numPoints );
275                         fread( triObj.pPoints, sizeof( triObj.pPoints[0] ), triObj.numPoints, fp );
276                         bytesRead += sizeof( triObj.numPoints ) + triObj.numPoints * sizeof( triObj.pPoints[0] ) + 6;
277
278                         // flip points around into our coordinate system
279                         for ( i = 0; i < triObj.numPoints; i++ )
280                         {
281                                 float x, y, z;
282
283                                 x = triObj.pPoints[i].x;
284                                 y = triObj.pPoints[i].y;
285                                 z = triObj.pPoints[i].z;
286
287                                 triObj.pPoints[i].x = -y;
288                                 triObj.pPoints[i].y = x;
289                                 triObj.pPoints[i].z = z;
290                         }
291
292                         if ( s_verbose ) {
293                                 printf( "            found point array with %d points\n", triObj.numPoints );
294                                 for ( i = 0; i < triObj.numPoints; i++ )
295                                 {
296                                         printf( "                %d: %f,%f,%f\n", i, triObj.pPoints[i].x, triObj.pPoints[i].y, triObj.pPoints[i].z );
297                                 }
298                         }
299                         break;
300                 case _3DS_CHUNK_TEX_VERTS:
301                         fread( &triObj.numTexVerts, sizeof( triObj.numTexVerts ), 1, fp );
302                         triObj.pTexVerts = malloc( sizeof( triObj.pTexVerts[0] ) * triObj.numTexVerts );
303                         fread( triObj.pTexVerts, sizeof( triObj.pTexVerts[0] ), triObj.numTexVerts, fp );
304                         bytesRead += sizeof( triObj.numTexVerts ) + sizeof( triObj.pTexVerts[0] ) * triObj.numTexVerts + 6;
305
306                         if ( s_verbose ) {
307                                 printf( "            found tex vert array with %d tex verts\n", triObj.numTexVerts );
308                                 for ( i = 0; i < triObj.numTexVerts; i++ )
309                                 {
310                                         printf( "                %d: %f,%f\n", i, triObj.pTexVerts[i].s, triObj.pTexVerts[i].t );
311                                 }
312                         }
313                         break;
314                 default:
315                         fread( s_buffer, chunkLen - 6, 1, fp );
316                         bytesRead += chunkLen;
317                         break;
318                 }
319
320                 if ( bytesRead >= thisChunkLen ) {
321                         break;
322                 }
323         }
324         *pTO = triObj;
325
326         if ( numMeshMaterialGroups == 0 ) {
327                 numMeshMaterialGroups = 1;
328                 strcpy( meshMaterialGroups[0].name, "(null)" );
329                 if ( pTO->numTexVerts ) {
330                         printf( "Warning: assigning (null) skin to tri object\n" );
331                 }
332         }
333         else
334         {
335                 assert( pTO->numFaces == meshMaterialGroups[0].numFaces );
336         }
337
338         pTO->pMeshMaterialGroups = malloc( sizeof( _3DSMeshMaterialGroup_t ) * numMeshMaterialGroups );
339         memcpy( pTO->pMeshMaterialGroups, meshMaterialGroups, numMeshMaterialGroups * sizeof( meshMaterialGroups[0] ) );
340         pTO->numMeshMaterialGroups = numMeshMaterialGroups;
341
342         //
343         // sanity checks
344         //
345         assert( numMeshMaterialGroups <= 1 );
346 }
347
348 static void LoadNamedObject( FILE *fp, long thisChunkLen, _3DSNamedObject_t *pNO ){
349         long chunkLen;
350         unsigned short chunkID;
351         int i = 0;
352         long bytesRead = 0;
353         char name[100];
354         _3DSTriObject_t triObj[MAX_TRI_OBJECTS];
355         int numTriObjects = 0;
356
357         memset( triObj, 0, sizeof( triObj ) );
358
359         bytesRead += ReadString( fp, name );
360
361         if ( s_verbose ) {
362                 printf( "    >>> NAMED OBJECT '%s'\n", name );
363         }
364
365         while ( ReadChunkAndLength( fp, &chunkID, &chunkLen ) )
366         {
367                 switch ( chunkID )
368                 {
369                 case _3DS_CHUNK_NAMED_TRI_OBJECT:
370                         LoadNamedTriObject( fp, chunkLen - 6, &triObj[numTriObjects] );
371                         numTriObjects++;
372                         break;
373                 default:
374                         fread( s_buffer, chunkLen - 6, 1, fp );
375                         break;
376                 }
377
378                 bytesRead += chunkLen;
379
380                 if ( bytesRead >= thisChunkLen ) {
381                         break;
382                 }
383         }
384
385         strcpy( pNO->name, name );
386         pNO->pTriObjects = malloc( sizeof( _3DSTriObject_t ) * numTriObjects );
387         memcpy( pNO->pTriObjects, triObj, sizeof( triObj[0] ) * numTriObjects );
388         pNO->numTriObjects = numTriObjects;
389
390         assert( numTriObjects <= 1 );
391 }
392
393 static void LoadEditChunk( FILE *fp, long thisChunkLen, _3DSEditChunk_t *pEC ){
394         unsigned short chunkID;
395         long chunkLen;
396         long bytesRead = 0;
397         _3DSEditChunk_t editChunk;
398
399         _3DSMaterial_t mat[MAX_MATERIALS];
400         _3DSNamedObject_t namedObjects[MAX_NAMED_OBJECTS];
401
402         int numMaterials = 0, numNamedObjects = 0;
403
404         memset( &editChunk, 0, sizeof( editChunk ) );
405
406         if ( s_verbose ) {
407                 printf( ">>> EDIT CHUNK\n" );
408         }
409
410         while ( ReadChunkAndLength( fp, &chunkID, &chunkLen ) )
411         {
412                 switch ( chunkID )
413                 {
414                 case _3DS_CHUNK_MAT_LIST:
415                         LoadMaterialList( fp, chunkLen - 6, &mat[numMaterials] );
416                         numMaterials++;
417                         break;
418                 case _3DS_CHUNK_NAMED_OBJECT:
419                         LoadNamedObject( fp, chunkLen - 6, &namedObjects[numNamedObjects] );
420                         if ( namedObjects[numNamedObjects].numTriObjects != 0 ) {
421                                 ++numNamedObjects;
422                         }
423                         break;
424                 case _3DS_CHUNK_MESH_VERSION:
425                 default:
426                         fread( s_buffer, chunkLen - 6, 1, fp );
427                         break;
428                 }
429
430                 bytesRead += chunkLen;
431
432                 if ( bytesRead >= thisChunkLen ) {
433                         break;
434                 }
435         }
436
437         if ( numMaterials == 0 ) {
438                 numMaterials = 1;
439                 strcpy( mat[0].name, "(null)" );
440                 printf( "Warning: no material definitions found\n" );
441         }
442
443         pEC->numNamedObjects = numNamedObjects;
444
445         pEC->pMaterials = malloc( sizeof( _3DSMaterial_t ) * numMaterials );
446         pEC->pNamedObjects = malloc( sizeof( _3DSNamedObject_t ) * numNamedObjects );
447
448         memcpy( pEC->pMaterials, mat, numMaterials * sizeof( mat[0] ) );
449         memcpy( pEC->pNamedObjects, namedObjects, numNamedObjects * sizeof( namedObjects[0] ) );
450 }
451
452 static void Load3DS( const char *filename, _3DS_t *p3DS, qboolean verbose ){
453         FILE *fp;
454         unsigned short chunkID;
455         long chunkLen;
456         _3DSEditChunk_t editChunk;
457
458         s_verbose = verbose;
459
460         if ( ( fp = fopen( filename, "rb" ) ) == 0 ) {
461                 Error( "Unable to open '%s'", filename );
462         }
463
464         // read magic number
465         if ( ( fread( &chunkID, sizeof( short ), 1, fp ) != 1 ) ||
466                  ( LittleShort( chunkID ) != _3DS_CHUNK_MAGIC ) ) {
467                 Error( "Missing or incorrect magic number in '%s'", filename );
468         }
469         if ( fread( &chunkLen, sizeof( chunkLen ), 1, fp ) != 1 ) {
470                 Error( "Unexpected EOF encountered in '%s'", filename );
471         }
472         // version number
473         if ( !ReadChunkAndLength( fp, &chunkID, &chunkLen ) ) {
474                 Error( "Missing version number in '%s'", filename );
475         }
476         if ( fread( s_buffer, chunkLen - 6, 1, fp ) != 1 ) {
477                 Error( "Unexpected EOF encountered in '%s'", filename );
478         }
479
480         while ( ReadChunkAndLength( fp, &chunkID, &chunkLen ) )
481         {
482                 switch ( chunkID )
483                 {
484                 case _3DS_CHUNK_EDIT:
485                         LoadEditChunk( fp, chunkLen - 6, &editChunk );
486                         break;
487                 case _3DS_CHUNK_KEYFRAME_DATA:
488                         fread( s_buffer, chunkLen - 6, 1, fp );
489                         break;
490                 default:
491                         fread( s_buffer, chunkLen - 6, 1, fp );
492                         break;
493                 }
494         }
495
496         fclose( fp );
497
498         p3DS->editChunk = editChunk;
499 }
500
501 static void ComputeNormals( _3DSTriObject_t *pTO, triangle_t *pTris ){
502         vec3_t faceNormals[POLYSET_MAXTRIANGLES];
503         vec3_t vertexNormals[POLYSET_MAXTRIANGLES * 3];
504         vec3_t side0, side1, facenormal;
505         int f, v;
506
507         memset( faceNormals, 0, sizeof( faceNormals ) );
508         memset( vertexNormals, 0, sizeof( vertexNormals ) );
509
510         //
511         // compute face normals
512         //
513         for ( f = 0; f < pTO->numFaces; f++ )
514         {
515                 VectorSubtract( pTris[f].verts[0], pTris[f].verts[1], side0 );
516                 VectorSubtract( pTris[f].verts[2], pTris[f].verts[1], side1 );
517
518                 CrossProduct( side0, side1, facenormal );
519                 VectorNormalize( facenormal, faceNormals[f] );
520         }
521
522         //
523         // sum vertex normals
524         //
525         for ( v = 0; v < pTO->numPoints; v++ )
526         {
527                 for ( f = 0; f < pTO->numFaces; f++ )
528                 {
529                         if ( ( pTO->pFaces[f].a == v ) ||
530                                  ( pTO->pFaces[f].b == v ) ||
531                                  ( pTO->pFaces[f].c == v ) ) {
532                                 vertexNormals[v][0] += faceNormals[f][0];
533                                 vertexNormals[v][1] += faceNormals[f][1];
534                                 vertexNormals[v][2] += faceNormals[f][2];
535                         }
536                 }
537
538                 VectorNormalize( vertexNormals[v], vertexNormals[v] );
539         }
540
541         //
542         // copy vertex normals into triangles
543         //
544         for ( f = 0; f < pTO->numFaces; f++ )
545         {
546                 int i0 = pTO->pFaces[f].c;
547                 int i1 = pTO->pFaces[f].b;
548                 int i2 = pTO->pFaces[f].a;
549
550                 VectorCopy( vertexNormals[i0], pTris[f].normals[0] );
551                 VectorCopy( vertexNormals[i1], pTris[f].normals[1] );
552                 VectorCopy( vertexNormals[i2], pTris[f].normals[2] );
553         }
554 }
555
556 /*
557 ** void _3DS_LoadPolysets
558 */
559 void _3DS_LoadPolysets( const char *filename, polyset_t **ppPSET, int *numpsets, qboolean verbose ){
560         _3DS_t _3ds;
561         int numPolysets;
562         polyset_t *pPSET;
563         triangle_t *ptri, *triangles;
564         int i;
565
566         // load the 3DS
567         memset( &_3ds, 0, sizeof( _3ds ) );
568         Load3DS( filename, &_3ds, verbose );
569
570         // compute information
571         numPolysets = _3ds.editChunk.numNamedObjects;
572
573         // allocate memory
574         pPSET = calloc( 1, numPolysets * sizeof( polyset_t ) );
575         triangles = ptri = calloc( 1, POLYSET_MAXTRIANGLES * sizeof( triangle_t ) );
576
577         // copy the data over
578         for ( i = 0; i < numPolysets; i++ )
579         {
580                 char matnamebuf[1024];
581                 int j;
582                 triangle_t *tri;
583                 _3DSTriObject_t *pTO = &_3ds.editChunk.pNamedObjects[i].pTriObjects[0];
584
585                 pPSET[i].triangles = ptri;
586                 pPSET[i].numtriangles = pTO->numFaces;
587                 strcpy( pPSET[i].name, _3ds.editChunk.pNamedObjects[i].name );
588
589                 strcpy( matnamebuf, filename );
590                 if ( strrchr( matnamebuf, '/' ) ) {
591                         *( strrchr( matnamebuf, '/' ) + 1 ) = 0;
592                 }
593                 strcat( matnamebuf, pTO->pMeshMaterialGroups[0].name );
594
595                 if ( strstr( matnamebuf, gamedir ) ) {
596                         strcpy( pPSET[i].materialname, strstr( matnamebuf, gamedir ) + strlen( gamedir ) );
597                 }
598                 else{
599                         strcpy( pPSET[i].materialname, pTO->pMeshMaterialGroups[0].name );
600                 }
601
602                 assert( pPSET[i].numtriangles < POLYSET_MAXTRIANGLES );
603
604                 for ( tri = ptri, j = 0; j < pPSET[i].numtriangles; j++ )
605                 {
606                         int i0 = pTO->pFaces[j].c;
607                         int i1 = pTO->pFaces[j].b;
608                         int i2 = pTO->pFaces[j].a;
609
610                         tri->verts[0][0] = pTO->pPoints[i0].x;
611                         tri->verts[0][1] = pTO->pPoints[i0].y;
612                         tri->verts[0][2] = pTO->pPoints[i0].z;
613
614                         tri->verts[1][0] = pTO->pPoints[i1].x;
615                         tri->verts[1][1] = pTO->pPoints[i1].y;
616                         tri->verts[1][2] = pTO->pPoints[i1].z;
617
618                         tri->verts[2][0] = pTO->pPoints[i2].x;
619                         tri->verts[2][1] = pTO->pPoints[i2].y;
620                         tri->verts[2][2] = pTO->pPoints[i2].z;
621 /*
622             for ( k = 0; k < 3; k++ )
623             {
624                 tri->colors[0][k] = 1;
625                 tri->colors[1][k] = 1;
626                 tri->colors[2][k] = 1;
627             }
628  */
629
630                         if ( pTO->pTexVerts ) {
631                                 tri->texcoords[0][0] = pTO->pTexVerts[i0].s;
632                                 tri->texcoords[0][1] = 1.0f - pTO->pTexVerts[i0].t;
633                                 tri->texcoords[1][0] = pTO->pTexVerts[i1].s;
634                                 tri->texcoords[1][1] = 1.0f - pTO->pTexVerts[i1].t;
635                                 tri->texcoords[2][0] = pTO->pTexVerts[i2].s;
636                                 tri->texcoords[2][1] = 1.0f - pTO->pTexVerts[i2].t;
637                         }
638
639                         tri++;
640                 }
641
642                 ptri += pPSET[i].numtriangles;
643                 assert( ptri - triangles < POLYSET_MAXTRIANGLES );
644         }
645
646         // compute normal data
647 #if 0
648         for ( i = 0; i < numPolysets; i++ )
649         {
650                 // unique vertices based solely on vertex position
651                 ComputeNormals( &_3ds.editChunk.pNamedObjects[i].pTriObjects[0],
652                                                 pPSET[i].triangles );
653         }
654 #endif
655
656         free( _3ds.editChunk.pMaterials );
657         free( _3ds.editChunk.pNamedObjects );
658
659         *ppPSET = pPSET;
660         *numpsets = numPolysets;
661 }