cv/mgflib/3ds2mgf.c

/*
      3DS2POV.C  Copyright (c) 1996 Steve Anger and Jeff Bowermaster
                        MGF output added by Greg Ward

      Reads a 3D Studio .3DS file and writes a POV-Ray, Vivid,
      Polyray, MGF or raw scene file.

      Version 2.0 Written Feb/96

      Compiled with MSDOS GNU C++ 2.4.1 or generic ANSI-C compiler
*/

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <ctype.h>
#include "vect.h"
#include "rayopt.h"

#ifdef __TURBOC__
#include <alloc.h>
extern unsigned _stklen = 16384;
#endif


#define FALSE 0
#define TRUE  1

/* Internal bounding modes */
#define OFF  0
#define ON   1
#define AUTO 2

#define MAX_LIB  10
#define ASPECT   1.333

/* Output formats */
#define POV10    0
#define POV20    1
#define VIVID    2
#define POLYRAY  3
#define MGF      4
#define RAW      99

#define DEG(x) ((double)(180.0/M_PI)*(x))
#define RAD(x) ((double)(M_PI/180.0)*(x))

#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

#ifndef MAXFLOAT
#define MAXFLOAT (1e37)
#endif
                                /* RGB chromaticity definitions for MGF */
#define CIE_x_r         0.640
#define CIE_y_r         0.330
#define CIE_x_g         0.290
#define CIE_y_g         0.600
#define CIE_x_b         0.150
#define CIE_y_b         0.060
                                /* computed luminances from above */
#define CIE_Y_r         0.265
#define CIE_Y_g         0.670
#define CIE_Y_b         0.065

/* A generic list type */
#define LIST_INSERT(root, node) list_insert ((List **)&root, (List *)node)
#define LIST_FIND(root, name)   list_find   ((List **)&root, name)
#define LIST_DELETE(root, node) list_delete ((List **)&root, (List *)node)
#define LIST_KILL(root)         list_kill   ((List **)&root)

#define LIST_FIELDS  \
    char name[80];   \
    void *next;


typedef unsigned char  byte;
typedef unsigned short word;
typedef unsigned long  dword;

typedef struct {
    LIST_FIELDS
} List;


typedef struct {
    int a, b, c;
} Face;


typedef struct {
    float red, green, blue;
} Colour;


/* Transformation command */
typedef struct {
    LIST_FIELDS

    Matrix matrix;
} Transform;


/* Morph command */
typedef struct {
    LIST_FIELDS

    int    count;          /* Number of objects in morph */
    char   names[4][80];   /* Name of n'th object in average */
    float  weight[4];      /* Weight applied to n'th object */

    Matrix matrix;
} Morph;


/* Omni light command */
typedef struct {
    LIST_FIELDS

    Vector pos;            /* Light position */
    Colour col;            /* Light colour */
} OmniLight;


/* Spotlight command */
typedef struct {
    LIST_FIELDS

    Vector pos;            /* Spotlight position */
    Vector target;         /* Spotlight target location */
    Colour col;            /* Spotlight colour */
    float  hotspot;        /* Hotspot angle (degrees) */
    float  falloff;        /* Falloff angle (degrees) */
    int    shadow_flag;    /* Shadow flag (not used) */
} Spotlight;


/* Camera command */
typedef struct {
    LIST_FIELDS

    Vector pos;            /* Camera location */
    Vector target;         /* Camera target */
    float  bank;           /* Banking angle (degrees) */
    float  lens;           /* Camera lens size (mm) */
} Camera;


/* Material list */
typedef struct {
    LIST_FIELDS

    int  external;         /* Externally defined material? */
} Material;


/* Object summary */
typedef struct {
    LIST_FIELDS

    Vector center;         /* Min value of object extents */
    Vector lengths;        /* Max value of object extents */
} Summary;


/* Material property */
typedef struct {
    LIST_FIELDS

    Colour ambient;
    Colour diffuse;
    Colour specular;
    float  shininess;
    float  transparency;
    float  reflection;
    int    self_illum;
    int    two_side;
    char   tex_map[40];
    float  tex_strength;
    char   bump_map[40];
    float  bump_strength;
} MatProp;


/* Default material property */
MatProp DefaultMaterial = { "Default", NULL, {1.0, 1.0, 1.0}, {1.0, 1.0, 1.0},
                             {1.0, 1.0, 1.0}, 70.0, 0.0, 0.0, FALSE, FALSE };

/* A mesh object */
typedef struct {
    LIST_FIELDS

    int  vertices;         /* Number of vertices */
    Vector *vertex;        /* List of object vertices */

    int  faces;            /* Number of faces */
    Face *face;            /* List of object faces */
    Material **mtl;        /* Materials for each face */

    Matrix matrix;         /* Local mesh matrix */
    Matrix invmatrix;
    Vector center;         /* Center of object */
    Vector lengths;        /* Dimensions of object */

    int hidden;            /* Hidden flag */
    int shadow;            /* Shadow flag */
} Mesh;


typedef struct {
    dword start;
    dword end;
    dword length;
    word  tag;
} Chunk;


typedef struct {
    byte red;
    byte green;
    byte blue;
} Colour_24;


Colour Black = {0.0, 0.0, 0.0};

OmniLight *omni_list  = NULL;
Spotlight *spot_list  = NULL;
Camera    *cam_list   = NULL;
Mesh      *mesh_list  = NULL;
Transform *trans_list = NULL;
Morph     *morph_list = NULL;
Material  *mtl_list   = NULL;
List      *excl_list  = NULL;
List      *box_list   = NULL;
MatProp   *mprop_list = NULL;
Summary   *summary    = NULL;


FILE   *in;
FILE   *out;
char   inname[80];
char   outname[80];
char   vuename[80];
char   obj_name[80] = "";
Colour fog_colour = {0.0, 0.0, 0.0};
Colour col        = {0.0, 0.0, 0.0};
Colour global_amb = {0.1, 0.1, 0.1};
Vector pos        = {0.0, 0.0, 0.0};
Vector target     = {0.0, 0.0, 0.0};
float  fog_distance = 0.0;
float  hotspot = -1;
float  falloff = -1;
Mesh   *mesh = NULL;
int    frame = -1;
char   libname[MAX_LIB][80];
float  smooth = 60.0;
int    bound = 0;
int    verbose = 0;
int    format = POV20;
int    internal_bounding = AUTO;
int    box_all = FALSE;
int    cameras = 0;
int    libs = 0;
float  vue_version = 1.0;
Matrix *ani_matrix = NULL;
int    no_opt = FALSE;
FILE   *meshf = NULL;


void process_args (int argc, char *argv[]);
void parse_option (char *option);
void list_insert (List **root, List *new_node);
void *list_find (List **root, char *name);
void list_delete (List **root, List *node);
void list_kill (List **root);
Material *update_materials (char *new_material, int ext);
MatProp *create_mprop (void);
void read_library (char *fname);
void write_intro (FILE *f);
void write_summary (FILE *f);
void write_bgsolid (FILE *f, Colour col);
void write_light (FILE *f, char *name, Vector pos, Colour col);
void write_spot (FILE *f, char *name, Vector pos, Vector target, Colour col,
         float hotspot, float falloff);
void write_fog (FILE *f, Colour col, float dist);
void write_camera (FILE *f, char *name, Vector pos, Vector target, float lens,
         float bank);
void write_material (FILE *f, char *mat);
void write_pov10_material (FILE *f, MatProp *m);
void write_pov20_material (FILE *f, MatProp *m);
void write_vivid_material (FILE *f, MatProp *m);
void write_polyray_material (FILE *f, MatProp *m);
void write_mgf_material (FILE *f, MatProp *m);
void write_mesh (FILE *f, Mesh *mesh);
Transform *parse_transform (char *string);
Morph *parse_morph (char *string);
OmniLight *parse_omnilight (char *string);
Spotlight *parse_spotlight (char *string);
Camera *parse_camera (char *string);
void read_frame (char *filename, int frame_no);
void find_frame (FILE *f, int frame_no);
void save_animation (void);
Mesh *create_mesh (char *name, int vertices, int faces);
Mesh *copy_mesh (Mesh *mesh);
void free_mesh_data (Mesh *mesh);
void update_limits (Mesh *mesh);
char *before (char *str, char *target);
char *after (char *str, char *target);
char *between (char *str, char *target1, char *target2);
char *parse_string (char *str);
char upcase (char c);
float colour_intens (Colour *colour);
void parse_file (void);
void parse_3ds (Chunk *mainchunk);
void parse_mdata (Chunk *mainchunk);
void parse_fog (Chunk *mainchunk);
void parse_fog_bgnd (void);
void parse_mat_entry (Chunk *mainchunk);
char *parse_mapname (Chunk *mainchunk);
void parse_named_object (Chunk *mainchunk);
void parse_n_tri_object (Chunk *mainchunk);
void parse_point_array (void);
void parse_face_array (Chunk *mainchunk);
void parse_msh_mat_group (void);
void parse_smooth_group (void);
void parse_mesh_matrix (void);
void parse_n_direct_light (Chunk *mainchunk);
void parse_dl_spotlight (void);
void parse_n_camera (void);
void parse_colour (Colour *colour);
void parse_colour_f (Colour *colour);
void parse_colour_24 (Colour_24 *colour);
float parse_percentage (void);
short parse_int_percentage (void);
float parse_float_percentage (void);
void start_chunk (Chunk *chunk);
void end_chunk (Chunk *chunk);
byte read_byte (void);
word read_word (void);
dword read_dword (void);
float read_float (void);
void read_point (Vector v);
char *read_string (void);
float findfov (float lens);
int read_mgfmatname (char *s, int n, FILE *f);

char *progname;


