api/grscene_8cpp_source.html

/***************************************************************************


    file                 : grscene.cpp

    created              : Mon Aug 21 20:13:56 CEST 2000

    copyright            : (C) 2000 by Eric Espie

    email                : torcs@free.fr

    version              : $Id$


 ***************************************************************************/


/***************************************************************************

 *                                                                         *

 *   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 <math.h>

#include <stdlib.h>

#include <sys/types.h>

#include <stdio.h>

#include <ctype.h>

#ifdef WIN32

#include <windows.h>

#include <GL/gl.h>

#include <GL/glext.h>

#endif

#include <GL/glut.h>

#include <plib/ssg.h>

#include <plib/ssgAux.h>

#include <tgfclient.h>

#include <track.h>

#include <car.h>

#include <graphic.h>

#include <robottools.h>

#include <portability.h>


#include "grmain.h"

#include "grshadow.h"

#include "grskidmarks.h"

#include "grsmoke.h"

#include "grcar.h"

#include "grcam.h"

#include "grscene.h"

#include "grutil.h"

#include "grssgext.h"

#include "grtexture.h"


int grWrldX;

int grWrldY;

int grWrldZ;

int grWrldMaxSize;

sgVec3 grRenderOrigin;

tTrack     *grTrack;


ssgStateSelector    *grEnvSelector;

grMultiTexState  *grEnvState=NULL;

grMultiTexState  *grEnvShadowState=NULL;

grMultiTexState  *grEnvShadowStateOnCars=NULL;

#define NB_BG_FACES 36

#define BG_DIST     1.0


ssgRoot *TheScene = 0;

static ssgRoot *TheBackground = 0;

static ssgTransform *WorldAnchor = 0;


/* TheScene kid order */

ssgTransform *SunAnchor = 0;

ssgBranch *LandAnchor = 0;

ssgBranch *CarsAnchor = 0;

ssgBranch *ShadowAnchor = 0;

ssgBranch *PitsAnchor = 0;

ssgTransform *SmokeAnchor = 0;

ssgBranch *SkidAnchor = 0;

ssgBranch *CarlightAnchor = 0;


ssgBranch *ThePits = 0;

ssgTransform *sun_grscene = NULL ;


static void initBackground(void);


extern ssgEntity *grssgLoadAC3D ( const char *fname, const ssgLoaderOptions* options );


int preScene(ssgEntity *e)

{

  return TRUE;

}


int


grInitScene(void)

{

    void *hndl = grTrackHandle;

    ssgLight *light = ssgGetLight(0);


    GLfloat mat_specular[]   = {0.3, 0.3, 0.3, 1.0};

    GLfloat mat_shininess[]  = {50.0};

    GLfloat light_position[] = {0, 0, 200, 0.0};

    GLfloat lmodel_ambient[] = {0.2, 0.2, 0.2, 1.0};

    GLfloat lmodel_diffuse[] = {0.8, 0.8, 0.8, 1.0};

    GLfloat fog_clr[]        = {1.0, 1.0, 1.0, 0.5};


    mat_specular[0] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_SPEC_R, NULL, mat_specular[0]);

    mat_specular[1] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_SPEC_G, NULL, mat_specular[1]);

    mat_specular[2] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_SPEC_B, NULL, mat_specular[2]);


    lmodel_ambient[0] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_AMBIENT_R, NULL, lmodel_ambient[0]);

    lmodel_ambient[1] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_AMBIENT_G, NULL, lmodel_ambient[1]);

    lmodel_ambient[2] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_AMBIENT_B, NULL, lmodel_ambient[2]);


    lmodel_diffuse[0] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_DIFFUSE_R, NULL, lmodel_diffuse[0]);

    lmodel_diffuse[1] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_DIFFUSE_G, NULL, lmodel_diffuse[1]);

    lmodel_diffuse[2] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_DIFFUSE_B, NULL, lmodel_diffuse[2]);


    mat_shininess[0] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_SHIN, NULL, mat_shininess[0]);


    light_position[0] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_LIPOS_X, NULL, light_position[0]);

    light_position[1] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_LIPOS_Y, NULL, light_position[1]);

    light_position[2] = GfParmGetNum(hndl, TRK_SECT_GRAPH, TRK_ATT_LIPOS_Z, NULL, light_position[2]);


    glShadeModel(GL_SMOOTH);


    light->setPosition(light_position[0],light_position[1],light_position[2]);

    light->setColour(GL_AMBIENT,lmodel_ambient);

    light->setColour(GL_DIFFUSE,lmodel_diffuse);

    light->setColour(GL_SPECULAR,mat_specular);

    light->setSpotAttenuation(0.0, 0.0, 0.0);


    sgCopyVec3 (fog_clr,  grTrack->graphic.bgColor);

    sgScaleVec3 (fog_clr, 0.8);

    glFogi(GL_FOG_MODE, GL_LINEAR);

    glFogfv(GL_FOG_COLOR, fog_clr);

    glFogf(GL_FOG_DENSITY, 0.05);

    glHint(GL_FOG_HINT, GL_DONT_CARE);


    glEnable(GL_LIGHTING);

    glEnable(GL_LIGHT0);

    glEnable(GL_DEPTH_TEST);


    if (!sun_grscene) {

        ssgaLensFlare *sun_obj = NULL ;

        sun_obj = new ssgaLensFlare () ;

        sun_grscene = new ssgTransform ;

        sun_grscene->setTransform( light_position );

        sun_grscene-> addKid(sun_obj);

        SunAnchor-> addKid(sun_grscene);

    }


    /* GUIONS GL_TRUE */

    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_FALSE);


