#include "common/cmdlib.h"
#include "common/mathlib.h"
#include "common/qfiles.h"
#include "common/threads.h"
static char * help_string =
    "4bld supporting v38 and v220 map formats plus QBSP extended limits.\n"
    "Usage: 4bld [options] [mapfile | bspfile]\n\n"
    "    -moddir [path]: Set a mod directory. Default is parent dir of map file.\n"
    "    -basedir [path]: Set the directory for assets not in moddir. Default is moddir.\n"
    "    -gamedir [path]: Set game directory, the folder with game executable.\n"
    "    -threads #: number of CPU threads to use\n"
    "BSP pass:\n"
    "    -bsp: enable bsp pass, requires a .map file as input\n"
    "    -chop #: Subdivide size.\n"
    "        Default: 240  Range: 32-1024\n"
    "    -choplight #: Subdivide size for surface lights.\n"
    "        Default: 240  Range: 32-1024\n"
    "    -largebounds or -lb: Increase max map size for supporting engines.\n"
    "    -micro #: Minimum microbrush size. Default: 0.02\n"
    "        Suggested range: 0.02 - 1.0\n"
    "    -nosubdiv: Disable subdivision.\n"
    "    -qbsp: Greatly expanded map and entity limits for supporting engines.\n"
    "VIS pass:\n"
    "    -vis: enable vis pass, requires a .bsp file as input or bsp pass enabled\n"
    "    -fast: fast single vis pass"
    "RAD pass:\n"
    "    -rad: enable rad pass, requires a .bsp file as input or bsp and vis passes enabled\n"
    "    -ambient #\n"
    "    -bounce #\n"
    "    -dice\n"
    "    -direct #\n"
    "    -entity #\n"
    "    -extra\n"
    "    -maxdata #\n"
    "    -maxlight #\n"
    "    -noedgefix\n"
    "    -nudge #\n"
    "    -saturate #\n"
    "    -scale #\n"
    "    -smooth #\n"
    "    -subdiv\n"
    "    -sunradscale #\n"
    "Debugging tools:\n"
    "    -block # #: Division tree block size, square\n"
    "    -blocks # # # #: Div tree block size, rectangular\n"
    "    -blocksize: map cube size for processing. Default: 1024\n"
    "    -fulldetail: Change most brushes to detail.\n"
    "    -leaktest: Perform leak test only.\n"
    "    -nocsg: No constructive solid geometry.\n"
    "    -nodetail: No detail brushes.\n"
    "    -nomerge: Don't merge visible faces per node.\n"
    "    -noorigfix: Disable texture fix for origin offsets.\n"
    "    -noprune: Disable node pruning.\n"
    "    -noshare: Don't look for shared edges on save.\n"
    "    -noskipfix: Do not automatically set skip contents to zero.\n"
    "    -notjunc: Disable edge cleanup.\n"
    "    -nowater: Ignore warp surfaces.\n"
    "    -noweld: Disable vertex welding.\n"
    "    -onlyents: Grab the entites and resave.\n"
    "    -v: Display more verbose output.\n"
    "    -dump\n"
    "    -noblock\n"
    "    -nopvs\n"
    "    -savetrace\n"
    "    -tmpin\n"
    "    -tmpout\n"
    ;
extern qboolean origfix;
extern qboolean noweld;
extern qboolean nocsg;
extern qboolean noshare;
extern qboolean notjunc;
extern qboolean nowater;
extern qboolean noprune;
extern qboolean nomerge;
extern qboolean nosubdiv;
extern qboolean nodetail;
extern qboolean fulldetail;
extern qboolean onlyents;
extern float microvolume;
extern qboolean leaktest;
extern qboolean use_qbsp;
extern int32_t max_entities;
extern int32_t max_bounds;
extern int32_t block_size;
extern qboolean noskipfix;
extern float subdivide_size;
extern float sublight_size;
extern int32_t block_xl;
extern int32_t block_yl;
extern int32_t block_xh;
extern int32_t block_yh;
extern char inbase[32];
extern char outbase[32];
extern qboolean fastvis;
extern qboolean nosort;
extern qboolean dumppatches;
extern int32_t numbounce;
extern qboolean extrasamples;
extern qboolean noedgefix;
extern int32_t maxdata;
extern float lightscale;
extern float sunradscale;
extern float patch_cutoff;
extern float direct_scale;
extern float entity_scale;
extern qboolean noblock;
extern float smoothing_value;
extern float sample_nudge;
extern float ambient;
extern qboolean save_trace;
extern float maxlight;
extern qboolean dicepatches;
extern float saturation;
extern qboolean nopvs;
void BSP_ProcessArgument(const char * arg);
void VIS_ProcessArgument(const char * arg);
void RAD_ProcessArgument(const char * arg);
int main(int argc, char *argv []) {
    char tgamedir[1024] = "";
    char tbasedir[1024] = "";
    char tmoddir[1024]  = "";
    qboolean do_bsp = false;
    qboolean do_vis = false;
    qboolean do_rad = false;
    ThreadSetDefault();
    int32_t i;
    for (i = 1; i < argc; i++) {
        if (!strcmp(argv[i], "-bsp")) {
            do_bsp = true;
        } else if (!strcmp(argv[i], "-vis")) {
            do_vis = true;
        } else if (!strcmp(argv[i], "-rad")) {
            do_rad = true;
        } else if (!strcmp(argv[i], "-noorigfix")) {
            printf("origfix = false\n");
            origfix = false;
        } else if (!strcmp(argv[i], "-v")) {
            printf("verbose = true\n");
            verbose = true;
        } else if (!strcmp(argv[i], "-help")) {
            printf("%s\n", help_string);
            exit(1);
        } else if (!strcmp(argv[i],"-threads")) {
            numthreads = atoi(argv[i+1]);
            printf("threads = %i\n", numthreads);
            i++;
        } else if (!strcmp(argv[i], "-noweld")) {
            printf("noweld = true\n");
            noweld = true;
        } else if (!strcmp(argv[i], "-nocsg")) {
            printf("nocsg = true\n");
            nocsg = true;
        } else if (!strcmp(argv[i], "-noshare")) {
            printf("noshare = true\n");
            noshare = true;
        } else if (!strcmp(argv[i], "-notjunc")) {
            printf("notjunc = true\n");
            notjunc = true;
        } else if (!strcmp(argv[i], "-nowater")) {
            printf("nowater = true\n");
            nowater = true;
        } else if (!strcmp(argv[i], "-noprune")) {
            printf("noprune = true\n");
            noprune = true;
        } else if (!strcmp(argv[i], "-nomerge")) {
            printf("nomerge = true\n");
            nomerge = true;
        } else if (!strcmp(argv[i], "-nosubdiv")) {
            printf("nosubdiv = true\n");
            nosubdiv = true;
        } else if (!strcmp(argv[i], "-nodetail")) {
            printf("nodetail = true\n");
            nodetail = true;
        } else if (!strcmp(argv[i], "-fulldetail")) {
            printf("fulldetail = true\n");
            fulldetail = true;
        } else if (!strcmp(argv[i], "-onlyents")) {
            printf("onlyents = true\n");
            onlyents = true;
        } else if (!strcmp(argv[i], "-micro")) {
            microvolume = atof(argv[i + 1]);
            i++;
        } else if (!strcmp(argv[i], "-leaktest")) {
            printf("leaktest = true\n");
            leaktest = true;
        } else if (!strcmp(argv[i], "-qbsp")) {
            // qb: qbsp
            printf("use_qbsp = true\n");
            use_qbsp     = true;
            max_entities = MAX_MAP_ENTITIES_QBSP;
            max_bounds   = MAX_MAP_SIZE;
            block_size   = MAX_BLOCK_SIZE; // qb: otherwise limits map range
        } else if (!strcmp(argv[i], "-noskipfix")) {
            printf("noskipfix = true\n");
            noskipfix = true;
        } else if (!strcmp(argv[i], "-largebounds") || !strcmp(argv[i], "-lb")) {
             // qb: from kmqbsp3- Knightmare added
            if (use_qbsp) {
                printf("[-largebounds is not required with -qbsp]\n");
            } else {
                max_bounds = MAX_MAP_SIZE;
                block_size = MAX_BLOCK_SIZE; // qb: otherwise limits map range
                printf("largebounds: using max bound size of %i\n", MAX_MAP_SIZE);
            }
        }
        // qb:  set gamedir, moddir, and basedir
        else if (!strcmp(argv[i], "-gamedir")) {
            strcpy(tgamedir, argv[i + 1]);
            i++;
        } else if (!strcmp(argv[i], "-moddir")) {
            strcpy(tmoddir, argv[i + 1]);
            i++;
        } else if (!strcmp(argv[i], "-basedir")) {
            strcpy(tbasedir, argv[i + 1]);
            i++;
        } else if((!strcmp(argv[i], "-chop")) || (!strcmp(argv[i], "-subdiv"))) {
            subdivide_size = atof(argv[i + 1]);
            if (subdivide_size < 32) {
                subdivide_size = 32;
                printf("subdivide_size set to minimum size: 32\n");
            }
            if (subdivide_size > 1024) {
                subdivide_size = 1024;
                printf("subdivide_size set to maximum size: 1024\n");
            }
            printf("subdivide_size = %f\n", subdivide_size);
            i++;
        } else if((!strcmp(argv[i], "-choplight")) || (!strcmp(argv[i], "-choplights")) || (!strcmp(argv[i], "-subdivlight"))) {
            // qb: chop surf lights independently
            sublight_size = atof(argv[i + 1]);
            if (sublight_size < 32) {
                sublight_size = 32;
                printf("sublight_size set to minimum size: 32\n");
            }
            if (sublight_size > 1024) {
                sublight_size = 1024;
                printf("sublight_size set to maximum size: 1024\n");
            }
            printf("sublight_size = %f\n", sublight_size);
            i++;
        } else if(!strcmp(argv[i], "-blocksize")) {
            block_size = atof(argv[i + 1]);
            if (block_size < 128) {
                block_size = 128;
                printf("block_size set to minimum size: 128\n");
            }
            if (block_size > MAX_BLOCK_SIZE) {
                block_size = MAX_BLOCK_SIZE;
                printf("block_size set to minimum size: MAX_BLOCK_SIZE\n");
            }
            printf("blocksize: %i\n", block_size);
            i++;
        } else if (!strcmp(argv[i], "-block")) {
            block_xl = block_yl = atoi(argv[i + 1]); // qb: fixed... has it always been wrong? was xl = xh and yl = yh
            block_xh = block_yh = atoi(argv[i + 2]);
            printf("block: %i,%i\n", block_xl, block_xh);
            i += 2;
        } else if (!strcmp(argv[i], "-blocks")) {
            block_xl = atoi(argv[i + 1]);
            block_yl = atoi(argv[i + 2]);
            block_xh = atoi(argv[i + 3]);
            block_yh = atoi(argv[i + 4]);
            printf("blocks: %i,%i to %i,%i\n",
                   block_xl, block_yl, block_xh, block_yh);
            i += 4;
        } else if (!strcmp(argv[i], "-tmpin"))
            strcpy(inbase, "/tmp");
        else if (!strcmp(argv[i], "-tmpout"))
            strcpy(outbase, "/tmp");
        else if (!strcmp(argv[i], "-fast")) {
            printf("fastvis = true\n");
            fastvis = true;
        } else if (!strcmp(argv[i], "-nosort")) {
            printf("nosort = true\n");
            nosort = true;
        } else if (!strcmp(argv[i], "-dump")) {
                    printf("dicepatches = true\n");
            dumppatches = true;
        } else if (!strcmp(argv[i], "-bounce")) {
            numbounce = atoi(argv[i + 1]);
            i++;
        } else if (!strcmp(argv[i], "-extra")) {
            extrasamples = true;
            printf("extrasamples = true\n");
        } else if (!strcmp(argv[i], "-noedgefix")) {
            // qb: light warp surfaces
            noedgefix = true;
            printf("no edge fix = true\n");
        } else if (!strcmp(argv[i], "-dice")) {
            dicepatches = true;
            printf("dicepatches = true\n");
        } else if (!strcmp(argv[i], "-threads")) {
            numthreads = atoi(argv[i + 1]);
            i++;
        } else if (!strcmp(argv[i], "-maxdata")) { // qb: allows increase for some engines
            maxdata = atoi(argv[i + 1]);
            i++;
            if (maxdata > DEFAULT_MAP_LIGHTING) {
                printf("lighting maxdata (%i) exceeds typical limit (%i).\n", maxdata, DEFAULT_MAP_LIGHTING);
            }
        } else if (!strcmp(argv[i], "-scale")) {
            lightscale = atof(argv[i + 1]);
            i++;
        } else if (!strcmp(argv[i], "-sunradscale")) {
            sunradscale = atof(argv[i + 1]);
            if (sunradscale < 0) {
                sunradscale = 0;
                printf("sunradscale set to minimum: 0\n");
            }
            printf("sunradscale = %f\n", sunradscale);
            i++;
        } else if (!strcmp(argv[i], "-saturation")) {
            saturation = atof(argv[i + 1]);
            i++;
        } else if (!strcmp(argv[i], "-radmin")) {
            patch_cutoff = atof(argv[i + 1]);
            i++;
        } else if (!strcmp(argv[i], "-direct")) {
            direct_scale *= atof(argv[i + 1]);
            // printf ("direct light scaling at %f\n", direct_scale);
            i++;
        } else if (!strcmp(argv[i], "-entity")) {
            entity_scale *= atof(argv[i + 1]);
            // printf ("entity light scaling at %f\n", entity_scale);
            i++;
        } else if (!strcmp(argv[i], "-nopvs")) {
            nopvs = true;
            printf("nopvs = true\n");
        } else if (!strcmp(argv[i], "-noblock")) {
            noblock = true;
            printf("noblock = true\n");
        } else if (!strcmp(argv[i], "-smooth")) {
            // qb: limit range
            smoothing_value = BOUND(0, atof(argv[i + 1]), 90);
            i++;
        } else if (!strcmp(argv[i], "-nudge")) {
            sample_nudge = atof(argv[i + 1]);
            // qb: nah, go crazy.  sample_nudge = BOUND(0, sample_nudge, 1.0);
            i++;
        } else if (!strcmp(argv[i], "-ambient")) {
            ambient = BOUND(0, atof(argv[i + 1]), 255);
            i++;
        } else if (!strcmp(argv[i], "-savetrace")) {
            save_trace = true;
            printf("savetrace = true\n");
        } else if (!strcmp(argv[i], "-maxlight")) {
            maxlight = BOUND(0, atof(argv[i + 1]), 255);
        } else
            break;
    }
    for(; i < argc; i++) {
        size_t input_length = strlen(argv[i]);
        qboolean is_map = strcmp(argv[i] + input_length - 4, ".map") == 0;
        if(do_bsp) {
            if(!is_map)
                Error("bsp operation requires a map file input.");
        } else if(do_vis || do_rad) {
            if(is_map)
                Error("bsp operation requires a bsp file input.");
        } else {
            Error("no operations chosen to be performed on input.");
        }
        SetQdirFromPath(argv[i]);
        if (strcmp(tmoddir, "")) {
            strcpy(moddir, tmoddir);
            Q_pathslash(moddir);
            strcpy(basedir, moddir);
        }
        if (strcmp(tbasedir, "")) {
            strcpy(basedir, tbasedir);
            Q_pathslash(basedir);
            if (!strcmp(tmoddir, ""))
                strcpy(moddir, basedir);
        }
        if (strcmp(tgamedir, "")) {
            strcpy(gamedir, tgamedir);
            Q_pathslash(gamedir);
        }
        // qb: display dirs
        printf("moddir = %s\n", moddir);
        printf("basedir = %s\n", basedir);
        printf("gamedir = %s\n", gamedir);
        if(do_bsp) {
            int32_t old_numthreads = numthreads;
            // qb: below is from original source release.  On Windows, multi threads cause false leak errors.
            numthreads = 1; // multiple threads aren't helping...
            BSP_ProcessArgument(argv[i]);
            numthreads = old_numthreads;
        }
        if(do_vis || (do_bsp && do_rad && is_map)) {
            VIS_ProcessArgument(argv[i]);
        }
        if(do_rad) {
            RAD_ProcessArgument(argv[i]);
        }
    }
}

