grmain.cpp

Go to the documentation of this file.

/***************************************************************************
 
    file                 : grmain.cpp
    created              : Thu Aug 17 23:23:49 CEST 2000
    copyright            : (C) 2013-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 <time.h>
#include <stdlib.h>
#include <stdio.h>
#ifdef WIN32
#include <windows.h>
#endif
#include <GL/glut.h>
#include <plib/ssg.h>
 
#include <tgfclient.h>
#include <portability.h>
#include <graphic.h>
 
#include "grmain.h"
#include "grshadow.h"
#include "grskidmarks.h"
#include "grsmoke.h"
#include "grcar.h"
#include "grscreen.h"
#include "grcam.h"
#include "grscene.h"
#include "grsound.h"
#include "grboard.h"
#include "grutil.h"
#include "grtrackmap.h"
#include "grcarlight.h"
#include <glfeatures.h>
 
int maxTextureUnits = 0;
static double OldTime;
static int nFrame;
float grFps;
double grCurTime;
double grDeltaTime;
int segIndice = 0;
 
tdble grMaxDammage = 10000.0;
int grNbCars = 0;
 
void *grHandle = NULL;
void *grTrackHandle = NULL;
 
int grWinx, grWiny, grWinw, grWinh;
 
static float grMouseRatioX, grMouseRatioY;
 
tgrCarInfo *grCarInfo;
ssgContext grContext;
class cGrScreen *grScreens[GR_NB_MAX_SCREEN] = {NULL, NULL, NULL, NULL};
int grNbScreen = 1;
tdble grLodFactorValue = 1.0;
EWheelDetail grUseDetailedWheels = DETAILED;
 
#ifdef WIN32
#include <GL/glext.h>
PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = NULL;
PFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB = NULL;
PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = NULL;
PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = NULL;
#endif
 
 
// InitMultiTex
// desc: sets up OpenGL for multitexturing support
bool InitMultiTex(void)
{
    if (GetSingleTextureMode ()) {
        maxTextureUnits = 1;
        return true;
    } else {
        // list of available extensions
        char *extensionStr = (char*)glGetString(GL_EXTENSIONS);
        if (extensionStr == NULL)
            return false;
 
        if (strstr(extensionStr, "GL_ARB_multitexture")) {
            // retrieve the maximum number of texture units allowed
            glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnits);
#ifdef WIN32
            // retrieve addresses of multitexturing functions
            glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC) wglGetProcAddress("glMultiTexCoord2fARB");
            glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTextureARB");
            glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) wglGetProcAddress("glClientActiveTextureARB");
            glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC) wglGetProcAddress("glMultiTexCoord2fvARB");
#endif
            return true;
        } else {
            return false;
        }
    }
}
 
 
static void grAdaptScreenSize(void)
{
    switch (grNbScreen) {
    case 0:
    case 1:
    grScreens[0]->activate(grWinx, grWiny, grWinw, grWinh);
    grScreens[1]->desactivate();
    grScreens[2]->desactivate();
    grScreens[3]->desactivate();
    break;
    case 2:
    grScreens[0]->activate(grWinx, grWiny + grWinh / 2, grWinw, grWinh / 2);
    grScreens[1]->activate(grWinx, grWiny,              grWinw, grWinh / 2);
    grScreens[2]->desactivate();
    grScreens[3]->desactivate();
    break;
    case 3:
    grScreens[0]->activate(grWinx,              grWiny + grWinh / 2, grWinw / 2, grWinh / 2);
    grScreens[1]->activate(grWinx + grWinw / 2, grWiny + grWinh / 2, grWinw / 2, grWinh / 2);
    grScreens[2]->activate(grWinx + grWinw / 4, grWiny,              grWinw / 2, grWinh / 2);
    grScreens[3]->desactivate();
    break;
    case 4:
    grScreens[0]->activate(grWinx,              grWiny + grWinh / 2, grWinw / 2, grWinh / 2);
    grScreens[1]->activate(grWinx + grWinw / 2, grWiny + grWinh / 2, grWinw / 2, grWinh / 2);
    grScreens[2]->activate(grWinx,              grWiny,              grWinw / 2, grWinh / 2);
    grScreens[3]->activate(grWinx + grWinw / 2, grWiny,              grWinw / 2, grWinh / 2);
    break;
    }
}
 
static void
grSplitScreen(int p)
{
    switch (p) {
    case GR_SPLIT_ADD:
    grNbScreen++;
    if (grNbScreen > GR_NB_MAX_SCREEN) {
        grNbScreen = GR_NB_MAX_SCREEN;
    }
    break;
    case GR_SPLIT_REM:
    grNbScreen--;
    if (grNbScreen < 1) {
        grNbScreen = 1;
    }
    break;
    }
    GfParmSetNum(grHandle, GR_SCT_DISPMODE, GR_ATT_NB_SCREENS, NULL, grNbScreen);
    GfParmWriteFile(NULL, grHandle, "Graph");
    grAdaptScreenSize();
}
 
static class cGrScreen *
grGetcurrentScreen(void)
{
    tMouseInfo    *mouse;
    int     i;
    int     x, y;
 
    mouse = GfuiMouseInfo();
    x = (int)(mouse->X * grMouseRatioX);
    y = (int)(mouse->Y * grMouseRatioY);
    for (i = 0; i < GR_NB_MAX_SCREEN; i++) {
    if (grScreens[i]->isInScreen(x, y)) {
        return grScreens[i];
    }
    }
    return grScreens[0];
}
 
static void
grSetZoom(int zoom)
{
    grGetcurrentScreen()->setZoom(zoom);
}
 
static void
grSelectCamera(int camera)
{
    grGetcurrentScreen()->selectCamera(camera);
}
 
static void
grSelectBoard(int board)
{
    grGetcurrentScreen()->selectBoard(board);
}
 
static void
grSelectTrackMap(void * /* vp */)
{
    grGetcurrentScreen()->selectTrackMap();
}
 