#ifdef GL_SEPARATE_SPECULAR_COLOR

    glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR);

#else

#ifdef GL_SEPARATE_SPECULAR_COLOR_EXT

    glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL_EXT,GL_SEPARATE_SPECULAR_COLOR_EXT);

#endif

#endif


    return 0;

}


static ssgLoaderOptionsEx options;


int


grLoadScene(tTrack *track)

{

    void *hndl = grTrackHandle;

    const char *acname;

    ssgEntity *desc;

    const int BUFSIZE = 256;

    char buf[BUFSIZE];


    if (maxTextureUnits==0) {

        InitMultiTex();

    }


    ssgSetCurrentOptions(&options);

    ssgAddTextureFormat(".png", grLoadPngTexture);

    grRegisterCustomSGILoader();


    grTrack = track;

    grRenderOrigin[0] = grRenderOrigin[1] = grRenderOrigin[2] = 0.0f;

    TheScene = new ssgRoot;

    WorldAnchor = new ssgTransform;

    TheScene->addKid(WorldAnchor);


    /* Landscape */

    LandAnchor = new ssgBranch;

    WorldAnchor->addKid(LandAnchor);


    /* Pit stops walls */

    PitsAnchor = new ssgBranch;

    WorldAnchor->addKid(PitsAnchor);


    /* Skid Marks */

    SkidAnchor = new ssgBranch;

    WorldAnchor->addKid(SkidAnchor);


    /* Car shadows */

    ShadowAnchor = new ssgBranch;

    WorldAnchor->addKid(ShadowAnchor);


    /* Car lights */

    CarlightAnchor = new ssgBranch;

    WorldAnchor->addKid(CarlightAnchor);


    /* Car bodies use rebased matrices; global effects use scene transforms. */

    CarsAnchor = new ssgBranch;

    TheScene->addKid(CarsAnchor);


    /* Smoke */

    SmokeAnchor = new ssgTransform;

    TheScene->addKid(SmokeAnchor);


    /* Lens Flares */

    SunAnchor = new ssgTransform;

    TheScene->addKid(SunAnchor);


    initBackground();


    grWrldX = (int)(track->max.x - track->min.x + 1);

    grWrldY = (int)(track->max.y - track->min.y + 1);

    grWrldZ = (int)(track->max.z - track->min.z + 1);

    grWrldMaxSize = (int)(MAX(MAX(grWrldX, grWrldY), grWrldZ));


    acname = GfParmGetStr(hndl, TRK_SECT_GRAPH, TRK_ATT_3DDESC, "track.ac");

    if (strlen(acname) == 0) {

        return -1;

    }


    snprintf(buf, BUFSIZE, "tracks/%s/%s;data/textures;data/img;.", grTrack->category, grTrack->internalname);

    ssgTexturePath(buf);

    snprintf(buf, BUFSIZE, "tracks/%s/%s", grTrack->category, grTrack->internalname);

    ssgModelPath(buf);


    desc = grssgLoadAC3D(acname, NULL);

    LandAnchor->addKid(desc);


    return 0;

}


void grDrawScene(void)

{

    TRACE_GL("refresh: ssgCullAndDraw start");

    ssgCullAndDraw(TheScene);

    TRACE_GL("refresh: ssgCullAndDraw");

}


void grSetRenderOrigin(double x, double y)

{

    const float originX = (float)(floor(x / 1000.0) * 1000.0);

    const float originY = (float)(floor(y / 1000.0) * 1000.0);

    if ((originX == grRenderOrigin[0]) && (originY == grRenderOrigin[1])) {

        return;

    }


    sgMat4 mat;

    grRenderOrigin[0] = originX;

    grRenderOrigin[1] = originY;

    grRenderOrigin[2] = 0.0f;

    sgMakeTransMat4(mat, -grRenderOrigin[0], -grRenderOrigin[1], 0.0f);

    WorldAnchor->setTransform(mat);

    SmokeAnchor->setTransform(mat);

    SunAnchor->setTransform(mat);

}


