reduce more diff noise
[xonotic/netradiant.git] / tools / quake3 / q3data / p3dlib.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 "p3dlib.h"
23 #include "globaldefs.h"
24
25 #if GDEF_OS_WINDOWS
26 #include <io.h>
27 #endif
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <string.h>
31
32 #define MAX_POLYSETS 64
33
34 #if GDEF_OS_LINUX || GDEF_OS_MACOS
35         #include "cmdlib.h"
36         #define _strcmpi Q_stricmp
37         #define strlwr strlower
38         #define filelength(f) Q_filelength(f)
39 #else
40         #define filelength(f) filelength(fileno(f))
41 #endif
42 typedef struct
43 {
44         long len;
45
46         int numPairs;
47         char polysetNames[MAX_POLYSETS][256];
48         char shaders[MAX_POLYSETS][256];
49
50         char *buffer, *curpos;
51 } p3d_t;
52
53 static p3d_t p3d;
54
55 static int P3DProcess();
56 static int P3DGetToken( int restOfLine );
57
58 static char s_token[1024];
59 static int s_curpair;
60
61 /*
62 ** P3DLoad
63 **
64 */
65 int P3DLoad( const char *filename ){
66         FILE *fp = fopen( filename, "rb" );
67
68         if ( !fp ) {
69                 return 0;
70         }
71
72         memset( &p3d, 0, sizeof( p3d ) );
73
74         p3d.len = filelength( fp );
75
76         p3d.curpos = p3d.buffer = malloc( p3d.len );
77
78         if ( fread( p3d.buffer, p3d.len, 1, fp ) != 1 ) {
79                 fclose( fp );
80                 return 0;
81         }
82
83         fclose( fp );
84
85         return P3DProcess();
86 }
87
88 /*
89 ** P3DClose
90 **
91 */
92 void P3DClose(){
93         if ( p3d.buffer ) {
94                 free( p3d.buffer );
95                 p3d.buffer = 0;
96         }
97 }
98
99 int CharIsTokenDelimiter( int ch ){
100         if ( ch <= 32 ) {
101                 return 1;
102         }
103         return 0;
104 }
105
106 int P3DSkipToToken( const char *name ){
107         while ( P3DGetToken( 0 ) )
108         {
109                 if ( !_strcmpi( s_token, name ) ) {
110                         return 1;
111                 }
112         }
113
114         return 0;
115 }
116
117 /*
118 ** P3DGetToken
119 **
120 */
121 int P3DGetToken( int restOfLine ){
122         int i = 0;
123
124         if ( p3d.buffer == 0 ) {
125                 return 0;
126         }
127
128         if ( ( p3d.curpos - p3d.buffer ) == p3d.len ) {
129                 return 0;
130         }
131
132         // skip over crap
133         while ( ( ( p3d.curpos - p3d.buffer ) < p3d.len ) &&
134                         ( *p3d.curpos <= 32 ) )
135         {
136                 p3d.curpos++;
137         }
138
139         while ( ( p3d.curpos - p3d.buffer ) < p3d.len )
140         {
141                 s_token[i] = *p3d.curpos;
142
143                 p3d.curpos++;
144                 i++;
145
146                 if ( ( CharIsTokenDelimiter( s_token[i - 1] ) && !restOfLine ) ||
147                          ( ( s_token[i - 1] == '\n' ) ) ) {
148                         s_token[i - 1] = 0;
149                         break;
150                 }
151         }
152
153         s_token[i] = 0;
154
155         return 1;
156 }
157
158 int P3DGetNextPair( char **psetName, char **associatedShader ){
159         if ( s_curpair < p3d.numPairs ) {
160                 *psetName = p3d.polysetNames[s_curpair];
161                 *associatedShader = p3d.shaders[s_curpair];
162                 s_curpair++;
163                 return 1;
164         }
165
166         return 0;
167 }
168
169 int P3DSkipToTokenInBlock( const char *name ){
170         int iLevel = 0;
171
172         while ( P3DGetToken( 0 ) )
173         {
174                 if ( !_strcmpi( s_token, "}" ) ) {
175                         iLevel--;
176                 }
177                 else if ( !_strcmpi( s_token, "{" ) ) {
178                         iLevel++;
179                 }
180
181                 if ( !_strcmpi( s_token, name ) ) {
182                         return 1;
183                 }
184
185                 if ( iLevel == 0 ) {
186                         return 0;
187                 }
188         }
189
190         return 0;
191 }
192
193 /*
194 ** P3DProcess
195 **
196 ** Nothing fancy here.
197 */
198 int P3DProcess(){
199
200         s_curpair = 0;
201
202         // first token should be a string
203         P3DGetToken( 1 );       // Voodoo Ascii File
204
205         // skip to the first Obj declaration
206         while ( P3DGetToken( 0 ) )
207         {
208                 if ( !_strcmpi( s_token, "Obj" ) ) {
209                         int j = 0, k = 0;
210
211                         if ( P3DSkipToToken( "Text" ) ) {
212                                 if ( P3DSkipToTokenInBlock( "TMap" ) ) {
213                                         char *p;
214
215                                         if ( !P3DSkipToToken( "Path" ) ) {
216                                                 return 0;
217                                         }
218
219                                         if ( !P3DGetToken( 1 ) ) {
220                                                 return 0;
221                                         }
222
223                                         while ( s_token[j] != 0 )
224                                         {
225                                                 if ( s_token[j] == '\\' ) {
226                                                         j++;
227                                                         p3d.shaders[p3d.numPairs][k] = '/';
228                                                 }
229                                                 else
230                                                 {
231                                                         p3d.shaders[p3d.numPairs][k] = s_token[j];
232                                                 }
233                                                 j++;
234                                                 k++;
235                                         }
236                                         p3d.shaders[p3d.numPairs][k] = 0;
237
238                                         //
239                                         // strip off any explicit extensions
240                                         //
241                                         if ( ( p = strrchr( p3d.shaders[p3d.numPairs], '/' ) ) != 0 ) {
242                                                 while ( *p )
243                                                 {
244                                                         if ( *p == '.' ) {
245                                                                 *p = 0;
246                                                                 break;
247                                                         }
248                                                         p++;
249                                                 }
250                                         }
251
252                                         //
253                                         // skip to the end of the Object and grab its name
254                                         //
255                                         if ( !P3DSkipToToken( "Name" ) ) {
256                                                 return 0;
257                                         }
258
259                                         if ( P3DGetToken( 0 ) ) {
260                                                 // strip off leading 'Obj_' if it exists
261                                                 if ( strstr( s_token, "Obj_" ) == s_token ) {
262                                                         strcpy( p3d.polysetNames[p3d.numPairs], s_token + strlen( "Obj_" ) );
263                                                 }
264                                                 else{
265                                                         strcpy( p3d.polysetNames[p3d.numPairs], s_token );
266                                                 }
267
268                                                 // strip off trailing unused color information
269 //                                              if ( strrchr( p3d.polysetNames[p3d.numPairs], '_' ) != 0 )
270 //                                                      *strrchr( p3d.polysetNames[p3d.numPairs], '_' ) = 0;
271
272                                                 p3d.numPairs++;
273                                         }
274                                         else
275                                         {
276                                                 return 0;
277                                         }
278                                 }
279                         }
280                 }
281         }
282
283         s_curpair = 0;
284
285         return 1;
286 }
287
288 #if 0
289 void SkinFromP3D( const char *file ){
290         char filename[1024];
291         char *psetName, *associatedShader;
292
293         /*
294         ** a P3D file contains a list of polysets, each with a list of associated
295         ** texture names that constitute it's
296         **
297         ** Thus:
298         **
299         ** P3D file -> skin
300         ** polyset  -> polyset
301         **   texture -> texture.SHADER becomes polyset's shader
302         */
303         sprintf( filename, "%s/%s", g_cddir, file );
304
305         if ( !P3DLoad( filename ) ) {
306                 Error( "unable to load '%s'", filename );
307         }
308
309         while ( P3DGetNextPair( &psetName, &associatedShader ) )
310         {
311                 int i;
312
313                 // find the polyset in the object that this particular pset/shader pair
314                 // corresponds to and append the shader to it
315                 for ( i = 0; i < g_data.model.numSurfaces; i++ )
316                 {
317                         if ( !_strcmpi( g_data.surfData[i].header.name, psetName ) ) {
318                                 char *p;
319
320                                 if ( strstr( associatedShader, gamedir + 1 ) ) {
321                                         p = strstr( associatedShader, gamedir + 1 ) + strlen( gamedir ) - 1;
322                                 }
323                                 else
324                                 {
325                                         p = associatedShader;
326                                 }
327
328                                 strcpy( g_data.surfData[i].shaders[g_data.surfData[i].header.numShaders].name, p );
329
330                                 g_data.surfData[i].header.numShaders++;
331                         }
332                 }
333
334         }
335
336         P3DClose();
337 }
338 #endif