track4.cpp

Go to the documentation of this file.

/***************************************************************************
 
    file                 : track4.cpp
    created              : Sat May 18 12:46:26 CEST 2002
    copyright            : (C) 2002-2026 by Eric Espié, Bernhard Wymann
    email                : berniw@bluewin.ch
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/

 
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <stdarg.h>
#include <limits>
 
#include <tgf.h>
#include <robottools.h>
#include <track.h>
#include <portability.h>
#include "trackinc.h"
 
static tdble   xmin, xmax, ymin, ymax, zmin, zmax;
 
#define TSTX(x) do {                \
    if (xmin > (x)) xmin = (x);         \
    if (xmax < (x)) xmax = (x);         \
    } while (0)
 
#define TSTY(y) do {                \
    if (ymin > (y)) ymin = (y);         \
    if (ymax < (y)) ymax = (y);         \
    } while (0)
 
#define TSTZ(z) do {                \
    if (zmin > (z)) zmin = (z);         \
    if (zmax < (z)) zmax = (z);         \
    } while (0)
 
/*
 * Sides global variables
 */
static const char* SectSide[2] = { TRK_SECT_RSIDE, TRK_SECT_LSIDE };
static const char* SectBorder[2] = { TRK_SECT_RBORDER, TRK_SECT_LBORDER };
static const char* SectBarrier[2] = { TRK_SECT_RBARRIER, TRK_SECT_LBARRIER };
 
static const char* ValStyle[] = { TRK_VAL_PLAN, TRK_VAL_CURB, TRK_VAL_WALL, TRK_VAL_FENCE, TRK_VAL_FENCE }; // TODO: TRK_VAL_FENCE 2 times, remove?
 

static void formatTrackPath(char* buffer, const int size, const char* format, ...)
{
    va_list args;
    int len;
 
    if (size <= 0) {
        GfFatal("Track parameter path buffer has invalid size\n");
        exit(1);
    }
 
    va_start(args, format);
    len = vsnprintf(buffer, size, format, args);
    va_end(args);
 
    if ((len < 0) || (len >= size)) {
        buffer[0] = '\0';
        GfFatal("Track parameter path too long\n");
        exit(1);
    }
}
 
/* track->seg is the final generated segment in the circular ring. */
static tTrackSeg* findFirstSegmentByName(const tTrack* track, const char* name)
{
    tTrackSeg* segment = track->seg->next;
    for (int i = 0; i < track->nseg; i++) {
        if (strcmp(name, segment->name) == 0) {
            return segment;
        }
        segment = segment->next;
    }
    return NULL;
}
 
 
static tTrackSeg* findLastSegmentByName(const tTrack* track, const char* name)
{
    tTrackSeg* segment = track->seg;
    for (int i = 0; i < track->nseg; i++) {
        if (strcmp(name, segment->name) == 0) {
            return segment;
        }
        segment = segment->prev;
    }
    return NULL;
}
 
 
static tdble sideEndWidth[2];
static tdble sideStartWidth[2];
static int sideBankType[2];
static const char* sideMaterial[2];
static tTrackSurface* sideSurface[2];
 
static int envIndex;
 
static tdble borderWidth[2];
static tdble borderHeight[2];
static int borderStyle[2];
static const char* borderMaterial[2];
static tTrackSurface* borderSurface[2];
 
static tdble barrierWidth[2];
static tdble barrierHeight[2];
static int barrierStyle[2];
static const char* barrierMaterial[2];
static tTrackSurface* barrierSurface[2];
 
static tdble   GlobalStepLen = 0;
 
// Function prototypes
static void initSideForTurn(
    const int turntype,
    tTrackSeg* const curBorder,
    const tTrackSeg* const curSeg,
    const int side,
    const int bankingtype,
    const tdble startwidth,
    const tdble endwidth,
    const tdble maxwidth
);
 
static void initSideForStraight(
    tTrackSeg* const curBorder,
    const tTrackSeg* const curSeg,
    const int side,
    const int bankingtype,
    const tdble startwidth,
    const tdble endwidth
);
 
static tTrackSeg* commonSideInit(
    tTrackSeg* const curSeg,
    const int side,
    const int lefttype,
    const int righttype,
    const int bankingtype,
    const tdble startwidth,
    const tdble endwidth,
    tTrackSurface* surface,
    const tdble borderheight,
    const int borderstyle
);
 

static tTrackSurface* getTrackSurface(void* trackHandle, tTrack* theTrack, const char* material)
{
    const int BUFSIZE = 256;
    char path[BUFSIZE];
    tTrackSurface* curSurf;
 
    // Search within existing surfaces
    curSurf = theTrack->surfaces;
    while (curSurf) {
        if (strcmp(curSurf->material, material) == 0) {
            return curSurf;
        }
        curSurf = curSurf->next;
    }
 
    // Create a new surface
    curSurf = (tTrackSurface*)malloc(sizeof(tTrackSurface));
    if (!curSurf) {
        GfFatal("AddTrackSurface: Memory allocation failed\n");
        exit(1);
    }
 
    curSurf->material = material;
    formatTrackPath(path, BUFSIZE, "%s/%s", TRK_SECT_SURFACES, material);
    curSurf->kFriction = GfParmGetNum(trackHandle, path, TRK_ATT_FRICTION, (char*)NULL, 0.8f);
    curSurf->kRollRes = GfParmGetNum(trackHandle, path, TRK_ATT_ROLLRES, (char*)NULL, 0.001f);
    curSurf->kRoughness = GfParmGetNum(trackHandle, path, TRK_ATT_ROUGHT, (char*)NULL, 0.0f) / 2.0f;
    curSurf->kRoughWaveLen = 2.0 * PI / GfParmGetNum(trackHandle, path, TRK_ATT_ROUGHTWL, (char*)NULL, 1.0f);
    curSurf->kDammage = GfParmGetNum(trackHandle, path, TRK_ATT_DAMMAGE, (char*)NULL, 10.0f);
    curSurf->kRebound = GfParmGetNum(trackHandle, path, TRK_ATT_REBOUND, (char*)NULL, 0.5f);
 
    curSurf->next = theTrack->surfaces;
    theTrack->surfaces = curSurf;
 
    return curSurf;
}
 

static void readDefaultSideParameters(void* trackHandle, tTrack* theTrack)
{
    int side;
    const char* style;
    const int BUFSIZE = 256;
    char path[BUFSIZE];
 
    // Side: right and left (see SectSide, SectBorder, SectBarrier)
    for (side = 0; side < 2; side++) {
        // Side parameters
        formatTrackPath(path, BUFSIZE, "%s/%s", TRK_SECT_MAIN, SectSide[side]);
        sideMaterial[side] = GfParmGetStr(trackHandle, path, TRK_ATT_SURF, TRK_VAL_GRASS);
        sideSurface[side] = getTrackSurface(trackHandle, theTrack, sideMaterial[side]);
        sideEndWidth[side] = GfParmGetNum(trackHandle, path, TRK_ATT_WIDTH, (char*)NULL, 0.0);
 
        // Banking of sides
        if (strcmp(TRK_VAL_LEVEL, GfParmGetStr(trackHandle, path, TRK_ATT_BANKTYPE, TRK_VAL_LEVEL)) == 0) {
            sideBankType[side] = 0;
        }
        else {
            sideBankType[side] = 1;
        }
 
        // Border parameters
        formatTrackPath(path, BUFSIZE, "%s/%s", TRK_SECT_MAIN, SectBorder[side]);
        borderMaterial[side] = GfParmGetStr(trackHandle, path, TRK_ATT_SURF, TRK_VAL_GRASS);
        borderSurface[side] = getTrackSurface(trackHandle, theTrack, borderMaterial[side]);
        borderWidth[side] = GfParmGetNum(trackHandle, path, TRK_ATT_WIDTH, (char*)NULL, 0.0);
        borderHeight[side] = GfParmGetNum(trackHandle, path, TRK_ATT_HEIGHT, (char*)NULL, 0.0);
        style = GfParmGetStr(trackHandle, path, TRK_ATT_STYLE, TRK_VAL_PLAN);
 
        if (strcmp(style, TRK_VAL_PLAN) == 0) {
            borderStyle[side] = TR_PLAN;
        }
        else if (strcmp(style, TRK_VAL_CURB) == 0) {
            borderStyle[side] = TR_CURB;
        }
        else {
            borderStyle[side] = TR_WALL;
        }
 
        // Barrier parameters
        formatTrackPath(path, BUFSIZE, "%s/%s", TRK_SECT_MAIN, SectBarrier[side]);
        barrierMaterial[side] = GfParmGetStr(trackHandle, path, TRK_ATT_SURF, TRK_VAL_BARRIER);
        barrierSurface[side] = getTrackSurface(trackHandle, theTrack, barrierMaterial[side]);
        barrierHeight[side] = GfParmGetNum(trackHandle, path, TRK_ATT_HEIGHT, (char*)NULL, 0.6f);
        style = GfParmGetStr(trackHandle, path, TRK_ATT_STYLE, TRK_VAL_FENCE);
        if (strcmp(style, TRK_VAL_FENCE) == 0) {
            barrierStyle[side] = TR_FENCE;
            barrierWidth[side] = 0;
        }
        else {
            barrierStyle[side] = TR_WALL;
            barrierWidth[side] = GfParmGetNum(trackHandle, path, TRK_ATT_WIDTH, (char*)NULL, 0.5);
        }
    }
}
 