void grShutdownScene(void)

{

    if (TheScene) {

        delete TheScene;

        TheScene = 0;

    }


    if (TheBackground) {

        delete TheBackground;

        TheBackground = 0;

    }


    if (grEnvState != NULL) {

        ssgDeRefDelete(grEnvState);

        grEnvState = NULL;

    }

    if (grEnvShadowState != NULL) {

        ssgDeRefDelete(grEnvShadowState);

        grEnvShadowState = NULL;

    }

    if (grEnvShadowStateOnCars != NULL) {

        ssgDeRefDelete(grEnvShadowStateOnCars);

        grEnvShadowStateOnCars = NULL;

    }

    if(grEnvSelector != NULL) {

        delete grEnvSelector;

        grEnvSelector = NULL;

    }


    options.endLoad();

}


static void


initBackground(void)

{

    int         i;

    float       x, y, z1, z2;

    double      alpha;

    float       texLen;

    tTrackGraphicInfo  *graphic;

    ssgSimpleState  *envst;

    sgVec3      vtx;

    sgVec4      clr;

    sgVec3      nrm;

    sgVec2      tex;

    const int BUFSIZE = 1024;

    char buf[BUFSIZE];

    ssgVtxTable     *bg;

    ssgVertexArray  *bg_vtx;

    ssgTexCoordArray    *bg_tex;

    ssgColourArray  *bg_clr;

    ssgNormalArray  *bg_nrm;

    ssgSimpleState  *bg_st;


    snprintf(buf, BUFSIZE, "tracks/%s/%s;data/img;data/textures;.", grTrack->category, grTrack->internalname);

    grFilePath = buf;

    grGammaValue = 1.8;

    grMipMap = 0;


    graphic = &grTrack->graphic;

    glClearColor(graphic->bgColor[0], graphic->bgColor[1], graphic->bgColor[2], 1.0);


    TheBackground = new ssgRoot();

    clr[0] = clr[1] = clr[2] = 1.0;

    clr[3] = 1.0;

    nrm[0] = nrm[2] = 0.0;

    nrm[1] = 1.0;


    z1 = -0.5;

    z2 = 1.0;

    switch (graphic->bgtype) {

    case 0:

    bg_vtx = new ssgVertexArray(NB_BG_FACES + 1);

    bg_tex = new ssgTexCoordArray(NB_BG_FACES + 1);

    bg_clr = new ssgColourArray(1);

    bg_nrm = new ssgNormalArray(1);


    bg_clr->add(clr);

    bg_nrm->add(nrm);


    for (i = 0; i < NB_BG_FACES + 1; i++) {

        alpha = (float)i * 2 * PI / (float)NB_BG_FACES;

        texLen = (float)i / (float)NB_BG_FACES;


        x = BG_DIST * cos(alpha);

        y = BG_DIST * sin(alpha);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z1;

        bg_vtx->add(vtx);

        tex[0] = texLen*4.0;

        tex[1] = 0;

        bg_tex->add(tex);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z2;

        bg_vtx->add(vtx);

        tex[0] = texLen*4.0;

        tex[1] = 1.0;

        bg_tex->add(tex);

    }

    bg = new ssgVtxTable(GL_TRIANGLE_STRIP, bg_vtx, bg_nrm, bg_tex, bg_clr);

    bg_st = (ssgSimpleState*)grSsgLoadTexState(graphic->background);

    bg_st->disable(GL_LIGHTING);

    bg->setState(bg_st);

    bg->setCullFace(0);

    TheBackground->addKid(bg);

    break;


    case 2:

    bg_vtx = new ssgVertexArray(NB_BG_FACES + 1);

    bg_tex = new ssgTexCoordArray(NB_BG_FACES + 1);

    bg_clr = new ssgColourArray(1);

    bg_nrm = new ssgNormalArray(1);


    bg_clr->add(clr);

    bg_nrm->add(nrm);


    for (i = 0; i < NB_BG_FACES / 4 + 1; i++) {

        alpha = (float)i * 2 * PI / (float)NB_BG_FACES;

        texLen = (float)i / (float)NB_BG_FACES;


        x = BG_DIST * cos(alpha);

        y = BG_DIST * sin(alpha);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z1;

        bg_vtx->add(vtx);

        tex[0] = texLen*4.0;

        tex[1] = 0;

        bg_tex->add(tex);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z2;

        bg_vtx->add(vtx);

        tex[0] = texLen*4.0;

        tex[1] = 0.5;

        bg_tex->add(tex);

    }

    bg = new ssgVtxTable(GL_TRIANGLE_STRIP, bg_vtx, bg_nrm, bg_tex, bg_clr);

    bg_st = (ssgSimpleState*)grSsgLoadTexState(graphic->background);

    bg_st->disable(GL_LIGHTING);

    bg->setState(bg_st);

    bg->setCullFace(0);

    TheBackground->addKid(bg);


    bg_vtx = new ssgVertexArray(NB_BG_FACES + 1);

    bg_tex = new ssgTexCoordArray(NB_BG_FACES + 1);

    bg_clr = new ssgColourArray(1);

    bg_nrm = new ssgNormalArray(1);


    bg_clr->add(clr);

    bg_nrm->add(nrm);


    for (i = NB_BG_FACES/4; i < NB_BG_FACES / 2 + 1; i++) {

        alpha = (float)i * 2 * PI / (float)NB_BG_FACES;

        texLen = (float)i / (float)NB_BG_FACES;


        x = BG_DIST * cos(alpha);

        y = BG_DIST * sin(alpha);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z1;

        bg_vtx->add(vtx);

        tex[0] = texLen*4.0;

        tex[1] = 0.5;

        bg_tex->add(tex);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z2;

        bg_vtx->add(vtx);

        tex[0] = texLen*4.0;

        tex[1] = 1.0;

        bg_tex->add(tex);

    }

    bg = new ssgVtxTable(GL_TRIANGLE_STRIP, bg_vtx, bg_nrm, bg_tex, bg_clr);

    bg_st = (ssgSimpleState*)grSsgLoadTexState(graphic->background);

    bg_st->disable(GL_LIGHTING);

    bg->setState(bg_st);

    bg->setCullFace(0);

    TheBackground->addKid(bg);


    bg_vtx = new ssgVertexArray(NB_BG_FACES + 1);

    bg_tex = new ssgTexCoordArray(NB_BG_FACES + 1);

    bg_clr = new ssgColourArray(1);

    bg_nrm = new ssgNormalArray(1);


    bg_clr->add(clr);

    bg_nrm->add(nrm);


    for (i = NB_BG_FACES / 2; i < 3 * NB_BG_FACES / 4 + 1; i++) {

        alpha = (float)i * 2 * PI / (float)NB_BG_FACES;

        texLen = (float)i / (float)NB_BG_FACES;


        x = BG_DIST * cos(alpha);

        y = BG_DIST * sin(alpha);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z1;

        bg_vtx->add(vtx);

        tex[0] = texLen*4.0;

        tex[1] = 0.0;

        bg_tex->add(tex);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z2;

        bg_vtx->add(vtx);

        tex[0] = texLen*4.0;

        tex[1] = 0.5;

        bg_tex->add(tex);

    }

    bg = new ssgVtxTable(GL_TRIANGLE_STRIP, bg_vtx, bg_nrm, bg_tex, bg_clr);

    bg_st = (ssgSimpleState*)grSsgLoadTexState(graphic->background);

    bg_st->disable(GL_LIGHTING);

    bg->setState(bg_st);

    bg->setCullFace(0);

    TheBackground->addKid(bg);


    bg_vtx = new ssgVertexArray(NB_BG_FACES + 1);

    bg_tex = new ssgTexCoordArray(NB_BG_FACES + 1);

    bg_clr = new ssgColourArray(1);

    bg_nrm = new ssgNormalArray(1);


    bg_clr->add(clr);

    bg_nrm->add(nrm);


    for (i = 3 * NB_BG_FACES / 4; i < NB_BG_FACES + 1; i++) {

        alpha = (float)i * 2 * PI / (float)NB_BG_FACES;

        texLen = (float)i / (float)NB_BG_FACES;


        x = BG_DIST * cos(alpha);

        y = BG_DIST * sin(alpha);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z1;

        bg_vtx->add(vtx);

        tex[0] = texLen*4.0;

        tex[1] = 0.5;

        bg_tex->add(tex);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z2;

        bg_vtx->add(vtx);

        tex[0] = texLen*4.0;

        tex[1] = 1.0;

        bg_tex->add(tex);

    }

    bg = new ssgVtxTable(GL_TRIANGLE_STRIP, bg_vtx, bg_nrm, bg_tex, bg_clr);

    bg_st = (ssgSimpleState*)grSsgLoadTexState(graphic->background);

    bg_st->disable(GL_LIGHTING);

    bg->setState(bg_st);

    bg->setCullFace(0);

    TheBackground->addKid(bg);


    break;


    case 4:

    z1 = -1.0;

    z2 = 1.0;


    bg_vtx = new ssgVertexArray(NB_BG_FACES + 1);

    bg_tex = new ssgTexCoordArray(NB_BG_FACES + 1);

    bg_clr = new ssgColourArray(1);

    bg_nrm = new ssgNormalArray(1);


    bg_clr->add(clr);

    bg_nrm->add(nrm);


    for (i = 0; i < NB_BG_FACES + 1; i++) {

        alpha = (double)i * 2 * PI / (double)NB_BG_FACES;

        texLen = 1.0 - (float)i / (float)NB_BG_FACES;


        x = BG_DIST * cos(alpha);

        y = BG_DIST * sin(alpha);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z1;

        bg_vtx->add(vtx);

        tex[0] = texLen;

        tex[1] = 0;

        bg_tex->add(tex);


        vtx[0] = x;

        vtx[1] = y;

        vtx[2] = z2;

        bg_vtx->add(vtx);

        tex[0] = texLen;

        tex[1] = 1.0;

        bg_tex->add(tex);

    }

    bg = new ssgVtxTable(GL_TRIANGLE_STRIP, bg_vtx, bg_nrm, bg_tex, bg_clr);

    bg_st = (ssgSimpleState*)grSsgLoadTexState(graphic->background);

    bg_st->disable(GL_LIGHTING);

    bg->setState(bg_st);

    bg->setCullFace(0);

    TheBackground->addKid(bg);

    break;


    default:

    break;

    }


    /* Environment Mapping Settings */

    grEnvSelector = new ssgStateSelector(graphic->envnb);

    for (i = 0; i < graphic->envnb; i++) {

      GfOut("Loading Environment Mapping Image %s\n", graphic->env[i]);

      envst = (ssgSimpleState*)grSsgLoadTexState(graphic->env[i]);

      envst->enable(GL_BLEND);

      grEnvSelector->setStep(i, envst);

    }

    grEnvSelector->selectStep(0); /* mandatory !!! */

    grEnvState=(grMultiTexState*)grSsgEnvTexState(graphic->env[0]);

    grEnvShadowState=(grMultiTexState*)grSsgEnvTexState("envshadow.png");

    grEnvShadowStateOnCars=(grMultiTexState*)grSsgEnvTexState("shadow2.rgb");


    if (grEnvState != NULL) {

        grEnvState->ref();

    }


    if (grEnvShadowState == NULL) {

        ulSetError ( UL_WARNING, "grscene:initBackground Failed to open envshadow.png for reading") ;

        ulSetError ( UL_WARNING, "        mandatory for top env mapping ") ;

        ulSetError ( UL_WARNING, "        should be in the .xml !! ") ;

        ulSetError ( UL_WARNING, "        copy the envshadow.png from g-track-2 to the track you selected ") ;

        ulSetError ( UL_WARNING, "        c'est pas classe comme sortie, mais ca evite un crash ") ;

        GfScrShutdown();

        exit(-1);

    } else {

        grEnvShadowState->ref();

    }


    if (grEnvShadowStateOnCars == NULL) {

        ulSetError ( UL_WARNING, "grscene:initBackground Failed to open shadow2.rgb for reading") ;

        ulSetError ( UL_WARNING, "        no shadow mapping on cars for this track ") ;

    } else {

        grEnvShadowStateOnCars->ref();

    }

}