int main (int argc, char *argv[])
{
    char meshfname[128];
    Material *m;
    int i;

    process_args (argc, argv);

    if (!no_opt) {
        opt_set_format (format);
        opt_set_dec (4);
        opt_set_bound (bound);
        opt_set_smooth (smooth);
        opt_set_quiet (!verbose);
        opt_set_fname (outname, "");
    } else if (format == MGF) {
        strcpy(meshfname, outname);
        add_ext(meshfname, "inc", 1);
        if (!strcmp(meshfname, outname)) {
            printf ("Output and mesh file names are identical!\n");
            exit (1);
        }
        if ((meshf = fopen (meshfname, "w")) == NULL) {
            printf ("Cannot open mesh output file %s!\n", meshfname);
            exit (1);
        }
    }

    if ((in = fopen (inname, "rb")) == NULL) {
        printf ("Cannot open input file %s!\n", inname);
        exit (1);
    }

    if ((out = fopen (outname, "w")) == NULL) {
        printf ("Cannot open output file %s!\n", outname);
        exit (1);
    }

    /* Load the names of pre-defined materials */
    for (i = 0; i < MAX_LIB; i++) {
        if (strlen(libname[i]) > 0)
            read_library (libname[i]);
    }

    /* Load the instructions for the current frame */
    if (strlen(vuename) > 0)
        read_frame (vuename, frame);

    printf("Output to: %s\n", outname);

    if (frame >= 0)
        printf ("Generating frame #%d\n", frame);

    printf("\nPlease wait; Processing...\n");

    write_intro(out);

    parse_file();

    fclose(in);

    for (m = mtl_list; m != NULL; m = m->next) {
        if (!m->external)
            write_material (out, m->name);
    }

    if (frame >= 0)
        save_animation();

    if (!no_opt) {
        write_summary (out);
        fflush (out);

        opt_finish();
    } else if (meshf != NULL) {
        fclose(meshf);
        fprintf (out, "i %s\n", meshfname);
    }

    fclose (out);

    LIST_KILL (omni_list);
    LIST_KILL (spot_list);
    LIST_KILL (cam_list);
    LIST_KILL (mesh_list);
    LIST_KILL (trans_list);
    LIST_KILL (morph_list);
    LIST_KILL (mtl_list);
    LIST_KILL (excl_list);
    LIST_KILL (box_list);
    LIST_KILL (mprop_list);
    LIST_KILL (summary);

    return 0;
}


/* Handle the command line args */
void process_args (int argc, char *argv[])
{
    int i;
    char *env_opt, *option;

    printf("\n\nAutodesk 3D Studio to Raytracer file Translator. Feb/96\n");
    printf("Version 2.0 Copyright (c) 1996 Steve Anger and Jeff Bowermaster\n");
#ifdef __GNUC__
    printf ("32 bit version. DOS extender Copyright (c) 1991 DJ Delorie\n");
#endif
    printf ("\n");

    if (argc < 2) {
        printf ("Usage: %s inputfile[.3ds] [outputfile] [options]\n\n", argv[0]);
        printf ("Options: -snnn        - Smooth triangles with angles < nnn\n");
        printf ("         -l<filename> - Specifies native material library\n");
        printf ("         -a<filename> - Use animation information in specified file\n");
        printf ("         -fnnn        - Generate frame nnn of animation\n");
        printf ("         -x<object>   - Exclude this object from conversion\n");
        printf ("         -b<object>   - Convert this object as a box\n");
        printf ("         +i, -i       - Turn internal bounding on or off\n");
        printf ("         +v, -v       - Turn verbose status messages on or off\n");
        printf ("         -op          - Output to POV-Ray 2.0 format\n");
        printf ("         -op1         - Output to POV-Ray 1.0 format\n");
        printf ("         -ov          - Output to Vivid format\n");
        printf ("         -ol          - Output to poLyray format\n");
        printf ("         -om          - Output to MGF\n");
        printf ("         -or          - Output to RAW triangle format\n\n");
        printf ("ex. %s birdshow +v -lmaterials.inc\n\n", argv[0]);
        exit(1);
    }
                                        /* figure default format from name */
    progname = strrchr(argv[0], '/');
    if (progname == NULL) progname = argv[0];
    else progname++;
    if (!strcmp(progname, "3ds2pov"))
        format = POV20;
    else if (!strcmp(progname, "3ds2viv"))
        format = VIVID;
    else if (!strcmp(progname, "3ds2pi"))
        format = POLYRAY;
    else if (!strcmp(progname, "3ds2mgf"))
        format = MGF;
    else if (!strcmp(progname, "3ds2raw"))
        format = RAW;
    else
        format = POV20;         /* default if program name strange */

    strcpy (inname, "");
    strcpy (outname, "");
    strcpy (vuename, "");

    for (i = 0; i < MAX_LIB; i++)
        strcpy (libname[i], "");

    frame = -1;
    smooth = 70.0;
    bound = 0;
    verbose = 0;
    internal_bounding = AUTO;
    box_all = FALSE;
    libs = 0;

    /* Parse the enviroment string options */
    env_opt = getenv ("3DS2POV");

    if (env_opt != NULL) {
        option = parse_string (env_opt);

        while (strlen(option) > 0) {
            parse_option (option);
            option = parse_string (NULL);
        }
    }

    /* Parse the command line options */
    for (i = 1; i < argc; i++)
        parse_option (argv[i]);

    if (strlen(inname) == 0)
        abortmsg ("No input file specified", 1);

    if (strlen(outname) == 0)
        strcpy (outname, inname);

    switch (format) {
        case POV10:
        case POV20:   add_ext (outname, "pov", 1); break;
        case VIVID:   add_ext (outname, "v",   1); break;
        case POLYRAY: add_ext (outname, "pi",  1); break;
        case MGF:     add_ext (outname, "mgf", 1); break;
        case RAW:     add_ext (outname, "raw", 1); break;
    }

    switch (internal_bounding) {
        case OFF:  bound = 2; break;
        case ON:   bound = 0; break;
        case AUTO: bound = (format == POV10) ? 0 : 2; break;
    }

    if ((strlen(vuename) > 0) != (frame >= 0))
        abortmsg ("The -a and -f parameters must be used together", 1);

    if (format == RAW || (format == MGF && smooth < 0.1))
        no_opt = TRUE;
}


void parse_option (char *option)
{
    List *excl, *box;
    char name[80];

    if (option[0] == '-' || option[0] == '+') {
        switch (upcase(option[1])) {
            case 'A': strcpy (vuename, &option[2]);
                      break;

            case 'B': strcpy (name, parse_string (&option[2]));
                      if (strlen(name) == 0)
                          box_all = TRUE;
                      else {
                          cleanup_name (name);

                          box = malloc (sizeof (*box));
                          strcpy (box->name, name);

                          LIST_INSERT (box_list, box);
                      }
                      break;

            case 'F': if (option[2] != '\0')
                          frame = atoi (&option[2]);
                      break;

            case 'I': if (option[0] == '-')
                          internal_bounding = OFF;
                      else
                          internal_bounding = ON;
                      break;

            case 'L': if (libs == MAX_LIB)
                          abortmsg ("Too many libraries specified", 1);

                      strcpy (libname[libs++], &option[2]);
                      break;

            case 'O': switch (upcase(option[2])) {
                          case 'P': if (option[3] == '1')
                                        format = POV10;
                                    else
                                        format = POV20;
                                    break;

                          case 'V': format = VIVID;
                                    break;

                          case 'L': format = POLYRAY;
                                    break;

                          case 'R': format = RAW;
                                    break;

                          case 'M': format = MGF;
                                    break;

                          default:  printf ("Invalid output format %s specified\n", option);
                                    exit(1);
                      }
                      break;

            case 'S': if (option[2] != '\0')
                          smooth = atof (&option[2]);
                      break;

            case 'U': printf ("Warning: -u parameter no long has any effect\n");
                      printf ("         use +i or -i instead.\n");
                      break;

            case 'V': if (option[0] == '-')
                          verbose = 0;
                      else
                          verbose = 1;
                      break;

            case 'X': strcpy (name, parse_string (&option[2]));
                      cleanup_name (name);

                      excl = malloc (sizeof (*excl));
                      strcpy (excl->name, name);

                      LIST_INSERT (excl_list, excl);
                      break;

            default : printf ("\nInvalid option %s specified\n", option);
                      exit (1);
        }
    }
    else if (strlen (inname) == 0) {
        strcpy (inname, option);
        add_ext (inname, "3ds", 0);
    }
    else if (strlen (outname) == 0)
        strcpy (outname, option);
    else
        abortmsg ("Too many file names specified.\n", 1);
}


/* Insert a new node into the list */
void list_insert (List **root, List *new_node)
{
    new_node->next = *root;

    *root = new_node;
}


/* Find the node with the specified name */
void *list_find (List **root, char *name)
{
    List *p;

    for (p = *root; p != NULL; p = p->next) {
        if (strcmp (p->name, name) == 0)
            break;
    }

    return (void *)p;
}


/* Delete the indicated node from the list */
void list_delete (List **root, List *node)
{
    List *prev;

    prev = *root;
    while (prev != NULL && prev->next != node)
        prev = prev->next;

    if (prev == NULL)
        *root = node->next;
    else
        prev->next = node->next;

    free (node);
}


/* Delete the entire list */
void list_kill (List **root)
{
    List *temp;

    while (*root != NULL) {
        temp = *root;
        *root = (*root)->next;
        free (temp);
    }
}


/* Add a new material to the material list */
Material *update_materials (char *new_material, int ext)
{
    Material *p;

    p = LIST_FIND (mtl_list, new_material);

    if (p == NULL) {
        p = malloc (sizeof (*p));

        if (p == NULL)
            abortmsg ("Out of memory adding material", 1);

        strcpy (p->name, new_material);
        p->external = ext;

        LIST_INSERT (mtl_list, p);
    }

    return p;
}


MatProp *create_mprop()
{
    MatProp *new_mprop;

    new_mprop = malloc (sizeof(*new_mprop));
    if (new_mprop == NULL)
        abortmsg ("Out of memory adding material", 1);

    strcpy (new_mprop->name, "");
    new_mprop->ambient = Black;
    new_mprop->diffuse = Black;
    new_mprop->specular = Black;
    new_mprop->shininess = 0.0;
    new_mprop->transparency = 0.0;
    new_mprop->reflection = 0.0;
    new_mprop->self_illum = FALSE;
    new_mprop->two_side = FALSE;

    strcpy (new_mprop->tex_map, "");
    new_mprop->tex_strength = 0.0;

    strcpy (new_mprop->bump_map, "");
    new_mprop->bump_strength = 0.0;

    return new_mprop;
}


/* Load in any predefined materials */
void read_library (char *fname)
{
    FILE *lib;
    char string[256], name[80];

    if ((lib = fopen (fname, "r")) == NULL) {
        printf ("Cannot open texture library file %s!\n", fname);
        exit(1);
    }

    switch (format) {
        case POV10:
        case POV20:
            while (fgets (string, 256, lib) != NULL) {
                if (strstr (string, "#declare")) {
                    strcpy (name, between (string, "#declare", "="));
                    cleanup_name (name);
                    (void)update_materials (name, TRUE);
                }
            }
            break;

        case VIVID:
            while (fgets (string, 256, lib) != NULL) {
                if (strstr (string, "#define")) {
                    (void)parse_string (string);
                    strcpy (name, parse_string (NULL));
                    cleanup_name (name);
                    (void)update_materials (name, TRUE);
                }
            }
            break;

        case POLYRAY:
            while (fgets (string, 256, lib) != NULL) {
                if (strstr (string, "define")) {
                    (void)parse_string (string);
                    strcpy (name, parse_string (NULL));
                    cleanup_name (name);
                    (void)update_materials (name, TRUE);
                }
            }
            break;

        case MGF:
            while (read_mgfmatname(name, 80, lib))
                (void)update_materials (name, TRUE);
            break;
    }

    fclose (lib);
}