static void addSides(tTrackSeg* curSeg, void* trackHandle, tTrack* theTrack, int curStep, int steps)
{
    tTrackSeg* mSeg;
    tTrackBarrier* curBarrier;
    tdble w, sw, ew, bw;
    int side;
    const char* style;
    tdble Kew;
    const int BUFSIZE = 256;
    char path[BUFSIZE];
    char path2[BUFSIZE];
    char* segName;
 
    mSeg = curSeg;
 
    formatTrackPath(path, BUFSIZE, "%s/%s", TRK_SECT_MAIN, TRK_LST_SEGMENTS);
    segName = GfParmListGetCurEltName(trackHandle, path);
    formatTrackPath(path, BUFSIZE, "%s/%s/%s", TRK_SECT_MAIN, TRK_LST_SEGMENTS, segName);
 
    for (side = 0; side < 2; side++) {
        curSeg = mSeg;
 
        if (curStep == 0) {
            // Initialize on the first step
            // Side parameters
            formatTrackPath(path2, BUFSIZE, "%s/%s", path, SectSide[side]);
            sw = GfParmGetNum(trackHandle, path2, TRK_ATT_SWIDTH, (char*)NULL, sideEndWidth[side]);
            w = GfParmGetNum(trackHandle, path2, TRK_ATT_WIDTH, (char*)NULL, sw);
            ew = GfParmGetNum(trackHandle, path2, TRK_ATT_EWIDTH, (char*)NULL, w);
 
            sideStartWidth[side] = sw;
            sideEndWidth[side] = ew;
            sideMaterial[side] = GfParmGetStr(trackHandle, path2, TRK_ATT_SURF, sideMaterial[side]);
            sideSurface[side] = getTrackSurface(trackHandle, theTrack, sideMaterial[side]);
 
            // Border parameters
            formatTrackPath(path2, BUFSIZE, "%s/%s", path, SectBorder[side]);
            bw = GfParmGetNum(trackHandle, path2, TRK_ATT_WIDTH, (char*)NULL, borderWidth[side]);
            borderWidth[side] = bw;
            borderHeight[side] = GfParmGetNum(trackHandle, path2, TRK_ATT_HEIGHT, (char*)NULL, borderHeight[side]);
            borderMaterial[side] = GfParmGetStr(trackHandle, path2, TRK_ATT_SURF, borderMaterial[side]);
            borderSurface[side] = getTrackSurface(trackHandle, theTrack, borderMaterial[side]);
            style = GfParmGetStr(trackHandle, path2, TRK_ATT_STYLE, ValStyle[borderStyle[side]]);
 
            if (strcmp(style, TRK_VAL_PLAN) == 0) {
                borderStyle[side] = TR_PLAN;
            }
            else if (strcmp(style, TRK_VAL_CURB) == 0) {
                borderStyle[side] = TR_CURB;
            }
            else {
                borderStyle[side] = TR_WALL;
            }
 
            // Barrier parameters
            formatTrackPath(path2, BUFSIZE, "%s/%s", path, SectBarrier[side]);
            barrierMaterial[side] = GfParmGetStr(trackHandle, path2, TRK_ATT_SURF, barrierMaterial[side]);
            barrierSurface[side] = getTrackSurface(trackHandle, theTrack, barrierMaterial[side]);
            barrierHeight[side] = GfParmGetNum(trackHandle, path2, TRK_ATT_HEIGHT, (char*)NULL, barrierHeight[side]);
            style = GfParmGetStr(trackHandle, path2, TRK_ATT_STYLE, ValStyle[barrierStyle[side]]);
 
            if (strcmp(style, TRK_VAL_FENCE) == 0) {
                barrierStyle[side] = TR_FENCE;
                barrierWidth[side] = 0;
            }
            else {
                barrierStyle[side] = TR_WALL;
                barrierWidth[side] = GfParmGetNum(trackHandle, path2, TRK_ATT_WIDTH, (char*)NULL, barrierWidth[side]);
            }
        }
        else {
            // Reset sw, ew, bw for steps after initialization
            sw = sideStartWidth[side];
            ew = sideEndWidth[side];
            bw = borderWidth[side];
        }
 
        // Calculate parameters considering the current step
        Kew = (ew - sw) / (tdble)steps;
        ew = sw + (tdble)(curStep + 1) * Kew;
        sw = sw + (tdble)(curStep)*Kew;
 
        // Add borders
        if (bw > 0.0f) {
            curSeg = commonSideInit(curSeg, side, TR_LBORDER, TR_RBORDER, sideBankType[side], bw, bw,
                borderSurface[side], borderHeight[side], borderStyle[side]);
        }
 
        // Add sides
        if ((sw > 0.0f) || (ew > 0.0f)) {
            commonSideInit(curSeg, side, TR_LSIDE, TR_RSIDE, sideBankType[side], sw, ew,
                sideSurface[side], 0.0f, TR_PLAN);
        }
 
        // Add barriers
        curBarrier = (tTrackBarrier*)malloc(sizeof(tTrackBarrier));
        if (!curBarrier) {
            GfFatal("AddSides: memory allocation error");
            exit(1);
        }
        curBarrier->style = barrierStyle[side];
        curBarrier->width = barrierWidth[side];
        curBarrier->height = barrierHeight[side];
        curBarrier->surface = barrierSurface[side];
 
        // Compute normal of barrier for side collisions.
        tTrackSeg* bseg = mSeg;
        int bstart, bend;
        float bsign;
 
        if (side == TR_SIDE_LFT) {
            bstart = TR_SL;
            bend = TR_EL;
            bsign = -1.0f;
        }
        else {
            bstart = TR_SR;
            bend = TR_ER;
            bsign = 1.0f;
        }
 
        while (bseg->side[side] != NULL) {
            bseg = bseg->side[side];
        }
 
        vec2f n(
            -(bseg->vertex[bend].y - bseg->vertex[bstart].y) * bsign,
            (bseg->vertex[bend].x - bseg->vertex[bstart].x) * bsign
        );
 
        n.normalize();
        curBarrier->normal = n;
 
        mSeg->barrier[side] = curBarrier;
    }
}
 