void grDrawBackground(class cGrCamera *cam, class cGrBackgroundCam *bgCam)

{

    TRACE_GL("grDrawBackground: ssgCullAndDraw start");


    bgCam->update(cam);

    bgCam->action();


    ssgCullAndDraw(TheBackground);


    TRACE_GL("grDrawBackground: ssgCullAndDraw");

}


void


grCustomizePits(void)

{

    tTrackPitInfo *pits;

    int i;

    tdble x, y;

    tdble x2, y2, z2;


    ThePits = new ssgBranch();

    PitsAnchor->addKid(ThePits);


    pits = &(grTrack->pits);

    /* draw the pit identification */


    switch (pits->type) {

    case TR_PIT_ON_TRACK_SIDE:

        for (i = 0; i < pits->nMaxPits; i++) {

            const int BUFSIZE=256;

            char buf[BUFSIZE];

            t3Dd normalvector;

            sgVec3 vtx;

            sgVec4 clr = {0,0,0,1};

            sgVec3 nrm;

            sgVec2 tex;

            ssgState *st;

            ssgVertexArray *pit_vtx = new ssgVertexArray(4);

            ssgTexCoordArray *pit_tex = new ssgTexCoordArray(4);

            ssgColourArray *pit_clr = new ssgColourArray(1);

            ssgNormalArray *pit_nrm = new ssgNormalArray(1);


            pit_clr->add(clr);


            if (pits->driversPits[i].car[0]) {

                // If we have more than one car in the pit use the team pit logo of driver 0.

                if (pits->driversPits[i].freeCarIndex == 1) {

                    // One car assigned to the pit.

                    snprintf(buf, BUFSIZE, "drivers/%s/%d;drivers/%s;data/textures;data/img;.",

                        pits->driversPits[i].car[0]->_modName, pits->driversPits[i].car[0]->_driverIndex,

                        pits->driversPits[i].car[0]->_modName);

                } else {

                    // Multiple cars assigned to the pit.

                    snprintf(buf, BUFSIZE, "drivers/%s;data/textures;data/img;.", pits->driversPits[i].car[0]->_modName);

                }

            } else {

                snprintf(buf, BUFSIZE, "data/textures;data/img;.");

            }


            st = grSsgLoadTexStateEx("logo.rgb", buf, FALSE, FALSE);

            ((ssgSimpleState*)st)->setShininess(50);


            RtTrackLocal2Global(&(pits->driversPits[i].pos), &x, &y, pits->driversPits[i].pos.type);

            RtTrackSideNormalG(pits->driversPits[i].pos.seg, x, y, pits->side, &normalvector);

            x2 = x - pits->width/2.0 * normalvector.x + pits->len/2.0 * normalvector.y;

            y2 = y - pits->width/2.0 * normalvector.y - pits->len/2.0 * normalvector.x;

            z2 = RtTrackHeightG(pits->driversPits[i].pos.seg, x2, y2);


            nrm[0] = normalvector.x;

            nrm[1] = normalvector.y;

            nrm[2] = 0;

            pit_nrm->add(nrm);


            tex[0] = -0.7;

            tex[1] = 0.33;

            vtx[0] = x2;

            vtx[1] = y2;

            vtx[2] = z2;

            pit_tex->add(tex);

            pit_vtx->add(vtx);


            tex[0] = -0.7;

            tex[1] = 1.1;

            vtx[0] = x2;

            vtx[1] = y2;

            vtx[2] = z2 + 4.8;

            pit_tex->add(tex);

            pit_vtx->add(vtx);


            x2 = x - pits->width/2.0 * normalvector.x - pits->len/2.0 * normalvector.y;

            y2 = y - pits->width/2.0 * normalvector.y + pits->len/2.0 * normalvector.x;

            z2 = RtTrackHeightG(pits->driversPits[i].pos.seg, x2, y2);


            tex[0] = 1.3;

            tex[1] = 0.33;

            vtx[0] = x2;

            vtx[1] = y2;

            vtx[2] = z2;

            pit_tex->add(tex);

            pit_vtx->add(vtx);


            tex[0] = 1.3;

            tex[1] = 1.1;

            vtx[0] = x2;

            vtx[1] = y2;

            vtx[2] = z2 + 4.8;

            pit_tex->add(tex);

            pit_vtx->add(vtx);


            ssgVtxTable *pit = new ssgVtxTable(GL_TRIANGLE_STRIP, pit_vtx, pit_nrm, pit_tex, pit_clr);

            pit->setState(st);

            pit->setCullFace(0);

            ThePits->addKid(pit);

        }

    break;

    case TR_PIT_ON_SEPARATE_PATH:

    break;

    case TR_PIT_NONE:

    break;

    }

}