/* parse the next MGF material name from f, return FALSE if EOF */
int read_mgfmatname (char *s, int n, FILE *f)
{       
    char inpline[128];
    register char *cp, *cp2;
    register int i;
                                        /* find material */
    while (fgets(inpline, sizeof(inpline), f) != NULL) {
        for (cp = inpline; isspace(*cp); cp++)
            ;
        if (*cp++ != 'm' || !isspace(*cp++))
            continue;
        while (isspace(*cp))
            cp++;
        if (!*cp)
            continue;
        for (i=n, cp2=s; *cp && !isspace(*cp); cp++)    /* get name */
            if (--i > 0)
                *cp2++ = *cp;
        *cp2 = '\0';
        while (isspace(*cp))
            cp++;
        if (*cp++ != '=' || !isspace(*cp))              /* not defined? */
            continue;
        return TRUE;
    }
    return FALSE;
}


void write_intro (FILE *f)
{
    int i;

    switch (format) {
        case POV10:
        case POV20:
            fprintf (f, "#include \"colors.inc\"\n");
            fprintf (f, "#include \"shapes.inc\"\n");
            fprintf (f, "#include \"textures.inc\"\n");

            for (i = 0; i < MAX_LIB; i++) {
                if (strlen(libname[i]) > 0)
                    fprintf (f, "#include \"%s\"\n", libname[i]);
            }

            fprintf (f, "\n");
            break;

        case VIVID:
            fprintf (f, "#include color.vc\n");

            for (i = 0; i < MAX_LIB; i++) {
                if (strlen(libname[i]) > 0)
                    fprintf (f, "#include %s\n", libname[i]);
            }

            fprintf (f, "\n");
            break;

        case POLYRAY:
            fprintf (f, "include \"colors.inc\"\n");

            for (i = 0; i < MAX_LIB; i++) {
                if (strlen(libname[i]) > 0)
                    fprintf (f, "include \"%s\"\n", libname[i]);
            }

            fprintf (f, "\n");
            break;

        case MGF:
            fprintf (f, "c R =\n\tcxy %.3f %.3f\n", CIE_x_r, CIE_y_r);
            fprintf (f, "c G =\n\tcxy %.3f %.3f\n", CIE_x_g, CIE_y_g);
            fprintf (f, "c B =\n\tcxy %.3f %.3f\n", CIE_x_b, CIE_y_b);

            for (i = 0; i < MAX_LIB; i++) {
                if (strlen(libname[i]) > 0)
                    fprintf (f, "i %s\n", libname[i]);
            }

            fprintf (f, "\n");
            break;
    }
}


/* Write the object summary */
void write_summary (FILE *f)
{
    char *comstr;
    Summary *s;

    if (summary == NULL)
        return;

    switch (format) {
        case POV10:
        case POV20:
        case VIVID:
        case POLYRAY:
            comstr = "//";
            break;
        case MGF:
            comstr = "# ";
            break;
    }
    fprintf (f, "%s   Object    CenterX    CenterY    CenterZ    LengthX    LengthY    LengthZ\n", comstr);
    fprintf (f, "%s ---------- ---------- ---------- ---------- ---------- ---------- ----------\n", comstr);

    for (s = summary; s != NULL; s = s->next) {
        fprintf (f, "%s %-10s%11.2f%11.2f%11.2f%11.2f%11.2f%11.2f\n",
                 comstr, s->name, s->center[X], s->center[Y], s->center[Z],
                 s->lengths[X], s->lengths[Y], s->lengths[Z]);
    }

    fprintf (f, "\n");
}


/* Write background solid colour */
void write_bgsolid (FILE *f, Colour col)
{
    switch (format) {
        case POV10:
            fprintf (f, "/* Background colour */\n");
            fprintf (f, "object {\n");
            fprintf (f, "   sphere { <0.0 0.0 0.0> 1e6 }\n");
            fprintf (f, "   texture {\n");
            fprintf (f, "      ambient 1.0\n");
            fprintf (f, "      diffuse 0.0\n");
            fprintf (f, "      color red %4.2f green %4.2f blue %4.2f\n",
                                 col.red, col.green, col.blue);
            fprintf (f, "   }\n");
            fprintf (f, "}\n\n");
            break;

        case POV20:
            fprintf (f, "background { color red %4.2f green %4.2f blue %4.2f }\n\n",
                           col.red, col.green, col.blue);
            break;

        case POLYRAY:
            fprintf (f, "background <%4.2f, %4.2f, %4.2f>\n\n",
                           col.red, col.green, col.blue);
            break;
    }
}


void write_light (FILE *f, char *name, Vector pos, Colour col)
{
    switch (format) {
        case POV10:
            fprintf (f, "/* Light: %s */\n", name);
            fprintf (f, "object {\n");
            fprintf (f, "    light_source { <%.4f %.4f %.4f> color red %4.2f green %4.2f blue %4.2f }\n",
                        pos[X], pos[Y], pos[Z], col.red, col.green, col.blue);
            fprintf (f, "}\n\n");
            break;

        case POV20:
            fprintf (f, "/* Light: %s */\n", name);
            fprintf (f, "light_source {\n");
            fprintf (f, "    <%.4f, %.4f, %.4f> color rgb <%4.2f, %4.2f, %4.2f>\n",
                     pos[X], pos[Y], pos[Z], col.red, col.green, col.blue);
            fprintf (f, "}\n\n");
            break;

        case VIVID:
            fprintf (f, "/* Light: %s */\n", name);
            fprintf (f, "light {\n");
            fprintf (f, "    type point\n");
            fprintf (f, "    position %.4f %.4f %.4f\n",
                             pos[X], pos[Y], pos[Z]);
            fprintf (f, "    color %4.2f %4.2f %4.2f\n",
                             col.red, col.green, col.blue);
            fprintf (f, "}\n\n");
            break;

        case POLYRAY:
            fprintf (f, "// Light: %s\n", name);
            fprintf (f, "light <%4.2f, %4.2f, %4.2f>, <%.4f, %.4f, %.4f>\n\n",
                         col.red, col.green, col.blue, pos[X], pos[Y], pos[Z]);
            break;

        case MGF:
            fprintf (f, "\n# Light\n");
            if (name[0]) fprintf (f, "o %s\n", name);
            fprintf (f, "m\n\tsides 1\n\tc\n\t\t\tcmix %.3f R %.3f G %.3f B\n\ted %e\n",
                    CIE_Y_r*col.red, CIE_Y_g*col.green, CIE_Y_b*col.blue,
            100000.0*(CIE_Y_r*col.red + CIE_Y_g*col.green + CIE_Y_b*col.blue));
            fprintf (f, "v c =\n\tp %.4f %.4f %.4f\nsph c .01\n",
                    pos[X], pos[Y], pos[Z]);
            if (name[0]) fprintf (f, "o\n");
            fprintf (f, "\n");
            break;
    }
}


void write_spot (FILE *f, char *name, Vector pos, Vector target, Colour col,
                          float hotspot, float falloff)
{
    switch (format) {
        case POV10:
            fprintf (f, "/* Spotlight: %s */\n", name);
            fprintf (f, "object {\n");
            fprintf (f, "    light_source {\n");
            fprintf (f, "        <%.4f %.4f %.4f> color red %4.2f green %4.2f blue %4.2f\n",
                                   pos[X], pos[Y], pos[Z],
                                   col.red, col.green, col.blue);
            fprintf (f, "        spotlight\n");
            fprintf (f, "        point_at <%.4f %.4f %.4f>\n",
                                   target[X], target[Y], target[Z]);
            fprintf (f, "        tightness 0\n");
            fprintf (f, "        radius %.2f\n", 0.5*hotspot);
            fprintf (f, "        falloff %.2f\n", 0.5*falloff);
            fprintf (f, "    }\n");
            fprintf (f, "}\n\n");
            break;

        case POV20:
            fprintf (f, "/* Spotlight: %s */\n", name);
            fprintf (f, "light_source {\n");
            fprintf (f, "    <%.4f, %.4f, %.4f> color rgb <%4.2f, %4.2f, %4.2f>\n",
                             pos[X], pos[Y], pos[Z],
                             col.red, col.green, col.blue);
            fprintf (f, "    spotlight\n");
            fprintf (f, "    point_at <%.4f, %.4f, %.4f>\n",
                             target[X], target[Y], target[Z]);
            fprintf (f, "    tightness 0\n");
            fprintf (f, "    radius %.2f\n", 0.5*hotspot);
            fprintf (f, "    falloff %.2f\n", 0.5*falloff);
            fprintf (f, "}\n\n");
            break;

        case VIVID:
            fprintf (f, "/* Spotlight: %s */\n", name);
            fprintf (f, "light {\n");
            fprintf (f, "    type spot\n");
            fprintf (f, "    position %.4f %.4f %.4f\n",
                             pos[X], pos[Y], pos[Z]);
            fprintf (f, "    at %.4f %.4f %.4f\n",
                             target[X], target[Y], target[Z]);
            fprintf (f, "    color %4.2f %4.2f %4.2f\n",
                             col.red, col.green, col.blue);
            fprintf (f, "    min_angle %.2f\n", hotspot);
            fprintf (f, "    max_angle %.2f\n", falloff);
            fprintf (f, "}\n\n");
            break;

        case POLYRAY:
            fprintf (f, "// Spotlight: %s\n", name);
            fprintf (f, "spot_light <%4.2f, %4.2f, %4.2f>, <%.4f, %.4f, %.4f>,\n",
                          col.red, col.green, col.blue, pos[X], pos[Y], pos[Z]);
            fprintf (f, "           <%.4f, %.4f, %.4f>, 0.0, %.2f, %.2f\n\n",
                          target[X], target[Y], target[Z], hotspot/2.0, falloff/2.0);
            break;

        case MGF:
            fprintf (f, "\n# Spotlight\n");
            if (name[0]) fprintf (f, "o %s\n", name);
            fprintf (f, "# hotspot: %.2f\n# falloff: %.2f\n", hotspot, falloff);
            fprintf (f, "m\n\tsides 1\n\tc\n\t\t\tcmix %.3f R %.3f G %.3f B\n\ted %e\n",
                    CIE_Y_r*col.red, CIE_Y_g*col.green, CIE_Y_b*col.blue,
            100000.0*(CIE_Y_r*col.red + CIE_Y_g*col.green + CIE_Y_b*col.blue));
            fprintf (f, "v c =\n\tp %.4f %.4f %.4f\n\tn %.4f %.4f %.4f\n",
                    pos[X], pos[Y], pos[Z],
                    target[X]-pos[X], target[Y]-pos[Y], target[Z]-pos[Z]);
            fprintf (f, "ring c 0 .01\n");
            if (name[0]) fprintf (f, "o\n");
            fprintf (f, "\n");
            break;
    }
}