static void normSeg(tTrackSeg* curSeg)
{
    curSeg->vertex[TR_SR].x -= xmin;
    curSeg->vertex[TR_SR].y -= ymin;
    curSeg->vertex[TR_SR].z -= zmin;
    curSeg->vertex[TR_SL].x -= xmin;
    curSeg->vertex[TR_SL].y -= ymin;
    curSeg->vertex[TR_SL].z -= zmin;
    curSeg->vertex[TR_ER].x -= xmin;
    curSeg->vertex[TR_ER].y -= ymin;
    curSeg->vertex[TR_ER].z -= zmin;
    curSeg->vertex[TR_EL].x -= xmin;
    curSeg->vertex[TR_EL].y -= ymin;
    curSeg->vertex[TR_EL].z -= zmin;
    curSeg->center.x -= xmin;
    curSeg->center.y -= ymin;
}
 
 
static void CreateSegRing(void* TrackHandle, tTrack* theTrack, int ext)
{
    int     j;
    int     segread, curindex;
    tdble  radius, radiusend = 0, dradius;
    tdble  innerradius;
    tdble  arc;
    tdble  length;
    tTrackSeg* curSeg;
    tTrackSeg* root;
    tdble  alf;
    tdble  xr, yr, newxr, newyr;
    tdble  xl, yl, newxl, newyl;
    tdble  cenx, ceny;
    tdble  width, wi2;
    tdble  x1, x2, y1, y2;
    tdble  al, alfl;
    tdble  zsl, zsr, zel, zer, zs, ze;
    tdble  bankings, bankinge, dz; //dzl, dzr;
    tdble  etgt, stgt;
    tdble  etgtl, stgtl;
    tdble  etgtr, stgtr;
    tdble  stepslg = 0;
    int     steps, curStep;
    const char* segtype = (char*)NULL;
    const char* material;
    tTrackSurface* surface;
    const char* segName;
    int     type;
    const char* profil;
    tdble  totLength;
 
    tdble  tl, dtl, T1l, T2l;
    tdble  tr, dtr, T1r, T2r;
    tdble  curzel, curzer, curArc, curLength, curzsl, curzsr;
    tdble  grade;
 
    void* segNameHash = NULL;
    const int BUFSIZE = 256;
    char    path[BUFSIZE];
 
#define MAX_TMP_INTS    256
    int     mi[MAX_TMP_INTS];
    int     ind = 0;
 
    radius = arc = length = alf = xr = yr = newxr = newyr = xl = yl = 0;
    zel = zer = etgtl = etgtr = newxl = newyl = 0;
    type = 0;
 
    width = GfParmGetNum(TrackHandle, TRK_SECT_MAIN, TRK_ATT_WIDTH, (char*)NULL, 15.0);
    wi2 = width / 2.0;
 
    grade = -100000.0;
    root = (tTrackSeg*)NULL;
    totLength = 0;
 
    formatTrackPath(path, BUFSIZE, "%s/%s", TRK_SECT_MAIN, TRK_LST_SEGMENTS);
    yl = width;
    zsl = zsr = zel = zer = zs = ze = 0.0;
    stgt = etgt = 0.0;
    stgtl = etgtl = 0.0;
    stgtr = etgtr = 0.0;
 
    /* Main Track */
    material = GfParmGetStr(TrackHandle, TRK_SECT_MAIN, TRK_ATT_SURF, TRK_VAL_ASPHALT);
    surface = getTrackSurface(TrackHandle, theTrack, material);
    envIndex = 0;
    readDefaultSideParameters(TrackHandle, theTrack);
 
    if (ext) {
        segNameHash = GfHashCreate(GF_HASH_TYPE_STR);
    }
 
    segread = 0;
    curindex = 0;
    GfParmListSeekFirst(TrackHandle, path);
    do {
        segtype = GfParmGetCurStr(TrackHandle, path, TRK_ATT_TYPE, NULL);
        if (segtype == 0) {
            continue;
        }
        segread++;
 
        zsl = zel;
        zsr = zer;
        TSTZ(zsl);
        TSTZ(zsr);
 
        /* Turn Marks */
        if (ext) {
            const char* marks = GfParmGetCurStr(TrackHandle, path, TRK_ATT_MARKS, NULL);
            ind = 0;
            if (marks) {
                char* tmpmarks = strdup(marks);
                char* s = strtok(tmpmarks, ";");
                while ((s != NULL) && (ind < MAX_TMP_INTS)) {
                    mi[ind] = (int)strtol(s, NULL, 0);
                    ind++;
                    s = strtok(NULL, ";");
                }
                free(tmpmarks);
            }
        }
 
        /* surface change */
        material = GfParmGetCurStr(TrackHandle, path, TRK_ATT_SURF, material);
        surface = getTrackSurface(TrackHandle, theTrack, material);
        envIndex = (int)GfParmGetCurNum(TrackHandle, path, TRK_ATT_ENVIND, (char*)NULL, (float)(envIndex + 1)) - 1;
 
        /* get segment type and length */
        segName = GfParmListGetCurEltName(TrackHandle, path);
        if (strcmp(segtype, TRK_VAL_STR) == 0) {
            /* straight */
            length = GfParmGetCurNum(TrackHandle, path, TRK_ATT_LG, (char*)NULL, 0);
            type = TR_STR;
            radius = radiusend = 0;
        }
        else if (strcmp(segtype, TRK_VAL_LFT) == 0) {
            /* left curve */
            radius = GfParmGetCurNum(TrackHandle, path, TRK_ATT_RADIUS, (char*)NULL, 0);
            radiusend = GfParmGetCurNum(TrackHandle, path, TRK_ATT_RADIUSEND, (char*)NULL, radius);
            arc = GfParmGetCurNum(TrackHandle, path, TRK_ATT_ARC, (char*)NULL, 0);
            type = TR_LFT;
            length = (radius + radiusend) / 2.0 * arc;
        }
        else if (strcmp(segtype, TRK_VAL_RGT) == 0) {
            /* right curve */
            radius = GfParmGetCurNum(TrackHandle, path, TRK_ATT_RADIUS, (char*)NULL, 0);
            radiusend = GfParmGetCurNum(TrackHandle, path, TRK_ATT_RADIUSEND, (char*)NULL, radius);
            arc = GfParmGetCurNum(TrackHandle, path, TRK_ATT_ARC, (char*)NULL, 0);
            type = TR_RGT;
            length = (radius + radiusend) / 2.0 * arc;
        }
        else {
            GfFatal("Unknown track segment type \"%s\" in segment \"%s\"\n", segtype, segName);
            exit(1);
        }
        if (ext) {
            if (GfHashGetStr(segNameHash, segName)) {
                printf(">>>>>>>>> DUPLICATED SEGMENT NAME \"%s\" PLEASE CHANGE IT !!!!\n", segName);
                exit(1);
            }
            GfHashAddStr(segNameHash, segName, segName);
        }
 
        /* elevation and banking */
        zsl = GfParmGetCurNum(TrackHandle, path, TRK_ATT_ZSL, (char*)NULL, zsl);
        zsr = GfParmGetCurNum(TrackHandle, path, TRK_ATT_ZSR, (char*)NULL, zsr);
        zel = GfParmGetCurNum(TrackHandle, path, TRK_ATT_ZEL, (char*)NULL, zel);
        zer = GfParmGetCurNum(TrackHandle, path, TRK_ATT_ZER, (char*)NULL, zer);
        ze = zs = -100000.0;
        ze = GfParmGetCurNum(TrackHandle, path, TRK_ATT_ZE, (char*)NULL, ze);
        zs = GfParmGetCurNum(TrackHandle, path, TRK_ATT_ZS, (char*)NULL, zs);
        grade = GfParmGetCurNum(TrackHandle, path, TRK_ATT_GRADE, (char*)NULL, grade);
        if (zs != -100000.0) {
            zsr = zsl = zs;
        }
        else {
            zs = (zsl + zsr) / 2.0;
        }
        if (ze != -100000.0) {
            zer = zel = ze;
        }
        else if (grade != -100000.0) {
            ze = zs + length * grade;
        }
        else {
            ze = (zel + zer) / 2.0;
        }
        bankings = atan2(zsl - zsr, width);
        bankinge = atan2(zel - zer, width);
        bankings = GfParmGetCurNum(TrackHandle, path, TRK_ATT_BKS, (char*)NULL, bankings);
        bankinge = GfParmGetCurNum(TrackHandle, path, TRK_ATT_BKE, (char*)NULL, bankinge);
        dz = tan(bankings) * width / 2.0;
        zsl = zs + dz;
        zsr = zs - dz;
        dz = tan(bankinge) * width / 2.0;
        zel = ze + dz;
        zer = ze - dz;
 
        TSTZ(zsl);
        TSTZ(zsr);
 
        /* Get segment profil */
        profil = GfParmGetCurStr(TrackHandle, path, TRK_ATT_PROFIL, TRK_VAL_SPLINE);
        stgtl = etgtl;
        stgtr = etgtr;
        if (strcmp(profil, TRK_VAL_SPLINE) == 0) {
            steps = (int)GfParmGetCurNum(TrackHandle, path, TRK_ATT_PROFSTEPS, (char*)NULL, 1.0);
            if (steps == 1) {
                stepslg = GfParmGetCurNum(TrackHandle, path, TRK_ATT_PROFSTEPSLEN, (char*)NULL, GlobalStepLen);
                if (stepslg) {
                    steps = (int)(length / stepslg) + 1;
                }
                else {
                    steps = 1;
                }
            }
            stgtl = GfParmGetCurNum(TrackHandle, path, TRK_ATT_PROFTGTSL, (char*)NULL, stgtl);
            etgtl = GfParmGetCurNum(TrackHandle, path, TRK_ATT_PROFTGTEL, (char*)NULL, etgtl);
            stgtr = GfParmGetCurNum(TrackHandle, path, TRK_ATT_PROFTGTSR, (char*)NULL, stgtr);
            etgtr = GfParmGetCurNum(TrackHandle, path, TRK_ATT_PROFTGTER, (char*)NULL, etgtr);
            stgt = etgt = -100000.0;
            stgt = GfParmGetCurNum(TrackHandle, path, TRK_ATT_PROFTGTS, (char*)NULL, stgt);
            etgt = GfParmGetCurNum(TrackHandle, path, TRK_ATT_PROFTGTE, (char*)NULL, etgt);
            if (stgt != -100000.0) {
                stgtl = stgtr = stgt;
            }
            if (etgt != -100000.0) {
                etgtl = etgtr = etgt;
            }
        }
        else {
            steps = 1;
            stgtl = etgtl = (zel - zsl) / length;
            stgtr = etgtr = (zer - zsr) / length;
        }
        GfParmSetCurNum(TrackHandle, path, TRK_ATT_ID, (char*)NULL, (tdble)curindex);
 
        //dzl = zel - zsl;
        //dzr = zer - zsr;
        T1l = stgtl * length;
        T2l = etgtl * length;
        tl = 0.0;
        dtl = 1.0 / (tdble)steps;
        T1r = stgtr * length;
        T2r = etgtr * length;
        tr = 0.0;
        dtr = 1.0 / (tdble)steps;
 
        curStep = 0;
        curzel = zsl;
        curzer = zsr;
        curArc = arc / (tdble)steps;
        curLength = length / (tdble)steps;
        dradius = (radiusend - radius) / (tdble)steps;
        if (radiusend != radius) {
            /* Compute the correct curLength... */
            if (steps != 1) {
                dradius = (radiusend - radius) / (tdble)(steps - 1);
                tdble tmpAngle = 0;
                tdble tmpRadius = radius;
                for (curStep = 0; curStep < steps; curStep++) {
                    tmpAngle += curLength / tmpRadius;
                    tmpRadius += dradius;
                }
                curLength *= arc / tmpAngle;
            }
        }
        curStep = 0;
 
        while (curStep < steps) {
 
            tl += dtl;
            tr += dtr;
 
            curzsl = curzel;
            curzel = TrackSpline(zsl, zel, T1l, T2l, tl);
 
            curzsr = curzer;
            curzer = TrackSpline(zsr, zer, T1r, T2r, tr);
 
            if (dradius != 0) {
                curArc = curLength / radius;
            }
 
            /* allocate a new segment */
            curSeg = (tTrackSeg*)calloc(1, sizeof(tTrackSeg));
            if (root == NULL) {
                root = curSeg;
                curSeg->next = curSeg;
                curSeg->prev = curSeg;
            }
            else {
                curSeg->next = root->next;
                curSeg->next->prev = curSeg;
                curSeg->prev = root;
                root->next = curSeg;
                root = curSeg;
            }
            curSeg->type2 = TR_MAIN;
            curSeg->name = segName;
            curSeg->id = curindex;
            curSeg->width = curSeg->startWidth = curSeg->endWidth = width;
            curSeg->surface = surface;
            curSeg->envIndex = envIndex;
            curSeg->lgfromstart = totLength;
 
            if (ext && ind) {
                int* mrks = (int*)calloc(ind, sizeof(int));
                tSegExt* segExt = (tSegExt*)calloc(1, sizeof(tSegExt));
 
                memcpy(mrks, mi, ind * sizeof(int));
                segExt->nbMarks = ind;
                segExt->marks = mrks;
                curSeg->ext = segExt;
                ind = 0;
            }
 
 
            switch (type) {
            case TR_STR:
                /* straight */
                curSeg->type = TR_STR;
                curSeg->length = curLength;
 
                newxr = xr + curLength * cos(alf);      /* find end coordinates */
                newyr = yr + curLength * sin(alf);
                newxl = xl + curLength * cos(alf);
                newyl = yl + curLength * sin(alf);
 
                curSeg->vertex[TR_SR].x = xr;
                curSeg->vertex[TR_SR].y = yr;
                curSeg->vertex[TR_SR].z = curzsr;
 
                curSeg->vertex[TR_SL].x = xl;
                curSeg->vertex[TR_SL].y = yl;
                curSeg->vertex[TR_SL].z = curzsl;
 
                curSeg->vertex[TR_ER].x = newxr;
                curSeg->vertex[TR_ER].y = newyr;
                curSeg->vertex[TR_ER].z = curzer;
 
                curSeg->vertex[TR_EL].x = newxl;
                curSeg->vertex[TR_EL].y = newyl;
                curSeg->vertex[TR_EL].z = curzel;
 
                curSeg->angle[TR_ZS] = alf;
                curSeg->angle[TR_ZE] = alf;
                curSeg->angle[TR_YR] = atan2(curSeg->vertex[TR_ER].z - curSeg->vertex[TR_SR].z, curLength);
                curSeg->angle[TR_YL] = atan2(curSeg->vertex[TR_EL].z - curSeg->vertex[TR_SL].z, curLength);
                curSeg->angle[TR_XS] = atan2(curSeg->vertex[TR_SL].z - curSeg->vertex[TR_SR].z, width);
                curSeg->angle[TR_XE] = atan2(curSeg->vertex[TR_EL].z - curSeg->vertex[TR_ER].z, width);
 
                curSeg->Kzl = tan(curSeg->angle[TR_YR]);
                curSeg->Kzw = (curSeg->angle[TR_XE] - curSeg->angle[TR_XS]) / curLength;
                curSeg->Kyl = 0;
 
                curSeg->rgtSideNormal.x = -sin(alf);
                curSeg->rgtSideNormal.y = cos(alf);
 
                TSTX(newxr); TSTX(newxl);
                TSTY(newyr); TSTY(newyl);
 
                break;
 
            case TR_LFT:
                /* left curve */
                curSeg->type = TR_LFT;
                curSeg->radius = radius;
                curSeg->radiusr = radius + wi2;
                curSeg->radiusl = radius - wi2;
                curSeg->arc = curArc;
                curSeg->length = curLength;
 
                innerradius = radius - wi2; /* left side aligned */
                cenx = xl - innerradius * sin(alf);  /* compute center location: */
                ceny = yl + innerradius * cos(alf);
                curSeg->center.x = cenx;
                curSeg->center.y = ceny;
 
                curSeg->angle[TR_ZS] = alf;
                curSeg->angle[TR_CS] = alf - PI / 2.0;
                alf += curArc;
                curSeg->angle[TR_ZE] = alf;
 
                newxl = cenx + innerradius * sin(alf);   /* location of end */
                newyl = ceny - innerradius * cos(alf);
                newxr = cenx + (innerradius + width) * sin(alf);   /* location of end */
                newyr = ceny - (innerradius + width) * cos(alf);
 
                curSeg->vertex[TR_SR].x = xr;
                curSeg->vertex[TR_SR].y = yr;
                curSeg->vertex[TR_SR].z = curzsr;
 
                curSeg->vertex[TR_SL].x = xl;
                curSeg->vertex[TR_SL].y = yl;
                curSeg->vertex[TR_SL].z = curzsl;
 
                curSeg->vertex[TR_ER].x = newxr;
                curSeg->vertex[TR_ER].y = newyr;
                curSeg->vertex[TR_ER].z = curzer;
 
                curSeg->vertex[TR_EL].x = newxl;
                curSeg->vertex[TR_EL].y = newyl;
                curSeg->vertex[TR_EL].z = curzel;
 
                curSeg->angle[TR_YR] = atan2(curSeg->vertex[TR_ER].z - curSeg->vertex[TR_SR].z, curArc * (innerradius + width));
                curSeg->angle[TR_YL] = atan2(curSeg->vertex[TR_EL].z - curSeg->vertex[TR_SL].z, curArc * innerradius);
                curSeg->angle[TR_XS] = atan2(curSeg->vertex[TR_SL].z - curSeg->vertex[TR_SR].z, width);
                curSeg->angle[TR_XE] = atan2(curSeg->vertex[TR_EL].z - curSeg->vertex[TR_ER].z, width);
 
                curSeg->Kzl = tan(curSeg->angle[TR_YR]) * (innerradius + width);
                curSeg->Kzw = (curSeg->angle[TR_XE] - curSeg->angle[TR_XS]) / curArc;
                curSeg->Kyl = 0;
 
                /* to find the boundary */
                al = curArc / 36.0;
                alfl = curSeg->angle[TR_CS];
 
                for (j = 0; j < 36; j++) {
                    alfl += al;
                    x1 = curSeg->center.x + (innerradius)*cos(alfl);   /* location of end */
                    y1 = curSeg->center.y + (innerradius)*sin(alfl);
                    x2 = curSeg->center.x + (innerradius + width) * cos(alfl);   /* location of end */
                    y2 = curSeg->center.y + (innerradius + width) * sin(alfl);
                    TSTX(x1); TSTX(x2);
                    TSTY(y1); TSTY(y2);
                }
 
                break;
 
            case TR_RGT:
                /* right curve */
                curSeg->type = TR_RGT;
                curSeg->radius = radius;
                curSeg->radiusr = radius - wi2;
                curSeg->radiusl = radius + wi2;
                curSeg->arc = curArc;
                curSeg->length = curLength;
 
                innerradius = radius - wi2; /* right side aligned */
                cenx = xr + innerradius * sin(alf);  /* compute center location */
                ceny = yr - innerradius * cos(alf);
                curSeg->center.x = cenx;
                curSeg->center.y = ceny;
 
                curSeg->angle[TR_ZS] = alf;
                curSeg->angle[TR_CS] = alf + PI / 2.0;
                alf -= curSeg->arc;
                curSeg->angle[TR_ZE] = alf;
 
                newxl = cenx - (innerradius + width) * sin(alf);   /* location of end */
                newyl = ceny + (innerradius + width) * cos(alf);
                newxr = cenx - innerradius * sin(alf);   /* location of end */
                newyr = ceny + innerradius * cos(alf);
 
                curSeg->vertex[TR_SR].x = xr;
                curSeg->vertex[TR_SR].y = yr;
                curSeg->vertex[TR_SR].z = curzsr;
 
                curSeg->vertex[TR_SL].x = xl;
                curSeg->vertex[TR_SL].y = yl;
                curSeg->vertex[TR_SL].z = curzsl;
 
                curSeg->vertex[TR_ER].x = newxr;
                curSeg->vertex[TR_ER].y = newyr;
                curSeg->vertex[TR_ER].z = curzer;
 
                curSeg->vertex[TR_EL].x = newxl;
                curSeg->vertex[TR_EL].y = newyl;
                curSeg->vertex[TR_EL].z = curzel;
 
                curSeg->angle[TR_YR] = atan2(curSeg->vertex[TR_ER].z - curSeg->vertex[TR_SR].z, curArc * innerradius);
                curSeg->angle[TR_YL] = atan2(curSeg->vertex[TR_EL].z - curSeg->vertex[TR_SL].z, curArc * (innerradius + width));
                curSeg->angle[TR_XS] = atan2(curSeg->vertex[TR_SL].z - curSeg->vertex[TR_SR].z, width);
                curSeg->angle[TR_XE] = atan2(curSeg->vertex[TR_EL].z - curSeg->vertex[TR_ER].z, width);
 
                curSeg->Kzl = tan(curSeg->angle[TR_YR]) * innerradius;
                curSeg->Kzw = (curSeg->angle[TR_XE] - curSeg->angle[TR_XS]) / curArc;
                curSeg->Kyl = 0;
 
                /* to find the boundaries */
                al = curSeg->arc / 36.0;
                alfl = curSeg->angle[TR_CS];
 
                for (j = 0; j < 36; j++) {
                    alfl -= al;
                    x1 = curSeg->center.x + (innerradius + width) * cos(alfl);   /* location of end */
                    y1 = curSeg->center.y + (innerradius + width) * sin(alfl);
                    x2 = curSeg->center.x + innerradius * cos(alfl);   /* location of end */
                    y2 = curSeg->center.y + innerradius * sin(alfl);
                    TSTX(x1); TSTX(x2);
                    TSTY(y1); TSTY(y2);
                }
                break;
 
            }
 
            addSides(curSeg, TrackHandle, theTrack, curStep, steps);
 
            totLength += curSeg->length;
            xr = newxr;
            yr = newyr;
            xl = newxl;
            yl = newyl;
            curindex++;
            curStep++;
            if (type != TR_STR) {
                /*      printf("radius = %f arc = %f steps %d, length %f, stepslg %f\n", radius, RAD2DEG(curArc), steps, length, curLength); */
                radius += dradius;
            }
        }
 
    } while (GfParmListSeekNext(TrackHandle, path) == 0);
 
    if (ext) {
        GfHashRelease(segNameHash, NULL);
    }
 
    /* printf("\n"); */
 
 
    theTrack->seg = root;
    theTrack->length = totLength;
    theTrack->nseg = curindex;
}
 
 
 
 
/*
 * Read version 4 track segments
 */