/*
===========================================================================
Copyright (C) 1997-2006 Id Software, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
===========================================================================
*/
//
// trilib.c: library for loading triangles from an Alias triangle file
//
#include <stdio.h>
#include "cmdlib.h"
#include "mathlib.h"
#include "4data.h"
// on disk representation of a face
#define FLOAT_START BOGUS_RANGE
#define FLOAT_END   -FLOAT_START
#define MAGIC       123322
//#define NOISY 1
typedef struct {
    float v[3];
} vector;
typedef struct
{
    vector n; /* normal */
    vector p; /* point */
    vector c; /* color */
    float u;  /* u */
    float v;  /* v */
} aliaspoint_t;
typedef struct {
    aliaspoint_t pt[3];
} tf_triangle;
void ByteSwapTri(tf_triangle *tri) {
    int32_t i;
    for (i = 0; i < sizeof(tf_triangle) / 4; i++) {
        ((int32_t *)tri)[i] = BigLong(((int32_t *)tri)[i]);
    }
}
void LoadTriangleList(char *filename, triangle_t **pptri, int32_t *numtriangles) {
    FILE *input;
    float start;
    char name[256], tex[256];
    int32_t i, count, magic;
    tf_triangle tri;
    triangle_t *ptri;
    int32_t iLevel;
    int32_t exitpattern;
    float t;
    t                              = -FLOAT_START;
    *((uint8_t *)&exitpattern + 0) = *((uint8_t *)&t + 3);
    *((uint8_t *)&exitpattern + 1) = *((uint8_t *)&t + 2);
    *((uint8_t *)&exitpattern + 2) = *((uint8_t *)&t + 1);
    *((uint8_t *)&exitpattern + 3) = *((uint8_t *)&t + 0);
    if ((input = fopen(filename, "rb")) == 0)
        Error("reader: could not open file '%s'", filename);
    iLevel = 0;
    fread(&magic, sizeof(int32_t), 1, input);
    if (BigLong(magic) != MAGIC)
        Error("%s is not a Alias object separated triangle file, magic number is wrong.", filename);
    ptri   = malloc(MAXTRIANGLES * sizeof(triangle_t));
    *pptri = ptri;
    while (feof(input) == 0) {
        if (fread(&start, sizeof(float), 1, input) < 1)
            break;
        *(int32_t *)&start = BigLong(*(int32_t *)&start);
        if (*(int32_t *)&start != exitpattern) {
            if (start == FLOAT_START) {
                /* Start of an object or group of objects. */
                i = -1;
                do {
                    /* There are probably better ways to read a string from */
                    /* a file, but this does allow you to do error checking */
                    /* (which I'm not doing) on a per character basis.      */
                    ++i;
                    fread(&(name[i]), sizeof(char), 1, input);
                } while (name[i] != '\0');
                //				indent();
                //				fprintf(stdout,"OBJECT START: %s\n",name);
                fread(&count, sizeof(int32_t), 1, input);
                count = BigLong(count);
                ++iLevel;
                if (count != 0) {
                    //					indent();
                    //					fprintf(stdout,"NUMBER OF TRIANGLES: %d\n",count);
                    i = -1;
                    do {
                        ++i;
                        fread(&(tex[i]), sizeof(char), 1, input);
                    } while (tex[i] != '\0');
                    //					indent();
                    //					fprintf(stdout,"  Object texture name: '%s'\n",tex);
                }
                /* Else (count == 0) this is the start of a group, and */
                /* no texture name is present. */
            } else if (start == FLOAT_END) {
                /* End of an object or group. Yes, the name should be */
                /* obvious from context, but it is in here just to be */
                /* safe and to provide a little extra information for */
                /* those who do not wish to write a recursive reader. */
                /* Mia culpa. */
                --iLevel;
                i = -1;
                do {
                    ++i;
                    fread(&(name[i]), sizeof(char), 1, input);
                } while (name[i] != '\0');
                //				indent();
                //				fprintf(stdout,"OBJECT END: %s\n",name);
                continue;
            }
        }
        //
        // read the triangles
        //
        for (i = 0; i < count; ++i) {
            int32_t j;
            fread(&tri, sizeof(tf_triangle), 1, input);
            ByteSwapTri(&tri);
            for (j = 0; j < 3; j++) {
                int32_t k;
                for (k = 0; k < 3; k++) {
                    ptri->verts[j][k] = tri.pt[j].p.v[k];
                }
            }
            ptri++;
            if ((ptri - *pptri) >= MAXTRIANGLES)
                Error("Error: too many triangles; increase MAXTRIANGLES\n");
        }
    }
    *numtriangles = ptri - *pptri;
    fclose(input);
    free(ptri); // qb: stop mem leak
}

/*
===========================================================================
Copyright (C) 1997-2006 Id Software, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
===========================================================================
*/
#include "cmdlib.h"
#include "threads.h"
#define MAX_THREADS 64
int32_t dispatch;
int32_t workcount;
int32_t oldf;
qboolean pacifier;
qboolean threaded;
/*
=============
GetThreadWork
=============
*/
int32_t GetThreadWork(void) {
    int32_t r;
    int32_t f;
    ThreadLock();
    if (dispatch == workcount) {
        ThreadUnlock();
        return -1;
    }
    f = 10 * dispatch / workcount;
    if (f != oldf) {
        oldf = f;
        if (pacifier) {
            printf("%i...", f);
            fflush(stdout);
        }
    }
    r = dispatch;
    dispatch++;
    ThreadUnlock();
    return r;
}
void (*workfunction)(int32_t);
void ThreadWorkerFunction(int32_t threadnum) {
    int32_t work;
    while (1) {
        work = GetThreadWork();
        if (work == -1)
            break;
        // printf ("thread %i, work %i\n", threadnum, work);
        workfunction(work);
    }
}
void RunThreadsOnIndividual(int32_t workcnt, qboolean showpacifier, void (*func)(int32_t)) {
    if (numthreads == -1)
        ThreadSetDefault();
    workfunction = func;
    RunThreadsOn(workcnt, showpacifier, ThreadWorkerFunction);
}
#ifdef USE_PTHREADS
#ifdef WIN32
#define USED
#include <windows.h>
int32_t numthreads = -1;
CRITICAL_SECTION crit;
static int32_t enter;
void ThreadSetDefault(void) {
    SYSTEM_INFO info;
    if (numthreads == -1) // not set manually
    {
        GetSystemInfo(&info);
        numthreads = info.dwNumberOfProcessors;
        if (numthreads < 1 || numthreads > 32)
            numthreads = 1;
    }
    qprintf("%i threads\n", numthreads);
}
void ThreadLock(void) {
    if (!threaded)
        return;
    EnterCriticalSection(&crit);
    if (enter)
        Error("Recursive ThreadLock\n");
    enter = 1;
}
void ThreadUnlock(void) {
    if (!threaded)
        return;
    if (!enter)
        Error("ThreadUnlock without lock\n");
    enter = 0;
    LeaveCriticalSection(&crit);
}
/*
=============
RunThreadsOn
=============
*/
void RunThreadsOn(int32_t workcnt, qboolean showpacifier, void (*func)(int32_t)) {
    int32_t threadid[MAX_THREADS];
    HANDLE threadhandle[MAX_THREADS];
    int32_t i;
    int32_t start, end;
    start     = I_FloatTime();
    dispatch  = 0;
    workcount = workcnt;
    oldf      = -1;
    pacifier  = showpacifier;
    threaded  = true;
    //
    // run threads in parallel
    //
    InitializeCriticalSection(&crit);
    if (numthreads == 1) { // use same thread
        func(0);
    } else {
        for (i = 0; i < numthreads; i++) {
            threadhandle[i] = CreateThread(
                NULL,                         // LPSECURITY_ATTRIBUTES lpsa,
                0,                            // DWORD cbStack,
                (LPTHREAD_START_ROUTINE)func, // LPTHREAD_START_ROUTINE lpStartAddr,
                (LPVOID)i,                    // LPVOID lpvThreadParm,
                0,                            //   DWORD fdwCreate,
                &threadid[i]);
        }
        for (i = 0; i < numthreads; i++)
            WaitForSingleObject(threadhandle[i], INFINITE);
    }
    DeleteCriticalSection(&crit);
    threaded = false;
    end      = I_FloatTime();
    if (pacifier)
        printf(" (%i)\n", end - start);
}
#else
#define USED
int32_t numthreads = 4;
void ThreadSetDefault(void) {
    if (numthreads == -1) // not set manually
    {
        numthreads = 4;
    }
}
#include <pthread.h>
pthread_mutex_t *my_mutex;
void ThreadLock(void) {
    if (my_mutex)
        pthread_mutex_lock(my_mutex);
}
void ThreadUnlock(void) {
    if (my_mutex)
        pthread_mutex_unlock(my_mutex);
}
/*
=============
RunThreadsOn
=============
*/
void RunThreadsOn(int32_t workcnt, qboolean showpacifier, void (*func)(int32_t)) {
    int32_t i;
    pthread_t work_threads[MAX_THREADS];
    void *status;
    pthread_attr_t attrib;
    pthread_mutexattr_t mattrib;
    int32_t start, end;
    start     = I_FloatTime();
    dispatch  = 0;
    workcount = workcnt;
    oldf      = -1;
    pacifier  = showpacifier;
    threaded  = true;
    if (pacifier)
        setbuf(stdout, NULL);
    if (!my_mutex) {
        my_mutex = malloc(sizeof(*my_mutex));
        if (pthread_mutexattr_init(&mattrib) == -1)
            Error("pthread_mutex_attr_create failed");
        if (pthread_mutex_init(my_mutex, &mattrib) == -1)
            Error("pthread_mutex_init failed");
    }
    if (pthread_attr_init(&attrib) == -1)
        Error("pthread_attr_create failed");
    if (pthread_attr_setstacksize(&attrib, 0x1000000) == -1)
        Error("pthread_attr_setstacksize failed");
    for (i = 0; i < numthreads; i++) {
        if (pthread_create(&work_threads[i], &attrib, (void *)func, &i) == -1)
            Error("pthread_create failed");
    }
    for (i = 0; i < numthreads; i++) {
        if (pthread_join(work_threads[i], &status) == -1)
            Error("pthread_join failed");
    }
    threaded = false;
    end      = I_FloatTime();
    if (pacifier)
        printf(" (%i)\n", end - start);
}
#endif
#endif
/*
=======================================================================
  SINGLE THREAD
=======================================================================
*/
#ifndef USED
int32_t numthreads = 1;
void ThreadSetDefault(void) {
    numthreads = 1;
}
void ThreadLock(void) {
}
void ThreadUnlock(void) {
}
/*
=============
RunThreadsOn
=============
*/
void RunThreadsOn(int32_t workcnt, qboolean showpacifier, void (*func)(int32_t)) {
    int32_t start, end;
    dispatch  = 0;
    workcount = workcnt;
    oldf      = -1;
    pacifier  = showpacifier;
    start     = I_FloatTime();
#ifdef NeXT
    if (pacifier)
        setbuf(stdout, NULL);
#endif
    func(0);
    end = I_FloatTime();
    if (pacifier)
        printf(" (%i)\n", end - start);
}
#endif

/*
===========================================================================
Copyright (C) 1997-2006 Id Software, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
===========================================================================
*/
// scriplib.c
#include "cmdlib.h"
#include "scriplib.h"
/*
=============================================================================
                                                PARSING STUFF
=============================================================================
*/
typedef struct
{
    char filename[1024];
    char *buffer, *script_p, *end_p;
    int32_t line;
} script_t;
#define MAX_INCLUDES 8
script_t scriptstack[MAX_INCLUDES];
script_t *script;
int32_t scriptline;
char token[MAXTOKEN];
qboolean endofscript;
qboolean tokenready; // only true if UnGetToken was just called
// qb: brush info from AA tools
char brush_info[2000]      = "No brushes processed yet. Look near beginning of map";
static int32_t brush_begin = 1;
void MarkBrushBegin() {
    brush_begin = 1;
}
void TestBrushBegin() {
    if (!brush_begin)
        return;
    brush_begin = 0;
    sprintf(brush_info, "Line %d, file %s", script->line, script->filename);
}
/*
==============
AddScriptToStack
==============
*/
void AddScriptToStack(char *filename) {
    int32_t size;
    script++;
    if (script == &scriptstack[MAX_INCLUDES])
        Error("script file exceeded MAX_INCLUDES");
    strcpy(script->filename, ExpandPath(filename));
    size = LoadFile(script->filename, (void **)&script->buffer);
    printf("entering %s\n", script->filename);
    script->line     = 1;
    script->script_p = script->buffer;
    script->end_p    = script->buffer + size;
}
/*
==============
LoadScriptFile
==============
*/
void LoadScriptFile(char *filename) {
    script = scriptstack;
    AddScriptToStack(filename);
    endofscript = false;
    tokenready  = false;
}
/*
==============
ParseFromMemory
==============
*/
void ParseFromMemory(char *buffer, int32_t size) {
    script = scriptstack;
    script++;
    if (script == &scriptstack[MAX_INCLUDES])
        Error("script file exceeded MAX_INCLUDES");
    strcpy(script->filename, "memory buffer");
    script->buffer   = buffer;
    script->line     = 1;
    script->script_p = script->buffer;
    script->end_p    = script->buffer + size;
    endofscript      = false;
    tokenready       = false;
}
/*
==============
UnGetToken
Signals that the current token was not used, and should be reported
for the next GetToken.  Note that
GetToken (true);
UnGetToken ();
GetToken (false);
could cross a line boundary.
==============
*/
void UnGetToken(void) {
    tokenready = true;
}
qboolean EndOfScript(qboolean crossline) {
    if (!crossline)
        Error("Line %i is incomplete\n", scriptline);
    if (!strcmp(script->filename, "memory buffer")) {
        endofscript = true;
        return false;
    }
    free(script->buffer);
    if (script == scriptstack + 1) {
        endofscript = true;
        return false;
    }
    script--;
    scriptline = script->line;
    printf("returning to %s\n", script->filename);
    return GetToken(crossline);
}
/*
==============
GetToken
==============
*/
qboolean GetToken(qboolean crossline) {
    char *token_p;
    if (tokenready) // is a token allready waiting?
    {
        tokenready = false;
        return true;
    }
    if (script->script_p >= script->end_p)
        return EndOfScript(crossline);
    TestBrushBegin();
//
// skip space
//
skipspace:
    while (*script->script_p <= 32) {
        if (script->script_p >= script->end_p)
            return EndOfScript(crossline);
        if (*script->script_p++ == '\n') {
            if (!crossline)
                Error("Line %i is incomplete\n", scriptline);
            scriptline = script->line++;
        }
    }
    if (script->script_p >= script->end_p)
        return EndOfScript(crossline);
    // ; # // comments
    if (*script->script_p == ';' || *script->script_p == '#' || (script->script_p[0] == '/' && script->script_p[1] == '/')) {
        if (!crossline)
            Error("Line %i is incomplete\n", scriptline);
        while (*script->script_p++ != '\n')
            if (script->script_p >= script->end_p)
                return EndOfScript(crossline);
        scriptline = script->line++;
        goto skipspace;
    }
    // /* */ comments
    if (script->script_p[0] == '/' && script->script_p[1] == '*') {
        if (!crossline)
            Error("Line %i is incomplete\n", scriptline);
        script->script_p += 2;
        while (script->script_p[0] != '*' && script->script_p[1] != '/') {
            if (script->script_p[0] == '\n')
                scriptline = script->line++;
            script->script_p++;
            if (script->script_p >= script->end_p)
                return EndOfScript(crossline);
        }
        script->script_p += 2;
        goto skipspace;
    }
    //
    // copy token
    //
    token_p = token;
    if (*script->script_p == '"') {
        // quoted token
        script->script_p++;
        while (*script->script_p != '"') {
            *token_p++ = *script->script_p++;
            if (script->script_p == script->end_p)
                break;
            if (token_p == &token[MAXTOKEN])
                Error("Token too large on line %i\n", scriptline);
        }
        script->script_p++;
    } else // regular token
        while (*script->script_p > 32 && *script->script_p != ';') {
            *token_p++ = *script->script_p++;
            if (script->script_p == script->end_p)
                break;
            if (token_p == &token[MAXTOKEN])
                Error("Token too large on line %i\n", scriptline);
        }
    *token_p = 0;
    if (!strcmp(token, "$include")) {
        GetToken(false);
        AddScriptToStack(token);
        return GetToken(crossline);
    }
    return true;
}
/*
==============
TokenAvailable
Returns true if there is another token on the line
==============
*/
qboolean TokenAvailable(void) {
    char *search_p;
    search_p = script->script_p;
    if (search_p >= script->end_p)
        return false;
    while (*search_p <= 32) {
        if (*search_p == '\n')
            return false;
        search_p++;
        if (search_p == script->end_p)
            return false;
    }
    if (*search_p == ';')
        return false;
    return true;
}

/*
===========================================================================
Copyright (C) 1997-2006 Id Software, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
===========================================================================
*/
#include "cmdlib.h"
#include "mathlib.h"
#include "polylib.h"
extern int32_t numthreads;
// counters are only bumped when running single threaded,
// because they are an awefull coherence problem
int32_t c_active_windings;
int32_t c_peak_windings;
int32_t c_winding_allocs;
int32_t c_winding_points;
void pw(winding_t *w) {
    int32_t i;
    for (i = 0; i < w->numpoints; i++)
        printf("(%5.1f, %5.1f, %5.1f)\n", w->p[i][0], w->p[i][1], w->p[i][2]);
}
/*
=============
AllocWinding
=============
*/
winding_t *AllocWinding(int32_t points) {
    winding_t *w;
    int32_t s;
    if (numthreads == 1) {
        c_winding_allocs++;
        c_winding_points += points;
        c_active_windings++;
        if (c_active_windings > c_peak_windings)
            c_peak_windings = c_active_windings;
    }
    s = sizeof(vec_t) * 3 * points + sizeof(int32_t);
    w = malloc(s);
    memset(w, 0, s);
    return w;
}
void FreeWinding(winding_t *w) {
    if (*(unsigned *)w == 0xdeaddead)
        Error("FreeWinding: freed a freed winding");
    *(unsigned *)w = 0xdeaddead;
    if (numthreads == 1)
        c_active_windings--;
    free(w);
}
/*
============
RemoveColinearPoints
============
*/
int32_t c_removed;
void RemoveColinearPoints(winding_t *w) {
    int32_t i, j, k;
    vec3_t v1, v2;
    int32_t nump;
    vec3_t p[MAX_POINTS_ON_WINDING];
    nump = 0;
    for (i = 0; i < w->numpoints; i++) {
        j = (i + 1) % w->numpoints;
        k = (i + w->numpoints - 1) % w->numpoints;
        VectorSubtract(w->p[j], w->p[i], v1);
        VectorSubtract(w->p[i], w->p[k], v2);
        VectorNormalize(v1, v1);
        VectorNormalize(v2, v2);
        if (DotProduct(v1, v2) < 0.999) {
            VectorCopy(w->p[i], p[nump]);
            nump++;
        }
    }
    if (nump == w->numpoints)
        return;
    if (numthreads == 1)
        c_removed += w->numpoints - nump;
    w->numpoints = nump;
    memcpy(w->p, p, nump * sizeof(p[0]));
}
/*
============
WindingPlane
============
*/
void WindingPlane(winding_t *w, vec3_t normal, vec_t *dist) {
    vec3_t v1, v2;
    VectorSubtract(w->p[1], w->p[0], v1);
    VectorSubtract(w->p[2], w->p[0], v2);
    CrossProduct(v2, v1, normal);
    VectorNormalize(normal, normal);
    *dist = DotProduct(w->p[0], normal);
}
/*
=============
WindingArea
=============
*/
vec_t WindingArea(winding_t *w) {
    int32_t i;
    vec3_t d1, d2, cross;
    vec_t total;
    total = 0;
    for (i = 2; i < w->numpoints; i++) {
        VectorSubtract(w->p[i - 1], w->p[0], d1);
        VectorSubtract(w->p[i], w->p[0], d2);
        CrossProduct(d1, d2, cross);
        total += 0.5 * VectorLength(cross);
    }
    return total;
}
void WindingBounds(winding_t *w, vec3_t mins, vec3_t maxs) {
    vec_t v;
    int32_t i, j;
    mins[0] = mins[1] = mins[2] = BOGUS_RANGE;
    maxs[0] = maxs[1] = maxs[2] = -BOGUS_RANGE;
    for (i = 0; i < w->numpoints; i++) {
        for (j = 0; j < 3; j++) {
            v = w->p[i][j];
            if (v < mins[j])
                mins[j] = v;
            if (v > maxs[j])
                maxs[j] = v;
        }
    }
}
/*
=============
WindingCenter
=============
*/
void WindingCenter(winding_t *w, vec3_t center) {
    int32_t i;
    float scale;
    VectorCopy(vec3_origin, center);
    for (i = 0; i < w->numpoints; i++)
        VectorAdd(w->p[i], center, center);
    scale = 1.0 / w->numpoints;
    VectorScale(center, scale, center);
}
/*
=================
BaseWindingForPlane
=================
*/
winding_t *BaseWindingForPlane(vec3_t normal, vec_t dist) {
    int32_t i, x;
    vec_t max, v;
    vec3_t org, vright, vup;
    winding_t *w;
    // find the major axis
    max = -BOGUS_RANGE;
    x   = -1;
    for (i = 0; i < 3; i++) {
        v = fabs(normal[i]);
        if (v > max) {
            x   = i;
            max = v;
        }
    }
    if (x == -1)
        Error("BaseWindingForPlane: no axis found");
    VectorCopy(vec3_origin, vup);
    switch (x) {
    case 0:
    case 1:
        vup[2] = 1;
        break;
    case 2:
        vup[0] = 1;
        break;
    }
    v = DotProduct(vup, normal);
    VectorMA(vup, -v, normal, vup);
    VectorNormalize(vup, vup);
    VectorScale(normal, dist, org);
    CrossProduct(vup, normal, vright);
    VectorScale(vup, BOGUS_RANGE, vup);
    VectorScale(vright, BOGUS_RANGE, vright);
    // project a really big	axis aligned box onto the plane
    w = AllocWinding(4);
    VectorSubtract(org, vright, w->p[0]);
    VectorAdd(w->p[0], vup, w->p[0]);
    VectorAdd(org, vright, w->p[1]);
    VectorAdd(w->p[1], vup, w->p[1]);
    VectorAdd(org, vright, w->p[2]);
    VectorSubtract(w->p[2], vup, w->p[2]);
    VectorSubtract(org, vright, w->p[3]);
    VectorSubtract(w->p[3], vup, w->p[3]);
    w->numpoints = 4;
    return w;
}
/*
==================
CopyWinding
==================
*/
winding_t *CopyWinding(const winding_t *w) {
    int32_t size;
    winding_t *c;
    c    = AllocWinding(w->numpoints);
    size = (intptr_t)((winding_t *)0)->p[w->numpoints];
    memcpy(c, w, size);
    return c;
}
/*
==================
ReverseWinding
==================
*/
winding_t *ReverseWinding(winding_t *w) {
    int32_t i;
    winding_t *c;
    c = AllocWinding(w->numpoints);
    for (i = 0; i < w->numpoints; i++) {
        VectorCopy(w->p[w->numpoints - 1 - i], c->p[i]);
    }
    c->numpoints = w->numpoints;
    return c;
}
/*
=============
ClipWindingEpsilon
=============
*/
void ClipWindingEpsilon(
    const winding_t *in,
    const vec3_t normal,
    const vec_t dist,
    const vec_t epsilon,
    winding_t **front, winding_t **back) {
    vec_t dists[MAX_POINTS_ON_WINDING + 4];
    int32_t sides[MAX_POINTS_ON_WINDING + 4];
    int32_t counts[3];
    static vec_t dot; // VC 4.2 optimizer bug if not static
    int32_t i, j;
    vec_t *p1, *p2;
    vec3_t mid;
    winding_t *f, *b;
    int32_t maxpts;
    counts[0] = counts[1] = counts[2] = 0;
    sides[0] = dists[0] = 0;
    // determine sides for each point
    for (i = 0; i < in->numpoints; i++) {
        dot = DotProduct(in->p[i], normal);
        dot -= dist;
        dists[i] = dot;
        if (dot > epsilon)
            sides[i] = SIDE_FRONT;
        else if (dot < -epsilon)
            sides[i] = SIDE_BACK;
        else
            sides[i] = SIDE_ON;
        counts[sides[i]]++;
    }
    sides[i] = sides[0];
    dists[i] = dists[0];
    *front = *back = NULL;
    if (!counts[0]) {
        *back = CopyWinding(in);
        return;
    }
    if (!counts[1]) {
        *front = CopyWinding(in);
        return;
    }
    maxpts = in->numpoints + 4; // cant use counts[0]+2 because of fp grouping errors
    *front = f = AllocWinding(maxpts);
    *back = b = AllocWinding(maxpts);
    for (i = 0; i < in->numpoints; i++) {
        p1 = ((winding_t *)in)->p[i];
        if (sides[i] == SIDE_ON) {
            VectorCopy(p1, f->p[f->numpoints]);
            f->numpoints++;
            VectorCopy(p1, b->p[b->numpoints]);
            b->numpoints++;
            continue;
        }
        if (sides[i] == SIDE_FRONT) {
            VectorCopy(p1, f->p[f->numpoints]);
            f->numpoints++;
        }
        if (sides[i] == SIDE_BACK) {
            VectorCopy(p1, b->p[b->numpoints]);
            b->numpoints++;
        }
        if (sides[i + 1] == SIDE_ON || sides[i + 1] == sides[i])
            continue;
        // generate a split point
        p2  = ((winding_t *)in)->p[(i + 1) % in->numpoints];
        dot = dists[i] / (dists[i] - dists[i + 1]);
        for (j = 0; j < 3; j++) {
            // avoid round off error when possible
            if (normal[j] == 1)
                mid[j] = dist;
            else if (normal[j] == -1)
                mid[j] = -dist;
            else
                mid[j] = p1[j] + dot * (p2[j] - p1[j]);
        }
        VectorCopy(mid, f->p[f->numpoints]);
        f->numpoints++;
        VectorCopy(mid, b->p[b->numpoints]);
        b->numpoints++;
    }
    if (f->numpoints > maxpts || b->numpoints > maxpts)
        Error("ClipWinding: points exceeded estimate");
    if (f->numpoints > MAX_POINTS_ON_WINDING || b->numpoints > MAX_POINTS_ON_WINDING)
        Error("ClipWinding: MAX_POINTS_ON_WINDING");
}
/*
=============
ChopWindingInPlace
=============
*/
void ChopWindingInPlace(winding_t **inout, vec3_t normal, vec_t dist, vec_t epsilon) {
    winding_t *in;
    vec_t dists[MAX_POINTS_ON_WINDING + 4];
    int32_t sides[MAX_POINTS_ON_WINDING + 4];
    int32_t counts[3];
    static vec_t dot; // VC 4.2 optimizer bug if not static
    int32_t i, j;
    vec_t *p1, *p2;
    vec3_t mid;
    winding_t *f;
    int32_t maxpts;
    in        = *inout;
    counts[0] = counts[1] = counts[2] = 0;
    // determine sides for each point
    for (i = 0; i < in->numpoints; i++) {
        dot = DotProduct(in->p[i], normal);
        dot -= dist;
        dists[i] = dot;
        if (dot > epsilon)
            sides[i] = SIDE_FRONT;
        else if (dot < -epsilon)
            sides[i] = SIDE_BACK;
        else {
            sides[i] = SIDE_ON;
        }
        counts[sides[i]]++;
    }
    sides[i] = sides[0];
    dists[i] = dists[0];
    if (!counts[0]) {
        FreeWinding(in);
        *inout = NULL;
        return;
    }
    if (!counts[1])
        return; // inout stays the same
    maxpts = in->numpoints + 4; // can't use counts[0]+2 because of fp grouping errors
    f      = AllocWinding(maxpts);
    for (i = 0; i < in->numpoints; i++) {
        p1 = in->p[i];
        if (sides[i] == SIDE_ON) {
            VectorCopy(p1, f->p[f->numpoints]);
            f->numpoints++;
            continue;
        }
        if (sides[i] == SIDE_FRONT) {
            VectorCopy(p1, f->p[f->numpoints]);
            f->numpoints++;
        }
        if (sides[i + 1] == SIDE_ON || sides[i + 1] == sides[i])
            continue;
        // generate a split point
        p2  = in->p[(i + 1) % in->numpoints];
        dot = dists[i] / (dists[i] - dists[i + 1]);
        for (j = 0; j < 3; j++) {
            // avoid round off error when possible
            if (normal[j] >= 1)
                mid[j] = dist;
            else if (normal[j] <= -1)
                mid[j] = -dist;
            else
                mid[j] = p1[j] + dot * (p2[j] - p1[j]);
        }
        VectorCopy(mid, f->p[f->numpoints]);
        f->numpoints++;
    }
    if (f->numpoints > maxpts)
        Error("ClipWinding: points exceeded estimate");
    if (f->numpoints > MAX_POINTS_ON_WINDING)
        Error("ClipWinding: MAX_POINTS_ON_WINDING");
    FreeWinding(in);
    *inout = f;
}
/*
=================
ChopWinding
Returns the fragment of in that is on the front side
of the cliping plane.  The original is freed.
=================
*/
winding_t *ChopWinding(winding_t *in, vec3_t normal, vec_t dist) {
    winding_t *f, *b;
    ClipWindingEpsilon(in, normal, dist, ON_EPSILON, &f, &b);
    FreeWinding(in);
    if (b)
        FreeWinding(b);
    return f;
}
/*
=================
CheckWinding
=================
*/
void CheckWinding(winding_t *w) {
    int32_t i, j;
    vec_t *p1, *p2;
    vec_t d, edgedist;
    vec3_t dir, edgenormal, facenormal;
    vec_t area;
    vec_t facedist;
    if (w->numpoints < 3)
        Error("CheckWinding: %i points", w->numpoints);
    area = WindingArea(w);
    if (area < 1)
        Error("CheckWinding: %f area", area);
    WindingPlane(w, facenormal, &facedist);
    for (i = 0; i < w->numpoints; i++) {
        p1 = w->p[i];
        for (j = 0; j < 3; j++)
            if (p1[j] > BOGUS_RANGE || p1[j] < -BOGUS_RANGE)
                Error("CheckFace: BUGUS_RANGE: %f", p1[j]);
        j = i + 1 == w->numpoints ? 0 : i + 1;
        // check the point is on the face plane
        d = DotProduct(p1, facenormal) - facedist;
        if (d < -ON_EPSILON || d > ON_EPSILON)
            Error("CheckWinding: point off plane");
        // check the edge isnt degenerate
        p2 = w->p[j];
        VectorSubtract(p2, p1, dir);
        if (VectorLength(dir) < ON_EPSILON)
            Error("CheckWinding: degenerate edge");
        CrossProduct(facenormal, dir, edgenormal);
        VectorNormalize(edgenormal, edgenormal);
        edgedist = DotProduct(p1, edgenormal);
        edgedist += ON_EPSILON;
        // all other points must be on front side
        for (j = 0; j < w->numpoints; j++) {
            if (j == i)
                continue;
            d = DotProduct(w->p[j], edgenormal);
            if (d > edgedist)
                Error("CheckWinding: non-convex");
        }
    }
}
/*
============
WindingOnPlaneSide
============
*/
int32_t WindingOnPlaneSide(winding_t *w, vec3_t normal, vec_t dist) {
    qboolean front, back;
    int32_t i;
    vec_t d;
    front = false;
    back  = false;
    for (i = 0; i < w->numpoints; i++) {
        d = DotProduct(w->p[i], normal) - dist;
        if (d < -ON_EPSILON) {
            if (front)
                return SIDE_CROSS;
            back = true;
            continue;
        }
        if (d > ON_EPSILON) {
            if (back)
                return SIDE_CROSS;
            front = true;
            continue;
        }
    }
    if (back)
        return SIDE_BACK;
    if (front)
        return SIDE_FRONT;
    return SIDE_ON;
}