static void
grPrevCar(void * /* dummy */)
{
    grGetcurrentScreen()->selectPrevCar();
}
 
static void
grNextCar(void * /* dummy */)
{
    grGetcurrentScreen()->selectNextCar();
}
 
static void
grSwitchMirror(void * /* dummy */)
{
    grGetcurrentScreen()->switchMirror();
}
 
int
initView(int x, int y, int width, int height, int /* flag */, void *screen)
{
    int i;
    const int BUFSIZE = 1024;
    char buf[BUFSIZE];
    
    if (maxTextureUnits==0) {
        InitMultiTex();
    }
 
    grWinx = x;
    grWiny = y;
    grWinw = width;
    grWinh = height;
 
    grMouseRatioX = width / 640.0;
    grMouseRatioY = height / 480.0;
 
    OldTime = GfTimeClock();
    nFrame = 0;
    grFps = 0;
 
    snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), GR_PARAM_FILE);
    grHandle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
 
    for (i = 0; i < GR_NB_MAX_SCREEN; i++) {
        grScreens[i]->initBoard ();
    }
 
    GfuiAddSKeyAction(screen, GLUT_KEY_HOME, "Zoom Maximum", [] { grSetZoom(GR_ZOOM_MAX); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_END,  "Zoom Minimum", [] { grSetZoom(GR_ZOOM_MIN); }, tGfuiAction());
    GfuiAddKeyAction(screen, '*',            "Zoom Default", [] { grSetZoom(GR_ZOOM_DFLT); }, tGfuiAction());
 
    GfuiAddSKeyAction(screen, GLUT_KEY_PAGE_UP,   "Select Previous Car", [] { grPrevCar(NULL); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_PAGE_DOWN, "Select Next Car",     [] { grNextCar(NULL); }, tGfuiAction());
 
    GfuiAddSKeyAction(screen, GLUT_KEY_F2,   "Driver Views",      [] { grSelectCamera(0); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_F3,   "Car Views",         [] { grSelectCamera(1); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_F4,   "Side Car Views",    [] { grSelectCamera(2); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_F5,   "Up Car View",       [] { grSelectCamera(3); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_F6,   "Persp Car View",    [] { grSelectCamera(4); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_F7,   "All Circuit Views", [] { grSelectCamera(5); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_F8,   "Track View",        [] { grSelectCamera(6); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_F9,   "Track View Zoomed", [] { grSelectCamera(7); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_F10,  "Follow Car Zoomed", [] { grSelectCamera(8); }, tGfuiAction());
    GfuiAddSKeyAction(screen, GLUT_KEY_F11,  "TV Director View",  [] { grSelectCamera(9); }, tGfuiAction());
 
    GfuiAddKeyAction(screen, '5',            "FPS Counter",      [] { grSelectBoard(3); }, tGfuiAction());
    GfuiAddKeyAction(screen, '4',            "G/Cmd Graph",      [] { grSelectBoard(4); }, tGfuiAction());
    GfuiAddKeyAction(screen, '3',            "Leaders Board",    [] { grSelectBoard(2); }, tGfuiAction());
    GfuiAddKeyAction(screen, '2',            "Driver Counters",  [] { grSelectBoard(1); }, tGfuiAction());
    GfuiAddKeyAction(screen, '1',            "Driver Board",     [] { grSelectBoard(0); }, tGfuiAction());
    GfuiAddKeyAction(screen, '9',            "Mirror",         [] { grSwitchMirror(NULL); }, tGfuiAction());
    GfuiAddKeyAction(screen, '0',            "Arcade Board",     [] { grSelectBoard(5); }, tGfuiAction());
    GfuiAddKeyAction(screen, '>',            "Zoom In",          [] { grSetZoom(GR_ZOOM_IN); }, tGfuiAction());
    GfuiAddKeyAction(screen, '<',            "Zoom Out",         [] { grSetZoom(GR_ZOOM_OUT); }, tGfuiAction());
    GfuiAddKeyAction(screen, '[',            "Split Screen",     [] { grSplitScreen(GR_SPLIT_ADD); }, tGfuiAction());
    GfuiAddKeyAction(screen, ']',            "UnSplit Screen",   [] { grSplitScreen(GR_SPLIT_REM); }, tGfuiAction());
    GfuiAddKeyAction(screen, 'm',            "Track Maps",     [] { grSelectTrackMap(NULL); }, tGfuiAction());
 
    grAdaptScreenSize();
 
    grInitScene();
 
    grLodFactorValue = GfParmGetNum(grHandle, GR_SCT_GRAPHIC, GR_ATT_LODFACTOR, NULL, 1.0);
 
    const char* wheelDetailOption = GfParmGetStr(grHandle, GR_SCT_GRAPHIC, GR_ATT_WHEELRENDERING, GR_ATT_WHEELRENDERING_DETAILED);
    if (strcmp(wheelDetailOption,GR_ATT_WHEELRENDERING_DETAILED ) == 0) {
        grUseDetailedWheels = DETAILED;
    } else if (strcmp(wheelDetailOption,GR_ATT_WHEELRENDERING_SIMPLE ) == 0) {
        grUseDetailedWheels = SIMPLE;  
    }
 
    GfParmReleaseHandle(grHandle);
 
    return 0;
}
 
 
int
refresh(tSituation *s)
{
    int         i;
 
    START_PROFILE("refresh");
 
    nFrame++;
    grCurTime = GfTimeClock();
    grDeltaTime = grCurTime - OldTime;
    if ((grCurTime - OldTime) > 1.0) {
    /* The Frames Per Second (FPS) display is refreshed every second */
    grFps = (tdble)nFrame / (grCurTime - OldTime);
    nFrame = 0;
    OldTime = grCurTime;
    }
 
    TRACE_GL("refresh: start");
 
    START_PROFILE("grRefreshSound*");
    grRefreshSound(s, grScreens[0]->getCurCamera());
    STOP_PROFILE("grRefreshSound*");
 
    START_PROFILE("grDrawBackground/glClear");
    glDepthFunc(GL_LEQUAL);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    STOP_PROFILE("grDrawBackground/glClear");
 
    for (i = 0; i < GR_NB_MAX_SCREEN; i++) {
    grScreens[i]->update(s, grFps);
    }
 
    grUpdateSmoke(s->currentTime);
 
    STOP_PROFILE("refresh");
    return 0;
}
 
int
initCars(tSituation *s)
{
    const int IDXSIZE = 16;
    char idx[IDXSIZE];
    int index;
    int i;
    tCarElt *elt;
    void *hdle;
    const int BUFSIZE = 1024;
    char buf[1024];
    
    TRACE_GL("initCars: start");
 
    snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), GR_PARAM_FILE);
    grHandle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
 
    grInitCommonState();
    grInitCarlight(s->_ncars);
    grMaxDammage = (tdble)s->_maxDammage;
    grNbCars = s->_ncars;
 
    grCustomizePits();
 
    grCarInfo = (tgrCarInfo*)calloc(s->_ncars, sizeof(tgrCarInfo));
 
    for (i = 0; i < s->_ncars; i++) {
        elt = s->cars[i];
        /* Shadow init (Should be done before the cars for display order) */
        grInitShadow(elt);
        /* Skidmarks init */
        grInitSkidmarks(elt);
    }
 
    grNbScreen = 0;
    for (i = 0; i < s->_ncars; i++) {
        elt = s->cars[i];
        index = elt->index;
        hdle = elt->_paramsHandle;
        snprintf(idx, IDXSIZE, "Robots/index/%d", elt->_driverIndex);
        grCarInfo[index].iconColor[0] = GfParmGetNum(hdle, idx, "red",   (char*)NULL, 0);
        grCarInfo[index].iconColor[1] = GfParmGetNum(hdle, idx, "green", (char*)NULL, 0);
        grCarInfo[index].iconColor[2] = GfParmGetNum(hdle, idx, "blue",  (char*)NULL, 0);
        grCarInfo[index].iconColor[3] = 1.0;
        grInitCar(elt);
        if ((elt->_driverType == RM_DRV_HUMAN) && (grNbScreen < GR_NB_MAX_SCREEN)) {
            grScreens[grNbScreen]->setCurrentCar(elt);
            grNbScreen++;
        }
    }
 
    if (grNbScreen == 0) {
        grNbScreen = (int)GfParmGetNum(grHandle, GR_SCT_DISPMODE, GR_ATT_NB_SCREENS, NULL, 1.0);
    }
 
    for (i = 0; i < GR_NB_MAX_SCREEN; i++) {
        grScreens[i]->initCams(s);
    }
 
    TRACE_GL("initCars: end");
 
    grInitSmoke(s->_ncars);
    grInitSound(s, s->_ncars);
 
    grAdaptScreenSize();
 
    return 0;
}
 
void
shutdownCars(void)
{
    int i;
 
    GfOut("-- shutdownCars\n");
    grShutdownSound(grNbCars);
    if (grNbCars) {
        grShutdownBoardCar();
        grShutdownSkidmarks();
        grShutdownSmoke();
        grShudownCarlight();
        /* Delete ssg objects */
        CarsAnchor->removeAllKids();
        ShadowAnchor->removeAllKids();
        for (i = 0; i < grNbCars; i++) {
            ssgDeRefDelete(grCarInfo[i].envSelector);
            ssgDeRefDelete(grCarInfo[i].shadowBase);
            ssgDeRefDelete(grCarInfo[i].wheelTexture);
            if (grCarInfo[i].driverSelectorinsg == false) {
                delete grCarInfo[i].driverSelector;
            }
        }
 
        PitsAnchor->removeAllKids();
        ThePits = 0;
        free(grCarInfo);
    }
 
    GfParmReleaseHandle(grHandle);
 
    for (i = 0; i < GR_NB_MAX_SCREEN; i++) {
        grScreens[i]->setCurrentCar(NULL);
    }
}
 
int
initTrack(tTrack *track)
{
    int i;
 
    // The inittrack does as well init the context, that is highly inconsistent, IMHO.
    // TODO: Find a solution to init the graphics first independent of objects.
    grContext.makeCurrent();
 
    grTrackHandle = GfParmReadFile(track->filename, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
    grLoadScene(track);
 
    for (i = 0; i < GR_NB_MAX_SCREEN; i++) {
        grScreens[i] = new cGrScreen(i);
    }
 
    return 0;
}
 
 
void
shutdownTrack(void)
{
    int i;
 
    grShutdownScene();
    grShutdownState();
 
    for (i = 0; i < GR_NB_MAX_SCREEN; i++) {
        if (grScreens[i] != NULL) {
            delete grScreens[i];
            grScreens[i] = NULL;
        }
    }
 
    GfParmReleaseHandle(grTrackHandle);
}
 
/*void bendCar (int index, sgVec3 poc, sgVec3 force, int cnt)
{
    if (grCarInfo) 
        grPropagateDamage (grCarInfo[index].carEntity, poc, force, cnt);
}*/
 
 
void muteForMenu(void)
{
    grMuteForMenu();
}