static void
readGeoreference(tTrack* track, void* handle)
{
    tTrackGeoreference& geo = track->georeference;
    memset(&geo, 0, sizeof(geo));
    // Avoid <cmath>: its float overloads change the legacy geometry arithmetic.
    // On MSVC, adding that header changed existing sin/cos calls from double
    // results to float results, shifting Mogyorod's closure by about 32 cm and
    // splitting its pit wall into overlapping collision objects.
    // A future regression test should load a small large-radius, subdivided
    // track through the separately compiled loader and compare road endpoints
    // with fixed, known-good coordinates (not the same formulas recomputed in
    // the test). Including track4.cpp after Google Test headers is insufficient:
    // those headers can already expose <cmath> overloads, unlike production.
    // Verify the test catches this bug by temporarily reintroducing <cmath> in
    // the loader: it should fail, then pass again after removing that include.
    const tdble missing = std::numeric_limits<tdble>::quiet_NaN();
    const tdble maxFinite = (std::numeric_limits<tdble>::max)();
    const tdble lat = GfParmGetNum(handle, TRK_SECT_GEOREFERENCE, TRK_ATT_GEO_LATITUDE, "deg", missing);
    const tdble lon = GfParmGetNum(handle, TRK_SECT_GEOREFERENCE, TRK_ATT_GEO_LONGITUDE, "deg", missing);
    const tdble alt = GfParmGetNum(handle, TRK_SECT_GEOREFERENCE, TRK_ATT_GEO_ALTITUDE, "m", missing);
    const tdble heading = GfParmGetNum(handle, TRK_SECT_GEOREFERENCE, TRK_ATT_GEO_HEADING, "deg", missing);
    if (fabs(lat) <= 90.0 && fabs(lon) <= 180.0) {
        geo.latitude = lat;
        geo.longitude = lon;
        geo.hasLocation = 1;
    } else if (lat == lat || lon == lon) {
        GfError("Track Georeference: invalid or incomplete latitude/longitude\n");
    }
    if (fabs(alt) <= maxFinite) {
        geo.altitude = alt;
        geo.hasAltitude = 1;
    } else if (alt == alt) {
        GfError("Track Georeference: invalid altitude\n");
    }
    if (fabs(heading) <= maxFinite) {
        double degrees = fmod((double)heading, 360.0);
        if (degrees < 0.0) degrees += 360.0;
        geo.heading = (tdble)(degrees * PI / 180.0);
        geo.hasHeading = 1;
    } else if (heading == heading) {
        GfError("Track Georeference: invalid heading\n");
    }
}
 