/*
        mdfour.c
        An implementation of MD4 designed for use in the samba SMB
        authentication protocol
        Copyright (C) 1997-1998  Andrew Tridgell
        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.
        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
        See the GNU General Public License for more details.
        You should have received a copy of the GNU General Public License
        along with this program; if not, write to:
                Free Software Foundation, Inc.
                59 Temple Place - Suite 330
                Boston, MA  02111-1307, USA
*/
#include <stdint.h>
#include <string.h> /* XoXus: needed for memset call */
#include "mdfour.h"
/* NOTE: This code makes no attempt to be fast!
   It assumes that a int32_t is at least 32 bits long
*/
static struct mdfour *m;
#define F(X, Y, Z) (((X) & (Y)) | ((~(X)) & (Z)))
#define G(X, Y, Z) (((X) & (Y)) | ((X) & (Z)) | ((Y) & (Z)))
#define H(X, Y, Z) ((X) ^ (Y) ^ (Z))
#ifdef LARGE_INT32
#define lshift(x, s) ((((x) << (s)) & 0xFFFFFFFF) | (((x) >> (32 - (s))) & 0xFFFFFFFF))
#else
#define lshift(x, s) (((x) << (s)) | ((x) >> (32 - (s))))
#endif
#define ROUND1(a, b, c, d, k, s) a = lshift(a + F(b, c, d) + X[k], s)
#define ROUND2(a, b, c, d, k, s) a = lshift(a + G(b, c, d) + X[k] + 0x5A827999, s)
#define ROUND3(a, b, c, d, k, s) a = lshift(a + H(b, c, d) + X[k] + 0x6ED9EBA1, s)
/* this applies md4 to 64 byte chunks */
static void mdfour64(uint32_t *M) {
    int32_t j;
    uint32_t AA, BB, CC, DD;
    uint32_t X[16];
    uint32_t A, B, C, D;
    for (j = 0; j < 16; j++)
        X[j] = M[j];
    A  = m->A;
    B  = m->B;
    C  = m->C;
    D  = m->D;
    AA = A;
    BB = B;
    CC = C;
    DD = D;
    ROUND1(A, B, C, D, 0, 3);
    ROUND1(D, A, B, C, 1, 7);
    ROUND1(C, D, A, B, 2, 11);
    ROUND1(B, C, D, A, 3, 19);
    ROUND1(A, B, C, D, 4, 3);
    ROUND1(D, A, B, C, 5, 7);
    ROUND1(C, D, A, B, 6, 11);
    ROUND1(B, C, D, A, 7, 19);
    ROUND1(A, B, C, D, 8, 3);
    ROUND1(D, A, B, C, 9, 7);
    ROUND1(C, D, A, B, 10, 11);
    ROUND1(B, C, D, A, 11, 19);
    ROUND1(A, B, C, D, 12, 3);
    ROUND1(D, A, B, C, 13, 7);
    ROUND1(C, D, A, B, 14, 11);
    ROUND1(B, C, D, A, 15, 19);
    ROUND2(A, B, C, D, 0, 3);
    ROUND2(D, A, B, C, 4, 5);
    ROUND2(C, D, A, B, 8, 9);
    ROUND2(B, C, D, A, 12, 13);
    ROUND2(A, B, C, D, 1, 3);
    ROUND2(D, A, B, C, 5, 5);
    ROUND2(C, D, A, B, 9, 9);
    ROUND2(B, C, D, A, 13, 13);
    ROUND2(A, B, C, D, 2, 3);
    ROUND2(D, A, B, C, 6, 5);
    ROUND2(C, D, A, B, 10, 9);
    ROUND2(B, C, D, A, 14, 13);
    ROUND2(A, B, C, D, 3, 3);
    ROUND2(D, A, B, C, 7, 5);
    ROUND2(C, D, A, B, 11, 9);
    ROUND2(B, C, D, A, 15, 13);
    ROUND3(A, B, C, D, 0, 3);
    ROUND3(D, A, B, C, 8, 9);
    ROUND3(C, D, A, B, 4, 11);
    ROUND3(B, C, D, A, 12, 15);
    ROUND3(A, B, C, D, 2, 3);
    ROUND3(D, A, B, C, 10, 9);
    ROUND3(C, D, A, B, 6, 11);
    ROUND3(B, C, D, A, 14, 15);
    ROUND3(A, B, C, D, 1, 3);
    ROUND3(D, A, B, C, 9, 9);
    ROUND3(C, D, A, B, 5, 11);
    ROUND3(B, C, D, A, 13, 15);
    ROUND3(A, B, C, D, 3, 3);
    ROUND3(D, A, B, C, 11, 9);
    ROUND3(C, D, A, B, 7, 11);
    ROUND3(B, C, D, A, 15, 15);
    A += AA;
    B += BB;
    C += CC;
    D += DD;
#ifdef LARGE_INT32
    A &= 0xFFFFFFFF;
    B &= 0xFFFFFFFF;
    C &= 0xFFFFFFFF;
    D &= 0xFFFFFFFF;
#endif
    for (j = 0; j < 16; j++)
        X[j] = 0;
    m->A = A;
    m->B = B;
    m->C = C;
    m->D = D;
}
static void copy64(uint32_t *M, uint8_t *in) {
    int32_t i;
    for (i = 0; i < 16; i++)
        M[i] = (in[i * 4 + 3] << 24) | (in[i * 4 + 2] << 16) |
               (in[i * 4 + 1] << 8) | (in[i * 4 + 0] << 0);
}
static void copy4(uint8_t *out, uint32_t x) {
    out[0] = x & 0xFF;
    out[1] = (x >> 8) & 0xFF;
    out[2] = (x >> 16) & 0xFF;
    out[3] = (x >> 24) & 0xFF;
}
void mdfour_begin(struct mdfour *md) {
    md->A      = 0x67452301;
    md->B      = 0xefcdab89;
    md->C      = 0x98badcfe;
    md->D      = 0x10325476;
    md->totalN = 0;
}
static void mdfour_tail(uint8_t *in, int32_t n) {
    uint8_t buf[128];
    uint32_t M[16];
    uint32_t b;
    m->totalN += n;
    b = m->totalN * 8;
    memset(buf, 0, 128);
    if (n)
        memcpy(buf, in, n);
    buf[n] = 0x80;
    if (n <= 55) {
        copy4(buf + 56, b);
        copy64(M, buf);
        mdfour64(M);
    } else {
        copy4(buf + 120, b);
        copy64(M, buf);
        mdfour64(M);
        copy64(M, buf + 64);
        mdfour64(M);
    }
}
void mdfour_update(struct mdfour *md, uint8_t *in, int32_t n) {
    uint32_t M[16];
    if (n == 0)
        mdfour_tail(in, n);
    m = md;
    while (n >= 64) {
        copy64(M, in);
        mdfour64(M);
        in += 64;
        n -= 64;
        m->totalN += 64;
    }
    mdfour_tail(in, n);
}
void mdfour_result(struct mdfour *md, uint8_t *out) {
    m = md;
    copy4(out, m->A);
    copy4(out + 4, m->B);
    copy4(out + 8, m->C);
    copy4(out + 12, m->D);
}
void mdfour(uint8_t *out, uint8_t *in, int32_t n) {
    struct mdfour md;
    mdfour_begin(&md);
    mdfour_update(&md, in, n);
    mdfour_result(&md, out);
}
///////////////////////////////////////////////////////////////
//	MD4-based checksum utility functions
//
//	Copyright (C) 2000       Jeff Teunissen <d2deek@pmail.net>
//
//	Author: Jeff Teunissen	<d2deek@pmail.net>
//	Date: 01 Jan 2000
unsigned Com_BlockChecksum(void *buffer, int32_t length) {
    int32_t digest[4];
    unsigned val;
    mdfour((uint8_t *)digest, (uint8_t *)buffer, length);
    val = digest[0] ^ digest[1] ^ digest[2] ^ digest[3];
    return val;
}
void Com_BlockFullChecksum(void *buffer, int32_t len, uint8_t *outbuf) {
    mdfour(outbuf, (uint8_t *)buffer, len);
}