y
static Vector y[4]
Definition Convex.cpp:56

PI
static const double PI
Definition Distribution.cpp:17

cGrBackgroundCam
Definition grcam.h:232

cGrBackgroundCam::update
void update(tCarElt *car, tSituation *s)
Definition grcam.h:241

cGrCamera
Definition grcam.h:37

cGrCamera::action
void action(void)
Definition grcam.h:85

grMultiTexState
Definition grmultitexstate.h:25

ssgLoaderOptionsEx
Definition grssgext.h:81

grcam.h

grcar.h

maxTextureUnits
int maxTextureUnits
Definition grmain.cpp:47

grTrackHandle
void * grTrackHandle
Definition grmain.cpp:59

InitMultiTex
bool InitMultiTex(void)
Definition grmain.cpp:83

grmain.h

tdble
float tdble
Floating point type used in TORCS.
Definition tgf.h:47

GfParmGetStr
const char * GfParmGetStr(void *parmHandle, const char *path, const char *key, const char *deflt)
Get a string parameter from the parameter set handle.
Definition params.cpp:2453

GfParmGetNum
tdble GfParmGetNum(void *handle, const char *path, const char *key, const char *unit, tdble deflt)
Get a numerical parameter from the parameter set handle.
Definition params.cpp:2534

GfScrShutdown
void GfScrShutdown(void)
Shutdown the screen.
Definition screen.cpp:501