void
ReadTrack4(tTrack* theTrack, void* TrackHandle, tRoadCam** camList, int ext)
{
    int         i;
    tTrackSeg* curSeg = NULL, * mSeg;
    tTrackSeg* curSeg2;
    tTrackSeg* pitEntrySeg = NULL;
    tTrackSeg* pitExitSeg = NULL;
    tTrackSeg* pitStart = NULL;
    tTrackSeg* pitEnd = NULL;
    tTrackSeg* curPitSeg = NULL;
    tTrackPitInfo* pits;
    const char* segName;
    int         segId;
    tRoadCam* curCam;
    tTrkLocPos        trkPos;
    int         found = 0;
    const char* paramVal;
    const int BUFSIZE = 256;
    char        path2[BUFSIZE];
    int         changeSeg;
    tdble      offset = 0;
    tdble      toStart;
 
    xmin = xmax = ymin = ymax = zmin = zmax = 0.0;
    readGeoreference(theTrack, TrackHandle);
 
    GlobalStepLen = GfParmGetNum(TrackHandle, TRK_SECT_MAIN, TRK_ATT_PROFSTEPSLEN, (char*)NULL, 0);
 
    CreateSegRing(TrackHandle, theTrack, ext);
    if (!theTrack->seg) {
        GfFatal("Track definition contains no valid segments\n");
        exit(1);
    }
 
    /* PITS */
    pits = &(theTrack->pits);
    formatTrackPath(path2, BUFSIZE, "%s/%s", TRK_SECT_MAIN, TRK_SECT_PITS);
    segName = GfParmGetStr(TrackHandle, path2, TRK_ATT_ENTRY, NULL);
 
    if (segName != 0) {
        pitEntrySeg = findFirstSegmentByName(theTrack, segName);
 
        /* Pits Exit */
        segName = GfParmGetStr(TrackHandle, path2, TRK_ATT_EXIT, NULL);
        if (segName != 0) {
            pitExitSeg = findLastSegmentByName(theTrack, segName);
        }
 
        /* Pits Start */
        segName = GfParmGetStr(TrackHandle, path2, TRK_ATT_START, NULL);
        if (segName != 0) {
            pitStart = findFirstSegmentByName(theTrack, segName);
        }
 
        /* Pits End */
        segName = GfParmGetStr(TrackHandle, path2, TRK_ATT_END, NULL);
        if (segName != 0) {
            pitEnd = findLastSegmentByName(theTrack, segName);
        }
        paramVal = GfParmGetStr(TrackHandle, path2, TRK_ATT_SIDE, "right");
        if (strcmp(paramVal, "right") == 0) {
            pits->side = TR_RGT;
        }
        else {
            pits->side = TR_LFT;
        }
        pits->speedLimit = GfParmGetNum(TrackHandle, path2, TRK_ATT_SPD_LIM, (char*)NULL, 25.0);
        if ((pitEntrySeg != NULL) && (pitExitSeg != NULL) && (pitStart != NULL) && (pitEnd != NULL)) {
            pits->pitEntry = pitEntrySeg;
            pits->pitExit = pitExitSeg;
            pits->pitStart = pitStart;
            pits->pitEnd = pitEnd;
            pitEntrySeg->raceInfo |= TR_PITENTRY;
            pitExitSeg->raceInfo |= TR_PITEXIT;
            pits->len = GfParmGetNum(TrackHandle, path2, TRK_ATT_LEN, (char*)NULL, 15.0);
            pits->width = GfParmGetNum(TrackHandle, path2, TRK_ATT_WIDTH, (char*)NULL, 5.0);
            found = 1;
        }
        else {
            found = 0;
        }
    }
 
    if (found) {
        pits->type = TR_PIT_ON_TRACK_SIDE;
        pits->nPitSeg = 0;
        if (pitStart->lgfromstart > pitEnd->lgfromstart) {
            pits->nMaxPits = (int)((theTrack->length - pitStart->lgfromstart +
                pitEnd->lgfromstart + pitEnd->length + pits->len / 2.0) / pits->len);
        }
        else {
            pits->nMaxPits = (int)((pitEnd->lgfromstart + pitEnd->length
                - pitStart->lgfromstart + pits->len / 2.0) / pits->len);
        }
        pits->driversPits = (tTrackOwnPit*)calloc(pits->nMaxPits, sizeof(tTrackOwnPit));
 
        mSeg = pitStart->prev;
        changeSeg = 1;
        toStart = 0;
        i = 0;
        while (i < pits->nMaxPits) {
            pits->driversPits[i].pos.type = TR_LPOS_MAIN;
            if (changeSeg) {
                changeSeg = 0;
                offset = 0;
                mSeg = mSeg->next;
                if (toStart >= mSeg->length) {
                    toStart -= mSeg->length;
                    changeSeg = 1;
                    continue;
                }
                switch (pits->side) {
                case TR_RGT:
                    curPitSeg = mSeg->rside;
                    if (curPitSeg->rside) {
                        offset = curPitSeg->width;
                        curPitSeg = curPitSeg->rside;
                    }
                    break;
                case TR_LFT:
                    curPitSeg = mSeg->lside;
                    if (curPitSeg->lside) {
                        offset = curPitSeg->width;
                        curPitSeg = curPitSeg->lside;
                    }
                    break;
                }
            }
 
            pits->driversPits[i].pos.seg = mSeg;
            pits->driversPits[i].pos.toStart = toStart + pits->len / 2.0;
            switch (pits->side) {
            case TR_RGT:
                pits->driversPits[i].pos.toRight = -offset - RtTrackGetWidth(curPitSeg, toStart) + pits->width / 2.0;
                pits->driversPits[i].pos.toLeft = mSeg->width - pits->driversPits[i].pos.toRight;
                pits->driversPits[i].pos.toMiddle = mSeg->width / 2.0 - pits->driversPits[i].pos.toRight;
                break;
            case TR_LFT:
                pits->driversPits[i].pos.toLeft = -offset - RtTrackGetWidth(curPitSeg, toStart) + pits->width / 2.0;
                pits->driversPits[i].pos.toRight = mSeg->width - pits->driversPits[i].pos.toLeft;
                pits->driversPits[i].pos.toMiddle = mSeg->width / 2.0 - pits->driversPits[i].pos.toLeft;
                break;
            }
            toStart += pits->len;
            if (toStart >= mSeg->length) {
                toStart -= mSeg->length;
                changeSeg = 1;
            }
            i++;
        }
 
        for (mSeg = pitStart->prev; mSeg != pitEnd->next->next; mSeg = mSeg->next) {
            curSeg2 = NULL;
            switch (pits->side) {
            case TR_RGT:
                curSeg = mSeg->rside;
                curSeg2 = curSeg->rside;
                if ((mSeg != pitStart->prev) && (mSeg != pitEnd->next)) {
                    mSeg->barrier[0]->style = TR_PITBUILDING;
                }
                break;
            case TR_LFT:
                curSeg = mSeg->lside;
                curSeg2 = curSeg->lside;
                if ((mSeg != pitStart->prev) && (mSeg != pitEnd->next)) {
                    mSeg->barrier[1]->style = TR_PITBUILDING;
                }
                break;
            }
            if ((mSeg != pitStart->prev) && (mSeg != pitEnd->next)) {
                curSeg->raceInfo |= TR_PIT | TR_SPEEDLIMIT;
                if (curSeg2) {
                    curSeg2->raceInfo |= TR_PIT | TR_SPEEDLIMIT;
                }
            }
            else if (mSeg == pitStart->prev) {
                curSeg->raceInfo |= TR_PITSTART;
                if (curSeg2) {
                    curSeg2->raceInfo |= TR_PITSTART;
                }
            }
            else if (mSeg == pitEnd->next) {
                curSeg->raceInfo |= TR_PITEND;
                if (curSeg2) {
                    curSeg2->raceInfo |= TR_PITEND;
                }
            }
        }
    }
 
    /*
     * camera definitions
     */
    if (GfParmListSeekFirst(TrackHandle, TRK_SECT_CAM) == 0) {
        do {
            curCam = (tRoadCam*)calloc(1, sizeof(tRoadCam));
            if (!curCam) {
                GfFatal("ReadTrack4: Memory allocation error\n");
                exit(1);
            }
            if (*camList == NULL) {
                *camList = curCam;
                curCam->next = curCam;
            }
            else {
                curCam->next = (*camList)->next;
                (*camList)->next = curCam;
                *camList = curCam;
            }
            curCam->name = GfParmListGetCurEltName(TrackHandle, TRK_SECT_CAM);
            segName = GfParmGetCurStr(TrackHandle, TRK_SECT_CAM, TRK_ATT_SEGMENT, NULL);
            if (segName == 0) {
                GfFatal("Bad Track Definition: in Camera %s %s is missing\n", curCam->name, TRK_ATT_SEGMENT);
                exit(1);
            }
            formatTrackPath(path2, BUFSIZE, "%s/%s/%s", TRK_SECT_MAIN, TRK_LST_SEGMENTS, segName);
            segId = (int)GfParmGetNum(TrackHandle, path2, TRK_ATT_ID, (char*)NULL, 0);
            curSeg = theTrack->seg;
            for (i = 0; i < theTrack->nseg; i++) {
                if (curSeg->id == segId) {
                    break;
                }
                curSeg = curSeg->next;
            }
 
            trkPos.seg = curSeg;
            trkPos.toRight = GfParmGetCurNum(TrackHandle, TRK_SECT_CAM, TRK_ATT_TORIGHT, (char*)NULL, 0);
            trkPos.toStart = GfParmGetCurNum(TrackHandle, TRK_SECT_CAM, TRK_ATT_TOSTART, (char*)NULL, 0);
            TrackLocal2Global(&trkPos, &(curCam->pos.x), &(curCam->pos.y));
            curCam->pos.z = TrackHeightL(&trkPos) + GfParmGetCurNum(TrackHandle, TRK_SECT_CAM, TRK_ATT_HEIGHT, (char*)NULL, 0);
 
            segName = GfParmGetCurStr(TrackHandle, TRK_SECT_CAM, TRK_ATT_CAM_FOV, NULL);
            if (segName == 0) {
                GfFatal("Bad Track Definition: in Camera %s %s is missing\n", curCam->name, TRK_ATT_CAM_FOV);
                exit(1);
            }
            formatTrackPath(path2, BUFSIZE, "%s/%s/%s", TRK_SECT_MAIN, TRK_LST_SEGMENTS, segName);
            segId = (int)GfParmGetNum(TrackHandle, path2, TRK_ATT_ID, (char*)NULL, 0);
            curSeg = theTrack->seg;
            for (i = 0; i < theTrack->nseg; i++) {
                if (curSeg->id == segId) {
                    break;
                }
                curSeg = curSeg->next;
            }
            segName = GfParmGetCurStr(TrackHandle, TRK_SECT_CAM, TRK_ATT_CAM_FOVE, NULL);
            if (segName == 0) {
                GfFatal("Bad Track Definition: in Camera %s %s is missing\n", curCam->name, TRK_ATT_CAM_FOVE);
                exit(1);
            }
            formatTrackPath(path2, BUFSIZE, "%s/%s/%s", TRK_SECT_MAIN, TRK_LST_SEGMENTS, segName);
            segId = (int)GfParmGetNum(TrackHandle, path2, TRK_ATT_ID, (char*)NULL, 0);
 
            do {
                curSeg->cam = curCam;
                curSeg = curSeg->next;
            } while (curSeg->id != segId);
        } while (GfParmListSeekNext(TrackHandle, TRK_SECT_CAM) == 0);
    }
 
    /* Update the coord to be positives */
    theTrack->min.x = 0;
    theTrack->min.y = 0;
    theTrack->min.z = 0;
    theTrack->max.x = xmax - xmin;
    theTrack->max.y = ymax - ymin;
    theTrack->max.z = zmax - zmin;
 
    curSeg = theTrack->seg;
    for (i = 0; i < theTrack->nseg; i++) {         /* read the segment data: */
        if ((curSeg->lgfromstart + curSeg->length) > (theTrack->length - 50.0)) {
            curSeg->raceInfo |= TR_LAST;
        }
        else if (curSeg->lgfromstart < 50.0) {
            curSeg->raceInfo |= TR_START;
        }
        else {
            curSeg->raceInfo |= TR_NORMAL;
        }
        normSeg(curSeg);
        if (curSeg->lside) {
            normSeg(curSeg->lside);
            if (curSeg->lside->lside) {
                normSeg(curSeg->lside->lside);
            }
        }
        if (curSeg->rside) {
            normSeg(curSeg->rside);
            if (curSeg->rside->rside) {
                normSeg(curSeg->rside->rside);
            }
        }
        curSeg = curSeg->next;
    }
 
 
    if (*camList != NULL) {
        curCam = *camList;
        do {
            curCam = curCam->next;
            curCam->pos.x -= xmin;
            curCam->pos.y -= ymin;
            curCam->pos.z -= zmin;
        } while (curCam != *camList);
    }
}
 

