960 lines
35 KiB
C++
960 lines
35 KiB
C++
//interfaceoptions.cpp
|
|
//user interface for setting game options
|
|
|
|
#include <OpenGL/gl.h>
|
|
#include "gametime.h"
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include "interfaceutil.h"
|
|
#include "gamemem.h"
|
|
#include "fileio.h"
|
|
#include "screen.h"
|
|
#include "controls.h"
|
|
#include "text.h"
|
|
#include "interface.h"
|
|
#include "gameinitexit.h"
|
|
#include "parser.h"
|
|
#include "writeout.h"
|
|
#include "textures.h"
|
|
#include "config.h"
|
|
#include "gamesound.h"
|
|
#include "textures.h"
|
|
#include "renderframe.h"
|
|
#include "music.h"
|
|
|
|
#define kNumControlOptions 14
|
|
|
|
void InterfaceControlOptions()
|
|
{
|
|
int controlOptions[kNumControlOptions]={kInputGasButton,kInputBrakeButton,kInputSteerLeftButton,kInputSteerRightButton,kInputHandbrakeButton,kInputKickdownButton,kInputCamera,kInputCameraReverse,kInputCameraChangeCar,kInputPause,kInputGearUp,kInputGearDown,kInputHorn,kInputChat};
|
|
|
|
tInterfaceMenuDescribtion menu;
|
|
InterfaceInitMenu(&menu,kNumControlOptions+1,"Controls");
|
|
|
|
strcpy(menu.items[kNumControlOptions].label,"Return to previous menu");
|
|
menu.items[kNumControlOptions-1].lineSpacing*=1.5;
|
|
menu.background=FileGetReference("background-options.tif");
|
|
menu.RenderCallback=InterfaceRenderReplay;
|
|
menu.itemsYPos+=0.1;
|
|
|
|
char itemStrings[kNumControlOptions][32]={"Accelerate","Brake","Steer Left","Steer Right","Handbrake","Full Throttle","Change Camera","Look Backwards","Replay Car View","Pause Game","Shift Up","Shift Down","Horn","Type Message"};
|
|
for(int i=0;i<kNumControlOptions;i++)
|
|
{
|
|
menu.items[i].size*=0.7;
|
|
menu.items[i].lineSpacing*=0.6;
|
|
}
|
|
|
|
int exit=false;
|
|
do{
|
|
for(int i=0;i<kNumControlOptions;i++)
|
|
{
|
|
int keyUsed=false;
|
|
int controllerUsed=false;
|
|
for(int j=0;j<=kInputITunesPlay;j++)
|
|
if(gConfig->keys[controlOptions[i]].keyID==gConfig->keys[j].keyID&&j!=controlOptions[i])
|
|
keyUsed=true;
|
|
for(int j=0;j<=kInputITunesPlay;j++)
|
|
if(gConfig->keys[controlOptions[i]].controllerID1==gConfig->keys[j].controllerID1
|
|
&&gConfig->keys[controlOptions[i]].controllerID2==gConfig->keys[j].controllerID2
|
|
&&gConfig->keys[controlOptions[i]].elementID==gConfig->keys[j].elementID
|
|
&&j!=controlOptions[i])
|
|
controllerUsed=true;
|
|
if(gConfig->keys[controlOptions[i]].controllerID1)
|
|
{
|
|
if(keyUsed&&controllerUsed)
|
|
sprintf(menu.items[i].label,"%s:\255#r\255\t%s\t%s",itemStrings[i],gConfig->keys[controlOptions[i]].identifier,gConfig->keys[controlOptions[i]].controllerIdentifier);
|
|
else if(keyUsed)
|
|
sprintf(menu.items[i].label,"%s:\255#r\255\t%s\t\255#a\255%s",itemStrings[i],gConfig->keys[controlOptions[i]].identifier,gConfig->keys[controlOptions[i]].controllerIdentifier);
|
|
else if(controllerUsed)
|
|
sprintf(menu.items[i].label,"%s:\255#a\255\t%s\t\255#r\255%s",itemStrings[i],gConfig->keys[controlOptions[i]].identifier,gConfig->keys[controlOptions[i]].controllerIdentifier);
|
|
else
|
|
sprintf(menu.items[i].label,"%s:\255#a\255\t%s\t%s",itemStrings[i],gConfig->keys[controlOptions[i]].identifier,gConfig->keys[controlOptions[i]].controllerIdentifier);
|
|
}
|
|
else if(keyUsed)
|
|
sprintf(menu.items[i].label,"%s:\255#r\255\t%s",itemStrings[i],gConfig->keys[controlOptions[i]].identifier);
|
|
else
|
|
sprintf(menu.items[i].label,"%s:\255#a\255\t%s",itemStrings[i],gConfig->keys[controlOptions[i]].identifier);
|
|
}
|
|
InterfaceMenuZoomAnimation(&menu,-1,true);
|
|
int sel=InterfaceGetUserMenuSelection(&menu);
|
|
if(sel!=kInterfaceMenuEsc&&sel<kNumControlOptions)
|
|
{
|
|
while(GetInterfaceKey(kInterfaceKeyReturn)||GetInterfaceKey(kInterfaceKeyEnter));
|
|
|
|
menu.initialSelection=sel;
|
|
char keyString[80];
|
|
sprintf(keyString,"Press the new Key or Button for '%s'\n (Or press delete to clear)",itemStrings[sel]);
|
|
InterfaceDrawStrings("Assign new Key",keyString,kFileErr);
|
|
|
|
GetInput(gConfig->keys+controlOptions[sel]);
|
|
|
|
int interfaceKeyPressed;
|
|
do{
|
|
interfaceKeyPressed=false;
|
|
for(int i=kInterfaceKeyUp;i<kInterfaceNumKeys;i++)
|
|
if(GetInterfaceKey(i))
|
|
interfaceKeyPressed=true;
|
|
if(GetButtonInput(kInputITunesNext)||GetButtonInput(kInputITunesPlay))
|
|
interfaceKeyPressed=true;
|
|
}while(interfaceKeyPressed);
|
|
}
|
|
else
|
|
exit=true;
|
|
|
|
}while(!exit);
|
|
|
|
InterfaceDisposeMenu(&menu);
|
|
}
|
|
|
|
#define kNumTauntOptions 10
|
|
void InterfaceTauntOptions()
|
|
{
|
|
tInterfaceMenuDescribtion menu;
|
|
InterfaceInitMenu(&menu,kNumTauntOptions+1,"Taunts");
|
|
|
|
strcpy(menu.items[kNumTauntOptions].label,"Return to previous menu");
|
|
menu.items[kNumTauntOptions-1].lineSpacing*=1.5;
|
|
menu.background=FileGetReference("background-options.tif");
|
|
menu.RenderCallback=InterfaceRenderReplay;
|
|
|
|
char itemStrings[5][32];
|
|
for(int i=0;i<kNumTauntOptions;i++)
|
|
{
|
|
menu.items[i].size*=0.75;
|
|
if(i%2)
|
|
{
|
|
menu.items[i].lineSpacing*=0.9;
|
|
menu.items[i].flags|=kInterfaceMenuItemTypeable;
|
|
strcpy(menu.items[i].type,gConfig->taunts[i/2]);
|
|
sprintf(menu.items[i].label,"Taunt %d message: ",i/2+1);
|
|
}
|
|
else
|
|
{
|
|
menu.items[i].lineSpacing*=0.65;
|
|
sprintf(itemStrings[i/2],"Taunt %d key",i/2+1);
|
|
}
|
|
}
|
|
|
|
int exit=false;
|
|
do{
|
|
for(int i=0;i<kNumTauntOptions;i++)
|
|
if(!(i%2))
|
|
{
|
|
int keyUsed=false;
|
|
int controllerUsed=false;
|
|
for(int j=0;j<=kInputITunesPlay;j++)
|
|
if(gConfig->keys[kInputTaunt1+i/2].keyID==gConfig->keys[j].keyID&&j!=kInputTaunt1+i/2)
|
|
keyUsed=true;
|
|
for(int j=0;j<=kInputITunesPlay;j++)
|
|
if(gConfig->keys[kInputTaunt1+i/2].controllerID1==gConfig->keys[j].controllerID1
|
|
&&gConfig->keys[kInputTaunt1+i/2].controllerID2==gConfig->keys[j].controllerID2
|
|
&&gConfig->keys[kInputTaunt1+i/2].elementID==gConfig->keys[j].elementID
|
|
&&j!=kInputTaunt1+i/2)
|
|
controllerUsed=true;
|
|
if(gConfig->keys[kInputTaunt1+i/2].controllerID1)
|
|
{
|
|
if(keyUsed&&controllerUsed)
|
|
sprintf(menu.items[i].label,"%s:\255#r\255\t%s\t%s",itemStrings[i/2],gConfig->keys[kInputTaunt1+i/2].identifier,gConfig->keys[kInputTaunt1+i/2].controllerIdentifier);
|
|
else if(keyUsed)
|
|
sprintf(menu.items[i].label,"%s:\255#r\255\t%s\t\255#a\255%s",itemStrings[i/2],gConfig->keys[kInputTaunt1+i/2].identifier,gConfig->keys[kInputTaunt1+i/2].controllerIdentifier);
|
|
else if(controllerUsed)
|
|
sprintf(menu.items[i].label,"%s:\255#a\255\t%s\t\255#r\255%s",itemStrings[i/2],gConfig->keys[kInputTaunt1+i/2].identifier,gConfig->keys[kInputTaunt1+i/2].controllerIdentifier);
|
|
else
|
|
sprintf(menu.items[i].label,"%s:\255#a\255\t%s\t%s",itemStrings[i/2],gConfig->keys[kInputTaunt1+i/2].identifier,gConfig->keys[kInputTaunt1+i/2].controllerIdentifier);
|
|
}
|
|
else if(keyUsed)
|
|
sprintf(menu.items[i].label,"%s:\255#r\255\t%s",itemStrings[i/2],gConfig->keys[kInputTaunt1+i/2].identifier);
|
|
else
|
|
sprintf(menu.items[i].label,"%s:\255#a\255\t%s",itemStrings[i/2],gConfig->keys[kInputTaunt1+i/2].identifier);
|
|
}
|
|
|
|
InterfaceMenuZoomAnimation(&menu,-1,true);
|
|
int sel=InterfaceGetUserMenuSelection(&menu);
|
|
if(sel!=kInterfaceMenuEsc&&sel<kNumTauntOptions&&!(sel%2))
|
|
{
|
|
while(GetInterfaceKey(kInterfaceKeyReturn)||GetInterfaceKey(kInterfaceKeyEnter));
|
|
|
|
menu.initialSelection=sel;
|
|
char keyString[80];
|
|
sprintf(keyString,"Press the new Key or Button for '%s'",itemStrings[sel/2]);
|
|
InterfaceDrawStrings("Assign new Key",keyString,kFileErr);
|
|
|
|
GetInput(gConfig->keys+kInputTaunt1+sel/2);
|
|
|
|
int interfaceKeyPressed;
|
|
do{
|
|
interfaceKeyPressed=false;
|
|
for(int i=kInterfaceKeyUp;i<kInterfaceNumKeys;i++)
|
|
if(GetInterfaceKey(i))
|
|
interfaceKeyPressed=true;
|
|
}while(interfaceKeyPressed);
|
|
}
|
|
else
|
|
exit=true;
|
|
|
|
}while(!exit);
|
|
|
|
for(int i=1;i<kNumTauntOptions;i+=2)
|
|
strcpy(gConfig->taunts[i/2],menu.items[i].type);
|
|
|
|
InterfaceDisposeMenu(&menu);
|
|
}
|
|
|
|
void InterfaceCalibrateAxis()
|
|
{
|
|
if(gConfig->axis[kInputSteerAxis].axisControllerID1>0)
|
|
{
|
|
InterfaceDrawStrings("Calibrate Axis","Move the Steering Axis to its left and right \nmaximum several times and hit Return.",kFileErr);
|
|
CalibrateAxis(kInputSteerAxis);
|
|
}
|
|
if(!gConfig->seperateGasBrake)
|
|
if(gConfig->axis[kInputThrottleBrakeAxis].axisControllerID1>0)
|
|
{
|
|
InterfaceDrawStrings("Calibrate Axis","Move the Gas/Brake Axis to its left and right \nmaximum several times and hit Return.",kFileErr);
|
|
CalibrateAxis(kInputThrottleBrakeAxis);
|
|
}
|
|
FlushKeys();
|
|
}
|
|
|
|
enum{
|
|
kAnalougeSteerAxis,
|
|
kAnalougeGasSeperateAxes,
|
|
kAnalougeInvertGas,
|
|
kAnalougeGasAxis,
|
|
kAnalougeBrakeAxis,
|
|
kAnalougeDisableTCS,
|
|
kAnalougeCalibrate,
|
|
kAnalougeSteerCenterTolerance,
|
|
kAnalougeGasCenterTolerance,
|
|
kAnalougeFFB,
|
|
kAnalougeFFBIntensity,
|
|
kAnalougeExit,
|
|
kAnalougeNumOptions
|
|
};
|
|
|
|
void InterfaceAnalogueControlOptions()
|
|
{
|
|
tInterfaceMenuDescribtion menu;
|
|
InterfaceInitMenu(&menu,kAnalougeNumOptions,"Analog Controls");
|
|
menu.background=FileGetReference("background-options.tif");
|
|
menu.RenderCallback=InterfaceRenderReplay;
|
|
|
|
|
|
char itemStrings[][32]={"Steering","Seperate Gas/Brake:","Invert Gas/Brake axes","Gas","Brake","Traction Assistance","Calibrate Axis...","Steering Tolerance:","Gas Tolerance:","","FFB Intensity:","Return to previous menu"};
|
|
|
|
for(int i=0;i<kAnalougeNumOptions;i++)
|
|
sprintf(menu.items[i].label,"%s",itemStrings[i]);
|
|
|
|
menu.items[kAnalougeFFB].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kAnalougeInvertGas].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kAnalougeGasSeperateAxes].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kAnalougeDisableTCS].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kAnalougeFFBIntensity].flags|=kInterfaceMenuItemArrowInput|kInterfaceMenuItemSlider;
|
|
menu.items[kAnalougeSteerCenterTolerance].flags|=kInterfaceMenuItemArrowInput|kInterfaceMenuItemSlider;
|
|
menu.items[kAnalougeGasCenterTolerance].flags|=kInterfaceMenuItemArrowInput|kInterfaceMenuItemSlider;
|
|
if(!gFFB)
|
|
{
|
|
menu.items[kAnalougeFFB].flags|=kInterfaceMenuItemDisabled;
|
|
menu.items[kAnalougeFFBIntensity].flags|=kInterfaceMenuItemDisabled;
|
|
}
|
|
if(!gInputHID)
|
|
menu.items[kAnalougeCalibrate].flags|=kInterfaceMenuItemDisabled;
|
|
menu.items[kAnalougeExit-1].lineSpacing*=1.5;
|
|
|
|
for(int i=0;i<kAnalougeExit;i++)
|
|
{
|
|
menu.items[i].size*=0.75;
|
|
menu.items[i].lineSpacing*=0.75;
|
|
}
|
|
|
|
int exit=false;
|
|
do{
|
|
if(gConfig->axis[kInputSteerAxis].axisControllerID1)
|
|
sprintf(menu.items[kAnalougeSteerAxis].label,"%s: \255#a\255%s",itemStrings[kAnalougeSteerAxis],gConfig->axis[kInputSteerAxis].axisIdentifier);
|
|
else
|
|
sprintf(menu.items[kAnalougeSteerAxis].label,"%s: \255#a\255not assigned",itemStrings[kAnalougeSteerAxis]);
|
|
if(gConfig->seperateGasBrake)
|
|
{
|
|
if(gConfig->axis[kInputThrottleAxis].axisControllerID1)
|
|
sprintf(menu.items[kAnalougeGasAxis].label,"%s: \255#a\255%s","Gas",gConfig->axis[kInputThrottleAxis].axisIdentifier);
|
|
else
|
|
sprintf(menu.items[kAnalougeGasAxis].label,"%s: \255#a\255not assigned","Gas");
|
|
if(gConfig->axis[kInputBrakeAxis].axisControllerID1)
|
|
sprintf(menu.items[kAnalougeBrakeAxis].label,"%s: \255#a\255%s","Brake",gConfig->axis[kInputBrakeAxis].axisIdentifier);
|
|
else
|
|
sprintf(menu.items[kAnalougeBrakeAxis].label,"%s: \255#a\255not assigned","Brake");
|
|
} else {
|
|
if(gConfig->axis[kInputThrottleBrakeAxis].axisControllerID1)
|
|
sprintf(menu.items[kAnalougeGasAxis].label,"%s: \255#a\255%s","Gas/Brake",gConfig->axis[kInputThrottleBrakeAxis].axisIdentifier);
|
|
else
|
|
sprintf(menu.items[kAnalougeGasAxis].label,"%s: \255#a\255not assigned","Gas/Brake");
|
|
sprintf(menu.items[kAnalougeBrakeAxis].label,"%s: \255#a\255not applicable","Brake");
|
|
}
|
|
|
|
sprintf(menu.items[kAnalougeFFB].label,"Force Feedback: \255#a\255%s",gConfig->ffb?"On":"Off");
|
|
sprintf(menu.items[kAnalougeInvertGas].label,"Invert Gas/Brake axes: \255#a\255%s",gConfig->reverseGas?"On":"Off");
|
|
sprintf(menu.items[kAnalougeDisableTCS].label,"Traction Assistance: \255#a\255%s",gConfig->disableAnalogueTCS?"Off":"On");
|
|
sprintf(menu.items[kAnalougeGasSeperateAxes].label,"Seperate Gas/Brake: \255#a\255%s",gConfig->seperateGasBrake?"On":"Off");
|
|
if(gConfig->seperateGasBrake)
|
|
menu.items[kAnalougeBrakeAxis].flags&=~kInterfaceMenuItemDisabled;
|
|
else
|
|
menu.items[kAnalougeBrakeAxis].flags|=kInterfaceMenuItemDisabled;
|
|
|
|
menu.items[kAnalougeFFBIntensity].sliderPos=gConfig->ffbIntensity;
|
|
menu.items[kAnalougeSteerCenterTolerance].sliderPos=gConfig->axis[0].deadzone*5.0;
|
|
menu.items[kAnalougeGasCenterTolerance].sliderPos=gConfig->axis[1].deadzone*5.0;
|
|
|
|
if(gInputHID&&(gConfig->axis[kInputThrottleBrakeAxis].axisControllerID1||gConfig->axis[kInputSteerAxis].axisControllerID1))
|
|
menu.items[kAnalougeCalibrate].flags&=~kInterfaceMenuItemDisabled;
|
|
else
|
|
menu.items[kAnalougeCalibrate].flags|=kInterfaceMenuItemDisabled;
|
|
|
|
int sel=InterfaceGetUserMenuSelection(&menu);
|
|
menu.initialSelection=sel&kInterfaceMenuItemMask;
|
|
switch(menu.initialSelection)
|
|
{
|
|
case kAnalougeSteerAxis:
|
|
case kAnalougeGasAxis:
|
|
case kAnalougeBrakeAxis:
|
|
while(GetInterfaceKey(kInterfaceKeyReturn)||GetInterfaceKey(kInterfaceKeyEnter));
|
|
|
|
menu.initialSelection=sel;
|
|
char keyString[80];
|
|
switch(menu.initialSelection)
|
|
{
|
|
case kAnalougeSteerAxis:
|
|
sprintf(keyString,"Move the new axis for '%s'","Steering");
|
|
InterfaceDrawStrings("Assign new Axis",keyString,kFileErr);
|
|
GetAxis(gConfig->axis+kInputSteerAxis,false);
|
|
break;
|
|
case kAnalougeGasAxis:
|
|
if(!gConfig->seperateGasBrake)
|
|
{
|
|
sprintf(keyString,"Move the new axis for '%s'","Gas/Brake");
|
|
InterfaceDrawStrings("Assign new Axis",keyString,kFileErr);
|
|
GetAxis(gConfig->axis+kInputThrottleBrakeAxis,false);
|
|
}
|
|
else
|
|
{
|
|
sprintf(keyString,"Move the new axis for '%s'","Gas");
|
|
InterfaceDrawStrings("Assign new Axis",keyString,kFileErr);
|
|
GetAxis(gConfig->axis+kInputThrottleAxis,true);
|
|
}
|
|
break;
|
|
case kAnalougeBrakeAxis:
|
|
sprintf(keyString,"Move the new axis for '%s'","Brake");
|
|
InterfaceDrawStrings("Assign new Axis",keyString,kFileErr);
|
|
GetAxis(gConfig->axis+kInputBrakeAxis,true);
|
|
break;
|
|
}
|
|
InterfaceMenuZoomAnimation(&menu,-1,true);
|
|
|
|
break;
|
|
case kAnalougeGasSeperateAxes:
|
|
gConfig->seperateGasBrake=!gConfig->seperateGasBrake;
|
|
break;
|
|
case kAnalougeInvertGas:
|
|
gConfig->reverseGas=!gConfig->reverseGas;
|
|
break;
|
|
case kAnalougeCalibrate:
|
|
InterfaceCalibrateAxis();
|
|
InterfaceMenuZoomAnimation(&menu,-1,true);
|
|
break;
|
|
case kAnalougeFFB:
|
|
gConfig->ffb=!gConfig->ffb;
|
|
break;
|
|
case kAnalougeDisableTCS:
|
|
gConfig->disableAnalogueTCS=!gConfig->disableAnalogueTCS;
|
|
break;
|
|
case kAnalougeFFBIntensity:
|
|
if(sel&kInterfaceMenuLeftArrow){
|
|
gConfig->ffbIntensity-=0.05;
|
|
if(gConfig->ffbIntensity<0)gConfig->ffbIntensity=0;
|
|
}
|
|
else{
|
|
gConfig->ffbIntensity+=0.05;
|
|
if(gConfig->ffbIntensity>1.0)gConfig->ffbIntensity=1.0;
|
|
}
|
|
break;
|
|
case kAnalougeSteerCenterTolerance:
|
|
if(sel&kInterfaceMenuLeftArrow){
|
|
gConfig->axis[0].deadzone-=0.01;
|
|
if(gConfig->axis[0].deadzone<0)gConfig->axis[0].deadzone=0;
|
|
}
|
|
else{
|
|
gConfig->axis[0].deadzone+=0.01;
|
|
if(gConfig->axis[0].deadzone>0.2)gConfig->axis[0].deadzone=0.2;
|
|
}
|
|
break;
|
|
case kAnalougeGasCenterTolerance:
|
|
if(sel&kInterfaceMenuLeftArrow){
|
|
gConfig->axis[1].deadzone-=0.01;
|
|
if(gConfig->axis[1].deadzone<0)gConfig->axis[1].deadzone=0;
|
|
}
|
|
else{
|
|
gConfig->axis[1].deadzone+=0.01;
|
|
if(gConfig->axis[1].deadzone>0.2)gConfig->axis[1].deadzone=0.2;
|
|
}
|
|
break;
|
|
default:
|
|
exit=true;
|
|
}
|
|
}while(!exit);
|
|
gConfig->axis[2].deadzone=gConfig->axis[1].deadzone;
|
|
gConfig->axis[3].deadzone=gConfig->axis[1].deadzone;
|
|
InterfaceDisposeMenu(&menu);
|
|
}
|
|
|
|
enum{
|
|
kVideoOptionScreenSize,
|
|
kVideoOptionFullscreen,
|
|
kVideoOptionShadows,
|
|
kVideoOptionTextureFilter,
|
|
kVideoOptionTextureQuality,
|
|
// kVideoOptionClipDistance,
|
|
kVideoOptionInteriorDisplay,
|
|
kVideoOptionColor32Bit,
|
|
kVideoOptionFSAA,
|
|
kVideoOptionMotionBlur,
|
|
kVideoOptionsShowReplays,
|
|
//kVideoOptionsFPS,
|
|
kVideoOptionReturn,
|
|
kNumVideoOptions
|
|
};
|
|
|
|
#define kMaxTextureQuality 9
|
|
#define kMinTextureQuality 0
|
|
|
|
void InterfaceVideoOptions()
|
|
{
|
|
int screenReInitRequired=false;
|
|
int textureReLoadRequired=false;
|
|
int glReInitRequired=false;
|
|
|
|
int videoMode=0;
|
|
for(int i=0;i<gVideoNumModes;i++)
|
|
if(gConfig->screenXSize==gVideoModes[i].width&&gConfig->screenYSize==gVideoModes[i].height)
|
|
videoMode=i;
|
|
|
|
tInterfaceMenuDescribtion menu;
|
|
InterfaceInitMenu(&menu,kNumVideoOptions,"Video Options");
|
|
menu.background=FileGetReference("background-options.tif");
|
|
menu.RenderCallback=InterfaceRenderReplay;
|
|
|
|
char itemStrings[][256]={"Set the display resolution for Redline to use. Larger values means sharper graphics, but may slow the game down.",
|
|
"Switch between fullscreen and windowed modes. You can also switch at any time by pressing Command-F.",
|
|
"Turn shadows and light cones on or off. If you can't get Redline to run smooth on your machine, try disabling shadows.",
|
|
"Changes texture filter. Anisotropic filtering results in the smoothest graphics, Bilinear filtering is the fastest.",
|
|
"Changes the texture quality. Higher quality means sharper graphics, but may cause the game to run too slow, if your graphics card doesn't have enough memory.",
|
|
// "Changes the visible display range. Higher values let you see farther, but will cause the game to run slower.",
|
|
"Turns car interor display on or off. Turning interior display off will let the game run faster.",
|
|
"Changes between 16-bit and 32-bit color modes. 32-bit looks much nicer, but may be slower on older graphics cards.",
|
|
"Turns on Full screen Anti-Aliasing. Will cause the game to look smoother, but may cause slowdowns.",
|
|
"Turns motion blur on or off (Arcade modes only). Enabling this may cause severe slowdowns on older hardware.",
|
|
"Play replays of Races behind the menu screens. May slow down menu responsiveness on older systems.",
|
|
// "Display a frames-per-second counter in your HUD, to indicate how fast the graphics are rendering.",
|
|
""
|
|
};
|
|
for(int i=0;i<menu.numItems;i++)
|
|
strcpy(menu.items[i].describtion,itemStrings[i]);
|
|
|
|
|
|
strcpy(menu.items[kVideoOptionReturn].label,"Return to previous menu");
|
|
menu.items[kVideoOptionReturn-1].lineSpacing*=1.5;
|
|
|
|
for(int i=kVideoOptionScreenSize;i<=kVideoOptionsShowReplays;i++)
|
|
menu.items[i].flags|=kInterfaceMenuItemArrowInput;
|
|
|
|
// menu.items[kVideoOptionClipDistance].flags|=kInterfaceMenuItemSlider;
|
|
// strcpy(menu.items[kVideoOptionClipDistance].label,"Clipping Distance:");
|
|
menu.items[kVideoOptionTextureQuality].flags|=kInterfaceMenuItemSlider;
|
|
strcpy(menu.items[kVideoOptionTextureQuality].label,"Texture Quality:");
|
|
menu.enterAlwaysOK=true;
|
|
for(int i=0;i<kVideoOptionReturn;i++)
|
|
{
|
|
menu.items[i].size*=0.75;
|
|
menu.items[i].lineSpacing*=0.75;
|
|
}
|
|
|
|
if(gConfig->textureQuality<kMinTextureQuality)
|
|
gConfig->textureQuality=kMinTextureQuality;
|
|
if(gConfig->textureQuality>kMaxTextureQuality)
|
|
gConfig->textureQuality=kMaxTextureQuality;
|
|
|
|
if(ScreenNoWindow())
|
|
menu.items[kVideoOptionFullscreen].flags|=kInterfaceMenuItemDisabled;
|
|
|
|
int exit=false;
|
|
int zoom=false;
|
|
do{
|
|
sprintf(menu.items[kVideoOptionScreenSize].label,"Screen Size: \255#a\255%dx%d",gVideoModes[videoMode].width,gVideoModes[videoMode].height);
|
|
sprintf(menu.items[kVideoOptionFullscreen].label,"Screen Mode: \255#a\255%s",gConfig->fullscreen?"Fullscreen":"Window");
|
|
switch(gConfig->textureFilter){
|
|
case 0: strcpy(menu.items[kVideoOptionTextureFilter].label,"Texture Filter: \255#a\255Bilinear");break;
|
|
case 1: strcpy(menu.items[kVideoOptionTextureFilter].label,"Texture Filter: \255#a\255Trilinear");break;
|
|
case 2: strcpy(menu.items[kVideoOptionTextureFilter].label,"Texture Filter: \255#a\255Anisotropic");break;
|
|
}
|
|
switch(gConfig->fsaa){
|
|
case 0: strcpy(menu.items[kVideoOptionFSAA].label,"Anti-Aliasing: \255#a\255Off");break;
|
|
case 2: strcpy(menu.items[kVideoOptionFSAA].label,"Anti-Aliasing: \255#a\255Medium");break;
|
|
case 4: strcpy(menu.items[kVideoOptionFSAA].label,"Anti-Aliasing: \255#a\255Full");break;
|
|
}
|
|
sprintf(menu.items[kVideoOptionShadows].label,"Shadows & Lighting: \255#a\255%s",gConfig->stencil?"On":"Off");
|
|
sprintf(menu.items[kVideoOptionMotionBlur].label,"Motion Blur: \255#a\255%s",gConfig->motionBlur?"On":"Off");
|
|
sprintf(menu.items[kVideoOptionInteriorDisplay].label,"Interior Display: \255#a\255%s",gConfig->interiorDisplay?"On":"Off");
|
|
|
|
// menu.items[kVideoOptionClipDistance].sliderPos=(gConfig->clipFarDistance-160)/640.0;
|
|
menu.items[kVideoOptionTextureQuality].sliderPos=1-((float)gConfig->textureQuality-kMinTextureQuality)/(kMaxTextureQuality-kMinTextureQuality);
|
|
sprintf(menu.items[kVideoOptionColor32Bit].label,"Color Depth: \255#a\255%d",gConfig->color32Bit?32:16);
|
|
sprintf(menu.items[kVideoOptionsShowReplays].label,"Play Background Replays: \255#a\255%s",gConfig->showReplays?"On":"Off");
|
|
// sprintf(menu.items[kVideoOptionsFPS].label,"Show FPS counter: \255#a\255%s",gConfig->performanceStats?"On":"Off");
|
|
|
|
if(!zoom){
|
|
InterfaceMenuZoomAnimation(&menu,-1,true);
|
|
zoom=true;
|
|
}
|
|
|
|
int sel=InterfaceGetUserMenuSelection(&menu);
|
|
switch(menu.initialSelection=(sel&kInterfaceMenuItemMask))
|
|
{
|
|
case kVideoOptionScreenSize:
|
|
if(sel&kInterfaceMenuLeftArrow)
|
|
videoMode=(videoMode+1)%gVideoNumModes;
|
|
else{
|
|
videoMode--;
|
|
if(videoMode<0)videoMode=gVideoNumModes-1;
|
|
}
|
|
screenReInitRequired=true;
|
|
break;
|
|
case kVideoOptionFullscreen:
|
|
gConfig->fullscreen=!gConfig->fullscreen;
|
|
screenReInitRequired=true;
|
|
break;
|
|
case kVideoOptionShadows:
|
|
gConfig->stencil=!gConfig->stencil;
|
|
break;
|
|
case kVideoOptionMotionBlur:
|
|
gConfig->motionBlur=!gConfig->motionBlur;
|
|
break;
|
|
case kVideoOptionTextureQuality:
|
|
if(!(sel&kInterfaceMenuLeftArrow)){
|
|
if(gConfig->textureQuality>kMinTextureQuality)
|
|
gConfig->textureQuality--;
|
|
}
|
|
else{
|
|
if(gConfig->textureQuality<kMaxTextureQuality)
|
|
gConfig->textureQuality++;
|
|
}
|
|
textureReLoadRequired=true;
|
|
break;
|
|
case kVideoOptionTextureFilter:
|
|
if(!(sel&kInterfaceMenuLeftArrow)){
|
|
gConfig->textureFilter++;
|
|
if(gConfig->textureFilter>(ScreenSupportsAnisotropicFiltering()?2:1))
|
|
gConfig->textureFilter=0;
|
|
}
|
|
else{
|
|
gConfig->textureFilter--;
|
|
if(gConfig->textureFilter<0)
|
|
gConfig->textureFilter=ScreenSupportsAnisotropicFiltering()?2:1;
|
|
}
|
|
textureReLoadRequired=true;
|
|
break;
|
|
/* case kVideoOptionClipDistance:
|
|
if(sel&kInterfaceMenuLeftArrow){
|
|
if(gConfig->clipFarDistance>160)
|
|
gConfig->clipFarDistance-=20;
|
|
}
|
|
else{
|
|
if(gConfig->clipFarDistance<800)
|
|
gConfig->clipFarDistance+=20;
|
|
}
|
|
glReInitRequired=true;
|
|
break;*/
|
|
case kVideoOptionInteriorDisplay:
|
|
gConfig->interiorDisplay=!gConfig->interiorDisplay;
|
|
break;
|
|
case kVideoOptionColor32Bit:
|
|
gConfig->color32Bit=!gConfig->color32Bit;
|
|
screenReInitRequired=true;
|
|
textureReLoadRequired=true;
|
|
break;
|
|
case kVideoOptionFSAA:
|
|
if(sel&kInterfaceMenuLeftArrow){
|
|
gConfig->fsaa-=2;
|
|
if(gConfig->fsaa<0)gConfig->fsaa=4;
|
|
}
|
|
else
|
|
gConfig->fsaa=(gConfig->fsaa+2)%6;
|
|
screenReInitRequired=true;
|
|
break;
|
|
case kVideoOptionsShowReplays:
|
|
gConfig->showReplays=!gConfig->showReplays;
|
|
break;
|
|
|
|
// case kVideoOptionsFPS:
|
|
// gConfig->performanceStats=!gConfig->performanceStats;
|
|
// break;
|
|
|
|
case kVideoOptionReturn:
|
|
case kInterfaceMenuEsc:
|
|
case kInterfaceMenuOK:
|
|
exit=true;
|
|
break;
|
|
}
|
|
}while(!exit);
|
|
|
|
gConfig->screenXSize=gVideoModes[videoMode].width;
|
|
gConfig->screenYSize=gVideoModes[videoMode].height;
|
|
|
|
if(textureReLoadRequired)
|
|
TexturesUnloadAll();
|
|
if(screenReInitRequired)
|
|
ScreenReInit();
|
|
else
|
|
{
|
|
if(glReInitRequired)
|
|
InitGL();
|
|
}
|
|
InterfaceDisposeMenu(&menu);
|
|
}
|
|
|
|
enum{
|
|
kGameplayOptionsMetric,
|
|
kGameplayOptionsAutomatic,
|
|
kGameplayOptionsCamera,
|
|
kGameplayOptionsTransparency,
|
|
kGameplayOptionsName,
|
|
kGameplayOptionsRegisterLapTimes,
|
|
kGameplayOptionsShowPlayerNames,
|
|
kGameplayOptionsCornerGuides,
|
|
kGameplayOptionsHugeGames,
|
|
kGameplayOptionsGhost,
|
|
kGameplayOptionsReturn,
|
|
kNumGameplayOptionsButtons
|
|
};
|
|
|
|
void InterfaceGameplayOptions()
|
|
{
|
|
tInterfaceMenuDescribtion menu;
|
|
InterfaceInitMenu(&menu,kNumGameplayOptionsButtons,"Gameplay Options");
|
|
|
|
char itemStrings[][256]={"Switches the game to use either metric or imperial units for speed, power, mass, etc.",
|
|
"Switches between automatic or manual gear switching.",
|
|
"Switches the default camera mode.",
|
|
"Changes the transparency of in-game displays.",
|
|
"Lets you change your name used in network games and the internet track records.",
|
|
"If you enable this option, your lap times in Time Trial and Challenge modes will be submitted to the internet track record database.",
|
|
"If you enable this, player names will be displayed above the cars in network games.",
|
|
"Show guiding signs informing you about upcoming corners.",
|
|
"Allow races with up to 12 cars. \255#r\255A fast computer and a fast network connection (for multiplayer) are needed for a good gaming experience.",
|
|
"Show a ghost car in Time Trial mode, indicating your best lap.",
|
|
""
|
|
};
|
|
for(int i=0;i<menu.numItems;i++)
|
|
strcpy(menu.items[i].describtion,itemStrings[i]);
|
|
|
|
strcpy(menu.items[kGameplayOptionsReturn].label,"Return to previous menu");
|
|
menu.items[kGameplayOptionsReturn-1].lineSpacing*=1.5;
|
|
|
|
menu.items[kGameplayOptionsMetric].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kGameplayOptionsAutomatic].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kGameplayOptionsCamera].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kGameplayOptionsRegisterLapTimes].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kGameplayOptionsShowPlayerNames].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kGameplayOptionsCornerGuides].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kGameplayOptionsHugeGames].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kGameplayOptionsGhost].flags|=kInterfaceMenuItemArrowInput;
|
|
menu.items[kGameplayOptionsTransparency].flags|=kInterfaceMenuItemArrowInput|kInterfaceMenuItemSlider;
|
|
strcpy(menu.items[kGameplayOptionsTransparency].label,"HUD Transparency:");
|
|
menu.items[kGameplayOptionsName].flags|=kInterfaceMenuItemTypeable;
|
|
menu.items[kGameplayOptionsName].maxTypeLength=kMaxNameLength-1;
|
|
|
|
strcpy(menu.items[kGameplayOptionsName].label,"Network Name: ");
|
|
strcpy(menu.items[kGameplayOptionsName].type,gConfig->playerName);
|
|
|
|
menu.background=FileGetReference("background-options.tif");
|
|
menu.RenderCallback=InterfaceRenderReplay;
|
|
|
|
menu.enterAlwaysOK=true;
|
|
|
|
for(int i=0;i<kGameplayOptionsReturn;i++)
|
|
{
|
|
menu.items[i].size*=0.75;
|
|
menu.items[i].lineSpacing*=0.75;
|
|
}
|
|
|
|
int exit=false;
|
|
int zoom=false;
|
|
do{
|
|
sprintf(menu.items[kGameplayOptionsMetric].label,"Units: \255#a\255%s",gConfig->metricUnits?"Metric":"Imperial");
|
|
sprintf(menu.items[kGameplayOptionsAutomatic].label,"Transmission: \255#a\255%s",gConfig->automatic?"Automatic":"Manual");
|
|
sprintf(menu.items[kGameplayOptionsRegisterLapTimes].label,"Internet Lap Time Registering: \255#a\255%s",gConfig->registerLapTimes?"On":"Off");
|
|
sprintf(menu.items[kGameplayOptionsCornerGuides].label,"Show Corner Guides: \255#a\255%s",gConfig->guideSigns?"On":"Off");
|
|
sprintf(menu.items[kGameplayOptionsHugeGames].label,"Allow big races: \255#a\255%s",gConfig->allowHugeGames?"On":"Off");
|
|
sprintf(menu.items[kGameplayOptionsGhost].label,"Show ghost car: \255#a\255%s",!gConfig->noGhost?"On":"Off");
|
|
sprintf(menu.items[kGameplayOptionsShowPlayerNames].label,"Show Network Player Names: \255#a\255%s",gConfig->showPlayerNames?"On":"Off");
|
|
switch(gConfig->cameraMode)
|
|
{
|
|
case kCameraChase:
|
|
sprintf(menu.items[kGameplayOptionsCamera].label,"Default Camera: \255#a\255Chase");break;
|
|
case kCameraChaseClose:
|
|
sprintf(menu.items[kGameplayOptionsCamera].label,"Default Camera: \255#a\255Close Chase");break;
|
|
case kCameraCockpit:
|
|
sprintf(menu.items[kGameplayOptionsCamera].label,"Default Camera: \255#a\255Cockpit");break;
|
|
case kCameraCockpitCarHidden:
|
|
sprintf(menu.items[kGameplayOptionsCamera].label,"Default Camera: \255#a\255Cockpit");break;
|
|
}
|
|
menu.items[kGameplayOptionsTransparency].sliderPos=gConfig->hudTransparency*1/0.8;
|
|
menu.items[kGameplayOptionsTransparency].sliderTransparency=gConfig->hudTransparency;
|
|
|
|
if(!zoom){
|
|
InterfaceMenuZoomAnimation(&menu,-1,true);
|
|
zoom=true;
|
|
}
|
|
|
|
int sel=InterfaceGetUserMenuSelection(&menu);
|
|
switch(menu.initialSelection=(sel&kInterfaceMenuItemMask))
|
|
{
|
|
case kGameplayOptionsGhost:
|
|
gConfig->noGhost=!gConfig->noGhost;
|
|
break;
|
|
|
|
case kGameplayOptionsHugeGames:
|
|
gConfig->allowHugeGames=!gConfig->allowHugeGames;
|
|
break;
|
|
|
|
case kGameplayOptionsMetric:
|
|
gConfig->metricUnits=!gConfig->metricUnits;
|
|
break;
|
|
|
|
case kGameplayOptionsRegisterLapTimes:
|
|
gConfig->registerLapTimes=!gConfig->registerLapTimes;
|
|
break;
|
|
|
|
case kGameplayOptionsCornerGuides:
|
|
gConfig->guideSigns=!gConfig->guideSigns;
|
|
break;
|
|
|
|
case kGameplayOptionsAutomatic:
|
|
gConfig->automatic=!gConfig->automatic;
|
|
break;
|
|
|
|
case kGameplayOptionsCamera:
|
|
if(sel&kInterfaceMenuLeftArrow){
|
|
gConfig->cameraMode--;
|
|
if(gConfig->cameraMode<kCameraChase)gConfig->cameraMode=kCameraCockpitCarHidden;
|
|
}
|
|
else{
|
|
gConfig->cameraMode++;
|
|
if(gConfig->cameraMode>kCameraCockpitCarHidden)gConfig->cameraMode=kCameraChase;
|
|
}
|
|
break;
|
|
|
|
case kGameplayOptionsTransparency:
|
|
if(sel&kInterfaceMenuLeftArrow){
|
|
gConfig->hudTransparency-=0.05;
|
|
if(gConfig->hudTransparency<0)gConfig->hudTransparency=0;
|
|
}
|
|
else{
|
|
gConfig->hudTransparency+=0.05;
|
|
if(gConfig->hudTransparency>0.8)gConfig->hudTransparency=0.8;
|
|
}
|
|
break;
|
|
|
|
case kGameplayOptionsShowPlayerNames:
|
|
gConfig->showPlayerNames=!gConfig->showPlayerNames;
|
|
break;
|
|
|
|
case kGameplayOptionsReturn:
|
|
case kInterfaceMenuEsc:
|
|
case kInterfaceMenuOK:
|
|
exit=true;
|
|
break;
|
|
}
|
|
}while(!exit);
|
|
|
|
strcpy(gConfig->playerName,menu.items[kGameplayOptionsName].type);
|
|
|
|
InterfaceDisposeMenu(&menu);
|
|
}
|
|
|
|
enum{
|
|
kAudioOptionsVolume,
|
|
kAudioOptionsInterfaceSounds,
|
|
kAudioOptionsInputITunesNext,
|
|
kAudioOptionsInputITunesPrev,
|
|
kAudioOptionsInputITunesPlay,
|
|
kAudioOptionsReturn,
|
|
kNumAudioOptionsButtons
|
|
};
|
|
|
|
void InterfaceAudioOptions()
|
|
{
|
|
tInterfaceMenuDescribtion menu;
|
|
InterfaceInitMenu(&menu,kNumAudioOptionsButtons,"Audio Options");
|
|
|
|
char itemStrings[][256]={"Volume:",
|
|
"Interface Sounds:",
|
|
"iTunes next song key",
|
|
"iTunes previous song key",
|
|
"iTunes play/pause key",
|
|
"Return to previous menu",
|
|
""
|
|
};
|
|
for(int i=0;i<menu.numItems;i++)
|
|
strcpy(menu.items[i].label,itemStrings[i]);
|
|
|
|
menu.items[kAudioOptionsReturn-1].lineSpacing*=1.5;
|
|
menu.items[kAudioOptionsVolume].flags|=kInterfaceMenuItemArrowInput|kInterfaceMenuItemSlider;
|
|
menu.items[kAudioOptionsInterfaceSounds].flags|=kInterfaceMenuItemArrowInput;
|
|
|
|
int exit=false;
|
|
|
|
for(int i=0;i<kAudioOptionsReturn;i++)
|
|
{
|
|
menu.items[i].size*=0.75;
|
|
menu.items[i].lineSpacing*=0.75;
|
|
}
|
|
|
|
menu.background=FileGetReference("background-options.tif");
|
|
menu.RenderCallback=InterfaceRenderReplay;
|
|
|
|
for(int i=kAudioOptionsInputITunesNext;i<=kAudioOptionsInputITunesPlay;i++)
|
|
if(gConfig->keys[kInputITunesNext+i-kAudioOptionsInputITunesNext].controllerID1)
|
|
sprintf(menu.items[i].label,"%s:\255#a\255\t%s\t%s",itemStrings[i],gConfig->keys[kInputITunesNext+i-kAudioOptionsInputITunesNext].identifier,gConfig->keys[kInputITunesNext+i-kAudioOptionsInputITunesNext].controllerIdentifier);
|
|
else
|
|
sprintf(menu.items[i].label,"%s:\255#a\255\t%s",itemStrings[i],gConfig->keys[kInputITunesNext+i-kAudioOptionsInputITunesNext].identifier);
|
|
menu.items[kAudioOptionsVolume].sliderPos=gConfig->soundVolume;
|
|
|
|
InterfaceMenuZoomAnimation(&menu,-1,true);
|
|
do{
|
|
for(int i=kAudioOptionsInputITunesNext;i<=kAudioOptionsInputITunesPlay;i++)
|
|
if(gConfig->keys[kInputITunesNext+i-kAudioOptionsInputITunesNext].controllerID1)
|
|
sprintf(menu.items[i].label,"%s:\255#a\255\t%s\t%s",itemStrings[i],gConfig->keys[kInputITunesNext+i-kAudioOptionsInputITunesNext].identifier,gConfig->keys[kInputITunesNext+i-kAudioOptionsInputITunesNext].controllerIdentifier);
|
|
else
|
|
sprintf(menu.items[i].label,"%s:\255#a\255\t%s",itemStrings[i],gConfig->keys[kInputITunesNext+i-kAudioOptionsInputITunesNext].identifier);
|
|
|
|
menu.items[kAudioOptionsVolume].sliderPos=gConfig->soundVolume;
|
|
sprintf(menu.items[kAudioOptionsInterfaceSounds].label,"Interface Sounds: \255#a\255%s",gConfig->interfaceSounds?"On":"Off");
|
|
|
|
int sel=InterfaceGetUserMenuSelection(&menu);
|
|
switch(menu.initialSelection=(sel&kInterfaceMenuItemMask))
|
|
{
|
|
case kAudioOptionsVolume:
|
|
if(sel&kInterfaceMenuLeftArrow){
|
|
gConfig->soundVolume-=0.1;
|
|
if(gConfig->soundVolume<0)gConfig->soundVolume=0;
|
|
}
|
|
else{
|
|
gConfig->soundVolume+=0.1;
|
|
if(gConfig->soundVolume>1)gConfig->soundVolume=1;
|
|
}
|
|
SoundReInit();
|
|
break;
|
|
|
|
case kAudioOptionsInterfaceSounds:
|
|
gConfig->interfaceSounds=!gConfig->interfaceSounds;
|
|
break;
|
|
|
|
case kAudioOptionsInputITunesNext:
|
|
case kAudioOptionsInputITunesPrev:
|
|
case kAudioOptionsInputITunesPlay:
|
|
{
|
|
while(GetInterfaceKey(kInterfaceKeyReturn)||GetInterfaceKey(kInterfaceKeyEnter));
|
|
|
|
menu.initialSelection=sel;
|
|
char keyString[80];
|
|
sprintf(keyString,"Press the new Key or Button for '%s'\n (Or press delete to clear)",itemStrings[sel]);
|
|
InterfaceDrawStrings("Assign new Key",keyString,kFileErr);
|
|
|
|
GetInput(gConfig->keys+kInputITunesNext+menu.initialSelection-kAudioOptionsInputITunesNext);
|
|
|
|
int interfaceKeyPressed;
|
|
do{
|
|
interfaceKeyPressed=false;
|
|
for(int i=kInterfaceKeyUp;i<kInterfaceNumKeys;i++)
|
|
if(GetInterfaceKey(i))
|
|
interfaceKeyPressed=true;
|
|
if(GetButtonInput(kInputITunesNext)||GetButtonInput(kInputITunesPlay))
|
|
interfaceKeyPressed=true;
|
|
}while(interfaceKeyPressed);
|
|
}
|
|
break;
|
|
|
|
case kAudioOptionsReturn:
|
|
case kInterfaceMenuEsc:
|
|
case kInterfaceMenuOK:
|
|
exit=true;
|
|
break;
|
|
}
|
|
}while(!exit);
|
|
|
|
InterfaceDisposeMenu(&menu);
|
|
}
|
|
|
|
|
|
enum{
|
|
kOptionsGameplay,
|
|
kOptionsControls,
|
|
kOptionsAnalougeControls,
|
|
kOptionsTaunts,
|
|
kOptionsVideo,
|
|
kOptionsAudio,
|
|
kOptionsReturn,
|
|
kNumOptionsButtons
|
|
};
|
|
|
|
void InterfaceOptions()
|
|
{
|
|
tInterfaceMenuDescribtion menu;
|
|
InterfaceInitMenu(&menu,kNumOptionsButtons,"Options");
|
|
|
|
char itemStrings[][32]={"Gameplay","Controls","Analog Controls","Multiplayer Taunts","Video","Audio","Return to previous menu"};
|
|
|
|
for(int i=0;i<menu.numItems;i++)
|
|
{
|
|
strcpy(menu.items[i].label,itemStrings[i]);
|
|
menu.items[i].size*=1.15;
|
|
menu.items[i].lineSpacing*=1.15;
|
|
}
|
|
|
|
menu.items[kOptionsReturn-1].lineSpacing*=1.5;
|
|
|
|
menu.background=FileGetReference("background-options.tif");
|
|
menu.RenderCallback=InterfaceRenderReplay;
|
|
|
|
int exit=false;
|
|
do{
|
|
InterfaceMenuZoomAnimation(&menu,-1,true);
|
|
switch(menu.initialSelection=InterfaceGetUserMenuSelection(&menu))
|
|
{
|
|
case kOptionsGameplay:
|
|
InterfaceGameplayOptions();
|
|
break;
|
|
case kOptionsVideo:
|
|
InterfaceVideoOptions();
|
|
break;
|
|
case kOptionsControls:
|
|
InterfaceControlOptions();
|
|
break;
|
|
case kOptionsAnalougeControls:
|
|
InterfaceAnalogueControlOptions();
|
|
break;
|
|
case kOptionsTaunts:
|
|
InterfaceTauntOptions();
|
|
break;
|
|
case kOptionsAudio:
|
|
InterfaceAudioOptions();
|
|
break;
|
|
|
|
case kOptionsReturn:
|
|
case kInterfaceMenuEsc:
|
|
exit=true;
|
|
break;
|
|
}
|
|
}while(!exit);
|
|
InterfaceDisposeMenu(&menu);
|
|
WriteOutFile(FileGetReference(kConfigFileName),gConfig,kParserTypeConfigDesc);
|
|
}
|