Skip to content

Instantly share code, notes, and snippets.

@blewert

blewert/PCarsSharedMemory.cpp

Created October 30, 2018 14:36
Show Gist options
  • Save blewert/e42a08d7e37c6d9bf33d35f607d8c870 to your computer and use it in GitHub Desktop.
Save blewert/e42a08d7e37c6d9bf33d35f607d8c870 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
PCarsSharedMemory.cpp
#include <iostream>
#include <Windows.h>
#include "PCarsSharedMemory.h"
// Name of the pCars memory mapped file
#define MAP_OBJECT_NAME "$pcars$"
PCarsSharedMemory::PCarsSharedMemory(void)
{
this->game = this->getSharedMemory();
}
const SharedMemory* PCarsSharedMemory::getSharedMemory(void) const
{
// Open the memory-mapped file
HANDLE fileHandle = OpenFileMappingA(PAGE_READONLY, FALSE, MAP_OBJECT_NAME);
if (fileHandle == NULL)
{
printf("Could not open file mapping object (%d).\n", GetLastError());
return NULL;
}
// Get the data structure
const SharedMemory* sharedData = new SharedMemory;
//Get map
sharedData = (SharedMemory*)MapViewOfFile(fileHandle, PAGE_READONLY, 0, 0, sizeof(SharedMemory));
if (sharedData == NULL)
{
printf("Could not map view of file (%d).\n", GetLastError());
CloseHandle(fileHandle);
return NULL;
}
// Ensure we're sync'd to the correct data version
if (sharedData->mVersion != SHARED_MEMORY_VERSION)
{
printf("Data version mismatch\n");
return NULL;
}
return sharedData;
}
bool PCarsSharedMemory::isPlayerInGame(void) const
{
return (game->mGameState == GAME_INGAME_PAUSED || game->mGameState == GAME_INGAME_PLAYING);
}
bool PCarsSharedMemory::isPlayerInRaceSession(void) const
{
return isPlayerInGame() && (game->mSessionState == SESSION_RACE);
}
bool PCarsSharedMemory::isPlayerRacing(void) const
{
return isPlayerInGame() && isPlayerInRaceSession() && (game->mRaceState == RACESTATE_RACING);
}
bool PCarsSharedMemory::isRaceFinished(void) const
{
return isPlayerInGame() && isPlayerInRaceSession() && (game->mRaceState == RACESTATE_FINISHED);
}
bool PCarsSharedMemory::isWaitingForRaceStart(void) const
{
return isPlayerInGame() && (game->mRaceState == RACESTATE_NOT_STARTED);
}
std::string PCarsSharedMemory::getLapTime(void) const
{
float laptime = game->mLastLapTime;
char time[32];
int minutes = floorf(laptime / 60);
int seconds = floorf(fmod(laptime, 60.0f));
int milliseconds = floorf(fmod(laptime, 1.0f) * 1000000);
sprintf_s(time, "%02d:%02d.%d", minutes, seconds, milliseconds);
return std::string(time);
}
Raw
PCarsSharedMemory.h
/*************************************************************************************************
Description:
Storage structure for storing and updating shared memory
Copyright (c) MWL. All rights reserved.
*************************************************************************************************/
#ifndef _SHARED_MEMORY_HPP_
#define _SHARED_MEMORY_HPP_
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// NOTES:
//
// -The shared memory variables will be updated once per graphics frame.
//
// -Each variable comes with a UNIT, RANGE, and UNSET description where applicable.
// UNITS - Is the numeric form which a variable is stored in (e.g. KPH, Celsius)
// RANGE - Is the min-max ranges for a variable
// UNSET - Is the initialised/default/invalid value, depending on the variables usage
//
// -Constant/unchanging values are included in the data, such as 'maxRPM', 'fuelCapacity' - this is done to allow percentage calculations.
//
// -Also included are 12 unique enumerated types, to be used against the mentioned flag/state variables
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// *** Types ***
// Header version number to test against
enum
{
SHARED_MEMORY_VERSION = 5
};
// Maximum allowed length of string
enum
{
STRING_LENGTH_MAX = 64
};
// Maximum number of general participant information allowed to be stored in memory-mapped file
enum
{
STORED_PARTICIPANTS_MAX = 64
};
// Tyres
enum
{
TYRE_FRONT_LEFT = 0,
TYRE_FRONT_RIGHT,
TYRE_REAR_LEFT,
TYRE_REAR_RIGHT,
//--------------
TYRE_MAX
};
// Vector
enum
{
VEC_X = 0,
VEC_Y,
VEC_Z,
//-------------
VEC_MAX
};
// (Type#1) GameState (to be used with 'mGameState')
enum
{
GAME_EXITED = 0,
GAME_FRONT_END,
GAME_INGAME_PLAYING,
GAME_INGAME_PAUSED,
//-------------
GAME_MAX
};
// (Type#2) Session state (to be used with 'mSessionState')
enum
{
SESSION_INVALID = 0,
SESSION_PRACTICE,
SESSION_TEST,
SESSION_QUALIFY,
SESSION_FORMATION_LAP,
SESSION_RACE,
SESSION_TIME_ATTACK,
//-------------
SESSION_MAX
};
// (Type#3) RaceState (to be used with 'mRaceState')
enum
{
RACESTATE_INVALID,
RACESTATE_NOT_STARTED,
RACESTATE_RACING,
RACESTATE_FINISHED,
RACESTATE_DISQUALIFIED,
RACESTATE_RETIRED,
RACESTATE_DNF,
//-------------
RACESTATE_MAX
};
// (Type#4) Current Sector (to be used with 'mCurrentSector')
enum
{
SECTOR_INVALID = 0,
SECTOR_START,
SECTOR_SECTOR1,
SECTOR_SECTOR2,
SECTOR_FINISH,
SECTOR_STOP,
//-------------
SECTOR_MAX
};
// (Type#5) Flag Colours (to be used with 'mHighestFlagColour')
enum
{
FLAG_COLOUR_NONE = 0, // Not used for actual flags, only for some query functions
FLAG_COLOUR_GREEN, // End of danger zone, or race started
FLAG_COLOUR_BLUE, // Faster car wants to overtake the participant
FLAG_COLOUR_WHITE, // Approaching a slow car
FLAG_COLOUR_YELLOW, // Danger on the racing surface itself
FLAG_COLOUR_DOUBLE_YELLOW, // Danger that wholly or partly blocks the racing surface
FLAG_COLOUR_BLACK, // Participant disqualified
FLAG_COLOUR_CHEQUERED, // Chequered flag
//-------------
FLAG_COLOUR_MAX
};
// (Type#6) Flag Reason (to be used with 'mHighestFlagReason')
enum
{
FLAG_REASON_NONE = 0,
FLAG_REASON_SOLO_CRASH,
FLAG_REASON_VEHICLE_CRASH,
FLAG_REASON_VEHICLE_OBSTRUCTION,
//-------------
FLAG_REASON_MAX
};
// (Type#7) Pit Mode (to be used with 'mPitMode')
enum
{
PIT_MODE_NONE = 0,
PIT_MODE_DRIVING_INTO_PITS,
PIT_MODE_IN_PIT,
PIT_MODE_DRIVING_OUT_OF_PITS,
PIT_MODE_IN_GARAGE,
//-------------
PIT_MODE_MAX
};
// (Type#8) Pit Stop Schedule (to be used with 'mPitSchedule')
enum
{
PIT_SCHEDULE_NONE = 0, // Nothing scheduled
PIT_SCHEDULE_STANDARD, // Used for standard pit sequence
PIT_SCHEDULE_DRIVE_THROUGH, // Used for drive-through penalty
PIT_SCHEDULE_STOP_GO, // Used for stop-go penalty
//-------------
PIT_SCHEDULE_MAX
};
// (Type#9) Car Flags (to be used with 'mCarFlags')
enum
{
CAR_HEADLIGHT = (1 << 0),
CAR_ENGINE_ACTIVE = (1 << 1),
CAR_ENGINE_WARNING = (1 << 2),
CAR_SPEED_LIMITER = (1 << 3),
CAR_ABS = (1 << 4),
CAR_HANDBRAKE = (1 << 5),
};
// (Type#10) Tyre Flags (to be used with 'mTyreFlags')
enum
{
TYRE_ATTACHED = (1 << 0),
TYRE_INFLATED = (1 << 1),
TYRE_IS_ON_GROUND = (1 << 2),
};
// (Type#11) Terrain Materials (to be used with 'mTerrain')
enum
{
TERRAIN_ROAD = 0,
TERRAIN_LOW_GRIP_ROAD,
TERRAIN_BUMPY_ROAD1,
TERRAIN_BUMPY_ROAD2,
TERRAIN_BUMPY_ROAD3,
TERRAIN_MARBLES,
TERRAIN_GRASSY_BERMS,
TERRAIN_GRASS,
TERRAIN_GRAVEL,
TERRAIN_BUMPY_GRAVEL,
TERRAIN_RUMBLE_STRIPS,
TERRAIN_DRAINS,
TERRAIN_TYREWALLS,
TERRAIN_CEMENTWALLS,
TERRAIN_GUARDRAILS,
TERRAIN_SAND,
TERRAIN_BUMPY_SAND,
TERRAIN_DIRT,
TERRAIN_BUMPY_DIRT,
TERRAIN_DIRT_ROAD,
TERRAIN_BUMPY_DIRT_ROAD,
TERRAIN_PAVEMENT,
TERRAIN_DIRT_BANK,
TERRAIN_WOOD,
TERRAIN_DRY_VERGE,
TERRAIN_EXIT_RUMBLE_STRIPS,
TERRAIN_GRASSCRETE,
TERRAIN_LONG_GRASS,
TERRAIN_SLOPE_GRASS,
TERRAIN_COBBLES,
TERRAIN_SAND_ROAD,
TERRAIN_BAKED_CLAY,
TERRAIN_ASTROTURF,
TERRAIN_SNOWHALF,
TERRAIN_SNOWFULL,
//-------------
TERRAIN_MAX
};
// (Type#12) Crash Damage State (to be used with 'mCrashState')
enum
{
CRASH_DAMAGE_NONE = 0,
CRASH_DAMAGE_OFFTRACK,
CRASH_DAMAGE_LARGE_PROP,
CRASH_DAMAGE_SPINNING,
CRASH_DAMAGE_ROLLING,
//-------------
CRASH_MAX
};
// (Type#13) ParticipantInfo struct (to be used with 'mParticipantInfo')
typedef struct
{
bool mIsActive;
char mName[STRING_LENGTH_MAX]; // [ string ]
float mWorldPosition[VEC_MAX]; // [ UNITS = World Space X Y Z ]
float mCurrentLapDistance; // [ UNITS = Metres ] [ RANGE = 0.0f->... ] [ UNSET = 0.0f ]
unsigned int mRacePosition; // [ RANGE = 1->... ] [ UNSET = 0 ]
unsigned int mLapsCompleted; // [ RANGE = 0->... ] [ UNSET = 0 ]
unsigned int mCurrentLap; // [ RANGE = 0->... ] [ UNSET = 0 ]
unsigned int mCurrentSector; // [ enum (Type#4) Current Sector ]
} ParticipantInfo;
// *** Shared Memory ***
typedef struct
{
// Version Number
unsigned int mVersion; // [ RANGE = 0->... ]
unsigned int mBuildVersionNumber; // [ RANGE = 0->... ] [ UNSET = 0 ]
// Game States
unsigned int mGameState; // [ enum (Type#1) Game state ]
unsigned int mSessionState; // [ enum (Type#2) Session state ]
unsigned int mRaceState; // [ enum (Type#3) Race State ]
// Participant Info
int mViewedParticipantIndex; // [ RANGE = 0->STORED_PARTICIPANTS_MAX ] [ UNSET = -1 ]
int mNumParticipants; // [ RANGE = 0->STORED_PARTICIPANTS_MAX ] [ UNSET = -1 ]
ParticipantInfo mParticipantInfo[STORED_PARTICIPANTS_MAX]; // [ struct (Type#13) ParticipantInfo struct ]
// Unfiltered Input
float mUnfilteredThrottle; // [ RANGE = 0.0f->1.0f ]
float mUnfilteredBrake; // [ RANGE = 0.0f->1.0f ]
float mUnfilteredSteering; // [ RANGE = -1.0f->1.0f ]
float mUnfilteredClutch; // [ RANGE = 0.0f->1.0f ]
// Vehicle information
char mCarName[STRING_LENGTH_MAX]; // [ string ]
char mCarClassName[STRING_LENGTH_MAX]; // [ string ]
// Event information
unsigned int mLapsInEvent; // [ RANGE = 0->... ] [ UNSET = 0 ]
char mTrackLocation[STRING_LENGTH_MAX]; // [ string ]
char mTrackVariation[STRING_LENGTH_MAX]; // [ string ]
float mTrackLength; // [ UNITS = Metres ] [ RANGE = 0.0f->... ] [ UNSET = 0.0f ]
// Timings
bool mLapInvalidated; // [ UNITS = boolean ] [ RANGE = false->true ] [ UNSET = false ]
float mBestLapTime; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mLastLapTime; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = 0.0f ]
float mCurrentTime; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = 0.0f ]
float mSplitTimeAhead; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mSplitTimeBehind; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mSplitTime; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = 0.0f ]
float mEventTimeRemaining; // [ UNITS = milli-seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mPersonalFastestLapTime; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mWorldFastestLapTime; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mCurrentSector1Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mCurrentSector2Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mCurrentSector3Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mFastestSector1Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mFastestSector2Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mFastestSector3Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mPersonalFastestSector1Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mPersonalFastestSector2Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mPersonalFastestSector3Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mWorldFastestSector1Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mWorldFastestSector2Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
float mWorldFastestSector3Time; // [ UNITS = seconds ] [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
// Flags
unsigned int mHighestFlagColour; // [ enum (Type#5) Flag Colour ]
unsigned int mHighestFlagReason; // [ enum (Type#6) Flag Reason ]
// Pit Info
unsigned int mPitMode; // [ enum (Type#7) Pit Mode ]
unsigned int mPitSchedule; // [ enum (Type#8) Pit Stop Schedule ]
// Car State
unsigned int mCarFlags; // [ enum (Type#9) Car Flags ]
float mOilTempCelsius; // [ UNITS = Celsius ] [ UNSET = 0.0f ]
float mOilPressureKPa; // [ UNITS = Kilopascal ] [ RANGE = 0.0f->... ] [ UNSET = 0.0f ]
float mWaterTempCelsius; // [ UNITS = Celsius ] [ UNSET = 0.0f ]
float mWaterPressureKPa; // [ UNITS = Kilopascal ] [ RANGE = 0.0f->... ] [ UNSET = 0.0f ]
float mFuelPressureKPa; // [ UNITS = Kilopascal ] [ RANGE = 0.0f->... ] [ UNSET = 0.0f ]
float mFuelLevel; // [ RANGE = 0.0f->1.0f ]
float mFuelCapacity; // [ UNITS = Liters ] [ RANGE = 0.0f->1.0f ] [ UNSET = 0.0f ]
float mSpeed; // [ UNITS = Metres per-second ] [ RANGE = 0.0f->... ]
float mRpm; // [ UNITS = Revolutions per minute ] [ RANGE = 0.0f->... ] [ UNSET = 0.0f ]
float mMaxRPM; // [ UNITS = Revolutions per minute ] [ RANGE = 0.0f->... ] [ UNSET = 0.0f ]
float mBrake; // [ RANGE = 0.0f->1.0f ]
float mThrottle; // [ RANGE = 0.0f->1.0f ]
float mClutch; // [ RANGE = 0.0f->1.0f ]
float mSteering; // [ RANGE = -1.0f->1.0f ]
int mGear; // [ RANGE = -1 (Reverse) 0 (Neutral) 1 (Gear 1) 2 (Gear 2) etc... ] [ UNSET = 0 (Neutral) ]
int mNumGears; // [ RANGE = 0->... ] [ UNSET = -1 ]
float mOdometerKM; // [ RANGE = 0.0f->... ] [ UNSET = -1.0f ]
bool mAntiLockActive; // [ UNITS = boolean ] [ RANGE = false->true ] [ UNSET = false ]
int mLastOpponentCollisionIndex; // [ RANGE = 0->STORED_PARTICIPANTS_MAX ] [ UNSET = -1 ]
float mLastOpponentCollisionMagnitude; // [ RANGE = 0.0f->... ]
bool mBoostActive; // [ UNITS = boolean ] [ RANGE = false->true ] [ UNSET = false ]
float mBoostAmount; // [ RANGE = 0.0f->100.0f ]
// Motion & Device Related
float mOrientation[VEC_MAX]; // [ UNITS = Euler Angles ]
float mLocalVelocity[VEC_MAX]; // [ UNITS = Metres per-second ]
float mWorldVelocity[VEC_MAX]; // [ UNITS = Metres per-second ]
float mAngularVelocity[VEC_MAX]; // [ UNITS = Radians per-second ]
float mLocalAcceleration[VEC_MAX]; // [ UNITS = Metres per-second ]
float mWorldAcceleration[VEC_MAX]; // [ UNITS = Metres per-second ]
float mExtentsCentre[VEC_MAX]; // [ UNITS = Local Space X Y Z ]
// Wheels / Tyres
unsigned int mTyreFlags[TYRE_MAX]; // [ enum (Type#10) Tyre Flags ]
unsigned int mTerrain[TYRE_MAX]; // [ enum (Type#11) Terrain Materials ]
float mTyreY[TYRE_MAX]; // [ UNITS = Local Space Y ]
float mTyreRPS[TYRE_MAX]; // [ UNITS = Revolutions per second ]
float mTyreSlipSpeed[TYRE_MAX]; // [ UNITS = Metres per-second ]
float mTyreTemp[TYRE_MAX]; // [ UNITS = Celsius ] [ UNSET = 0.0f ]
float mTyreGrip[TYRE_MAX]; // [ RANGE = 0.0f->1.0f ]
float mTyreHeightAboveGround[TYRE_MAX]; // [ UNITS = Local Space Y ]
float mTyreLateralStiffness[TYRE_MAX]; // [ UNITS = Lateral stiffness coefficient used in tyre deformation ]
float mTyreWear[TYRE_MAX]; // [ RANGE = 0.0f->1.0f ]
float mBrakeDamage[TYRE_MAX]; // [ RANGE = 0.0f->1.0f ]
float mSuspensionDamage[TYRE_MAX]; // [ RANGE = 0.0f->1.0f ]
float mBrakeTempCelsius[TYRE_MAX]; // [ UNITS = Celsius ]
float mTyreTreadTemp[TYRE_MAX]; // [ UNITS = Kelvin ]
float mTyreLayerTemp[TYRE_MAX]; // [ UNITS = Kelvin ]
float mTyreCarcassTemp[TYRE_MAX]; // [ UNITS = Kelvin ]
float mTyreRimTemp[TYRE_MAX]; // [ UNITS = Kelvin ]
float mTyreInternalAirTemp[TYRE_MAX]; // [ UNITS = Kelvin ]
// Car Damage
unsigned int mCrashState; // [ enum (Type#12) Crash Damage State ]
float mAeroDamage; // [ RANGE = 0.0f->1.0f ]
float mEngineDamage; // [ RANGE = 0.0f->1.0f ]
// Weather
float mAmbientTemperature; // [ UNITS = Celsius ] [ UNSET = 25.0f ]
float mTrackTemperature; // [ UNITS = Celsius ] [ UNSET = 30.0f ]
float mRainDensity; // [ UNITS = How much rain will fall ] [ RANGE = 0.0f->1.0f ]
float mWindSpeed; // [ RANGE = 0.0f->100.0f ] [ UNSET = 2.0f ]
float mWindDirectionX; // [ UNITS = Normalised Vector X ]
float mWindDirectionY; // [ UNITS = Normalised Vector Y ]
float mCloudBrightness; // [ RANGE = 0.0f->... ]
} SharedMemory;
#include <string>
class PCarsSharedMemory
{
public:
const SharedMemory* game;
//--
PCarsSharedMemory(void);
const SharedMemory* getSharedMemory(void) const;
bool isPlayerInGame(void) const;
bool isPlayerInRaceSession(void) const;
bool isPlayerRacing(void) const;
bool isRaceFinished(void) const;
bool isWaitingForRaceStart(void) const;
std::string getLapTime(void) const;
};
#endif // _SHARED_MEMORY_HPP_
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment