Superpower (Alt)/SUPERPOWER.iso/q/util/mbq319/qlumpy.c

C/C++ Source or Header | 1996-07-01 | 5.0 KB | 282 lines

#define VERSION "2.0"
#include "qlumpy.h"


#define MAXLUMP        0x50000         // biggest possible lump


byte            *byteimage, *lbmpalette;
int              byteimagewidth, byteimageheight;

char            basepath[1024];
char            lumpname[16];

char            destfile[1024];

byte            *lumpbuffer, *lump_p;

boolean            savesingle;
boolean            outputcreated;

/*
=============================================================================

                            MAIN

=============================================================================
*/

void GrabRaw (void);
void GrabPalette (void);
void GrabPic (void);
void GrabMip (void);
void GrabColormap (void);
void GrabColormap2 (void);

typedef struct
{
    char    *name;
    void    (*function) (void);
} command_t;

command_t       commands[] =
{
    {"palette",GrabPalette},
    {"colormap",GrabColormap},
    {"qpic",GrabPic},
    {"miptex",GrabMip},
    {"raw",GrabRaw},

    {"colormap2",GrabColormap2},

    {NULL,NULL}                     // list terminator
};



/*
==============
LoadScreen
==============
*/
void LoadScreen (char *name)
{
    printf ("grabbing from %s...\n",name);
    LoadLBM (name, &byteimage, &lbmpalette);

    byteimagewidth = bmhd.w;
    byteimageheight = bmhd.h;
}


/*
================
CreateOutput
================
*/
void CreateOutput (void)
{
    outputcreated = true;
//
// create the output wadfile file
//
    NewWad (destfile, false);    // create a new wadfile
}

/*
===============
WriteLump
===============
*/
void WriteLump (int type, int compression)
{
    int        size;

    if (!outputcreated)
        CreateOutput ();

//
// dword align the size
//
    while ((int)lump_p&3)
        *lump_p++ = 0;

    size = lump_p - lumpbuffer;
    if (size > MAXLUMP)
        Error ("Lump size exceeded %d, memory corrupted!",MAXLUMP);

//
// write the grabbed lump to the wadfile
//
    AddLump (lumpname,lumpbuffer,size,type, compression);
}

/*
===========
WriteFile

Save as a seperate file instead of as a wadfile lump
===========
*/
void WriteFile (void)
{
    char    filename[1024];

    sprintf (filename,"%s/%s.lmp", destfile, lumpname);
    printf ("saved %s\n", filename);
    SaveFile (filename, lumpbuffer, lump_p-lumpbuffer);
}

/*
================
ParseScript
================
*/
void ParseScript (void)
{
    int            cmd;
    int            size;

    do
    {
        //
        // get a command / lump name
        //
        GetToken (true);
        if (endofscript)
            break;
        if (!strcmpi (token,"$LOAD"))
        {
            GetToken (false);
            LoadScreen (token);
            continue;
        }

        if (!strcmpi (token,"$DEST"))
        {
            GetToken (false);
            strcpy (destfile, token);
            continue;
        }

        if (!strcmpi (token,"$SINGLEDEST"))
        {
            GetToken (false);
            strcpy (destfile, token);
            savesingle = true;
            continue;
        }


        //
        // new lump
        //
        if (strlen(token) >= sizeof(lumpname) )
            Error ("\"%s\" is too long to be a lump name",token);
        memset (lumpname,0,sizeof(lumpname));
        strcpy (lumpname, token);
        for (size=0 ; size<sizeof(lumpname) ; size++)
            lumpname[size] = tolower(lumpname[size]);

        //
        // get the grab command
        //
        lump_p = lumpbuffer;

        GetToken (false);

        //
        // call a routine to grab some data and put it in lumpbuffer
        // with lump_p pointing after the last byte to be saved
        //
        for (cmd=0 ; commands[cmd].name ; cmd++)
            if ( !strcmpi(token,commands[cmd].name) )
            {
                commands[cmd].function ();
                break;
            }

        if ( !commands[cmd].name )
            Error ("Unrecognized token '%s' at line %i",token,scriptline);

        grabbed++;

        if (savesingle)
            WriteFile ();
        else
            WriteLump (TYP_LUMPY+cmd, 0);

    } while (script_p < scriptend_p);
}

/*
=================
ProcessLumpyScript

Loads a script file, then grabs everything from it
=================
*/
void ProcessLumpyScript (char const *basename)
{
    char            script[256];

    printf ("qlumpy script: %s\n",basename);

//
// create default destination directory
//
    strcpy (destfile,basename);
    StripExtension (destfile);
    strcat (destfile,".wad");        // unless the script overrides, save in cwd

//
// save in a wadfile by default
//
    savesingle = false;
    grabbed = 0;
    outputcreated = false;


//
// read in the script file
//
    strcpy (script, basename);
    DefaultExtension (script, ".ls");
    LoadScriptFile (script);

    strcpy (basepath, basename);

    ParseScript ();                // execute load / grab commands

    if (!savesingle)
    {
        WriteWad ();                // write out the wad directory
        printf ("%i lumps grabbed in a wad file\n",grabbed);
    }
    else
        printf ("%i lumps written seperately\n",grabbed);
}


/*
==============================
main
==============================
*/
int main (int argc, char **argv)
{
    int        i;

    printf ("\nqlumpy "VERSION" by John Carmack, copyright (c) 1994 Id Software\n");

    if (argc == 1)
        Error ("qlumpy scriptfile [scriptfile ...]");

    lumpbuffer = malloc (MAXLUMP);

    for (i=1 ; i<argc ; i++)
        ProcessLumpyScript (argv[i]);

    return 0;
}