void write_fog (FILE *f, Colour col, float dist)
{
    if (dist <= 0.0)
        return;

    switch (format) {
        case POV10:
            fprintf (f, "fog {\n");
            fprintf (f, "    color red %4.2f green %4.2f blue %4.2f %.4f\n",
                          col.red, col.green, col.blue, dist/2.0);
            fprintf (f, "}\n\n");
            break;

        case POV20:
            fprintf (f, "fog {\n");
            fprintf (f, "    color red %4.2f green %4.2f blue %4.2f distance %.4f\n",
                          col.red, col.green, col.blue, dist/2.0);
            fprintf (f, "}\n\n");
            break;
    }
}


void write_camera (FILE *f, char *name, Vector pos, Vector target,
                            float lens, float bank)
{
    float fov;

    cameras++;

    fov = findfov (lens);

    switch (format) {
        case POV10:
            /* Comment out multiple cameras */
            if (cameras > 1)
                fprintf (f, "/*\n");

            fprintf (f, "/* Camera: %s */\n", name);
            fprintf (f, "camera {\n");
            fprintf (f, "   location <%.4f %.4f %.4f>\n",
                              pos[X], pos[Y], pos[Z]);
            fprintf (f, "   direction <0 %.3f 0>\n", 0.60/tan(0.5*RAD(fov)) );
            fprintf (f, "   up <0 0 1>\n");
            fprintf (f, "   sky  <0 0 1>\n");
            fprintf (f, "   right <%.3f 0 0>\n", ASPECT);
            fprintf (f, "   look_at <%.4f %.4f %.4f>\n",
                              target[X], target[Y], target[Z]);
            if (bank != 0.0)
                fprintf (f, "   /* Bank angle = %.2f */\n", bank);

            fprintf (f, "}\n");

            if (cameras > 1)
                fprintf (f, "*/\n");

            fprintf (f, "\n");
            break;

        case POV20:
            /* Comment out multiple cameras */
            if (cameras > 1)
                fprintf (f, "/*\n");

            fprintf (f, "/* Camera: %s */\n", name);
            fprintf (f, "camera {\n");
            fprintf (f, "   location <%.4f, %.4f, %.4f>\n",
                              pos[X], pos[Y], pos[Z]);
            fprintf (f, "   direction <0, %.3f, 0>\n", 0.60/tan(0.5*RAD(fov)) );
            fprintf (f, "   up <0, 0, 1>\n");
            fprintf (f, "   sky  <0, 0, 1>\n");
            fprintf (f, "   right <%.3f, 0, 0>\n", ASPECT);
            fprintf (f, "   look_at <%.4f, %.4f, %.4f>\n",
                              target[X], target[Y], target[Z]);
            if (bank != 0.0)
                fprintf (f, "   /* Bank angle = %.2f */\n", bank);

            fprintf (f, "}\n");

            if (cameras > 1)
                fprintf (f, "*/\n");

            fprintf (f, "\n");
            break;

        case VIVID:
            fprintf (f, "/* Camera: %s */\n", name);

            if (cameras > 1)
                fprintf (f, "/*\n");

            fprintf (f, "studio {\n");
            fprintf (f, "    from %.4f %.4f %.4f\n",
                               pos[X], pos[Y], pos[Z]);
            fprintf (f, "    at %.4f %.4f %.4f\n",
                               target[X], target[Y], target[Z]);
            fprintf (f, "    up 0 0 1\n");
            fprintf (f, "    angle %.2f\n", 1.1*fov);
            fprintf (f, "    aspect %.3f\n", ASPECT);
            fprintf (f, "    resolution 320 200\n");
            fprintf (f, "    antialias none\n");
            fprintf (f, "}\n");

            if (cameras > 1)
                fprintf (f, "*/\n");

            fprintf (f, "\n");
            break;

        case POLYRAY:
            if (cameras == 1) {
                fprintf (f, "// Camera: %s\n", name);
                fprintf (f, "viewpoint {\n");
                fprintf (f, "    from <%.4f, %.4f, %.4f>\n",
                                   pos[X], pos[Y], pos[Z]);
                fprintf (f, "    at <%.4f, %.4f, %.4f>\n",
                                   target[X], target[Y], target[Z]);
                fprintf (f, "    up <0, 0, 1>\n");
                fprintf (f, "    angle %.2f\n", 0.85*fov);
                fprintf (f, "    aspect %.3f\n", -(ASPECT));
                fprintf (f, "    resolution 320, 200\n");
                fprintf (f, "}\n");
            }

            fprintf (f, "\n");
            break;

        case MGF:
            fprintf (f, "# Camera %s\n", name);
            fprintf (f, "# from: %.4f %.4f %.4f\n", pos[X], pos[Y], pos[Z]);
            fprintf (f, "# to: %.4f %.4f %.4f\n", target[X], target[Y], target[Z]);
            fprintf (f, "# lens length: %.2f\n", lens);
            fprintf (f, "# bank: %.2f\n", bank);
            break;
    }
}


void write_material (FILE *f, char *mat)
{
    MatProp *mprop = LIST_FIND (mprop_list, mat);

    if (mprop == NULL) {
       mprop = &DefaultMaterial;
       (void)strcpy(mprop->name, mat);
    }

    switch (format) {
        case POV10:
            write_pov10_material (f, mprop);
            break;

        case POV20:
            write_pov20_material (f, mprop);
            break;

        case VIVID:
            write_vivid_material (f, mprop);
            break;

        case POLYRAY:
            write_polyray_material (f, mprop);
            break;

        case MGF:
            write_mgf_material (f, mprop);
            break;
    }
}


void write_pov10_material (FILE *f, MatProp *m)
{
    float amb = 0.1, dif = 0.9, spec = 1.0;
    float dist_white, dist_diff, phong, phong_size;
    float red, green, blue;

    /* amb = get_ambient (m); */

    if (m->self_illum) {
        amb = 0.9;
        dif = 0.1;
    }

    dist_white = fabs(1.0 - m->specular.red) +
                 fabs(1.0 - m->specular.green) +
                 fabs(1.0 - m->specular.blue);

    dist_diff  = fabs(m->diffuse.red   - m->specular.red) +
                 fabs(m->diffuse.green - m->specular.green) +
                 fabs(m->diffuse.blue  - m->specular.blue);


    phong_size = 0.7*m->shininess;
    if (phong_size < 1.0) phong_size = 1.0;

    if (phong_size > 30.0)
        phong = 1.0;
    else
        phong = phong_size/30.0;

    fprintf (f, "#declare %s = texture {\n", m->name);
    fprintf (f, "    ambient %.2f\n", amb);
    fprintf (f, "    diffuse %.2f\n", dif);
    fprintf (f, "    phong %.2f\n", phong);
    fprintf (f, "    phong_size %.1f\n", phong_size);

    if (dist_diff < dist_white)
        fprintf (f, "    metallic\n");

    if (m->reflection > 0.0) {
        spec = (m->specular.red + m->specular.green + m->specular.blue)/3.0;
        fprintf (f, "    reflection %.3f\n", spec * m->reflection);
    }

    if (m->transparency > 0.0) {
        red   = m->diffuse.red;
        green = m->diffuse.green;
        blue  = m->diffuse.blue;

        /* Saturate the colour towards white as the transparency increases */
        red   = ((1.0 - m->transparency) * red)   + m->transparency;
        green = ((1.0 - m->transparency) * green) + m->transparency;
        blue  = ((1.0 - m->transparency) * blue)  + m->transparency;

        fprintf (f, "    color red %.3f green %.3f blue %.3f alpha %.3f\n",
                         red, green, blue, m->transparency);
        fprintf (f, "    ior 1.1\n");
        fprintf (f, "    refraction 1.0\n");
    }
    else
        fprintf (f, "    color red %.3f green %.3f blue %.3f\n",
                         m->diffuse.red, m->diffuse.green, m->diffuse.blue);

    if (strlen (m->tex_map) > 0) {
        fprintf (f, "    /* Image map: %s, Strength: %.2f */\n",
                         m->tex_map, m->tex_strength);
    }

    if (strlen (m->bump_map) > 0) {
        fprintf (f, "    /* Bump map: %s, Strength: %.2f */\n",
                         m->bump_map, m->bump_strength);
    }

    fprintf (f, "}\n\n");
}


void write_pov20_material (FILE *f, MatProp *m)
{
    float amb = 0.1, dif = 0.9, spec = 1.0;
    float dist_white, dist_diff, phong, phong_size;
    float red, green, blue;

    /* amb = get_ambient (m); */

    if (m->self_illum) {
        amb = 0.9;
        dif = 0.1;
    }

    dist_white = fabs(1.0 - m->specular.red) +
                 fabs(1.0 - m->specular.green) +
                 fabs(1.0 - m->specular.blue);

    dist_diff  = fabs(m->diffuse.red   - m->specular.red) +
                 fabs(m->diffuse.green - m->specular.green) +
                 fabs(m->diffuse.blue  - m->specular.blue);

    phong_size = 0.7*m->shininess;
    if (phong_size < 1.0) phong_size = 1.0;

    if (phong_size > 30.0)
        phong = 1.0;
    else
        phong = phong_size/30.0;

    fprintf (f, "#declare %s = texture {\n", m->name);
    fprintf (f, "    finish {\n");
    fprintf (f, "        ambient %.2f\n", amb);
    fprintf (f, "        diffuse %.2f\n", dif);
    fprintf (f, "        phong %.2f\n", phong);
    fprintf (f, "        phong_size %.1f\n", phong_size);

    if (dist_diff < dist_white)
        fprintf (f, "        metallic\n");

    if (m->reflection > 0.0) {
        spec = (m->specular.red + m->specular.green + m->specular.blue)/3.0;
        fprintf (f, "        reflection %.3f\n", spec * m->reflection);
    }

    if (m->transparency > 0.0) {
        fprintf (f, "        ior 1.1\n");
        fprintf (f, "        refraction 1.0\n");
    }

    fprintf (f, "    }\n");

    if (m->transparency > 0.0) {
        red   = m->diffuse.red;
        green = m->diffuse.green;
        blue  = m->diffuse.blue;

        /* Saturate the colour towards white as the transparency increases */
        red   = ((1.0 - m->transparency) * red)   + m->transparency;
        green = ((1.0 - m->transparency) * green) + m->transparency;
        blue  = ((1.0 - m->transparency) * blue)  + m->transparency;

        fprintf (f, "    pigment { rgbf <%.3f, %.3f, %.3f, %.3f> }\n",
                    red, green, blue, m->transparency);
    }
    else
        fprintf (f, "    pigment { rgb <%.3f, %.3f, %.3f> }\n",
                    m->diffuse.red, m->diffuse.green, m->diffuse.blue);

    if (strlen (m->tex_map) > 0) {
        fprintf (f, "    /* Image map: %s, Strength: %.2f */\n",
                         m->tex_map, m->tex_strength);
    }

    if (strlen (m->bump_map) > 0) {
        fprintf (f, "    /* Bump map: %s, Strength: %.2f */\n",
                         m->bump_map, m->bump_strength);
    }

    fprintf (f, "}\n\n");
}


void write_vivid_material (FILE *f, MatProp *m)
{
    float amb = 0.1, dif = 0.9;

    /* amb = get_ambient (m); */

    if (m->self_illum) {
        amb = 0.9;
        dif = 0.1;
    }

    if (m->transparency > 0.0) {
       dif = dif - m->transparency;
       if (dif < 0.0) dif = 0.0;
    }

    fprintf (f, "#define %s \\ \n", m->name);
    fprintf (f, "    surface {           \\ \n");
    fprintf (f, "        ambient %.3f %.3f %.3f \\ \n",
                         amb*m->ambient.red, amb*m->ambient.green, amb*m->ambient.blue);

    fprintf (f, "        diffuse %.3f %.3f %.3f \\ \n",
                         dif*m->diffuse.red, dif*m->diffuse.green, dif*m->diffuse.blue);

    fprintf (f, "        shine %.1f  %.3f %.3f %.3f \\ \n",
                         0.7*m->shininess, m->specular.red, m->specular.green, m->specular.blue);

    if (m->transparency > 0.0) {
        fprintf (f, "        transparent %.3f*white \\ \n", 1.0 - (1.0 - m->transparency)/14.0);
        fprintf (f, "        ior 1.1 \\ \n");
    }

    if (m->reflection > 0.0)
        fprintf (f, "        specular %.3f*white \\ \n", m->reflection);

    if (strlen (m->tex_map) > 0) {
        fprintf (f, "        /* Image map: %s, Strength: %.2f */ \\ \n",
                             m->tex_map, m->tex_strength);
    }

    if (strlen (m->bump_map) > 0) {
        fprintf (f, "        /* Bump map: %s, Strength: %.2f */ \\ \n",
                             m->bump_map, m->bump_strength);
    }

    fprintf (f, "    }\n\n");
}


void write_polyray_material (FILE *f, MatProp *m)
{
    float amb = 0.1, dif = 0.9, spec;

    /* amb = get_ambient (m); */

    if (m->self_illum) {
        amb = 0.9;
        dif = 0.1;
    }

    if (m->transparency > 0.0) {
       dif = dif - m->transparency;
       if (dif < 0.0) dif = 0.0;
    }

    if (m->shininess == 0.0)
        m->shininess = 0.1;

    if (m->shininess > 40.0)
        spec = 1.0;
    else
        spec = m->shininess/40.0;

    fprintf (f, "define %s\n", m->name);
    fprintf (f, "texture {\n");
    fprintf (f, "    surface {\n");
    fprintf (f, "        ambient <%.3f, %.3f, %.3f>, %.1f\n",
                         m->ambient.red, m->ambient.green, m->ambient.blue, amb);

    fprintf (f, "        diffuse <%.3f, %.3f, %.3f>, %.1f\n",
                         m->diffuse.red, m->diffuse.green, m->diffuse.blue, dif);

    fprintf (f, "        specular <%.3f, %.3f, %.3f>, %.2f\n",
                         m->specular.red, m->specular.green, m->specular.blue, spec);

    fprintf (f, "        microfacet Reitz %.1f\n", 400.0/m->shininess);

    if (m->transparency > 0.0)
        fprintf (f, "        transmission %.3f, 1.1\n", m->transparency);

    if (m->reflection > 0.0)
        fprintf (f, "        reflection %.3f\n", m->reflection);

    if (strlen (m->tex_map) > 0) {
        fprintf (f, "        // Image map: %s, Strength: %.2f\n",
                             m->tex_map, m->tex_strength);
    }

    if (strlen (m->bump_map) > 0) {
        fprintf (f, "        // Bump map: %s, Strength: %.2f\n",
                             m->bump_map, m->bump_strength);
    }

    fprintf (f, "    }\n");
    fprintf (f, "}\n\n");
}


void write_mgf_material (FILE *f, MatProp *m)
{
    float  dmag, smag, rdmag, rsmag, tdmag, tsmag, total;

    fprintf (f, "m %s =\n", m->name);
    fprintf (f, "\tsides %d\n", m->two_side ? 2 : 1);
    dmag = CIE_Y_r*m->diffuse.red + CIE_Y_g*m->diffuse.green
                + CIE_Y_b*m->diffuse.blue;
    smag = CIE_Y_r*m->specular.red + CIE_Y_g*m->specular.green
                + CIE_Y_b*m->specular.blue;
    rdmag = dmag;
    rsmag = smag * m->reflection;
    tdmag = 0.0;
    tsmag = m->transparency;
    total = rdmag + rsmag + tdmag + tsmag;
    if (total > 0.99) {
        total = 0.9/total;
        dmag *= total;
        smag *= total;
        rdmag *= total;
        rsmag *= total;
        tdmag *= total;
        tsmag *= total;
        total = 0.9;
    }
    if (dmag > 0.005) {
        fprintf (f, "\tc\n\t\tcmix %.3f R %.3f G %.3f B\n",
                CIE_Y_r*m->diffuse.red,
                CIE_Y_g*m->diffuse.green,
                CIE_Y_b*m->diffuse.blue);
        if (rdmag > 0.005)
            fprintf (f, "\trd %.4f\n", rdmag);
        if (tdmag > 0.005)
            fprintf (f, "\ttd %.4f\n", tdmag);
        if (m->self_illum)
            fprintf (f, "\ted %.4f\n", dmag);
    }
    if (m->shininess > 1.1 && rsmag > 0.005) {
        fprintf (f, "\tc\n\t\tcmix %.3f R %.3f G %.3f B\n",
                CIE_Y_r*m->specular.red,
                CIE_Y_g*m->specular.green,
                CIE_Y_b*m->specular.blue);
        fprintf (f, "\trs %.4f %.4f\n", rsmag, 0.6/sqrt(m->shininess));
    }
    if (tsmag > 0.005)
        fprintf (f, "\tc\n\tts %.4f 0\n", tsmag);

    if (strlen (m->tex_map) > 0) {
        fprintf (f, "# image map: %s, strength: %.2f\n",
                         m->tex_map, m->tex_strength);
    }

    if (strlen (m->bump_map) > 0) {
        fprintf (f, "# bump map: %s, strength: %.2f\n",
                         m->bump_map, m->bump_strength);
    }

    fprintf (f, "\n");
}


/* Write a mesh file */
void write_mesh (FILE *f, Mesh *mesh)
{
    FILE *fi;
    int i;
    char curmat[80];
    Vector va, vb, vc;
    Summary *new_summary;
    Matrix obj_matrix;

    if (mesh->hidden || LIST_FIND (excl_list, mesh->name))
        return;

    /* Add this object's stats to the summary */
    new_summary = malloc (sizeof(*new_summary));
    if (new_summary == NULL)
        abortmsg ("Out of memory adding summary", 1);

    strcpy (new_summary->name, mesh->name);
    vect_copy (new_summary->center,  mesh->center);
    vect_copy (new_summary->lengths, mesh->lengths);

    LIST_INSERT (summary, new_summary);

    /* Compute the object transformation matrix for animations */
    if (ani_matrix != NULL) {
        mat_copy (obj_matrix, *ani_matrix);
        if (vue_version > 2.0)
            mat_mult (obj_matrix, mesh->invmatrix, obj_matrix);
    }

    switch (format) {
        case MGF:
            if (no_opt) {
                if (mesh->name[0]) fprintf (meshf, "o %s\n", mesh->name);
                for (i = 0; i < mesh->vertices; i++) {
                    vect_copy(va, mesh->vertex[i]);
                    if (ani_matrix != NULL)
                        vect_transform (va, va, obj_matrix);
                    fprintf (meshf, "v v%d =\n\tp %.5f %.5f %.5f\n",
                                i, va[X], va[Y], va[Z]);
                }
                curmat[0] = '\0';
                for (i = 0; i < mesh->faces; i++) {
                    if (strcmp(mesh->mtl[i]->name, curmat)) {
                        strcpy(curmat, mesh->mtl[i]->name);
                        fprintf (meshf, "m %s\n", curmat);
                    }
                    fprintf (meshf, "f v%d v%d v%d\n", mesh->face[i].a,
                                mesh->face[i].b, mesh->face[i].c);
                }
                if (mesh->name[0]) fprintf (meshf, "o\n");
                break;
            }
            /*FALL THROUGH*/
        case POV10:
        case POV20:
        case VIVID:
        case POLYRAY:
            opt_set_vert (mesh->vertices);

            for (i = 0; i < mesh->faces; i++) {
                vect_copy (va, mesh->vertex[mesh->face[i].a]);
                vect_copy (vb, mesh->vertex[mesh->face[i].b]);
                vect_copy (vc, mesh->vertex[mesh->face[i].c]);

                opt_set_texture (mesh->mtl[i]->name);

                opt_add_tri (va[X], va[Y], va[Z], vc[X], vc[Y], vc[Z],
                             vb[X], vb[Y], vb[Z]);
            }

            fflush (f);

            if (ani_matrix != NULL)
                opt_set_transform (obj_matrix);

            if (box_all || LIST_FIND (box_list, mesh->name))
                opt_write_box (mesh->name);
            else
                opt_write_file (mesh->name);

            break;

        case RAW:
            fprintf (f, "%s\n", mesh->name);

            for (i = 0; i < mesh->faces; i++) {
                vect_copy (va, mesh->vertex[mesh->face[i].a]);
                vect_copy (vb, mesh->vertex[mesh->face[i].b]);
                vect_copy (vc, mesh->vertex[mesh->face[i].c]);

                if (ani_matrix != NULL) {
                    vect_transform (va, va, obj_matrix);
                    vect_transform (vb, vb, obj_matrix);
                    vect_transform (vc, vc, obj_matrix);
                }

                fprintf (f, "%f %f %f   %f %f %f   %f %f %f\n",
                            va[X], va[Y], va[Z], vb[X], vb[Y], vb[Z],
                            vc[X], vc[Y], vc[Z]);
            }

            break;
    }
}


/* Parses an object transformation and returns a pointer to the
   newly allocated transformation */