/*
===========================================================================
Copyright (C) 1997-2006 Id Software, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
===========================================================================
*/
// mathlib.c -- math primitives
#include "cmdlib.h"
#include "mathlib.h"
vec3_t vec3_origin = {0, 0, 0};
// qb: inline math from AA tools
#ifndef MATH_INLINE
double VectorLength(vec3_t v) {
    int32_t i;
    double length;
    length = 0;
    for (i = 0; i < 3; i++)
        length += v[i] * v[i];
    length = sqrt(length); // FIXME
    return length;
}
qboolean VectorCompare(vec3_t v1, vec3_t v2) {
    int32_t i;
    for (i = 0; i < 3; i++)
        if (fabs(v1[i] - v2[i]) > EQUAL_EPSILON)
            return false;
    return true;
}
vec_t Q_rint(vec_t in) {
    return floor(in + 0.5);
}
void VectorMA(vec3_t va, double scale, vec3_t vb, vec3_t vc) {
    vc[0] = va[0] + scale * vb[0];
    vc[1] = va[1] + scale * vb[1];
    vc[2] = va[2] + scale * vb[2];
}
void CrossProduct(vec3_t v1, vec3_t v2, vec3_t cross) {
    cross[0] = v1[1] * v2[2] - v1[2] * v2[1];
    cross[1] = v1[2] * v2[0] - v1[0] * v2[2];
    cross[2] = v1[0] * v2[1] - v1[1] * v2[0];
}
vec_t _DotProduct(vec3_t v1, vec3_t v2) {
    return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
}
void _VectorSubtract(vec3_t va, vec3_t vb, vec3_t out) {
    out[0] = va[0] - vb[0];
    out[1] = va[1] - vb[1];
    out[2] = va[2] - vb[2];
}
void _VectorAdd(vec3_t va, vec3_t vb, vec3_t out) {
    out[0] = va[0] + vb[0];
    out[1] = va[1] + vb[1];
    out[2] = va[2] + vb[2];
}
void _VectorCopy(vec3_t in, vec3_t out) {
    out[0] = in[0];
    out[1] = in[1];
    out[2] = in[2];
}
void _VectorScale(vec3_t v, vec_t scale, vec3_t out) {
    out[0] = v[0] * scale;
    out[1] = v[1] * scale;
    out[2] = v[2] * scale;
}
vec_t VectorNormalize(vec3_t in, vec3_t out) {
    vec_t length, ilength;
    length = sqrt(in[0] * in[0] + in[1] * in[1] + in[2] * in[2]);
    if (length == 0) {
        VectorClear(out);
        return 0;
    }
    ilength = 1.0 / length;
    out[0]  = in[0] * ilength;
    out[1]  = in[1] * ilength;
    out[2]  = in[2] * ilength;
    return length;
}
vec_t ColorNormalize(vec3_t in, vec3_t out) {
    float max, scale;
    max = in[0];
    if (in[1] > max)
        max = in[1];
    if (in[2] > max)
        max = in[2];
    if (max == 0)
        return 0;
    scale = 1.0 / max;
    VectorScale(in, scale, out);
    return max;
}
void VectorInverse(vec3_t v) {
    v[0] = -v[0];
    v[1] = -v[1];
    v[2] = -v[2];
}
void ClearBounds(vec3_t mins, vec3_t maxs) {
    mins[0] = mins[1] = mins[2] = BOGUS_RANGE;
    maxs[0] = maxs[1] = maxs[2] = -BOGUS_RANGE;
}
void AddPointToBounds(vec3_t v, vec3_t mins, vec3_t maxs) {
    int32_t i;
    vec_t val;
    for (i = 0; i < 3; i++) {
        val = v[i];
        if (val < mins[i])
            mins[i] = val;
        if (val > maxs[i])
            maxs[i] = val;
    }
}
// qb: from AA tools
qboolean RayPlaneIntersect(vec3_t p_n, vec_t p_d, vec3_t l_o, vec3_t l_n,
                           vec3_t res) {
    float dot, t;
    dot = DotProduct(p_n, l_n);
    if (dot > -0.001)
        return false;
    t      = (p_d - (l_o[0] * p_n[0]) - (l_o[1] * p_n[1]) - (l_o[2] * p_n[2])) / dot;
    res[0] = l_o[0] + (t * l_n[0]);
    res[1] = l_o[1] + (t * l_n[1]);
    res[2] = l_o[2] + (t * l_n[2]);
    return true;
}
#endif

//
// llwolib.c: library for loading triangles from a Lightwave triangle file
//
#include <stdio.h>
#include "cmdlib.h"
#include "mathlib.h"
#include "4data.h"
#define MAXPOINTS 2000
#define MAXPOLYS  2000
struct {
    float p[3];
} pnt[MAXPOINTS];
struct {
    short pl[3];
} ply[MAXPOLYS];
char trashcan[10000];
char buffer[1000];
long counter;
union {
    char c[4];
    float f;
    long l;
} buffer4;
union {
    char c[2];
    short i;
} buffer2;
FILE *lwo;
short numpoints, numpolys;
long lflip(long x) {
    union {
        char b[4];
        long l;
    } in, out;
    in.l     = x;
    out.b[0] = in.b[3];
    out.b[1] = in.b[2];
    out.b[2] = in.b[1];
    out.b[3] = in.b[0];
    return out.l;
}
float fflip(float x) {
    union {
        char b[4];
        float l;
    } in, out;
    in.l     = x;
    out.b[0] = in.b[3];
    out.b[1] = in.b[2];
    out.b[2] = in.b[1];
    out.b[3] = in.b[0];
    return out.l;
}
int sflip(short x) {
    union {
        char b[2];
        short i;
    } in, out;
    in.i     = x;
    out.b[0] = in.b[1];
    out.b[1] = in.b[0];
    return out.i;
}
void skipchunk() {
    long chunksize;
    fread(buffer4.c, 4, 1, lwo);
    counter -= 8;
    chunksize = lflip(buffer4.l);
    fread(trashcan, chunksize, 1, lwo);
    counter -= chunksize;
};
void getpoints() {
    long chunksize;
    short i, j;
    fread(buffer4.c, 4, 1, lwo);
    counter -= 8;
    chunksize = lflip(buffer4.l);
    counter -= chunksize;
    numpoints = chunksize / 12;
    if (numpoints > MAXPOINTS) {
        fprintf(stderr, "reader: Too many points!!!");
        exit(0);
    }
    for (i = 0; i < numpoints; i++) {
        for (j = 0; j < 3; j++) {
            fread(buffer4.c, 4, 1, lwo);
            pnt[i].p[j] = fflip(buffer4.f);
        }
    }
}
void getpolys() {
    short temp, i, j;
    short polypoints;
    long chunksize;
    fread(buffer4.c, 4, 1, lwo);
    counter -= 8;
    chunksize = lflip(buffer4.l);
    counter -= chunksize;
    numpolys = 0;
    for (i = 0; i < chunksize;) {
        fread(buffer2.c, 2, 1, lwo);
        polypoints = sflip(buffer2.i);
        if (polypoints != 3) {
            fprintf(stderr, "reader: Not a triangle!!!");
            exit(0);
        }
        i += 10;
        for (j = 0; j < 3; j++) {
            fread(buffer2.c, 2, 1, lwo);
            temp                = sflip(buffer2.i);
            ply[numpolys].pl[j] = temp;
        }
        fread(buffer2.c, 2, 1, lwo);
        numpolys++;
        if (numpolys > MAXPOLYS) {
            fprintf(stderr, "reader: Too many polygons!!!\n");
            exit(0);
        }
    }
}
void LoadLWOTriangleList(char *filename, triangle_t **pptri, int32_t *numtriangles) {
    int32_t i, j;
    triangle_t *ptri;
    if ((lwo = fopen(filename, "rb")) == 0) {
        fprintf(stderr, "reader: could not open file '%s'\n", filename);
        exit(0);
    }
    fread(buffer4.c, 4, 1, lwo);
    fread(buffer4.c, 4, 1, lwo);
    counter = lflip(buffer4.l) - 4;
    fread(buffer4.c, 4, 1, lwo);
    while (counter > 0) {
        fread(buffer4.c, 4, 1, lwo);
        if (!strncmp(buffer4.c, "PNTS", 4)) {
            getpoints();
        } else {
            if (!strncmp(buffer4.c, "POLS", 4)) {
                getpolys();
            } else {
                skipchunk();
            }
        }
    }
    fclose(lwo);
    ptri   = malloc(MAXTRIANGLES * sizeof(triangle_t));
    *pptri = ptri;
    for (i = 0; i < numpolys; i++) {
        for (j = 0; j < 3; j++) {
            ptri[i].verts[j][0] = pnt[ply[i].pl[j]].p[0];
            ptri[i].verts[j][1] = pnt[ply[i].pl[j]].p[2];
            ptri[i].verts[j][2] = pnt[ply[i].pl[j]].p[1];
        }
    }
    *numtriangles = numpolys;
}