static void updateMinMaxForTurn(const tTrackSeg* const curBorder, const tdble radius, const tdble sign, const tdble z)
{
    tdble al, alfl, x, y;
    int j;
 
    // to find the boundary (global min/max, approximation)
    al = curBorder->arc / 36.0 * sign;
    alfl = curBorder->angle[TR_CS];
 
    for (j = 0; j < 36; j++) {
        alfl += al;
        x = curBorder->center.x + radius * cos(alfl);   // location of end
        y = curBorder->center.y + radius * sin(alfl);
        TSTX(x);
        TSTY(y);
    }
    TSTZ(z);
}
 

static void initAnglesAndGradients(tTrackSeg* const curBorder, const tdble startwidth, const tdble endwidth) {
    curBorder->angle[TR_YR] = atan2(curBorder->vertex[TR_ER].z - curBorder->vertex[TR_SR].z,
        curBorder->arc * curBorder->radiusr);
    curBorder->angle[TR_YL] = atan2(curBorder->vertex[TR_EL].z - curBorder->vertex[TR_SL].z,
        curBorder->arc * curBorder->radiusl);
 
    curBorder->Kzl = tan(curBorder->angle[TR_YR]) * curBorder->radiusr;
    curBorder->Kzw = (curBorder->angle[TR_XE] - curBorder->angle[TR_XS]) / curBorder->arc;
    curBorder->Kyl = (endwidth - startwidth) / curBorder->arc;
}
 

