tools/quake3/q3map2/convert_obj.c

   1 /* -------------------------------------------------------------------------------
   2
   3    Copyright (C) 1999-2007 id Software, Inc. and contributors.
   4    For a list of contributors, see the accompanying CONTRIBUTORS file.
   5
   6    This file is part of GtkRadiant.
   7
   8    GtkRadiant is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    GtkRadiant is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GtkRadiant; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21
  22    ----------------------------------------------------------------------------------
  23
  24    This code has been altered significantly from its original form, to support
  25    several games based on the Quake III Arena engine, in the form of "Q3Map2."
  26
  27    ------------------------------------------------------------------------------- */
  28
  29
  30
  31 /* marker */
  32 #define CONVERT_ASE_C
  33
  34
  35
  36 /* dependencies */
  37 #include "q3map2.h"
  38
  39
  40
  41 /*
  42    ConvertSurface()
  43    converts a bsp drawsurface to an obj chunk
  44  */
  45
  46 int firstLightmap = 0;
  47 int lastLightmap = -1;
  48 static void ConvertLightmapToMTL( FILE *f, const char *base, int lightmapNum );
  49
  50 int objVertexCount = 0;
  51 int objLastShaderNum = -1;
  52 static void ConvertSurfaceToOBJ( FILE *f, bspModel_t *model, int modelNum, bspDrawSurface_t *ds, int surfaceNum, vec3_t origin ){
  53         int i, v, a, b, c;
  54         bspDrawVert_t   *dv;
  55
  56         /* ignore patches for now */
  57         if ( ds->surfaceType != MST_PLANAR && ds->surfaceType != MST_TRIANGLE_SOUP ) {
  58                 return;
  59         }
  60
  61         fprintf( f, "g mat%dmodel%dsurf%d\r\n", ds->shaderNum, modelNum, surfaceNum );
  62         switch ( ds->surfaceType )
  63         {
  64         case MST_PLANAR:
  65                 fprintf( f, "# SURFACETYPE MST_PLANAR\r\n" );
  66                 break;
  67         case MST_TRIANGLE_SOUP:
  68                 fprintf( f, "# SURFACETYPE MST_TRIANGLE_SOUP\r\n" );
  69                 break;
  70         }
  71
  72         /* export shader */
  73         if ( lightmapsAsTexcoord ) {
  74                 if ( objLastShaderNum != ds->lightmapNum[0] ) {
  75                         fprintf( f, "usemtl lm_%04d\r\n", ds->lightmapNum[0] + deluxemap );
  76                         objLastShaderNum = ds->lightmapNum[0] + deluxemap;
  77                 }
  78                 if ( ds->lightmapNum[0] + (int)deluxemap < firstLightmap ) {
  79                         Sys_Printf( "WARNING: lightmap %d out of range (exporting anyway)\n", ds->lightmapNum[0] + deluxemap );
  80                         firstLightmap = ds->lightmapNum[0] + deluxemap;
  81                 }
  82                 if ( ds->lightmapNum[0] > lastLightmap ) {
  83                         Sys_Printf( "WARNING: lightmap %d out of range (exporting anyway)\n", ds->lightmapNum[0] + deluxemap );
  84                         lastLightmap = ds->lightmapNum[0] + deluxemap;
  85                 }
  86         }
  87         else
  88         {
  89                 if ( objLastShaderNum != ds->shaderNum ) {
  90                         fprintf( f, "usemtl %s\r\n", bspShaders[ds->shaderNum].shader );
  91                         objLastShaderNum = ds->shaderNum;
  92                 }
  93         }
  94
  95         /* export vertex */
  96         for ( i = 0; i < ds->numVerts; i++ )
  97         {
  98                 v = i + ds->firstVert;
  99                 dv = &bspDrawVerts[ v ];
 100                 fprintf( f, "# vertex %d\r\n", i + objVertexCount + 1 );
 101                 fprintf( f, "v %f %f %f\r\n", dv->xyz[ 0 ], dv->xyz[ 1 ], dv->xyz[ 2 ] );
 102                 fprintf( f, "vn %f %f %f\r\n", dv->normal[ 0 ], dv->normal[ 1 ], dv->normal[ 2 ] );
 103                 if ( lightmapsAsTexcoord ) {
 104                         fprintf( f, "vt %f %f\r\n", dv->lightmap[0][0], 1.0 - dv->lightmap[0][1] );
 105                 }
 106                 else{
 107                         fprintf( f, "vt %f %f\r\n", dv->st[ 0 ], 1.0 - dv->st[ 1 ] );
 108                 }
 109         }
 110
 111         /* export faces */
 112         for ( i = 0; i < ds->numIndexes; i += 3 )
 113         {
 114                 a = bspDrawIndexes[ i + ds->firstIndex ];
 115                 c = bspDrawIndexes[ i + ds->firstIndex + 1 ];
 116                 b = bspDrawIndexes[ i + ds->firstIndex + 2 ];
 117                 fprintf( f, "f %d/%d/%d %d/%d/%d %d/%d/%d\r\n",
 118                                  a + objVertexCount + 1, a + objVertexCount + 1, a + objVertexCount + 1,
 119                                  b + objVertexCount + 1, b + objVertexCount + 1, b + objVertexCount + 1,
 120                                  c + objVertexCount + 1, c + objVertexCount + 1, c + objVertexCount + 1
 121                                  );
 122         }
 123
 124         objVertexCount += ds->numVerts;
 125 }
 126
 127
 128
 129 /*
 130    ConvertModel()
 131    exports a bsp model to an ase chunk
 132  */
 133
 134 static void ConvertModelToOBJ( FILE *f, bspModel_t *model, int modelNum, vec3_t origin ){
 135         int i, s;
 136         bspDrawSurface_t    *ds;
 137
 138
 139         /* go through each drawsurf in the model */
 140         for ( i = 0; i < model->numBSPSurfaces; i++ )
 141         {
 142                 s = i + model->firstBSPSurface;
 143                 ds = &bspDrawSurfaces[ s ];
 144                 ConvertSurfaceToOBJ( f, model, modelNum, ds, s, origin );
 145         }
 146 }
 147
 148
 149
 150 /*
 151    ConvertShader()
 152    exports a bsp shader to an ase chunk
 153  */
 154
 155 static void ConvertShaderToMTL( FILE *f, bspShader_t *shader, int shaderNum ){
 156         shaderInfo_t    *si;
 157         char filename[ 1024 ];
 158
 159
 160         /* get shader */
 161         si = ShaderInfoForShader( shader->shader );
 162         if ( si == NULL ) {
 163                 Sys_Printf( "WARNING: NULL shader in BSP\n" );
 164                 return;
 165         }
 166
 167         /* set bitmap filename */
 168         if ( si->shaderImage->filename[ 0 ] != '*' ) {
 169                 strcpy( filename, si->shaderImage->filename );
 170         }
 171         else{
 172                 sprintf( filename, "%s.tga", si->shader );
 173         }
 174
 175         /* blender hates this, so let's not do it
 176            for( c = filename; *c != '\0'; c++ )
 177             if( *c == '/' )
 178            *c = '\\';
 179          */
 180
 181         /* print shader info */
 182         fprintf( f, "newmtl %s\r\n", shader->shader );
 183         fprintf( f, "Kd %f %f %f\r\n", si->color[ 0 ], si->color[ 1 ], si->color[ 2 ] );
 184         if ( shadersAsBitmap ) {
 185                 fprintf( f, "map_Kd %s\r\n", shader->shader );
 186         }
 187         else{
 188                 /* blender hates this, so let's not do it
 189                     fprintf( f, "map_Kd ..\\%s\r\n", filename );
 190                  */
 191                 fprintf( f, "map_Kd ../%s\r\n", filename );
 192         }
 193 }
 194
 195 static void ConvertLightmapToMTL( FILE *f, const char *base, int lightmapNum ){
 196         /* print shader info */
 197         fprintf( f, "newmtl lm_%04d\r\n", lightmapNum );
 198         if ( lightmapNum >= 0 ) {
 199                 /* blender hates this, so let's not do it
 200                     fprintf( f, "map_Kd %s\\lm_%04d.tga\r\n", base, lightmapNum );
 201                  */
 202                 fprintf( f, "map_Kd %s/lm_%04d.tga\r\n", base, lightmapNum );
 203         }
 204 }
 205
 206
 207
 208 /*
 209    ConvertBSPToASE()
 210    exports an 3d studio ase file from the bsp
 211  */
 212
 213 int ConvertBSPToOBJ( char *bspName ){
 214         int i, modelNum;
 215         FILE            *f, *fmtl;
 216         bspShader_t     *shader;
 217         bspModel_t      *model;
 218         entity_t        *e;
 219         vec3_t origin;
 220         const char      *key;
 221         char name[ 1024 ], base[ 1024 ], mtlname[ 1024 ], dirname[ 1024 ];
 222
 223
 224         /* note it */
 225         Sys_Printf( "--- Convert BSP to OBJ ---\n" );
 226
 227         /* create the ase filename from the bsp name */
 228         strcpy( dirname, bspName );
 229         StripExtension( dirname );
 230         strcpy( name, bspName );
 231         StripExtension( name );
 232         strcat( name, ".obj" );
 233         Sys_Printf( "writing %s\n", name );
 234         strcpy( mtlname, bspName );
 235         StripExtension( mtlname );
 236         strcat( mtlname, ".mtl" );
 237         Sys_Printf( "writing %s\n", mtlname );
 238
 239         ExtractFileBase( bspName, base );
 240
 241         /* open it */
 242         f = fopen( name, "wb" );
 243         if ( f == NULL ) {
 244                 Error( "Open failed on %s\n", name );
 245         }
 246         fmtl = fopen( mtlname, "wb" );
 247         if ( fmtl == NULL ) {
 248                 Error( "Open failed on %s\n", mtlname );
 249         }
 250
 251         /* print header */
 252         fprintf( f, "o %s\r\n", base );
 253         fprintf( f, "# Generated by Q3Map2 (ydnar) -convert -format obj\r\n" );
 254         fprintf( f, "mtllib %s.mtl\r\n", base );
 255
 256         fprintf( fmtl, "# Generated by Q3Map2 (ydnar) -convert -format obj\r\n" );
 257         if ( lightmapsAsTexcoord ) {
 258                 int lightmapCount;
 259                 for ( lightmapCount = 0; lightmapCount < numBSPLightmaps; lightmapCount++ )
 260                         ;
 261                 for ( ; ; lightmapCount++ )
 262                 {
 263                         char buf[1024];
 264                         FILE *tmp;
 265                         snprintf( buf, sizeof( buf ), "%s/lm_%04d.tga", dirname, lightmapCount );
 266                         buf[sizeof( buf ) - 1] = 0;
 267                         tmp = fopen( buf, "rb" );
 268                         if ( !tmp ) {
 269                                 break;
 270                         }
 271                         fclose( tmp );
 272                 }
 273                 lastLightmap = lightmapCount - 1;
 274         }
 275         else
 276         {
 277                 for ( i = 0; i < numBSPShaders; i++ )
 278                 {
 279                         shader = &bspShaders[ i ];
 280                         ConvertShaderToMTL( fmtl, shader, i );
 281                 }
 282         }
 283
 284         /* walk entity list */
 285         for ( i = 0; i < numEntities; i++ )
 286         {
 287                 /* get entity and model */
 288                 e = &entities[ i ];
 289                 if ( i == 0 ) {
 290                         modelNum = 0;
 291                 }
 292                 else
 293                 {
 294                         key = ValueForKey( e, "model" );
 295                         if ( key[ 0 ] != '*' ) {
 296                                 continue;
 297                         }
 298                         modelNum = atoi( key + 1 );
 299                 }
 300                 model = &bspModels[ modelNum ];
 301
 302                 /* get entity origin */
 303                 key = ValueForKey( e, "origin" );
 304                 if ( key[ 0 ] == '\0' ) {
 305                         VectorClear( origin );
 306                 }
 307                 else{
 308                         GetVectorForKey( e, "origin", origin );
 309                 }
 310
 311                 /* convert model */
 312                 ConvertModelToOBJ( f, model, modelNum, origin );
 313         }
 314
 315         if ( lightmapsAsTexcoord ) {
 316                 for ( i = firstLightmap; i <= lastLightmap; i++ )
 317                         ConvertLightmapToMTL( fmtl, base, i );
 318         }
 319
 320         /* close the file and return */
 321         fclose( f );
 322         fclose( fmtl );
 323
 324         /* return to sender */
 325         return 0;
 326 }