/*
===========================================================================
Copyright (C) 1997-2006 Id Software, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
===========================================================================
*/
// lbmlib.c
#include "cmdlib.h"
#include "lbmlib.h"
/*
============================================================================
                                                LBM STUFF
============================================================================
*/
typedef uint8_t UBYTE;
// conflicts with windows typedef short			WORD;
typedef uint16_t UWORD;
typedef long LONG;
typedef enum { ms_none, ms_mask, ms_transcolor, ms_lasso } mask_t;
typedef enum { cm_none, cm_rle1 } compress_t;
typedef struct {
  UWORD w, h;
  short x, y;
  UBYTE nPlanes;
  UBYTE masking;
  UBYTE compression;
  UBYTE pad1;
  UWORD transparentColor;
  UBYTE xAspect, yAspect;
  short pageWidth, pageHeight;
} bmhd_t;
extern bmhd_t bmhd; // will be in native byte order
#define FORMID ('F' + ('O' << 8) + ((int32_t)'R' << 16) + ((int32_t)'M' << 24))
#define ILBMID ('I' + ('L' << 8) + ((int32_t)'B' << 16) + ((int32_t)'M' << 24))
#define PBMID ('P' + ('B' << 8) + ((int32_t)'M' << 16) + ((int32_t)' ' << 24))
#define BMHDID ('B' + ('M' << 8) + ((int32_t)'H' << 16) + ((int32_t)'D' << 24))
#define BODYID ('B' + ('O' << 8) + ((int32_t)'D' << 16) + ((int32_t)'Y' << 24))
#define CMAPID ('C' + ('M' << 8) + ((int32_t)'A' << 16) + ((int32_t)'P' << 24))
bmhd_t bmhd;
int32_t Align(int32_t l) {
  if(l & 1)
    return l + 1;
  return l;
}
/*
================
LBMRLEdecompress
Source must be evenly aligned!
================
*/
byte *LBMRLEDecompress(byte *source, byte *unpacked, int32_t bpwidth) {
  int32_t count;
  byte b, rept;
  count = 0;
  do {
    rept = *source++;
    if(rept > 0x80) {
      rept = (rept ^ 0xff) + 2;
      b = *source++;
      memset(unpacked, b, rept);
      unpacked += rept;
    } else if(rept < 0x80) {
      rept++;
      memcpy(unpacked, source, rept);
      unpacked += rept;
      source += rept;
    } else
      rept = 0; // rept of 0x80 is NOP
    count += rept;
  } while(count < bpwidth);
  if(count > bpwidth)
    Error("Decompression exceeded width!\n");
  return source;
}
/*
=================
LoadLBM
=================
*/
void LoadLBM(char *filename, byte **picture, byte **palette) {
  byte *LBMbuffer, *picbuffer, *cmapbuffer;
  int32_t y;
  byte *LBM_P, *LBMEND_P;
  byte *pic_p;
  byte *body_p;
  int32_t formtype, formlength;
  int32_t chunktype, chunklength;
  // qiet compiler warnings
  picbuffer = NULL;
  cmapbuffer = NULL;
  //
  // load the LBM
  //
  LoadFile(filename, (void **)&LBMbuffer);
  //
  // parse the LBM header
  //
  LBM_P = LBMbuffer;
  if(*(int32_t *)LBMbuffer != LittleLong(FORMID))
    Error("No FORM ID at start of file!\n");
  LBM_P += 4;
  formlength = BigLong(*(int32_t *)LBM_P);
  LBM_P += 4;
  LBMEND_P = LBM_P + Align(formlength);
  formtype = LittleLong(*(int32_t *)LBM_P);
  if(formtype != ILBMID && formtype != PBMID)
    Error("Unrecognized form type: %c%c%c%c\n", formtype & 0xff, (formtype >> 8) & 0xff, (formtype >> 16) & 0xff,
          (formtype >> 24) & 0xff);
  LBM_P += 4;
  //
  // parse chunks
  //
  while(LBM_P < LBMEND_P) {
    chunktype = LBM_P[0] + (LBM_P[1] << 8) + (LBM_P[2] << 16) + (LBM_P[3] << 24);
    LBM_P += 4;
    chunklength = LBM_P[3] + (LBM_P[2] << 8) + (LBM_P[1] << 16) + (LBM_P[0] << 24);
    LBM_P += 4;
    switch(chunktype) {
    case BMHDID:
      memcpy(&bmhd, LBM_P, sizeof(bmhd));
      bmhd.w = BigShort(bmhd.w);
      bmhd.h = BigShort(bmhd.h);
      bmhd.x = BigShort(bmhd.x);
      bmhd.y = BigShort(bmhd.y);
      bmhd.pageWidth = BigShort(bmhd.pageWidth);
      bmhd.pageHeight = BigShort(bmhd.pageHeight);
      break;
    case CMAPID:
      cmapbuffer = malloc(768);
      memset(cmapbuffer, 0, 768);
      memcpy(cmapbuffer, LBM_P, chunklength);
      break;
    case BODYID:
      body_p = LBM_P;
      pic_p = picbuffer = malloc(bmhd.w * bmhd.h);
      if(formtype == PBMID) {
        //
        // unpack PBM
        //
        for(y = 0; y < bmhd.h; y++, pic_p += bmhd.w) {
          if(bmhd.compression == cm_rle1)
            body_p = LBMRLEDecompress((byte *)body_p, pic_p, bmhd.w);
          else if(bmhd.compression == cm_none) {
            memcpy(pic_p, body_p, bmhd.w);
            body_p += Align(bmhd.w);
          }
        }
      } else {
        //
        // unpack ILBM
        //
        Error("%s is an interlaced LBM, not packed", filename);
      }
      break;
    }
    LBM_P += Align(chunklength);
  }
  free(LBMbuffer);
  *picture = picbuffer;
  if(palette)
    *palette = cmapbuffer;
}
/*
============================================================================
                                                        WRITE LBM
============================================================================
*/
/*
==============
WriteLBMfile
==============
*/
void WriteLBMfile(char *filename, byte *data, int32_t width, int32_t height, byte *palette) {
  byte *lbm, *lbmptr;
  int32_t *formlength, *bmhdlength, *cmaplength, *bodylength;
  int32_t length;
  bmhd_t basebmhd;
  lbm = lbmptr = malloc(width * height + 1000);
  if(!lbm)
    return; // qb: NULL if width or height is zero.
  //
  // start FORM
  //
  *lbmptr++ = 'F';
  *lbmptr++ = 'O';
  *lbmptr++ = 'R';
  *lbmptr++ = 'M';
  formlength = (int32_t *)lbmptr;
  lbmptr += 4; // leave space for length
  *lbmptr++ = 'P';
  *lbmptr++ = 'B';
  *lbmptr++ = 'M';
  *lbmptr++ = ' ';
  //
  // write BMHD
  //
  *lbmptr++ = 'B';
  *lbmptr++ = 'M';
  *lbmptr++ = 'H';
  *lbmptr++ = 'D';
  bmhdlength = (int32_t *)lbmptr;
  lbmptr += 4; // leave space for length
  memset(&basebmhd, 0, sizeof(basebmhd));
  basebmhd.w = BigShort((short)width);
  basebmhd.h = BigShort((short)height);
  basebmhd.nPlanes = BigShort(8);
  basebmhd.xAspect = BigShort(5);
  basebmhd.yAspect = BigShort(6);
  basebmhd.pageWidth = BigShort((short)width);
  basebmhd.pageHeight = BigShort((short)height);
  memcpy(lbmptr, &basebmhd, sizeof(basebmhd));
  lbmptr += sizeof(basebmhd);
  length = lbmptr - (byte *)bmhdlength - 4;
  *bmhdlength = BigLong(length);
  if(length & 1)
    *lbmptr++ = 0; // pad chunk to even offset
  //
  // write CMAP
  //
  *lbmptr++ = 'C';
  *lbmptr++ = 'M';
  *lbmptr++ = 'A';
  *lbmptr++ = 'P';
  cmaplength = (int32_t *)lbmptr;
  lbmptr += 4; // leave space for length
  memcpy(lbmptr, palette, 768);
  lbmptr += 768;
  length = lbmptr - (byte *)cmaplength - 4;
  *cmaplength = BigLong(length);
  if(length & 1)
    *lbmptr++ = 0; // pad chunk to even offset
  //
  // write BODY
  //
  *lbmptr++ = 'B';
  *lbmptr++ = 'O';
  *lbmptr++ = 'D';
  *lbmptr++ = 'Y';
  bodylength = (int32_t *)lbmptr;
  lbmptr += 4; // leave space for length
  memcpy(lbmptr, data, width * height);
  lbmptr += width * height;
  length = lbmptr - (byte *)bodylength - 4;
  *bodylength = BigLong(length);
  if(length & 1)
    *lbmptr++ = 0; // pad chunk to even offset
  //
  // done
  //
  length = lbmptr - (byte *)formlength - 4;
  *formlength = BigLong(length);
  if(length & 1)
    *lbmptr++ = 0; // pad chunk to even offset
  //
  // write output file
  //
  SaveFile(filename, lbm, lbmptr - lbm);
  free(lbm);
}
/*
============================================================================
LOAD PCX
============================================================================
*/
typedef struct {
  char manufacturer;
  char version;
  char encoding;
  char bits_per_pixel;
  uint16_t xmin, ymin, xmax, ymax;
  uint16_t hres, vres;
  uint8_t palette[48];
  char reserved;
  char color_planes;
  uint16_t bytes_per_line;
  uint16_t palette_type;
  char filler[58];
  uint8_t data; // unbounded
} pcx_t;
/*
==============
LoadPCX
==============
*/
void LoadPCX(char *filename, byte **pic, byte **palette, int32_t *width, int32_t *height) {
  byte *raw;
  pcx_t *pcx;
  int32_t x, y;
  int32_t len;
  int32_t dataByte, runLength;
  byte *out, *pix;
  //
  // load the file
  //
  len = LoadFile(filename, (void **)&raw);
  //
  // parse the PCX file
  //
  pcx = (pcx_t *)raw;
  raw = &pcx->data;
  pcx->xmin = LittleShort(pcx->xmin);
  pcx->ymin = LittleShort(pcx->ymin);
  pcx->xmax = LittleShort(pcx->xmax);
  pcx->ymax = LittleShort(pcx->ymax);
  pcx->hres = LittleShort(pcx->hres);
  pcx->vres = LittleShort(pcx->vres);
  pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
  pcx->palette_type = LittleShort(pcx->palette_type);
  if(pcx->manufacturer != 0x0a || pcx->version != 5 || pcx->encoding != 1 || pcx->bits_per_pixel != 8 ||
     pcx->xmax >= 640 || pcx->ymax >= 480)
    Error("Bad pcx file %s", filename);
  if(palette) {
    *palette = malloc(768);
    memcpy(*palette, (byte *)pcx + len - 768, 768);
  }
  if(width)
    *width = pcx->xmax + 1;
  if(height)
    *height = pcx->ymax + 1;
  if(!pic)
    return;
  out = malloc((pcx->ymax + 1) * (pcx->xmax + 1));
  if(!out)
    Error("Skin_Cache: couldn't allocate");
  *pic = out;
  pix = out;
  for(y = 0; y <= pcx->ymax; y++, pix += pcx->xmax + 1) {
    for(x = 0; x <= pcx->xmax;) {
      dataByte = *raw++;
      if((dataByte & 0xC0) == 0xC0) {
        runLength = dataByte & 0x3F;
        dataByte = *raw++;
      } else
        runLength = 1;
      while(runLength-- > 0)
        pix[x++] = dataByte;
    }
  }
  if(raw - (byte *)pcx > len)
    Error("PCX file %s was malformed", filename);
  free(pcx);
}
/*
==============
WritePCXfile
==============
*/
void WritePCXfile(char *filename, byte *data, int32_t width, int32_t height, byte *palette) {
  int32_t i, j, length;
  pcx_t *pcx;
  byte *pack;
  pcx = malloc(width * height * 2 + 1000);
  memset(pcx, 0, sizeof(*pcx));
  pcx->manufacturer = 0x0a; // PCX id
  pcx->version = 5;         // 256 color
  pcx->encoding = 1;        // uncompressed
  pcx->bits_per_pixel = 8;  // 256 color
  pcx->xmin = 0;
  pcx->ymin = 0;
  pcx->xmax = LittleShort((short)(width - 1));
  pcx->ymax = LittleShort((short)(height - 1));
  pcx->hres = LittleShort((short)width);
  pcx->vres = LittleShort((short)height);
  pcx->color_planes = 1; // chunky image
  pcx->bytes_per_line = LittleShort((short)width);
  pcx->palette_type = LittleShort(2); // not a grey scale
  // pack the image
  pack = &pcx->data;
  for(i = 0; i < height; i++) {
    for(j = 0; j < width; j++) {
      if((*data & 0xc0) != 0xc0)
        *pack++ = *data++;
      else {
        *pack++ = 0xc1;
        *pack++ = *data++;
      }
    }
  }
  // write the palette
  *pack++ = 0x0c; // palette ID byte
  for(i = 0; i < 768; i++)
    *pack++ = *palette++;
  // write output file
  length = pack - (byte *)pcx;
  SaveFile(filename, pcx, length);
  free(pcx);
}
/*
============================================================================
LOAD IMAGE
============================================================================
*/
/*
==============
Load256Image
Will load either an lbm or pcx, depending on extension.
Any of the return pointers can be NULL if you don't want them.
==============
*/
void Load256Image(char *name, byte **pixels, byte **palette, int32_t *width, int32_t *height) {
  char ext[128];
  ExtractFileExtension(name, ext);
  if(!Q_strcasecmp(ext, "lbm")) {
    LoadLBM(name, pixels, palette);
    if(width)
      *width = bmhd.w;
    if(height)
      *height = bmhd.h;
  } else if(!Q_strcasecmp(ext, "pcx")) {
    LoadPCX(name, pixels, palette, width, height);
  } else
    Error("%s doesn't have a known image extension", name);
}
/*
==============
Save256Image
Will save either an lbm or pcx, depending on extension.
==============
*/
void Save256Image(char *name, byte *pixels, byte *palette, int32_t width, int32_t height) {
  char ext[128];
  ExtractFileExtension(name, ext);
  if(!Q_strcasecmp(ext, "lbm")) {
    WriteLBMfile(name, pixels, width, height, palette);
  } else if(!Q_strcasecmp(ext, "pcx")) {
    WritePCXfile(name, pixels, width, height, palette);
  } else
    Error("%s doesn't have a known image extension", name);
}
/*
============================================================================
TARGA IMAGE
============================================================================
*/
typedef struct _TargaHeader {
  uint8_t id_length, colormap_type, image_type;
  uint16_t colormap_index, colormap_length;
  uint8_t colormap_size;
  uint16_t x_origin, y_origin, width, height;
  uint8_t pixel_size, attributes;
} TargaHeader;
int32_t fgetLittleShort(FILE *f) {
  byte b1, b2;
  b1 = fgetc(f);
  b2 = fgetc(f);
  return (short)(b1 + b2 * 256);
}
int32_t fgetLittleLong(FILE *f) {
  byte b1, b2, b3, b4;
  b1 = fgetc(f);
  b2 = fgetc(f);
  b3 = fgetc(f);
  b4 = fgetc(f);
  return b1 + (b2 << 8) + (b3 << 16) + (b4 << 24);
}
/*
=============
LoadTGA
=============
*/
void LoadTGA(char *name, byte **pixels, int32_t *width, int32_t *height) {
  int32_t columns, rows, numPixels;
  byte *pixbuf;
  int32_t row, column;
  FILE *fin;
  byte *targa_rgba;
  TargaHeader targa_header;
  fin = fopen(name, "rb");
  if(!fin)
    Error("Couldn't read %s", name);
  targa_header.id_length = fgetc(fin);
  targa_header.colormap_type = fgetc(fin);
  targa_header.image_type = fgetc(fin);
  targa_header.colormap_index = fgetLittleShort(fin);
  targa_header.colormap_length = fgetLittleShort(fin);
  targa_header.colormap_size = fgetc(fin);
  targa_header.x_origin = fgetLittleShort(fin);
  targa_header.y_origin = fgetLittleShort(fin);
  targa_header.width = fgetLittleShort(fin);
  targa_header.height = fgetLittleShort(fin);
  targa_header.pixel_size = fgetc(fin);
  targa_header.attributes = fgetc(fin);
  if(targa_header.image_type != 2 && targa_header.image_type != 10)
    Error("LoadTGA %s: Only type 2 and 10 targa RGB images supported\n", name);
  if(targa_header.colormap_type != 0 || (targa_header.pixel_size != 32 && targa_header.pixel_size != 24))
    Error("LoadTGA %s: Only 32 or 24 bit images supported (no colormaps)\n", name);
  columns = targa_header.width;
  rows = targa_header.height;
  numPixels = columns * rows;
  if(width)
    *width = columns;
  if(height)
    *height = rows;
  targa_rgba = malloc(numPixels * 4);
  *pixels = targa_rgba;
  if(targa_header.id_length != 0)
    fseek(fin, targa_header.id_length, SEEK_CUR); // skip TARGA image comment
  if(targa_header.image_type == 2) { // Uncompressed, RGB images
    for(row = rows - 1; row >= 0; row--) {
      pixbuf = targa_rgba + row * columns * 4;
      for(column = 0; column < columns; column++) {
        uint8_t red, green, blue, alphabyte;
        switch(targa_header.pixel_size) {
        case 24:
          blue = getc(fin);
          green = getc(fin);
          red = getc(fin);
          *pixbuf++ = red;
          *pixbuf++ = green;
          *pixbuf++ = blue;
          *pixbuf++ = 255;
          break;
        case 32:
          blue = getc(fin);
          green = getc(fin);
          red = getc(fin);
          alphabyte = getc(fin);
          *pixbuf++ = red;
          *pixbuf++ = green;
          *pixbuf++ = blue;
          *pixbuf++ = alphabyte;
          break;
        }
      }
    }
  } else if(targa_header.image_type == 10) { // Runlength encoded RGB images
                                             // qb: set defaults. from AAtools
    uint8_t red = 255, green = 255, blue = 255, alphabyte = 255, packetHeader, packetSize, j;
    for(row = rows - 1; row >= 0; row--) {
      pixbuf = targa_rgba + row * columns * 4;
      for(column = 0; column < columns;) {
        packetHeader = getc(fin);
        packetSize = 1 + (packetHeader & 0x7f);
        if(packetHeader & 0x80) { // run-length packet
          switch(targa_header.pixel_size) {
          case 24:
            blue = getc(fin);
            green = getc(fin);
            red = getc(fin);
            alphabyte = 255;
            break;
          case 32:
            blue = getc(fin);
            green = getc(fin);
            red = getc(fin);
            alphabyte = getc(fin);
            break;
          }
          for(j = 0; j < packetSize; j++) {
            *pixbuf++ = red;
            *pixbuf++ = green;
            *pixbuf++ = blue;
            *pixbuf++ = alphabyte;
            column++;
            if(column == columns) { // run spans across rows
              column = 0;
              if(row > 0)
                row--;
              else
                goto breakOut;
              pixbuf = targa_rgba + row * columns * 4;
            }
          }
        } else { // non run-length packet
          for(j = 0; j < packetSize; j++) {
            switch(targa_header.pixel_size) {
            case 24:
              blue = getc(fin);
              green = getc(fin);
              red = getc(fin);
              *pixbuf++ = red;
              *pixbuf++ = green;
              *pixbuf++ = blue;
              *pixbuf++ = 255;
              break;
            case 32:
              blue = getc(fin);
              green = getc(fin);
              red = getc(fin);
              alphabyte = getc(fin);
              *pixbuf++ = red;
              *pixbuf++ = green;
              *pixbuf++ = blue;
              *pixbuf++ = alphabyte;
              break;
            }
            column++;
            if(column == columns) { // pixel packet run spans across rows
              column = 0;
              if(row > 0)
                row--;
              else
                goto breakOut;
              pixbuf = targa_rgba + row * columns * 4;
            }
          }
        }
      }
    breakOut:;
    }
  }
  fclose(fin);
}