Transform *parse_transform (char *string)
{
    Transform *t;
    char      *token;
    int       token_no;

    t = (Transform *)malloc (sizeof(*t));
    if (t == NULL)
        abortmsg ("Out of memory allocating transform", 1);

    mat_identity (t->matrix);

    token = parse_string (string);
    token_no = 0;

    while (strlen(token) > 0) {
         switch (token_no) {
             case  0: break;
             case  1: strcpy (t->name, token); break;
             case  2: t->matrix[0][0] = atof(token); break;
             case  3: t->matrix[0][1] = atof(token); break;
             case  4: t->matrix[0][2] = atof(token); break;
             case  5: t->matrix[1][0] = atof(token); break;
             case  6: t->matrix[1][1] = atof(token); break;
             case  7: t->matrix[1][2] = atof(token); break;
             case  8: t->matrix[2][0] = atof(token); break;
             case  9: t->matrix[2][1] = atof(token); break;
             case 10: t->matrix[2][2] = atof(token); break;
             case 11: t->matrix[3][0] = atof(token); break;
             case 12: t->matrix[3][1] = atof(token); break;
             case 13: t->matrix[3][2] = atof(token); break;

             default: abortmsg ("Error parsing transform", 1);
         }

         token = parse_string (NULL);
         token_no++;
    }

    t->matrix[0][3] = 0.0;
    t->matrix[1][3] = 0.0;
    t->matrix[2][3] = 0.0;
    t->matrix[3][3] = 1.0;

    cleanup_name (t->name);

    return t;
}


/* Parses a morph command and returns a pointer to the
   newly allocated morph */
Morph *parse_morph (char *string)
{
    Morph  *m;
    char   *token;
    int    i, token_no;

    m = (Morph *)malloc (sizeof(*m));
    if (m == NULL)
        abortmsg ("Out of memory allocating morph", 1);

    mat_identity (m->matrix);

    token = parse_string (string);

    token = parse_string (NULL);
    strcpy (m->name, token);

    token = parse_string (NULL);
    m->count = atoi (token);

    if (strlen (m->name) == 0 || m->count < 1 || m->count > 4)
        abortmsg ("Error parsing morph command", 1);

    cleanup_name (m->name);

    for (i = 0; i < m->count; i++) {
        token = parse_string (NULL);
        strcpy (m->names[i], token);

        token = parse_string (NULL);
        m->weight[i] = atof (token);

        if (strlen (m->names[i]) == 0)
            abortmsg ("Error parsing morph command", 1);

        cleanup_name (m->names[i]);
    }

    token = parse_string (NULL);
    token_no = 0;

    while (strlen(token) > 0) {
         switch (token_no) {
             case  0: m->matrix[0][0] = atof(token); break;
             case  1: m->matrix[0][1] = atof(token); break;
             case  2: m->matrix[0][2] = atof(token); break;
             case  3: m->matrix[1][0] = atof(token); break;
             case  4: m->matrix[1][1] = atof(token); break;
             case  5: m->matrix[1][2] = atof(token); break;
             case  6: m->matrix[2][0] = atof(token); break;
             case  7: m->matrix[2][1] = atof(token); break;
             case  8: m->matrix[2][2] = atof(token); break;
             case  9: m->matrix[3][0] = atof(token); break;
             case 10: m->matrix[3][1] = atof(token); break;
             case 11: m->matrix[3][2] = atof(token); break;

             default: abortmsg ("Error parsing morph command", 1);
         }

         token = parse_string (NULL);
         token_no++;
    }

    m->matrix[0][3] = 0.0;
    m->matrix[1][3] = 0.0;
    m->matrix[2][3] = 0.0;
    m->matrix[3][3] = 1.0;

    return m;
}


/* Parses an omni light and returns a pointer to the
   newly allocated light */
OmniLight *parse_omnilight (char *string)
{
    OmniLight *o;
    char      *token;
    int       token_no;

    o = (OmniLight *)malloc (sizeof(*o));
    if (o == NULL)
        abortmsg ("Out of memory allocating omnilight", 1);

    token = parse_string (string);
    token_no = 0;

    while (strlen(token) > 0) {
         switch (token_no) {
             case 0: break;
             case 1: strcpy (o->name, token); break;
             case 2: o->pos[X] = atof (token); break;
             case 3: o->pos[Y] = atof (token); break;
             case 4: o->pos[Z] = atof (token); break;
             case 5: o->col.red   = atof (token); break;
             case 6: o->col.green = atof (token); break;
             case 7: o->col.blue  = atof (token); break;

             default: abortmsg ("Error parsing omnilight", 1);
         }

         token = parse_string (NULL);
         token_no++;
    }

    cleanup_name (o->name);

    return o;
}


/* Parses a spotlight and returns a pointer to the
   newly allocated spotlight */
Spotlight *parse_spotlight (char *string)
{
    Spotlight *s;
    char      *token;
    int       token_no;

    s = (Spotlight *)malloc (sizeof(*s));
    if (s == NULL)
        abortmsg ("Out of memory allocating spotlight", 1);

    token = parse_string (string);
    token_no = 0;

    while (strlen(token) > 0) {
         switch (token_no) {
             case  0: break;
             case  1: strcpy (s->name, token); break;
             case  2: s->pos[X] = atof (token); break;
             case  3: s->pos[Y] = atof (token); break;
             case  4: s->pos[Z] = atof (token); break;
             case  5: s->target[X] = atof (token); break;
             case  6: s->target[Y] = atof (token); break;
             case  7: s->target[Z] = atof (token); break;
             case  8: s->col.red   = atof (token); break;
             case  9: s->col.green = atof (token); break;
             case 10: s->col.blue  = atof (token); break;
             case 11: s->hotspot   = atof (token); break;
             case 12: s->falloff   = atof (token); break;
             case 13: break;

             default: abortmsg ("Error parsing spotlight", 1);
         }

         token = parse_string (NULL);
         token_no++;
    }

    cleanup_name (s->name);

    return s;
}


/* Parses a camera command and returns a pointer to the
   newly allocated camera */
Camera *parse_camera (char *string)
{
    Camera *c;
    char   *token;
    int    token_no;

    c = (Camera *)malloc (sizeof(*c));
    if (c == NULL)
        abortmsg ("Out of memory allocating camera", 1);

    token = parse_string (string);
    token_no = 0;

    while (strlen(token) > 0) {
         switch (token_no) {
             case 0: break;
             case 1: c->pos[X] = atof (token); break;
             case 2: c->pos[Y] = atof (token); break;
             case 3: c->pos[Z] = atof (token); break;
             case 4: c->target[X] = atof (token); break;
             case 5: c->target[Y] = atof (token); break;
             case 6: c->target[Z] = atof (token); break;
             case 7: c->bank = atof (token); break;
             case 8: c->lens = atof (token); break;

             default: abortmsg ("Error parsing camera", 1);
         }

         token = parse_string (NULL);
         token_no++;
    }

    return c;
}


/* Load the transforms, camera movements, etc for the specified frame */
void read_frame (char *filename, int frame_no)
{
    FILE  *f;
    char  fname[80];
    char  string[256];
    char  *token;

    /* Open the .vue file */
    strcpy (fname, filename);   /* Make a copy we can mess with */
    add_ext (fname, "vue", 0);

    f = fopen (fname, "r");
    if (f == NULL) {
        printf ("Error opening file '%s'\n", fname);
        exit(1);
    }

    /* Load the specified frame */
    find_frame (f, frame_no);

    while (fgets (string, 256, f) != NULL) {
        token = parse_string (string);

        if (strcmp (token, "frame") == 0)
            break;
        else if (strcmp (token, "transform") == 0) {
            LIST_INSERT (trans_list, parse_transform (string));
        }
        else if (strcmp (token, "morph") == 0) {
            LIST_INSERT (morph_list, parse_morph (string));
        }
        else if (strcmp (token, "light") == 0) {
            LIST_INSERT (omni_list, parse_omnilight (string));
        }
        else if (strcmp (token, "spotlight") == 0) {
            LIST_INSERT (spot_list, parse_spotlight (string));
        }
        else if (strcmp (token, "camera") == 0) {
            if (cam_list != NULL)
                abortmsg ("ERROR - Multiple cameras in .vue file", 1);

            LIST_INSERT (cam_list, parse_camera (string));
        }
        else if (strcmp (token, "top") == 0)
            abortmsg ("ERROR - Orthogonal viewports are not supported", 1);
        else if (strcmp (token, "bottom") == 0)
            abortmsg ("ERROR - Orthogonal viewports are not supported", 1);
        else if (strcmp (token, "left") == 0)
            abortmsg ("ERROR - Orthogonal viewports are not supported", 1);
        else if (strcmp (token, "right") == 0)
            abortmsg ("ERROR - Orthogonal viewports are not supported", 1);
        else if (strcmp (token, "front") == 0)
            abortmsg ("ERROR - Orthogonal viewports are not supported", 1);
        else if (strcmp (token, "back") == 0)
            abortmsg ("ERROR - Orthogonal viewports are not supported", 1);
        else if (strcmp (token, "user") == 0)
            abortmsg ("ERROR - User viewports are not supported", 1);
    }

    fclose(f);
}


void find_frame (FILE *f, int frame_no)
{
    char  string[256];
    char  *token;
    int   frame = 0;

    /* Search the .vue file for the required frame */
    while (1) {
        /* Read the next line in the file */
        if (fgets (string, 256, f) == NULL) {
            printf ("Unable to locate frame #%d in .vue file\n", frame_no);
            exit(1);
        }

        token = parse_string (string);

        if (strcmp (token, "frame") == 0) {
            token = parse_string (NULL);

            if (strlen(token) == 0) {
                printf ("Unable to locate frame #%d in .vue file\n", frame_no);
                exit(1);
            }

            frame = atoi (token);

            if (frame == frame_no)
                break;
        }
        else if (strcmp (token, "VERSION") == 0) {
            token = parse_string (NULL);

            vue_version = atoi(token) / 100.0;
        }
    }
}


