home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / msdos / utils / cad3d2ra.zoo / cad3d2raw.c next >
Encoding:
C/C++ Source or Header  |  1994-04-05  |  10.9 KB  |  410 lines
  1. /*
  2.  * cad3d2raw - Atari CAD-3D 2.0 to RAW triangles
  3.  * $Id: cad3d2raw.c,v 1.2 1994/04/05 14:36:21 herborth Exp $
  4.  *
  5.  * Chris Herborth
  6.  * March 5/94
  7.  *
  8.  * This program will convert a CAD-3D file into a dump of RAW triangles
  9.  * suitable for processing with raw2pov or other programs.
  10.  *
  11.  * Todo: include lighting information in the RAW dump (if there's some
  12.  *       way raw2pov can deal with it)
  13.  *
  14.  * $Log: cad3d2raw.c,v $
  15.  * Revision 1.2  1994/04/05  14:36:21  herborth
  16.  * Fixed bogus usage message.
  17.  *
  18.  * Revision 1.1  1994/03/14  15:23:37  herborth
  19.  * Initial revision
  20.  *
  21.  */
  22.  
  23. #include <unistd.h>                /* needed for malloc()      */
  24. #include <stdio.h>                /* input/output stuff       */
  25. #include <string.h>                /* needed for strrchr()     */
  26. #include <stdlib.h>                /* needed for malloc()      */
  27. #include "cad3d2raw.h"            /* function prototypes, etc */
  28. #include "cad3dobj.h"            /* CAD-3D file structures   */
  29.  
  30. short cad3dobj_as_raw( FILE *fp, const CAD3D_OBJECT *obj,
  31.                        const CAD3D_HEADER *head );
  32.  
  33. #define VERBOSE        0x0001        /* verbose flag                  */
  34. #define NOISY        0x0002        /* debug flag                    */
  35. #define NO_OUTFILE    0x0004        /* no output file specified flag */
  36. #define COLOURS        0x0008        /* use CAD-3D colours in file    */
  37. #define COLOUR_BASE    0x0010        /* use colour group base         */
  38. #define BOZO        0x8000        /* Quit ASAP, bad options given  */
  39.  
  40. short flags = 0;
  41.  
  42. int main( int argc, char **argv )
  43. {
  44.     char *input_filename  = "",
  45.          *output_filename = "";
  46.  
  47.     FILE *input_stream,
  48.          *output_stream;
  49.  
  50.     short loop,
  51.           retval;                /* A spot to stick return values */
  52.  
  53.     CAD3D_HEADER  header;
  54.     CAD3D_OBJECT *objects;
  55.  
  56.     /* Check to see if the user doesn't know what they're doing... */
  57.     if( argc < 2 )
  58.     {
  59.         usage();
  60.         return 1;
  61.     }
  62.  
  63.     /* Parse the command-line arguments... */
  64.     for( loop = 1; loop < argc; loop++ )
  65.     {
  66.         char *arg;
  67.  
  68.         arg = argv[loop];
  69.         if( arg[0] == '-' )
  70.             switch( arg[1] )
  71.             {
  72.                 case 'V':
  73.                     version();
  74.                     break;
  75.  
  76.                 case 'h':
  77.                 case '?':
  78.                     usage();
  79.                     break;
  80.  
  81.                 case 'c':
  82.                     flags |= COLOURS;
  83.                     break;
  84.  
  85.                 case 'b':
  86.                     flags |= COLOUR_BASE;
  87.                     break;
  88.  
  89.                 case 'v':
  90.                     flags |= VERBOSE;
  91.                     break;
  92.  
  93.                 case 'd':
  94.                     flags |= ( NOISY | VERBOSE );
  95.                     break;
  96.  
  97.                 default:
  98.                     fprintf( stderr, "Unknown option \"%s\"!\n", arg );
  99.                     flags |= BOZO;
  100.                     break;
  101.             }
  102.         else
  103.             if( strlen( input_filename ) == 0 )
  104.                 input_filename = arg;
  105.             else
  106.                 if( strlen( output_filename ) == 0 )
  107.                     output_filename = arg;
  108.                 else
  109.                 {
  110.                     fprintf( stderr, "Extra file argument: %s\n", arg );
  111.                     flags |= BOZO;
  112.                 }
  113.     }
  114.  
  115.     /* Check to see if the user entered some mutant args... */
  116.     if( flags & BOZO )
  117.     {
  118.         fprintf( stderr, "Error parsing arguments.\n" );
  119.         return 1;
  120.     }
  121.  
  122.     /* Check to see if we've got an input file... */
  123.     if( strlen( input_filename ) == 0 )
  124.     {
  125.         fprintf( stderr, "No input filename specified.\n" );
  126.         return 1;
  127.     }
  128.  
  129.     /* Check to see if we need to create an output filename... */
  130.     if( strlen( output_filename ) == 0 )
  131.     {
  132.         flags |= NO_OUTFILE;
  133.         output_filename = make_outfile( input_filename, output_extension );
  134.     }
  135.  
  136.     if( flags & NOISY )
  137.     {
  138.         fprintf( stderr, "Debugging messages enabled.\n" );
  139.         if( flags & VERBOSE )
  140.             fprintf( stderr, "Verbose messages enabled.\n" );
  141.         fprintf( stderr, "Input filename: %s\n", input_filename );
  142.         if( flags & NO_OUTFILE )
  143.             fprintf( stderr, "Program will create an output filename: %s.\n",
  144.                      output_filename );
  145.         else
  146.             fprintf( stderr, "Output filename: %s\n", output_filename );
  147.         if( flags & COLOURS )
  148.         {
  149.             fprintf( stderr, "Using triangle colours.\n" );
  150.             fprintf( stderr, "(Will produce a Fractint RAW file.)\n" );
  151.         }
  152.         if( flags & COLOUR_BASE )
  153.         {
  154.             fprintf( stderr, "Using triangle base colours.\n" );
  155.             fprintf( stderr, "(Will produce a Fractint RAW file.)\n" );
  156.         }
  157.     }
  158.  
  159.     /* Open our input/output files */
  160.     input_stream = fopen( input_filename, "rb" );
  161.     if( input_stream == NULL )
  162.     {
  163.         fprintf( stderr, "Can't open input file: %s\n", input_filename );
  164.         return 1;
  165.     }
  166.  
  167.     output_stream = fopen( output_filename, "w" );
  168.     if( output_stream == NULL )
  169.     {
  170.         fprintf( stderr, "Can't open output file: %s\n", output_filename );
  171.         fclose( input_stream );
  172.         return 1;
  173.     }
  174.  
  175.     if( flags & VERBOSE )
  176.         fprintf( stderr, "Reading file header...\n" );
  177.     retval = get_cad3d_header( input_stream, &header );
  178.     if( retval != 0 )
  179.         switch( retval )
  180.         {
  181.             case -1:
  182.                 fprintf( stderr, "Error reading file: %s\n", output_filename );
  183.                 fclose( input_stream );
  184.                 fclose( output_stream );
  185.                 return 1;
  186.                 /* break; */
  187.             case -2:
  188.                 fprintf( stderr, "Bad CAD-3D file id: %x\n", header.file_id );
  189.                 fclose( input_stream );
  190.                 fclose( output_stream );
  191.                 return 1;
  192.                 /* break; */
  193.             default:
  194.                 fprintf( stderr, "Unknown error code %d from get_cad3d_header!\n",
  195.                          retval );
  196.                 break;
  197.         }
  198.  
  199.     if( flags & NOISY )
  200.         retval = dump_cad3d_header( stderr, &header );
  201.  
  202.     /* Load the objects from the 3d2 file... */
  203.     if( flags & VERBOSE )
  204.         fprintf( stderr, "Reading objects...\n" );
  205.  
  206.     objects = (CAD3D_OBJECT *)malloc( header.num_objects * sizeof( CAD3D_OBJECT ) );
  207.     if( objects == NULL )
  208.     {
  209.         fprintf( stderr, "Can't allocate memory for objects!\n" );
  210.         fclose( input_stream );
  211.         fclose( output_stream );
  212.         return 2;
  213.     }
  214.  
  215.     for( loop = 0; loop < header.num_objects; loop++ )
  216.     {
  217.         retval = get_cad3d_object( input_stream, &(objects[loop]) );
  218.         if( retval != 0 )
  219.             switch( retval )
  220.             {
  221.                 case -1:
  222.                     fprintf( stderr, "Error reading object %d!\n", loop );
  223.                     fclose( input_stream );
  224.                     fclose( output_stream );
  225.                     return 1;
  226.                     /* break; */
  227.                 case -2:
  228.                     fprintf( stderr, "Can't allocate memory for vertices in object %d!\n",
  229.                              loop );
  230.                     fclose( input_stream );
  231.                     fclose( output_stream );
  232.                     return 2;
  233.                     /* break; */
  234.                 case -3:
  235.                     fprintf( stderr, "Error reading %d vertices for object %d!\n",
  236.                              objects[loop].num_vertices, loop );
  237.                     fclose( input_stream );
  238.                     fclose( output_stream );
  239.                     return 1;
  240.                     /* break; */
  241.                 case -4:
  242.                     fprintf( stderr, "Can't allocate memory for triangles in object %d!\n",
  243.                              loop );
  244.                     fclose( input_stream );
  245.                     fclose( output_stream );
  246.                     return 2;
  247.                     /* break; */
  248.                 case -5:
  249.                     fprintf( stderr, "Error reading %d triangles for object %d!\n",
  250.                              objects[loop].num_triangles, loop );
  251.                     fclose( input_stream );
  252.                     fclose( output_stream );
  253.                     return 1;
  254.                     /* break; */
  255.                 default:
  256.                     fprintf( stderr, "Unknown error code %d from get_cad3d_object!\n",
  257.                              retval );
  258.                     break;
  259.             }
  260.         if( flags & VERBOSE )
  261.             fprintf( stderr, "Loaded object %d, \"%s\" with %d vertices and %d triangles...\n",
  262.                      loop, objects[loop].name, objects[loop].num_vertices,
  263.                      objects[loop].num_triangles );
  264.         if( flags & NOISY )
  265.             retval = dump_cad3d_object( stderr, &(objects[loop]) );
  266.     }
  267.  
  268.     /* Now that we've loaded the objects, dump them to a RAW file. */
  269.     fprintf( output_stream, "{ RAW file created with cad3d2raw }\n\n" );
  270.     for( loop = 0; loop < header.num_objects; loop++ )
  271.     {
  272.         if( flags & NOISY )
  273.             fprintf( stderr, "Dumping object %d, \"%s\", to RAW...\n",
  274.                      loop, objects[loop].name );
  275.         retval = cad3dobj_as_raw( output_stream, &(objects[loop]), &header );
  276.         if( retval != 0 )
  277.             switch( retval )
  278.             {
  279.                 case -1:
  280.                     fprintf( stderr, "Bad stream or object in cad3dobj_as_raw!\n" );
  281.                     fflush( output_stream );
  282.                     fclose( input_stream );
  283.                     fclose( output_stream );
  284.                     return 1;
  285.                     /* break; */
  286.                 default:
  287.                     fprintf( stderr, "Unknown return value %d from cad3dobj_as_raw!\n",
  288.                              retval );
  289.                     break;
  290.             }
  291.     }
  292.  
  293.     fflush( output_stream );
  294.     fclose( input_stream );
  295.     fclose( output_stream );
  296.  
  297.     /* All's well that ends well... */
  298.     return 0;
  299. }
  300.  
  301. short cad3dobj_as_raw( FILE *fp, const CAD3D_OBJECT *obj,
  302.                        const CAD3D_HEADER *head )
  303. {
  304.     unsigned short loop;
  305.     short retval;
  306.     RGB_TRIAD colour;
  307.     char tmp[9];
  308.  
  309.     if( fp == NULL || obj == NULL )
  310.         return -1;
  311.  
  312.     if( flags & NOISY )
  313.         fprintf( stderr, "Dumping %s, %d triangles...\n", obj->name,
  314.                  obj->num_triangles );
  315.     if( flags & VERBOSE )
  316.         fprintf( stderr, "Dumping %s...\n", obj->name );
  317.  
  318.     /* Fiddle with the object name, since raw2pov dies if you have */
  319.     /* spaces in object names...                                   */
  320.     strcpy( tmp, obj->name );
  321.     for( loop = 0; loop < strlen( tmp ); loop++ )
  322.         if( tmp[loop] == ' ' )    /* should probably be iswhite() */
  323.             tmp[loop] = '_';
  324.     fprintf( fp, "\"%s\"\n", tmp );
  325.     for( loop = 0; loop < obj->num_triangles; loop++ )
  326.     {
  327.         if( flags & COLOURS )
  328.         {
  329.             retval = obj->triangles[loop].colour_edge & 0x00ff;
  330.             retval = atari2rgb( head->obj_palette[retval],
  331.                                 &colour );
  332.             fprintf( fp, "%f %f %f\n", colour.red, colour.green, colour.blue );
  333.         }
  334.         if( flags & COLOUR_BASE )
  335.         {
  336.             retval = cad3d_triangle_colour( head, &(obj->triangles[loop]) );
  337.             retval = atari2rgb( retval, &colour );
  338.             fprintf( fp, "%f %f %f\n", colour.red, colour.green, colour.blue );
  339.         }
  340.         fprintf( fp, "%f %f %f\n",
  341.                  (float)(obj->vertices[obj->triangles[loop].index_a].x)/100.0,
  342.                  (float)(obj->vertices[obj->triangles[loop].index_a].y)/100.0,
  343.                  (float)(obj->vertices[obj->triangles[loop].index_a].z)/100.0 );
  344.         fprintf( fp, "%f %f %f\n",
  345.                  (float)(obj->vertices[obj->triangles[loop].index_b].x)/100.0,
  346.                  (float)(obj->vertices[obj->triangles[loop].index_b].y)/100.0,
  347.                  (float)(obj->vertices[obj->triangles[loop].index_b].z)/100.0 );
  348.         fprintf( fp, "%f %f %f\n\n",
  349.                  (float)(obj->vertices[obj->triangles[loop].index_c].x)/100.0,
  350.                  (float)(obj->vertices[obj->triangles[loop].index_c].y)/100.0,
  351.                  (float)(obj->vertices[obj->triangles[loop].index_c].z)/100.0 );
  352.     }
  353.     fprintf( fp, "\n" );
  354.  
  355.     return 0;
  356. }
  357.  
  358. char *make_outfile( const char *infile, const char *outext )
  359. {
  360.     char *tmp, *exten;
  361.  
  362.     if( flags & NOISY )
  363.     {
  364.         fprintf( stderr, "make_outfile[%d]: infile = %s\n", __LINE__, infile );
  365.         fprintf( stderr, "make_outfile[%d]: outext = %s\n", __LINE__, outext );
  366.     }
  367.  
  368.     tmp = (char *)malloc( strlen( infile ) + strlen( outext ) + 1 );
  369.     strcpy( tmp, infile );
  370.     if( flags & NOISY )
  371.         fprintf( stderr, "make_outfile[%d]: tmp = %s\n", __LINE__, tmp );
  372.     exten = strrchr( tmp, (int)'.' );
  373.     if( exten == NULL )
  374.         strcat( tmp, "." );
  375.     else
  376.     {
  377.         if( flags & NOISY )
  378.             fprintf( stderr, "make_outfile[%d]: exten = %s\n",
  379.                      __LINE__, exten );
  380.         exten[1] = 0x00;
  381.     }
  382.     strcat( tmp, outext );
  383.     if( flags & NOISY )
  384.         fprintf( stderr, "make_outfile[%d]: tmp = %s\n", __LINE__, tmp );
  385.  
  386.     return tmp;
  387. }    
  388.  
  389. void usage( void )
  390. {
  391.     puts( "usage: cad3d2raw [options] input.3d2 [output.raw]\n" );
  392.     puts( "       -c - use colours from CAD-3D file (makes a Fractint RAW file)" );
  393.     puts( "       -b - use colour base (works better; makes a Fractint RAW file)" );
  394.     puts( "       -v - verbose output" );
  395.     puts( "       -d - debugging output (ie, extra-verbose)\n" );
  396.     puts( "Less useful options:" );
  397.     puts( "       -h - print this message" );
  398.     puts( "       -? - print this message" );
  399.     puts( "       -V - print version info" );
  400.  
  401.     return;
  402. }
  403.  
  404. void version( void )
  405. {
  406.     puts( version_info );
  407.  
  408.     return;
  409. }
  410.