/*
===========================================================================
Copyright (C) 1997-2006 Id Software, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
===========================================================================
*/
//
// l3dslib.c: library for loading triangles from an Alias triangle file
//
#include <stdio.h>
#include "cmdlib.h"
#include "mathlib.h"
#include "4data.h"
#define MAIN3DS     0x4D4D
#define EDIT3DS     0x3D3D // this is the start of the editor config
#define EDIT_OBJECT 0x4000
#define OBJ_TRIMESH 0x4100
#define TRI_VERTEXL 0x4110
#define TRI_FACEL1  0x4120
#define MAXVERTS    2000
typedef struct {
    int32_t v[4];
} tri;
float fverts[MAXVERTS][3];
tri tris[MAXTRIANGLES];
int32_t bytesread, level, numtris, totaltris;
int32_t vertsfound, trisfound;
triangle_t *ptri;
// Alias stores triangles as 3 explicit vertices in .tri files, so even though we
// start out with a vertex pool and vertex indices for triangles, we have to convert
// to raw, explicit triangles
void StoreAliasTriangles(void) {
    int32_t i, j, k;
    if ((totaltris + numtris) > MAXTRIANGLES)
        Error("Error: Too many triangles");
    for (i = 0; i < numtris; i++) {
        for (j = 0; j < 3; j++) {
            for (k = 0; k < 3; k++) {
                ptri[i + totaltris].verts[j][k] = fverts[tris[i].v[j]][k];
            }
        }
    }
    totaltris += numtris;
    numtris    = 0;
    vertsfound = 0;
    trisfound  = 0;
}
int32_t ParseVertexL(FILE *input) {
    int32_t i, j, startbytesread, numverts;
    uint16_t tshort;
    if (vertsfound)
        Error("Error: Multiple vertex chunks");
    vertsfound     = 1;
    startbytesread = bytesread;
    if (feof(input))
        Error("Error: unexpected end of file");
    fread(&tshort, sizeof(tshort), 1, input);
    bytesread += sizeof(tshort);
    numverts = (int32_t)tshort;
    if (numverts > MAXVERTS)
        Error("Error: Too many vertices");
    for (i = 0; i < numverts; i++) {
        for (j = 0; j < 3; j++) {
            if (feof(input))
                Error("Error: unexpected end of file");
            fread(&fverts[i][j], sizeof(float), 1, input);
            bytesread += sizeof(float);
        }
    }
    if (vertsfound && trisfound)
        StoreAliasTriangles();
    return bytesread - startbytesread;
}
int32_t ParseFaceL1(FILE *input) {
    int32_t i, j, startbytesread;
    uint16_t tshort;
    if (trisfound)
        Error("Error: Multiple face chunks");
    trisfound      = 1;
    startbytesread = bytesread;
    if (feof(input))
        Error("Error: unexpected end of file");
    fread(&tshort, sizeof(tshort), 1, input);
    bytesread += sizeof(tshort);
    numtris = (int32_t)tshort;
    if (numtris > MAXTRIANGLES)
        Error("Error: Too many triangles");
    for (i = 0; i < numtris; i++) {
        for (j = 0; j < 4; j++) {
            if (feof(input))
                Error("Error: unexpected end of file");
            fread(&tshort, sizeof(tshort), 1, input);
            bytesread += sizeof(tshort);
            tris[i].v[j] = (int32_t)tshort;
        }
    }
    if (vertsfound && trisfound)
        StoreAliasTriangles();
    return bytesread - startbytesread;
}
int32_t ParseChunk(FILE *input) {
#define CHUNK_SIZE 4096
    char temp[CHUNK_SIZE];
    uint16_t type;
    int32_t i, length, w, t, retval;
    level++;
    retval = 0;
    // chunk type
    if (feof(input))
        Error("Error: unexpected end of file");
    fread(&type, sizeof(type), 1, input);
    bytesread += sizeof(type);
    // chunk length
    if (feof(input))
        Error("Error: unexpected end of file");
    fread(&length, sizeof(length), 1, input);
    bytesread += sizeof(length);
    w = length - 6;
    // process chunk if we care about it, otherwise skip it
    switch (type) {
    case TRI_VERTEXL:
        w -= ParseVertexL(input);
        goto ParseSubchunk;
    case TRI_FACEL1:
        w -= ParseFaceL1(input);
        goto ParseSubchunk;
    case EDIT_OBJECT:
        // read the name
        i = 0;
        do {
            if (feof(input))
                Error("Error: unexpected end of file");
            fread(&temp[i], 1, 1, input);
            i++;
            w--;
            bytesread++;
        } while (temp[i - 1]);
    case MAIN3DS:
    case OBJ_TRIMESH:
    case EDIT3DS:
        // parse through subchunks
    ParseSubchunk:
        while (w > 0) {
            w -= ParseChunk(input);
        }
        retval = length;
        goto Done;
    default:
        // skip other chunks
        while (w > 0) {
            t = w;
            if (t > CHUNK_SIZE)
                t = CHUNK_SIZE;
            if (feof(input))
                Error("Error: unexpected end of file");
            fread(&temp, t, 1, input);
            bytesread += t;
            w -= t;
        }
        retval = length;
        goto Done;
    }
Done:
    level--;
    return retval;
}
void Load3DSTriangleList(char *filename, triangle_t **pptri, int32_t *numtriangles) {
    FILE *input;
    int16_t tshort;
    bytesread  = 0;
    level      = 0;
    numtris    = 0;
    totaltris  = 0;
    vertsfound = 0;
    trisfound  = 0;
    if ((input = fopen(filename, "rb")) == 0) {
        fprintf(stderr, "reader: could not open file '%s'\n", filename);
        exit(0);
    }
    fread(&tshort, sizeof(tshort), 1, input);
    // should only be MAIN3DS, but some files seem to start with EDIT3DS, with
    // no MAIN3DS
    if ((tshort != MAIN3DS) && (tshort != EDIT3DS)) {
        fprintf(stderr, "File is not a 3DS file.\n");
        exit(0);
    }
    // back to top of file so we can parse the first chunk descriptor
    fseek(input, 0, SEEK_SET);
    ptri   = malloc(MAXTRIANGLES * sizeof(triangle_t));
    *pptri = ptri;
    // parse through looking for the relevant chunk tree (MAIN3DS | EDIT3DS | EDIT_OBJECT |
    // OBJ_TRIMESH | {TRI_VERTEXL, TRI_FACEL1}) and skipping other chunks
    ParseChunk(input);
    if (vertsfound || trisfound)
        Error("Incomplete triangle set");
    *numtriangles = totaltris;
    fclose(input);
    free(ptri); // qb: stop mem leak
}

/*
===========================================================================
Copyright (C) 1997-2006 Id Software, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
===========================================================================
*/
// cmdlib.c
#include "cmdlib.h"
#include <sys/types.h>
#include <sys/stat.h>
#ifdef WIN32
#include <direct.h>
#endif
#ifdef NeXT
#include <libc.h>
#endif
#ifdef __unix__
#include <unistd.h>
#endif
#define PATHSEPERATOR '/'
// set these before calling CheckParm
int32_t myargc;
char **myargv;
char com_token[1024];
qboolean com_eof;
qboolean archive;
char archivedir[1024];
char inbase[32];
char outbase[32];
char source[1024];
/*
===================
ExpandWildcards
Mimic unix command line expansion
===================
*/
#define MAX_EX_ARGC 1024
int32_t ex_argc;
char *ex_argv[MAX_EX_ARGC];
#ifdef _WIN32
#include "io.h"
void ExpandWildcards(int32_t *argc, char ***argv) {
    struct _finddata_t fileinfo;
    int32_t handle;
    int32_t i;
    char filename[1024];
    char filebase[1024];
    char *path;
    ex_argc = 0;
    for (i = 0; i < *argc; i++) {
        path = (*argv)[i];
        if (path[0] == '-' || (!strstr(path, "*") && !strstr(path, "?"))) {
            ex_argv[ex_argc++] = path;
            continue;
        }
        handle = _findfirst(path, &fileinfo);
        if (handle == -1)
            return;
        ExtractFilePath(path, filebase);
        do {
            sprintf(filename, "%s%s", filebase, fileinfo.name);
            ex_argv[ex_argc++] = copystring(filename);
        } while (_findnext(handle, &fileinfo) != -1);
        _findclose(handle);
    }
    *argc = ex_argc;
    *argv = ex_argv;
}
#else
void ExpandWildcards(int32_t *argc, char ***argv) {
}
#endif
#ifdef WIN_ERROR
#include <windows.h>
/*
=================
Error
For abnormal program terminations in windowed apps
=================
*/
void Error(char *error, ...) {
    va_list argptr;
    char text[1024];
    char text2[1024];
    int32_t err;
    err = GetLastError();
    va_start(argptr, error);
    vsprintf(text, error, argptr);
    va_end(argptr);
    sprintf(text2, "%s\nGetLastError() = %i", text, err);
    MessageBox(NULL, text2, "Error", 0 /* MB_OK */);
    exit(1);
}
#else
/*
=================
Error
For abnormal program terminations in console apps
=================
*/
void Error(char *error, ...) {
    va_list argptr;
    printf("\n************ ERROR ************\n");
    va_start(argptr, error);
    vprintf(error, argptr);
    va_end(argptr);
    printf("\n");
    exit(1);
}
#endif
// only qprintf if in verbose mode
qboolean verbose = false;
void qprintf(char *format, ...) {
    va_list argptr;
    if (!verbose)
        return;
    va_start(argptr, format);
    vprintf(format, argptr);
    va_end(argptr);
    fflush(stdout);
}
// qb: similar to AAtools, except basedir defaults to moddir
/*
 * Path determination
 *
 * assumes
 *   moddir is parent of whatever directory contains the .map/.bsp
 *   basedir is moddir
 *   gamedir is parent of moddir
 *   qdir is parent of gamedir
 */