void save_animation()
{
    Mesh      *mesh, *master;
    Transform *t;
    Morph     *m;
    Vector    temp;
    int       i, j;

    printf ("\n");

    for (t = trans_list; t != NULL; t = t->next) {
         printf ("Transforming object: %s\n", t->name);

         ani_matrix = &(t->matrix);

         mesh = LIST_FIND (mesh_list, t->name);

         if (mesh == NULL) {
             printf ("Unable to locate mesh object %s\n", t->name);
             exit(1);
         }

         write_mesh (out, mesh);
    }

    for (m = morph_list; m != NULL; m = m->next) {
        printf ("Morphing object: %s\n", m->name);

        ani_matrix = &(m->matrix);

        mesh = LIST_FIND (mesh_list, m->name);
        if (mesh == NULL) {
            printf ("Unable to locate mesh object %s\n", m->name);
            exit(1);
        }

        /* Make a copy to mess with */
        master = copy_mesh (mesh);
        master->hidden = FALSE;

        strcpy (master->name, m->name);

        for (i = 0; i < master->vertices; i++)
            vect_init (master->vertex[i], 0.0, 0.0, 0.0);

        for (i = 0; i < m->count; i++) {
            mesh = LIST_FIND (mesh_list, m->names[i]);
            if (mesh == NULL) {
                printf ("Unable to locate mesh object %s\n", m->names[0]);
                exit(1);
            }

            if (mesh->vertices != master->vertices)
                abortmsg ("Morphed objects do not contain the same number of vertices", 1);

            if (mesh->faces != master->faces)
                abortmsg ("Morphed objects do not contain the same number of faces", 1);

            for (j = 0; j < master->vertices; j++) {
                vect_transform (temp, mesh->vertex[j], mesh->invmatrix);
                vect_scale (temp, temp, m->weight[i]);
                vect_add (master->vertex[j], master->vertex[j], temp);
            }
        }

        for (i = 0; i < master->vertices; i++)
            vect_transform (master->vertex[i], master->vertex[i], master->matrix);

        write_mesh (out, master);

        free_mesh_data (master);
        free (master);
    }

    for (mesh = mesh_list; mesh != NULL; mesh = mesh->next)
        free_mesh_data (mesh);
}


/* Create a new mesh */
Mesh *create_mesh (char *name, int vertices, int faces)
{
    Mesh *new_mesh;

    new_mesh = malloc (sizeof(*new_mesh));
    if (new_mesh == NULL)
        abortmsg ("Out of memory allocating mesh", 1);

    strcpy (new_mesh->name, name);

    new_mesh->vertices = vertices;

    if (vertices <= 0)
        new_mesh->vertex = NULL;
    else {
        new_mesh->vertex = malloc (vertices * sizeof(*new_mesh->vertex));
        if (new_mesh->vertex == NULL)
            abortmsg ("Out of memory allocating mesh", 1);
    }

    new_mesh->faces = faces;

    if (faces <= 0) {
        new_mesh->face = NULL;
        new_mesh->mtl = NULL;
    }
    else {
        new_mesh->face = malloc (faces * sizeof(*new_mesh->face));
        if (new_mesh->face == NULL)
            abortmsg ("Out of memory allocating mesh", 1);

        new_mesh->mtl = malloc (faces * sizeof(*new_mesh->mtl));
        if (new_mesh->mtl == NULL)
            abortmsg ("Out of memory allocating mesh", 1);
    }

    vect_init (new_mesh->center,  0.0, 0.0, 0.0);
    vect_init (new_mesh->lengths, 0.0, 0.0, 0.0);

    mat_identity (new_mesh->matrix);
    mat_identity (new_mesh->invmatrix);

    new_mesh->hidden = FALSE;
    new_mesh->shadow = TRUE;

    return new_mesh;
}


/* Creates a duplicate copy of a mesh */
Mesh *copy_mesh (Mesh *mesh)
{
    Mesh *new_mesh;
    int  i;

    new_mesh = create_mesh (mesh->name, mesh->vertices, mesh->faces);

    if (new_mesh == NULL)
        abortmsg ("Out of memory allocating mesh", 1);

    for (i = 0; i < mesh->vertices; i++)
        vect_copy (new_mesh->vertex[i], mesh->vertex[i]);

    for (i = 0; i < mesh->faces; i++) {
        new_mesh->face[i] = mesh->face[i];
        new_mesh->mtl[i]  = mesh->mtl[i];
    }

    mat_copy (new_mesh->matrix, mesh->matrix);
    mat_copy (new_mesh->invmatrix, mesh->invmatrix);

    vect_copy (new_mesh->center,  mesh->center);
    vect_copy (new_mesh->lengths, mesh->lengths);

    new_mesh->hidden = mesh->hidden;
    new_mesh->shadow = mesh->shadow;

    return new_mesh;
}


/* Free all data associated with mesh object */
void free_mesh_data (Mesh *mesh)
{
    if (mesh->vertex != NULL)
        free (mesh->vertex);

    if (mesh->face != NULL)
        free (mesh->face);

    if (mesh->mtl != NULL)
        free (mesh->mtl);
}


/* Updates the center (pivot) point of the mesh */
void update_limits (Mesh *mesh)
{
    Vector vmin = {+MAXFLOAT, +MAXFLOAT, +MAXFLOAT};
    Vector vmax = {-MAXFLOAT, -MAXFLOAT, -MAXFLOAT};
    int    i;

    for (i = 0; i < mesh->vertices; i++) {
        vect_min (vmin, vmin, mesh->vertex[i]);
        vect_max (vmax, vmax, mesh->vertex[i]);
    }

    vect_add  (mesh->center, vmin, vmax);
    vect_scale (mesh->center, mesh->center, 0.5);

    vect_sub (mesh->lengths, vmax, vmin);
}


/* Return the sub-string of 'str' that is before 'target' */
char *before (char *str, char *target)
{
    static char result[256];
    char   *search;

    strncpy (result, str, 256);
    result[255] = '\0';

    search = strstr (result, target);

    if (search != NULL)
        *search = '\0';

    return result;
}


/* Return the sub-string of 'str' that is after 'target' */
char *after (char *str, char *target)
{
    static char result[256];
    char   *search;

    search = strstr (str, target);

    if (search == NULL)
        strncpy (result, "", 256);
    else
        strncpy (result, search + strlen(target), 256);

    result[255] = '\0';

    return result;
}


/* Return the sub-string of 'str' that is between 'target1' and 'target2' */
char *between (char *str, char *target1, char *target2)
{
    static char result[256];

    strcpy (result, after (str, target1));
    strcpy (result, before (result, target2));

    return result;
}


/* Works like the C strtok() function except that it can handle */
/* tokens enclosed in double quotes */
char *parse_string (char *str)
{
    static char result[256];
    static char *p;
    char QUOTE = '\"';
    int  index;

    strcpy (result, "");
    index = 0;

    if (str != NULL)
        p = str;

    /* Find the start of the next token */
    while (isspace (*p))
        p++;

    if (*p == QUOTE) {
        p++;

        while (*p != '\0' && *p != QUOTE)
            result[index++] = *p++;

        if (*p == QUOTE)
            p++;
    }
    else {
        while (*p != '\0' && !isspace(*p))
            result[index++] = *p++;
    }

    result[index] = '\0';

    return result;
}


/* Convert character 'c' to upper case */
char upcase (char c)
{
    if (c >= 'a' && c <= 'z')
        c = c - 'a' + 'A';

    return c;
}


float colour_intens (Colour *colour)
{
    return sqrt (colour->red   * colour->red +
                 colour->green * colour->green +
                 colour->blue  * colour->blue);
}


void parse_file()
{
    Chunk chunk;

    start_chunk(&chunk);

    if (chunk.tag == 0x4D4D)
        parse_3ds (&chunk);
    else
        abortmsg ("Error: Input file is not .3DS format", 1);

    end_chunk (&chunk);
}


void parse_3ds (Chunk *mainchunk)
{
    Chunk chunk;

    do  {
        start_chunk (&chunk);
        if (feof(in)) {
                fprintf(stderr, "%s: unexpected EOF\n", progname);
                break;
        }
        if (chunk.end <= mainchunk->end) {
            switch (chunk.tag) {
                case 0x3D3D: parse_mdata (&chunk);
                             break;
            }
        }

        end_chunk (&chunk);
    } while (chunk.end <= mainchunk->end);
}


void parse_mdata (Chunk *mainchunk)
{
    Chunk chunk;
    Colour bgnd_colour;

    do  {
        start_chunk (&chunk);

        if (chunk.end <= mainchunk->end) {
            switch (chunk.tag) {
                case 0x2100: parse_colour (&global_amb);
                             break;
                case 0x1200: parse_colour (&bgnd_colour);
                             break;
                case 0x1201: write_bgsolid (out, bgnd_colour);
                             break;
                case 0x2200: parse_fog (&chunk);
                             break;
                case 0x2210: parse_fog_bgnd();
                             break;
                case 0x2201: write_fog (out, fog_colour, fog_distance);
                             break;
                case 0xAFFF: parse_mat_entry (&chunk);
                             break;
                case 0x4000: parse_named_object (&chunk);
                             break;
            }
        }

        end_chunk (&chunk);
    } while (chunk.end <= mainchunk->end);
}


void parse_fog (Chunk *mainchunk)
{
    Chunk chunk;

    (void)read_float();
    (void)read_float();
    fog_distance = read_float();
    (void)read_float();

    parse_colour (&fog_colour);

    do  {
        start_chunk (&chunk);

        if (chunk.end <= mainchunk->end) {
            switch (chunk.tag) {
                case 0x2210: parse_fog_bgnd();
                             break;
            }
        }

        end_chunk (&chunk);
    } while (chunk.end <= mainchunk->end);
}


void parse_fog_bgnd()
{

}


void parse_mat_entry (Chunk *mainchunk)
{
    Chunk chunk;
    MatProp *mprop;

    mprop = create_mprop();

    do  {
        start_chunk (&chunk);

        if (chunk.end <= mainchunk->end) {
            switch (chunk.tag) {
                case 0xA000: strcpy (mprop->name, read_string());
                             cleanup_name (mprop->name);
                             break;

                case 0xA010: parse_colour (&mprop->ambient);
                             break;

                case 0xA020: parse_colour (&mprop->diffuse);
                             break;

                case 0xA030: parse_colour (&mprop->specular);
                             break;

                case 0xA040: mprop->shininess = 100.0*parse_percentage();
                             break;

                case 0xA050: mprop->transparency = parse_percentage();
                             break;

                case 0xA080: mprop->self_illum = TRUE;
                             break;

                case 0xA081: mprop->two_side = TRUE;
                             break;

                case 0xA220: mprop->reflection = parse_percentage();
                             (void)parse_mapname (&chunk);
                             break;

                case 0xA310: if (mprop->reflection == 0.0)
                                 mprop->reflection = 1.0;
                             break;

                case 0xA200: mprop->tex_strength = parse_percentage();
                             strcpy (mprop->tex_map, parse_mapname (&chunk));
                             break;

                case 0xA230: mprop->bump_strength = parse_percentage();
                             strcpy (mprop->bump_map, parse_mapname (&chunk));
                             break;
            }
        }

        end_chunk (&chunk);
    } while (chunk.end <= mainchunk->end);

    LIST_INSERT (mprop_list, mprop);
}