RtTrackHeightG
tdble RtTrackHeightG(tTrackSeg *seg, tdble X, tdble Y)
Returns the absolute height in meters of the road at the Global position (segment,...
Definition rttrack.cpp:465

RtTrackLocal2Global
void RtTrackLocal2Global(tTrkLocPos *p, tdble *X, tdble *Y, int flag)
Calculate global coordinates from a local position relative to the given track segment (segment,...
Definition rttrack.cpp:81

RtTrackSideNormalG
void RtTrackSideNormalG(tTrackSeg *seg, tdble X, tdble Y, int side, t3Dd *norm)
Compute the horizontal inward border normal using the supplied segment.
Definition rttrack.cpp:495

NB_BG_FACES
#define NB_BG_FACES
Definition grscene.cpp:64

grInitScene
int grInitScene(void)
Definition grscene.cpp:95

LandAnchor
ssgBranch * LandAnchor
Definition grscene.cpp:73

grShutdownScene
void grShutdownScene(void)
Definition grscene.cpp:276

TheScene
ssgRoot * TheScene
Definition grscene.cpp:67

grssgLoadAC3D
ssgEntity * grssgLoadAC3D(const char *fname, const ssgLoaderOptions *options)
Definition grloadac.cpp:1149

grEnvState
grMultiTexState * grEnvState
Definition grscene.cpp:61

grTrack
tTrack * grTrack
Definition grscene.cpp:58

grCustomizePits
void grCustomizePits(void)
Definition grscene.cpp:642

grWrldZ
int grWrldZ
Definition grscene.cpp:55

sun_grscene
ssgTransform * sun_grscene
Definition grscene.cpp:82

grWrldY
int grWrldY
Definition grscene.cpp:54

grWrldX
int grWrldX
Definition grscene.cpp:53

grEnvSelector
ssgStateSelector * grEnvSelector
Definition grscene.cpp:60

grEnvShadowState
grMultiTexState * grEnvShadowState
Definition grscene.cpp:62

SmokeAnchor
ssgTransform * SmokeAnchor
Definition grscene.cpp:77

grLoadScene
int grLoadScene(tTrack *track)
Definition grscene.cpp:170

grEnvShadowStateOnCars
grMultiTexState * grEnvShadowStateOnCars
Definition grscene.cpp:63

grRenderOrigin
sgVec3 grRenderOrigin
Definition grscene.cpp:57

grDrawBackground
void grDrawBackground(class cGrCamera *cam, class cGrBackgroundCam *bgCam)
Definition grscene.cpp:629

CarsAnchor
ssgBranch * CarsAnchor
Definition grscene.cpp:74

SkidAnchor
ssgBranch * SkidAnchor
Definition grscene.cpp:78

TheBackground
static ssgRoot * TheBackground
Definition grscene.cpp:68

initBackground
static void initBackground(void)
Definition grscene.cpp:310

preScene
int preScene(ssgEntity *e)
Definition grscene.cpp:88

PitsAnchor
ssgBranch * PitsAnchor
Definition grscene.cpp:76

WorldAnchor
static ssgTransform * WorldAnchor
Definition grscene.cpp:69

grWrldMaxSize
int grWrldMaxSize
Definition grscene.cpp:56

ShadowAnchor
ssgBranch * ShadowAnchor
Definition grscene.cpp:75

CarlightAnchor
ssgBranch * CarlightAnchor
Definition grscene.cpp:79

grSetRenderOrigin
void grSetRenderOrigin(double x, double y)
Definition grscene.cpp:257

ThePits
ssgBranch * ThePits
Definition grscene.cpp:81

SunAnchor
ssgTransform * SunAnchor
Definition grscene.cpp:72

grDrawScene
void grDrawScene(void)
Definition grscene.cpp:249

BG_DIST
#define BG_DIST
Definition grscene.cpp:65

options
static ssgLoaderOptionsEx options
Definition grscene.cpp:167

grscene.h

grshadow.h

grskidmarks.h

grsmoke.h

grssgext.h
This file contains the divergences from PLIB.

grRegisterCustomSGILoader
void grRegisterCustomSGILoader(void)
Definition grtexture.cpp:129

grtexture.h

grGammaValue
float grGammaValue
Definition grutil.cpp:39

grSsgLoadTexState
ssgState * grSsgLoadTexState(const char *img)
Definition grutil.cpp:219

grLoadPngTexture
bool grLoadPngTexture(const char *fname, ssgTextureInfo *info)
Definition grutil.cpp:91

grFilePath
char * grFilePath
Definition grutil.cpp:42

grSsgEnvTexState
ssgState * grSsgEnvTexState(const char *img)
Definition grutil.cpp:251

grMipMap
int grMipMap
Definition grutil.cpp:40

grSsgLoadTexStateEx
ssgState * grSsgLoadTexStateEx(const char *img, char *filepath, int wrap, int mipmap)
Definition grutil.cpp:284

grutil.h

TRACE_GL
#define TRACE_GL(msg)
Definition grutil.h:28

TrackOwnPit::pos
tTrkLocPos pos
Center of the pit position.
Definition track.h:457

TrackOwnPit::freeCarIndex
int freeCarIndex
Definition track.h:463

TrackOwnPit::car
struct CarElt * car[TR_PIT_MAXCARPERPIT]
Car links for pit.
Definition track.h:464

t3Dd
3D point.
Definition tgf.h:114

t3Dd::y
tdble y
y coordinate
Definition tgf.h:116

t3Dd::x
tdble x
x coordinate
Definition tgf.h:115

tTrackGraphicInfo
Definition track.h:504

tTrackGraphicInfo::envnb
int envnb
Definition track.h:509

tTrackGraphicInfo::bgColor
float bgColor[3]
Definition track.h:508

tTrackGraphicInfo::env
const char ** env
Definition track.h:510

tTrackGraphicInfo::background
const char * background
Definition track.h:505

tTrackGraphicInfo::bgtype
int bgtype
Definition track.h:507

tTrack
Track structure.
Definition track.h:533

tTrackPitInfo
Pits Info Structure.
Definition track.h:469

tTrackPitInfo::driversPits
tTrackOwnPit * driversPits
List of pits by driver.
Definition track.h:490

tTrackPitInfo::side
int side
Pits side:
Definition track.h:479

tTrackPitInfo::len
tdble len
Lenght of each pit stop.
Definition track.h:483

tTrackPitInfo::type
int type
Type of Pit:
Definition track.h:470

tTrackPitInfo::nMaxPits
int nMaxPits
number max of pits
Definition track.h:477

tTrackPitInfo::width
tdble width
Width of each pit stop.
Definition track.h:484

tTrkLocPos::seg
tTrackSeg * seg
Track segment.
Definition track.h:435

tTrkLocPos::type
int type
Type of description:
Definition track.h:436

GfOut
#define GfOut
Definition tgf.h:372

MAX
#define MAX(x, y)
Definition tgf.h:52

TRK_ATT_SHIN
#define TRK_ATT_SHIN
Definition track.h:79

TRK_ATT_LIPOS_Y
#define TRK_ATT_LIPOS_Y
Definition track.h:81

TRK_ATT_SPEC_G
#define TRK_ATT_SPEC_G
Definition track.h:71

TRK_SECT_GRAPH
#define TRK_SECT_GRAPH
Definition track.h:59

TRK_ATT_SPEC_B
#define TRK_ATT_SPEC_B
Definition track.h:72

TRK_ATT_AMBIENT_R
#define TRK_ATT_AMBIENT_R
Definition track.h:73

TRK_ATT_LIPOS_X
#define TRK_ATT_LIPOS_X
Definition track.h:80

TRK_ATT_LIPOS_Z
#define TRK_ATT_LIPOS_Z
Definition track.h:82

TRK_ATT_AMBIENT_G
#define TRK_ATT_AMBIENT_G
Definition track.h:74

TRK_ATT_SPEC_R
#define TRK_ATT_SPEC_R
Definition track.h:70

TRK_ATT_3DDESC
#define TRK_ATT_3DDESC
Definition track.h:61

TR_PIT_NONE
#define TR_PIT_NONE
No pits for that tracks.
Definition track.h:474

TRK_ATT_DIFFUSE_R
#define TRK_ATT_DIFFUSE_R
Definition track.h:76

TR_PIT_ON_TRACK_SIDE
#define TR_PIT_ON_TRACK_SIDE
The pits are on the track side.
Definition track.h:475

TRK_ATT_AMBIENT_B
#define TRK_ATT_AMBIENT_B
Definition track.h:75

TR_PIT_ON_SEPARATE_PATH
#define TR_PIT_ON_SEPARATE_PATH
Definition track.h:476

TRK_ATT_DIFFUSE_G
#define TRK_ATT_DIFFUSE_G
Definition track.h:77

TRK_ATT_DIFFUSE_B
#define TRK_ATT_DIFFUSE_B
Definition track.h:78

track
int track(tModInfo *modInfo)
Definition trackitf.cpp:85