char qdir[1024]    = "";
char gamedir[1024] = "";
char moddir[1024]  = "";
char basedir[1024] = "";
void SetQdirFromPath(char *path) {
    char cwd_map[512];
    char *lastslash;
    memset(cwd_map, 0, sizeof(cwd_map));
    strncpy(cwd_map, path, sizeof(cwd_map) - 1);
#ifdef WIN32
    lastslash = strrchr(cwd_map, '\\');
    // I believe Win32 can use either slash type. -Max
    if (lastslash == NULL)
#endif
        lastslash = strrchr(cwd_map, '/');
    if (lastslash == NULL) {
        // no slashes: CWD
        Q_getwd(cwd_map); // appends path separator
    } else {
        // get rid of everything after last path separator
        lastslash++;
        *lastslash = '\0';
    }
    strcpy(moddir, cwd_map);
#ifdef WIN32
    strcat(moddir, "..\\");
#else
    strcat(moddir, "../");
#endif
    strcpy(basedir, moddir);
    strcpy(gamedir, moddir);
#ifdef WIN32
    strcat(gamedir, "..\\");
#else
    strcat(gamedir, "../");
#endif
    strcpy(qdir, gamedir);
#ifdef WIN32
    strcat(qdir, "..\\");
#else
    strcat(qdir, "../");
#endif
}
char *ExpandArg(const char *path) {
    static char full[1024];
    if (path[0] != '/' && path[0] != '\\' && path[1] != ':') {
        Q_getwd(full);
        strcat(full, path);
    } else
        strcpy(full, path);
    return full;
}
char *ExpandPath(char *path) {
    static char full[1024];
    if (!qdir[0])
        Error("ExpandPath called without qdir set");
    if (path[0] == '/' || path[0] == '\\' || path[1] == ':')
        return path;
    sprintf(full, "%s%s", qdir, path);
    return full;
}
char *ExpandPathAndArchive(char *path) {
    char *expanded;
    char archivename[2060];
    expanded = ExpandPath(path);
    if (archive) {
        sprintf(archivename, "%s/%s", archivedir, path);
        QCopyFile(expanded, archivename);
    }
    return expanded;
}
char *copystring(char *s) {
    char *b;
    b = malloc(strlen(s) + 1);
    strcpy(b, s);
    return b;
}
/*
================
I_FloatTime
================
*/
double I_FloatTime(void) {
    time_t t;
    time(&t);
    return t;
#if 0
	// more precise, less portable
	struct timeval tp;
	struct timezone tzp;
	static int32_t		secbase;
	gettimeofday(&tp, &tzp);
	if (!secbase)
	{
		secbase = tp.tv_sec;
		return tp.tv_usec / 1000000.0;
	}
	return (tp.tv_sec - secbase) + tp.tv_usec / 1000000.0;
#endif
}
void Q_pathslash(char *out) { // qb: added
    qboolean lastslash;
#ifdef WIN32
    lastslash = (*out && out[strlen(out + 1)] == '\\');
    // I believe Win32 can use either slash type. -Max
    if (!lastslash)
#endif
        lastslash = (*out && out[strlen(out + 1)] == '/');
    if (!lastslash)
#ifdef WIN32
        strcat(out, "\\");
#else
        strcat(out, "/");
#endif
}
void Q_getwd(char *out) {
#ifdef WIN32
    if (!_getcwd(out, 256))
        Error("_getcwd failed");
    strcat(out, "\\");
#else
    if (!getcwd(out, 256)) // qb: was getwd(out)
        Error("getcwd failed");
    strcat(out, "/");
#endif
}
void Q_mkdir(char *path) {
#ifdef WIN32
    if (_mkdir(path) != -1)
        return;
#else
    if (mkdir(path, 0777) != -1)
        return;
#endif
    if (errno != EEXIST)
        Error("mkdir %s: %s", path, strerror(errno));
}
/*
============
FileTime
returns -1 if not present
============
*/
int32_t FileTime(char *path) {
    struct stat buf;
    if (stat(path, &buf) == -1)
        return -1;
    return buf.st_mtime;
}
/*
==============
COM_Parse
Parse a token out of a string
==============
*/
char *COM_Parse(char *data) {
    int32_t c;
    int32_t len;
    len          = 0;
    com_token[0] = 0;
    if (!data)
        return NULL;
    // skip whitespace
skipwhite:
    while ((c = *data) <= ' ') {
        if (c == 0) {
            com_eof = true;
            return NULL; // end of file;
        }
        data++;
    }
    // skip // comments
    if (c == '/' && data[1] == '/') {
        while (*data && *data != '\n')
            data++;
        goto skipwhite;
    }
    // handle quoted strings specially
    if (c == '\"') {
        data++;
        do {
            c = *data++;
            if (c == '\"') {
                com_token[len] = 0;
                return data;
            }
            com_token[len] = c;
            len++;
        } while (1);
    }
    // parse single characters
    if (c == '{' || c == '}' || c == ')' || c == '(' || c == '\'' || c == ':') {
        com_token[len] = c;
        len++;
        com_token[len] = 0;
        return data + 1;
    }
    // parse a regular word
    do {
        com_token[len] = c;
        data++;
        len++;
        c = *data;
        if (c == '{' || c == '}' || c == ')' || c == '(' || c == '\'' || c == ':')
            break;
    } while (c > 32);
    com_token[len] = 0;
    return data;
}
int32_t Q_strncasecmp(char *s1, char *s2, int32_t n) {
    int32_t c1, c2;
    do {
        c1 = *s1++;
        c2 = *s2++;
        if (!n--)
            return 0; // strings are equal until end point
        if (c1 != c2) {
            if (c1 >= 'a' && c1 <= 'z')
                c1 -= ('a' - 'A');
            if (c2 >= 'a' && c2 <= 'z')
                c2 -= ('a' - 'A');
            if (c1 != c2)
                return -1; // strings not equal
        }
    } while (c1);
    return 0; // strings are equal
}
int32_t Q_strcasecmp(char *s1, char *s2) {
    return Q_strncasecmp(s1, s2, 99999);
}
char *strtoupper(char *start) {
    char *in;
    in = start;
    while (*in) {
        *in = toupper(*in);
        in++;
    }
    return start;
}
char *strlower(char *start) {
    char *in;
    in = start;
    while (*in) {
        *in = tolower(*in);
        in++;
    }
    return start;
}
/*
=============================================================================
MISC FUNCTIONS
=============================================================================
*/
/*
=================
CheckParm
Checks for the given parameter in the program's command line arguments
Returns the argument number (1 to argc-1) or 0 if not present
=================
*/
int32_t CheckParm(char *check) {
    int32_t i;
    for (i = 1; i < myargc; i++) {
        if (!Q_strcasecmp(check, myargv[i]))
            return i;
    }
    return 0;
}
/*
================
Q_filelength
================
*/
int32_t Q_filelength(FILE *f) {
    int32_t pos;
    int32_t end;
    pos = ftell(f);
    fseek(f, 0, SEEK_END);
    end = ftell(f);
    fseek(f, pos, SEEK_SET);
    return end;
}
FILE *SafeOpenWrite(char *filename) {
    FILE *f;
    f = fopen(filename, "wb");
    if (!f)
        Error("Error opening %s: %s", filename, strerror(errno));
    return f;
}
FILE *SafeOpenRead(char *filename) {
    FILE *f;
    f = fopen(filename, "rb");
    if (!f)
        Error("Error opening %s: %s", filename, strerror(errno));
    return f;
}
void SafeRead(FILE *f, void *buffer, int32_t count) {
    if (fread(buffer, 1, count, f) != (size_t)count)
        Error("File read failure");
}
void SafeWrite(FILE *f, void *buffer, int32_t count) {
    if (fwrite(buffer, 1, count, f) != (size_t)count)
        Error("File write failure");
}
/*
==============
FileExists
==============
*/
qboolean FileExists(char *filename) {
    FILE *f;
    f = fopen(filename, "r");
    if (!f)
        return false;
    fclose(f);
    return true;
}
/*
==============
LoadFile
==============
*/
int32_t LoadFile(char *filename, void **bufferptr) {
    FILE *f;
    int32_t length;
    void *buffer;
    f                        = SafeOpenRead(filename);
    length                   = Q_filelength(f);
    buffer                   = malloc(length + 1);
    ((char *)buffer)[length] = 0;
    SafeRead(f, buffer, length);
    fclose(f);
    *bufferptr = buffer;
    return length;
}
/*
==============
TryLoadFile
Allows failure
==============
*/
int32_t TryLoadFile(char *filename, void **bufferptr, int32_t print_error) {
    FILE *f;
    int32_t length;
    void *buffer;
    *bufferptr = NULL;
    f          = fopen(filename, "rb");
    if (!f) // qb: print error - GDD tools
    {
        if (print_error)
            printf("  File %s failed to open\n", filename);
        return -1;
    }
    length                   = Q_filelength(f);
    buffer                   = malloc(length + 1);
    ((char *)buffer)[length] = 0;
    SafeRead(f, buffer, length);
    fclose(f);
    *bufferptr = buffer;
    return length;
}
/*
==============
TryLoadFileFromPak  //qb: GDD tools
Allows failure
==============
*/
typedef struct
{
    uint8_t magic[4]; // Name of the new WAD format
    long diroffset;   // Position of WAD directory from start of file
    long dirsize;     // Number of entries * 0x40 (64 char)
    uint8_t bogus[50];
} pakheader_t;
typedef struct
{
    uint8_t filename[0x38]; // Name of the file, Unix style, with extension,
    // 56 chars, padded with '\0'.
    long offset; // Position of the entry in PACK file
    long size;   // Size of the entry in PACK file
} pakentry_t;
int32_t TryLoadFileFromPak(char *filename, void **bufferptr, char *gd) {
    FILE *f;
    int32_t n, i, ret_len;
    long dir_ents;
    void *buffer;
    pakheader_t pak_header;
    pakentry_t *pak_entry;
    char file[1024];
    for (n = 0; filename[n] != 0; n++) {
        if (filename[n] == '\\')
            filename[n] = '/';
    }
    *bufferptr = NULL;
    ret_len    = -1;
    for (n = 0;; n++) {
        if (ret_len != -1)
            break;
        sprintf(file, "%spak%d.pak", gd, n);
        f = fopen(file, "rb");
        if (!f) {
            // if(errno == ENOENT) jit
            return -1;
            continue;
        }
        SafeRead(f, &pak_header, sizeof(pakheader_t));
        dir_ents  = pak_header.dirsize / sizeof(pakentry_t);
        pak_entry = malloc(pak_header.dirsize);
        if (pak_entry != NULL) {
            if (!fseek(f, pak_header.diroffset, SEEK_SET)) {
                memset(pak_entry, 0, pak_header.dirsize);
                SafeRead(f, pak_entry, pak_header.dirsize);
                for (i = 0; i < dir_ents; i++) {
                    for (n = 0; pak_entry[i].filename[n] != 0; n++) {
                        if (pak_entry[i].filename[n] == '\\')
                            pak_entry[i].filename[n] = '/';
                    }
                    if (!Q_strncasecmp((char *)pak_entry[i].filename, filename, 56)) {
                        if (!fseek(f, pak_entry[i].offset, SEEK_SET)) {
                            buffer                              = malloc(pak_entry[i].size + 1);
                            ((char *)buffer)[pak_entry[i].size] = 0;
                            SafeRead(f, buffer, pak_entry[i].size);
                            *bufferptr = buffer;
                            ret_len    = pak_entry[i].size;
                        }
                        break;
                    }
                }
            }
        }
        if (pak_entry != NULL)
            free(pak_entry);
        fclose(f);
    }
    return ret_len;
}
/*
 */
/*
==============
SaveFile
==============
*/
void SaveFile(char *filename, void *buffer, int32_t count) {
    FILE *f;
    f = SafeOpenWrite(filename);
    SafeWrite(f, buffer, count);
    fclose(f);
}
void DefaultExtension(char *path, char *extension) {
    char *src;
    //
    // if path doesnt have a .EXT, append extension
    // (extension should include the .)
    //
    src = path + strlen(path) - 1;
    while (*src != PATHSEPERATOR && src != path) {
        if (*src == '.')
            return; // it has an extension
        src--;
    }
    strcat(path, extension);
}
void DefaultPath(char *path, char *basepath) {
    char temp[128];
    if (path[0] == PATHSEPERATOR)
        return; // absolute path location
    strcpy(temp, path);
    strcpy(path, basepath);
    strcat(path, temp);
}
void StripFilename(char *path) {
    int32_t length;
    length = strlen(path) - 1;
    while (length > 0 && path[length] != PATHSEPERATOR)
        length--;
    path[length] = 0;
}
void StripExtension(char *path) {
    int32_t length;
    length = strlen(path) - 1;
    while (length > 0 && path[length] != '.') {
        length--;
        if (path[length] == '/' || path[length] == '\\')
            return; // no extension
    }
    if (length)
        path[length] = 0;
}
/*
====================
Extract file parts
====================
*/
// FIXME: should include the slash, otherwise
// backing to an empty path will be wrong when appending a slash
void ExtractFilePath(char *path, char *dest) {
    char *src;
    src = path + strlen(path) - 1;
    //
    // back up until a \ or the start
    //
    while (src != path && *(src - 1) != '\\' && *(src - 1) != '/')
        src--;
    memcpy(dest, path, src - path);
    dest[src - path] = 0;
}
void ExtractFileBase(char *path, char *dest) {
    char *src;
    src = path + strlen(path) - 1;
    //
    // back up until a \ or the start
    //
    while (src != path && *(src - 1) != PATHSEPERATOR)
        src--;
    while (*src && *src != '.') {
        *dest++ = *src++;
    }
    *dest = 0;
}
void ExtractFileExtension(char *path, char *dest) {
    char *src;
    src = path + strlen(path) - 1;
    //
    // back up until a . or the start
    //
    while (src != path && *(src - 1) != '.')
        src--;
    if (src == path) {
        *dest = 0; // no extension
        return;
    }
    strcpy(dest, src);
}
/*
==============
ParseNum / ParseHex
==============
*/
int32_t ParseHex(char *hex) {
    char *str;
    int32_t num;
    num = 0;
    str = hex;
    while (*str) {
        num <<= 4;
        if (*str >= '0' && *str <= '9')
            num += *str - '0';
        else if (*str >= 'a' && *str <= 'f')
            num += 10 + *str - 'a';
        else if (*str >= 'A' && *str <= 'F')
            num += 10 + *str - 'A';
        else
            Error("Bad hex number: %s", hex);
        str++;
    }
    return num;
}
int32_t ParseNum(char *str) {
    if (str[0] == '$')
        return ParseHex(str + 1);
    if (str[0] == '0' && str[1] == 'x')
        return ParseHex(str + 2);
    return atol(str);
}
/*
============================================================================
BYTE ORDER FUNCTIONS
============================================================================
*/
#ifdef _SGI_SOURCE
#define __BIG_ENDIAN__
#endif
#ifdef __BIG_ENDIAN__
short LittleShort(short l) {
    byte b1, b2;
    b1 = l & 255;
    b2 = (l >> 8) & 255;
    return (b1 << 8) + b2;
}
short BigShort(short l) {
    return l;
}
int32_t LittleLong(int32_t l) {
    byte b1, b2, b3, b4;
    b1 = l & 255;
    b2 = (l >> 8) & 255;
    b3 = (l >> 16) & 255;
    b4 = (l >> 24) & 255;
    return ((int32_t)b1 << 24) + ((int32_t)b2 << 16) + ((int32_t)b3 << 8) + b4;
}
int32_t BigLong(int32_t l) {
    return l;
}
float LittleFloat(float l) {
    union {
        byte b[4];
        float f;
    } in, out;
    in.f     = l;
    out.b[0] = in.b[3];
    out.b[1] = in.b[2];
    out.b[2] = in.b[1];
    out.b[3] = in.b[0];
    return out.f;
}
float BigFloat(float l) {
    return l;
}
#else
short BigShort(short l) {
    byte b1, b2;
    b1 = l & 255;
    b2 = (l >> 8) & 255;
    return (b1 << 8) + b2;
}
short LittleShort(short l) {
    return l;
}
int32_t BigLong(int32_t l) {
    byte b1, b2, b3, b4;
    b1 = l & 255;
    b2 = (l >> 8) & 255;
    b3 = (l >> 16) & 255;
    b4 = (l >> 24) & 255;
    return ((int32_t)b1 << 24) + ((int32_t)b2 << 16) + ((int32_t)b3 << 8) + b4;
}
int32_t LittleLong(int32_t l) {
    return l;
}
float BigFloat(float l) {
    union {
        byte b[4];
        float f;
    } in, out;
    in.f     = l;
    out.b[0] = in.b[3];
    out.b[1] = in.b[2];
    out.b[2] = in.b[1];
    out.b[3] = in.b[0];
    return out.f;
}
float LittleFloat(float l) {
    return l;
}
#endif
//=======================================================
// FIXME: byte swap?
// this is a 16 bit, non-reflected CRC using the polynomial 0x1021
// and the initial and final xor values shown below...  in other words, the
// CCITT standard CRC used by XMODEM
#define CRC_INIT_VALUE 0xffff
#define CRC_XOR_VALUE  0x0000
static uint16_t crctable[256] =
    {
        0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
        0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
        0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
        0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
        0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
        0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
        0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
        0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
        0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
        0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
        0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
        0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
        0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
        0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
        0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
        0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
        0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
        0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
        0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
        0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
        0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
        0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
        0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
        0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
        0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
        0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
        0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
        0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
        0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
        0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
        0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
        0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0};
void CRC_Init(uint16_t *crcvalue) {
    *crcvalue = CRC_INIT_VALUE;
}
void CRC_ProcessByte(uint16_t *crcvalue, byte data) {
    *crcvalue = (*crcvalue << 8) ^ crctable[(*crcvalue >> 8) ^ data];
}
uint16_t CRC_Value(uint16_t crcvalue) {
    return crcvalue ^ CRC_XOR_VALUE;
}
//=============================================================================
/*
============
CreatePath
============
*/
void CreatePath(char *path) {
    char *ofs, c;
    if (path[1] == ':')
        path += 2;
    for (ofs = path + 1; *ofs; ofs++) {
        c = *ofs;
        if (c == '/' || c == '\\') { // create the directory
            *ofs = 0;
            Q_mkdir(path);
            *ofs = c;
        }
    }
}
/*
============
QCopyFile
Used to archive source files
============
*/
void QCopyFile(char *from, char *to) {
    void *buffer;
    int32_t length;
    length = LoadFile(from, &buffer);
    CreatePath(to);
    SaveFile(to, buffer, length);
    free(buffer);
}