char *parse_mapname (Chunk *mainchunk)
{
    static char name[80] = "";
    Chunk chunk;

    do  {
        start_chunk (&chunk);

        if (chunk.end <= mainchunk->end) {
            switch (chunk.tag) {
                case 0xA300: strcpy (name, read_string());
                             break;
            }
        }

        end_chunk (&chunk);
    } while (chunk.end <= mainchunk->end);

    return name;
}


void parse_named_object (Chunk *mainchunk)
{
    Chunk chunk;

    strcpy (obj_name, read_string());
    cleanup_name (obj_name);

    printf ("Working on: %s\n", obj_name);

    mesh = NULL;

    do  {
        start_chunk (&chunk);

        if (chunk.end <= mainchunk->end) {
            switch (chunk.tag) {
                case 0x4100: parse_n_tri_object (&chunk);
                             break;
                case 0x4600: parse_n_direct_light (&chunk);
                             break;
                case 0x4700: parse_n_camera();
                             break;
                case 0x4010: if (mesh != NULL) mesh->hidden = TRUE;
                             break;
                case 0x4012: if (mesh != NULL) mesh->shadow = FALSE;
                             break;
            }
        }

        end_chunk (&chunk);
    } while (chunk.end <= mainchunk->end);

    if (mesh != NULL) {
        update_limits (mesh);

        if (frame >= 0)
            LIST_INSERT (mesh_list, mesh);
        else {
            write_mesh (out, mesh);

            free_mesh_data (mesh);
            free (mesh);
        }
    }
}


void parse_n_tri_object (Chunk *mainchunk)
{
    Chunk chunk;

    mesh = create_mesh (obj_name, 0, 0);

    do  {
        start_chunk (&chunk);

        if (chunk.end <= mainchunk->end) {
            switch (chunk.tag) {
                case 0x4110: parse_point_array();
                             break;
                case 0x4120: parse_face_array (&chunk);
                             break;
                case 0x4160: parse_mesh_matrix();
                             break;
            }
        }

        end_chunk (&chunk);
    } while (chunk.end <= mainchunk->end);
}


void parse_point_array()
{
    int i;

    mesh->vertices = read_word();
    mesh->vertex = malloc (mesh->vertices * sizeof(*(mesh->vertex)));
    if (mesh->vertex == NULL)
        abortmsg ("Out of memory allocating mesh", 1);

    for (i = 0; i < mesh->vertices; i++)
        read_point (mesh->vertex[i]);
}


void parse_face_array (Chunk *mainchunk)
{
    Chunk chunk;
    int i;

    mesh->faces = read_word();
    mesh->face = malloc (mesh->faces * sizeof(*(mesh->face)));
    if (mesh->face == NULL)
        abortmsg ("Out of memory allocating mesh", 1);

    mesh->mtl = malloc (mesh->faces * sizeof(*(mesh->mtl)));
    if (mesh->mtl == NULL)
        abortmsg ("Out of memory allocating mesh", 1);

    for (i = 0; i < mesh->faces; i++) {
        mesh->face[i].a = read_word();
        mesh->face[i].b = read_word();
        mesh->face[i].c = read_word();
        (void)read_word();

        mesh->mtl[i] = NULL;
    }

    do  {
        start_chunk (&chunk);

        if (chunk.end <= mainchunk->end) {
            switch (chunk.tag) {
                case 0x4130: parse_msh_mat_group();
                             break;
                case 0x4150: parse_smooth_group();
                             break;
            }
        }

        end_chunk (&chunk);
    } while (chunk.end <= mainchunk->end);

    for (i = 0; i < mesh->faces; i++) {
        if (mesh->mtl[i] == NULL)
            mesh->mtl[i] = update_materials ("Default", 0);
    }
}


void parse_msh_mat_group()
{
    Material *new_mtl;
    char mtlname[80];
    int  mtlcnt;
    int  i, face;

    strcpy (mtlname, read_string());
    cleanup_name (mtlname);

    new_mtl = update_materials (mtlname, 0);

    mtlcnt = read_word();

    for (i = 0; i < mtlcnt; i++) {
        face = read_word();
        mesh->mtl[face] = new_mtl;
    }
}


void parse_smooth_group()
{

}


void parse_mesh_matrix()
{
    int i, j;

    if (mesh != NULL) {
        for (i = 0; i < 4; i++) {
            for (j = 0; j < 3; j++)
                mesh->matrix[i][j] = read_float();
        }

        mat_inv (mesh->invmatrix, mesh->matrix);
    }
}


void parse_n_direct_light (Chunk *mainchunk)
{
    Chunk chunk;
    Spotlight *s;
    OmniLight *o;
    int light_off = FALSE;
    int spot_flag = FALSE;

    read_point (pos);
    parse_colour (&col);

    do  {
        start_chunk (&chunk);

        if (chunk.end <= mainchunk->end) {
            switch (chunk.tag) {
                case 0x4620: light_off = TRUE;
                             break;
                case 0x4610: parse_dl_spotlight();
                             spot_flag = TRUE;
                             break;
            }
        }

        end_chunk (&chunk);
    } while (chunk.end <= mainchunk->end);

    if (light_off)
        return;

    if (!spot_flag) {
        if (frame >= 0) {
            o = LIST_FIND (omni_list, obj_name);

            if (o != NULL) {
                pos[X] = o->pos[X];
                pos[Y] = o->pos[Y];
                pos[Z] = o->pos[Z];
                col    = o->col;
            }
        }

        write_light (out, obj_name, pos, col);
    }
    else {
        if (frame >= 0) {
            s = LIST_FIND (spot_list, obj_name);

            if (s != NULL) {
                pos[X]    = s->pos[X];
                pos[Y]    = s->pos[Y];
                pos[Z]    = s->pos[Z];
                target[X] = s->target[X];
                target[Y] = s->target[Y];
                target[Z] = s->target[Z];
                col       = s->col;
                hotspot   = s->hotspot;
                falloff   = s->falloff;
            }
        }

        if (falloff <= 0.0)
            falloff = 180.0;

        if (hotspot <= 0.0)
            hotspot = 0.7*falloff;

        write_spot (out, obj_name, pos, target, col, hotspot, falloff);
    }
}


void parse_dl_spotlight()
{
    read_point (target);

    hotspot = read_float();
    falloff = read_float();
}


void parse_n_camera()
{
    float  bank;
    float  lens;

    read_point (pos);
    read_point (target);
    bank = read_float();
    lens = read_float();

    if (frame >= 0 && cam_list != NULL) {
        pos[X]    = cam_list->pos[X];
        pos[Y]    = cam_list->pos[Y];
        pos[Z]    = cam_list->pos[Z];
        target[X] = cam_list->target[X];
        target[Y] = cam_list->target[Y];
        target[Z] = cam_list->target[Z];
        lens      = cam_list->lens;
        bank      = cam_list->bank;
    }

    write_camera (out, obj_name, pos, target, lens, bank);
}


void parse_colour (Colour *colour)
{
    Chunk chunk;
    Colour_24 colour_24;

    start_chunk (&chunk);

    switch (chunk.tag) {
        case 0x0010: parse_colour_f (colour);
                     break;

        case 0x0011: parse_colour_24 (&colour_24);
                     colour->red   = colour_24.red/255.0;
                     colour->green = colour_24.green/255.0;
                     colour->blue  = colour_24.blue/255.0;
                     break;

        default:     abortmsg ("Error parsing colour", 1);
    }

    end_chunk (&chunk);
}


void parse_colour_f (Colour *colour)
{
    colour->red   = read_float();
    colour->green = read_float();
    colour->blue  = read_float();
}


void parse_colour_24 (Colour_24 *colour)
{
    colour->red   = read_byte();
    colour->green = read_byte();
    colour->blue  = read_byte();
}


float parse_percentage()
{
    Chunk chunk;
    float percent = 0.0;

    start_chunk (&chunk);

    switch (chunk.tag) {
        case 0x0030: percent = parse_int_percentage()/100.0;
                     break;

        case 0x0031: percent = parse_float_percentage();
                     break;

        default:     printf ("WARNING: Error parsing percentage");
    }

    end_chunk (&chunk);

    return percent;
}


short parse_int_percentage()
{
    word percent = read_word();

    return percent;
}


float parse_float_percentage()
{
    float percent = read_float();

    return percent;
}


void start_chunk (Chunk *chunk)
{
    chunk->start  = ftell(in);
    chunk->tag    = read_word();
    chunk->length = read_dword();
    if (chunk->length < sizeof(word)+sizeof(dword))
        chunk->length = sizeof(word) + sizeof(dword);
    chunk->end    = chunk->start + chunk->length;
}


void end_chunk (Chunk *chunk)
{
    fseek (in, chunk->end, 0);
}


byte read_byte()
{
    byte data;

    data = fgetc (in);

    return data;
}


word read_word()
{
    word data;

    data = fgetc (in);
    data |= fgetc (in) << 8;

    return data;
}


dword read_dword()
{
    dword data;

    data = read_word();
    data |= read_word() << 16;

    return data;
}


float read_float()
{
    dword data;

    data = read_dword();

    return *(float *)&data;
}


void read_point (Vector v)
{
    v[X] = read_float();
    v[Y] = read_float();
    v[Z] = read_float();
}


char *read_string()
{
    static char string[80];
    int i;

    for (i = 0; i < 80; i++) {
        string[i] = read_byte();

        if (string[i] == '\0')
            break;
    }

    return string;
}


float findfov (float lens)
{
    static float lens_table[13] =
                 { 15.0, 17.0, 24.0, 35.0, 50.0, 85.0, 100.0, 135.0, 200.0,
                   500.0, 625.0, 800.0, 1000.0 };
    static float fov_table[13] =
                 { 115.0, 102.0, 84.0, 63.0, 46.0, 28.0, 24.0, 18.0,
                   12.0, 5.0, 4.0, 3.125, 2.5 };

    float fov, f1, f2, l1, l2;
    int   i;

    if (lens < 15.0)
        lens = 15.0;
    else if (lens > 1000.0)
        lens = 1000.0;

    for (i = 0; i < 13; i++)
        if (lens < lens_table[i])
            break;

    if (i == 13)
        i = 12;
    else if (i == 0)
        i = 1;

    f1 = fov_table[i-1];
    f2 = fov_table[i];
    l1 = lens_table[i-1];
    l2 = lens_table[i];

    fov = f1 + (lens - l1) * (f2 - f1) / (l2 - l1);

    return fov;
}


Revision:	1.5
Committed:	Fri Jan 16 10:47:27 1998 UTC (26 years, 3 months ago) by gregl
Content type:	text/plain
Branch:	MAIN
Changes since 1.4:	+2 -2 lines
Log Message:	changed M_PI definition to ward off long double problems