static void initSideForTurn(
    const int turntype,
    tTrackSeg* const curBorder,
    const tTrackSeg* const curSeg,
    const int side,
    const int bankingtype,
    const tdble startwidth,
    const tdble endwidth,
    const tdble maxwidth
)
{
    tdble sign, z;
 
    if (turntype == TR_LFT) {
        sign = 1.0f;
    }
    else {
        sign = -1.0f;
    }
 
    curBorder->center.x = curSeg->center.x;
    curBorder->center.y = curSeg->center.y;
 
    // Combining code for case 0 (TRK_SECT_RSIDE) and 1 (TRK_SECT_LSIDE)?
    // Tried it, but the setup code is then as long as the copy and less readable because of the additional 8 variables
    switch (side) {
    case 1:
        curBorder->radius = curSeg->radiusl - sign * startwidth / 2.0;
        curBorder->radiusr = curSeg->radiusl;
        curBorder->radiusl = curSeg->radiusl - sign * maxwidth;
        curBorder->arc = curSeg->arc;
        curBorder->length = curBorder->radius * curBorder->arc;
 
        curBorder->vertex[TR_SL].x = curBorder->vertex[TR_SR].x - sign * startwidth * cos(curBorder->angle[TR_CS]);
        curBorder->vertex[TR_SL].y = curBorder->vertex[TR_SR].y - sign * startwidth * sin(curBorder->angle[TR_CS]);
        curBorder->vertex[TR_SL].z = curBorder->vertex[TR_SR].z + (tdble)bankingtype * startwidth * tan(curSeg->angle[TR_XS]);
        curBorder->vertex[TR_EL].x = curBorder->vertex[TR_ER].x - sign * endwidth * cos(curBorder->angle[TR_CS] + sign * curBorder->arc);
        curBorder->vertex[TR_EL].y = curBorder->vertex[TR_ER].y - sign * endwidth * sin(curBorder->angle[TR_CS] + sign * curBorder->arc);
        z = curBorder->vertex[TR_EL].z = curBorder->vertex[TR_ER].z + (tdble)bankingtype * endwidth * tan(curSeg->angle[TR_XE]);
 
        initAnglesAndGradients(curBorder, startwidth, endwidth);
        updateMinMaxForTurn(curBorder, curBorder->radiusl, sign, z);
        break;
 
    case 0:
        curBorder->radius = curSeg->radiusr + sign * startwidth / 2.0;
        curBorder->radiusl = curSeg->radiusr;
        curBorder->radiusr = curSeg->radiusr + sign * maxwidth;
        curBorder->arc = curSeg->arc;
        curBorder->length = curBorder->radius * curBorder->arc;
 
        curBorder->vertex[TR_SR].x = curBorder->vertex[TR_SL].x + sign * startwidth * cos(curBorder->angle[TR_CS]);
        curBorder->vertex[TR_SR].y = curBorder->vertex[TR_SL].y + sign * startwidth * sin(curBorder->angle[TR_CS]);
        curBorder->vertex[TR_SR].z = curBorder->vertex[TR_SL].z - (tdble)bankingtype * startwidth * tan(curSeg->angle[TR_XS]);
        curBorder->vertex[TR_ER].x = curBorder->vertex[TR_EL].x + sign * endwidth * cos(curBorder->angle[TR_CS] + sign * curBorder->arc);
        curBorder->vertex[TR_ER].y = curBorder->vertex[TR_EL].y + sign * endwidth * sin(curBorder->angle[TR_CS] + sign * curBorder->arc);
        z = curBorder->vertex[TR_ER].z = curBorder->vertex[TR_EL].z - (tdble)bankingtype * endwidth * tan(curSeg->angle[TR_XE]);
 
        initAnglesAndGradients(curBorder, startwidth, endwidth);
        updateMinMaxForTurn(curBorder, curBorder->radiusr, sign, z);
        break;
    }
}
 

static void initSideForStraight(
    tTrackSeg* const curBorder,
    const tTrackSeg* const curSeg,
    const int side,
    const int bankingtype,
    const tdble startwidth,
    const tdble endwidth
)
{
    tdble z, x, y;
    x = y = z = 0.0f;
 
    switch (side) {
    case 1:
        curBorder->vertex[TR_SL].x = curBorder->vertex[TR_SR].x + startwidth * curSeg->rgtSideNormal.x;
        curBorder->vertex[TR_SL].y = curBorder->vertex[TR_SR].y + startwidth * curSeg->rgtSideNormal.y;
        curBorder->vertex[TR_SL].z = curBorder->vertex[TR_SR].z + (tdble)bankingtype * startwidth * tan(curSeg->angle[TR_XS]);
        x = curBorder->vertex[TR_EL].x = curBorder->vertex[TR_ER].x + endwidth * curSeg->rgtSideNormal.x;
        y = curBorder->vertex[TR_EL].y = curBorder->vertex[TR_ER].y + endwidth * curSeg->rgtSideNormal.y;
        z = curBorder->vertex[TR_EL].z = curBorder->vertex[TR_ER].z + (tdble)bankingtype * endwidth * tan(curSeg->angle[TR_XE]);
        break;
    case 0:
        curBorder->vertex[TR_SR].x = curBorder->vertex[TR_SL].x - startwidth * curSeg->rgtSideNormal.x;
        curBorder->vertex[TR_SR].y = curBorder->vertex[TR_SL].y - startwidth * curSeg->rgtSideNormal.y;
        curBorder->vertex[TR_SR].z = curBorder->vertex[TR_SL].z - (tdble)bankingtype * startwidth * tan(curSeg->angle[TR_XS]);
        x = curBorder->vertex[TR_ER].x = curBorder->vertex[TR_EL].x - endwidth * curSeg->rgtSideNormal.x;
        y = curBorder->vertex[TR_ER].y = curBorder->vertex[TR_EL].y - endwidth * curSeg->rgtSideNormal.y;
        z = curBorder->vertex[TR_ER].z = curBorder->vertex[TR_EL].z - (tdble)bankingtype * endwidth * tan(curSeg->angle[TR_XE]);
        break;
    }
 
    curBorder->angle[TR_YR] = atan2(curBorder->vertex[TR_ER].z - curBorder->vertex[TR_SR].z, curBorder->length);
    curBorder->angle[TR_YL] = atan2(curBorder->vertex[TR_EL].z - curBorder->vertex[TR_SL].z, curBorder->length);
 
    curBorder->Kzl = tan(curBorder->angle[TR_YR]);
    curBorder->Kzw = (curBorder->angle[TR_XE] - curBorder->angle[TR_XS]) / curBorder->length;
    curBorder->Kyl = (endwidth - startwidth) / curBorder->length;
 
    curBorder->rgtSideNormal.x = curSeg->rgtSideNormal.x;
    curBorder->rgtSideNormal.y = curSeg->rgtSideNormal.y;
 
    TSTX(x);
    TSTY(y);
    TSTZ(z);
}
 

static tTrackSeg* commonSideInit(
    tTrackSeg* const curSeg,
    const int side,
    const int lefttype,
    const int righttype,
    const int bankingtype,
    const tdble startwidth,
    const tdble endwidth,
    tTrackSurface* surface,
    const tdble borderheight,
    const int borderstyle
)
{
    tTrackSeg* curBorder = (tTrackSeg*)calloc(1, sizeof(tTrackSeg));
    if (side == 1) {
        curSeg->lside = curBorder;
        curBorder->vertex[TR_SR] = curSeg->vertex[TR_SL];
        curBorder->vertex[TR_ER] = curSeg->vertex[TR_EL];
        curBorder->type2 = lefttype;
    }
    else {
        curSeg->rside = curBorder;
        curBorder->vertex[TR_SL] = curSeg->vertex[TR_SR];
        curBorder->vertex[TR_EL] = curSeg->vertex[TR_ER];
        curBorder->type2 = righttype;
    }
 
    curBorder->startWidth = startwidth;
    curBorder->endWidth = endwidth;
    curBorder->width = MIN(startwidth, endwidth);
    tdble maxWidth = MAX(startwidth, endwidth);
 
    curBorder->type = curSeg->type;
    curBorder->surface = surface;
    curBorder->height = borderheight;
    curBorder->style = borderstyle;
    curBorder->envIndex = envIndex;     // TODO: Global?
    curBorder->angle[TR_XS] = curSeg->angle[TR_XS] * (tdble)bankingtype;
    curBorder->angle[TR_XE] = curSeg->angle[TR_XE] * (tdble)bankingtype;
    curBorder->angle[TR_ZS] = curSeg->angle[TR_ZS];
    curBorder->angle[TR_ZE] = curSeg->angle[TR_ZE];
    curBorder->angle[TR_CS] = curSeg->angle[TR_CS];
 
    switch (curSeg->type) {
    case TR_STR:
        curBorder->length = curSeg->length;
        initSideForStraight(curBorder, curSeg, side, bankingtype, startwidth, endwidth);
        break;
    case TR_LFT:
        initSideForTurn(TR_LFT, curBorder, curSeg, side, bankingtype, startwidth, endwidth, maxWidth);
        break;
    case TR_RGT:
        initSideForTurn(TR_RGT, curBorder, curSeg, side, bankingtype, startwidth, endwidth, maxWidth);
        break;
    }
 
    return curBorder;
}