@irsdk-node/native 3.0.0

package/lib/irsdk_utils.cpp

@@ -0,0 +1,377 @@
+/*
+Copyright (c) 2013, iRacing.com Motorsport Simulations, LLC.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of iRacing.com Motorsport Simulations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#define MIN_WIN_VER 0x0501
+
+#ifndef WINVER
+#	define WINVER			MIN_WIN_VER
+#endif
+
+#ifndef _WIN32_WINNT
+#	define _WIN32_WINNT		MIN_WIN_VER 
+#endif
+
+#include <windows.h>
+#include <stdio.h>
+#include <time.h>
+#include <limits.h>
+
+#ifdef _MSC_VER
+#include <crtdbg.h>
+#endif
+
+#include "irsdk_defines.h"
+
+// for timeBeginPeriod()
+#pragma comment(lib, "Winmm")
+// for RegisterWindowMessage() and SendMessage()
+#pragma comment(lib, "User32")
+
+// Local memory
+
+static HANDLE hDataValidEvent = NULL;
+static HANDLE hMemMapFile = NULL;
+
+static const char *pSharedMem = NULL;
+static const irsdk_header *pHeader = NULL;
+
+static int lastTickCount = INT_MAX;
+static bool isInitialized = false;
+
+static const double timeout = 30.0; // timeout after 30 seconds with no communication
+static time_t lastValidTime = 0;
+
+// Function Implementations
+
+bool irsdk_startup()
+{
+	if(!hMemMapFile)
+	{
+		hMemMapFile = OpenFileMapping( FILE_MAP_READ, FALSE, IRSDK_MEMMAPFILENAME);
+		lastTickCount = INT_MAX;
+	}
+
+	if(hMemMapFile)
+	{
+		if(!pSharedMem)
+		{
+			pSharedMem = (const char *)MapViewOfFile(hMemMapFile, FILE_MAP_READ, 0, 0, 0);
+			pHeader = (irsdk_header *)pSharedMem;
+			lastTickCount = INT_MAX;
+		}
+
+		if(pSharedMem)
+		{
+			if(!hDataValidEvent)
+			{
+				hDataValidEvent = OpenEvent(SYNCHRONIZE, false, IRSDK_DATAVALIDEVENTNAME);
+				lastTickCount = INT_MAX;
+			}
+
+			if(hDataValidEvent)
+			{
+				isInitialized = true;
+				return isInitialized;
+			}
+			//else printf("Error opening event: %d\n", GetLastError()); 
+		}
+		//else printf("Error mapping file: %d\n", GetLastError()); 
+	}
+	//else printf("Error opening file: %d\n", GetLastError()); 
+
+	isInitialized = false;
+	return isInitialized;
+}
+
+void irsdk_shutdown()
+{
+	if(hDataValidEvent)
+		CloseHandle(hDataValidEvent);
+
+	if(pSharedMem)
+		UnmapViewOfFile(pSharedMem);
+
+	if(hMemMapFile)
+		CloseHandle(hMemMapFile);
+
+	hDataValidEvent = NULL;
+	pSharedMem = NULL;
+	pHeader = NULL;
+	hMemMapFile = NULL;
+
+	isInitialized = false;
+	lastTickCount = INT_MAX;
+}
+
+bool irsdk_getNewData(char *data)
+{
+	if(isInitialized || irsdk_startup())
+	{
+#ifdef _MSC_VER
+		_ASSERTE(NULL != pHeader);
+#endif
+
+		// if sim is not active, then no new data
+		if(!(pHeader->status & irsdk_stConnected))
+		{
+			lastTickCount = INT_MAX;
+			return false;
+		}
+
+		int latest = 0;
+		for(int i=1; i<pHeader->numBuf; i++)
+			if(pHeader->varBuf[latest].tickCount < pHeader->varBuf[i].tickCount)
+			   latest = i;	
+
+		// if newer than last recieved, than report new data
+		if(lastTickCount < pHeader->varBuf[latest].tickCount)
+		{
+			// if asked to retrieve the data
+			if(data)
+			{
+				// try twice to get the data out
+				for(int count = 0; count < 2; count++)
+				{
+					int curTickCount =  pHeader->varBuf[latest].tickCount;
+					memcpy(data, pSharedMem + pHeader->varBuf[latest].bufOffset, pHeader->bufLen);
+					if(curTickCount ==  pHeader->varBuf[latest].tickCount)
+					{
+						lastTickCount = curTickCount;
+						lastValidTime = time(NULL);
+						return true;
+					}
+				}
+				// if here, the data changed out from under us.
+				return false;
+			}
+			else
+			{
+				lastTickCount =  pHeader->varBuf[latest].tickCount;
+				lastValidTime = time(NULL);
+				return true;
+			}
+		}
+		// if older than last recieved, than reset, we probably disconnected
+		else if(lastTickCount >  pHeader->varBuf[latest].tickCount)
+		{
+			lastTickCount =  pHeader->varBuf[latest].tickCount;
+			return false;
+		}
+		// else the same, and nothing changed this tick
+	}
+
+	return false;
+}
+
+
+bool irsdk_waitForDataReady(int timeOut, char *data)
+{
+#ifdef _MSC_VER
+	_ASSERTE(timeOut >= 0);
+#endif
+
+	if(isInitialized || irsdk_startup())
+	{
+		// just to be sure, check before we sleep
+		if(irsdk_getNewData(data))
+			return true;
+
+		// sleep till signaled
+		WaitForSingleObject(hDataValidEvent, timeOut);
+
+		// we woke up, so check for data
+		if(irsdk_getNewData(data))
+			return true;
+		else
+			return false;
+	}
+
+	// sleep if error
+	if(timeOut > 0)
+		Sleep(timeOut);
+
+	return false;
+}
+
+bool irsdk_isConnected()
+{
+	if(isInitialized)
+	{
+		int elapsed = (int)difftime(time(NULL), lastValidTime);
+		return (pHeader->status & irsdk_stConnected) > 0 && elapsed < timeout;
+	}
+
+	return false;
+}
+
+const irsdk_header *irsdk_getHeader()
+{
+	if(isInitialized)
+	{
+		return pHeader;
+	}
+
+	return NULL;
+}
+
+// direct access to the data buffer
+// Warnign! This buffer is volitile so read it out fast!
+// Use the cached copy from irsdk_waitForDataReady() or irsdk_getNewData() instead
+const char *irsdk_getData(int index)
+{
+	if(isInitialized)
+	{
+		return pSharedMem + pHeader->varBuf[index].bufOffset;
+	}
+
+	return NULL;
+}
+
+const char *irsdk_getSessionInfoStr()
+{
+	if(isInitialized)
+	{
+		return pSharedMem + pHeader->sessionInfoOffset;
+	}
+	return NULL;
+}
+
+int irsdk_getSessionInfoStrUpdate()
+{
+	if(isInitialized)
+	{
+		return pHeader->sessionInfoUpdate;
+	}
+	return -1;
+}
+
+const irsdk_varHeader *irsdk_getVarHeaderPtr()
+{
+	if(isInitialized)
+	{
+		return ((irsdk_varHeader*)(pSharedMem + pHeader->varHeaderOffset));
+	}
+	return NULL;
+}
+
+const irsdk_varHeader *irsdk_getVarHeaderEntry(int index)
+{
+	if(isInitialized)
+	{
+		if(index >= 0 && index < pHeader->numVars)
+		{
+			return &((irsdk_varHeader*)(pSharedMem + pHeader->varHeaderOffset))[index];
+		}
+	}
+	return NULL;
+}
+
+// Note: this is a linear search, so cache the results
+int irsdk_varNameToIndex(const char *name)
+{
+	const irsdk_varHeader *pVar;
+
+	if(name)
+	{
+		for(int index=0; index<pHeader->numVars; index++)
+		{
+			pVar = irsdk_getVarHeaderEntry(index);
+			if(pVar && 0 == strncmp(name, pVar->name, IRSDK_MAX_STRING))
+			{
+				return index;
+			}
+		}
+	}
+
+	return -1;
+}
+
+int irsdk_varNameToOffset(const char *name)
+{
+	const irsdk_varHeader *pVar;
+
+	if(name)
+	{
+		for(int index=0; index<pHeader->numVars; index++)
+		{
+			pVar = irsdk_getVarHeaderEntry(index);
+			if(pVar && 0 == strncmp(name, pVar->name, IRSDK_MAX_STRING))
+			{
+				return pVar->offset;
+			}
+		}
+	}
+
+	return -1;
+}
+
+unsigned int irsdk_getBroadcastMsgID()
+{
+	static unsigned int msgId = RegisterWindowMessage(IRSDK_BROADCASTMSGNAME); 
+
+	return msgId;
+}
+
+void irsdk_broadcastMsg(irsdk_BroadcastMsg msg, int var1, int var2, int var3)
+{
+	irsdk_broadcastMsg(msg, var1, MAKELONG(var2, var3));
+}
+
+void irsdk_broadcastMsg(irsdk_BroadcastMsg msg, int var1, float var2)
+{
+	// multiply by 2^16-1 to move fractional part to the integer part
+	int real = (int)(var2 * 65536.0f);
+
+	irsdk_broadcastMsg(msg, var1, real);
+}
+
+void irsdk_broadcastMsg(irsdk_BroadcastMsg msg, int var1, int var2)
+{
+	static unsigned int msgId = irsdk_getBroadcastMsgID();
+
+	if(msgId && msg >= 0 && msg < irsdk_BroadcastLast)
+	{
+		SendNotifyMessage(HWND_BROADCAST, msgId, MAKELONG(msg, var1), var2);
+	}
+}
+
+int irsdk_padCarNum(int num, int zero)
+{
+	int retVal = num;
+	int numPlace = 1;
+	if(num > 99)
+		numPlace = 3;
+	else if(num > 9)
+		numPlace = 2;
+	if(zero)
+	{
+		numPlace += zero;
+		retVal = num + 1000*numPlace;
+	}
+
+	return retVal;
+}

package/lib/yaml_parser.cpp

@@ -0,0 +1,176 @@
+/*
+Copyright (c) 2013, iRacing.com Motorsport Simulations, LLC.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of iRacing.com Motorsport Simulations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stdio.h>
+#include <string.h>
+
+enum yaml_state {
+	space,
+	key,
+	keysep,
+	value,
+	newline
+};
+
+// super simple YAML parser
+bool parseYaml(const char *data, const char* path, const char **val, int *len)
+{
+	if(data && path && val && len)
+	{
+		// make sure we set this to something
+		*val = NULL;
+		*len = 0;
+
+		int depth = 0;
+		yaml_state state = space;
+
+		const char *keystr = NULL;
+		int keylen = 0;
+
+		const char *valuestr = NULL;
+		int valuelen = 0;
+
+		const char *pathptr = path;
+		int pathdepth = 0;
+
+		while(*data)
+		{
+			switch(*data)
+			{
+			case ' ':
+				if(state == newline)
+					state = space;
+				if(state == space)
+					depth++;
+				else if(state == key)
+					keylen++;
+				else if(state == value)
+					valuelen++;
+				break;
+			case '-':
+				if(state == newline)
+					state = space;
+				if(state == space)
+					depth++;
+				else if(state == key)
+					keylen++;
+				else if(state == value)
+					valuelen++;
+				else if(state == keysep)
+				{
+					state = value;
+					valuestr = data;
+					valuelen = 1;
+				}
+				break;
+			case ':':
+				if(state == key)
+				{
+					state = keysep;
+					keylen++;
+				}
+				else if(state == keysep)
+				{
+					state = value;
+					valuestr = data;
+				}
+				else if(state == value)
+					valuelen++;
+				break;
+			case '\n':
+			case '\r':
+				if(state != newline)
+				{
+					if(depth < pathdepth)
+					{
+						return false;
+					}
+					else if(keylen && 0 == strncmp(keystr, pathptr, keylen))
+					{
+						bool found = true;
+						//do we need to test the value?
+						if(*(pathptr+keylen) == '{')
+						{
+							//search for closing brace
+							int pathvaluelen = keylen + 1; 
+							while(*(pathptr+pathvaluelen) && *(pathptr+pathvaluelen) != '}')
+								pathvaluelen++; 
+
+							if(valuelen == pathvaluelen - (keylen+1) && 0 == strncmp(valuestr, (pathptr+keylen+1), valuelen))
+								pathptr += valuelen + 2;
+							else
+								found = false;
+						}
+
+						if(found)
+						{
+							pathptr += keylen;
+							pathdepth = depth;
+
+							if(*pathptr == '\0')
+							{
+								*val = valuestr;
+								*len = valuelen;
+								return true;
+							}
+						}
+					}
+
+					depth = 0;
+					keylen = 0;
+					valuelen = 0;
+				}
+				state = newline;
+				break;
+			default:
+				if(state == space || state == newline)
+				{
+					state = key;
+					keystr = data;
+					keylen = 0; //redundant?
+				}
+				else if(state == keysep)
+				{
+					state = value;
+					valuestr = data;
+					valuelen = 0; //redundant?
+				}
+				if(state == key)
+					keylen++;
+				if(state == value)
+					valuelen++;
+				break;
+			}
+
+			// important, increment our pointer
+			data++;
+		}
+
+	}
+	return false;
+}
+

package/lib/yaml_parser.h

@@ -0,0 +1,34 @@
+/*
+Copyright (c) 2013, iRacing.com Motorsport Simulations, LLC.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of iRacing.com Motorsport Simulations nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef YAML_PARSER_H
+#define YAML_PARSER_H
+
+// super simple YAML parser
+bool parseYaml(const char *data, const char* path, const char **val, int *len);
+
+#endif //YAML_PARSER_H

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@irsdk-node/native",
+  "version": "3.0.0",
+  "author": {
+    "name": "Matt Bengston",
+    "email": "bengsfort@gmail.com"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "package.json",
+    "./build",
+    "./dist",
+    "./lib",
+    "./src",
+    "./scripts",
+    "./binding.gyp",
+    "./README.md"
+  ],
+  "main": "./dist/index.js",
+  "types": "./src/index.d.ts",
+  "scripts": {
+    "clean": "node-gyp clean && rm -rf dist",
+    "build": "yarn run pre-build && concurrently \"yarn:build-ts\" \"yarn:build-cpp\"",
+    "pre-build": "node-gyp clean && node-gyp configure",
+    "build-ts": "tsc --build --force",
+    "build-cpp": "concurrently \"yarn:build-cpp-release\" \"yarn:build-cpp-debug\"",
+    "build-cpp-release": "node-gyp build",
+    "build-cpp-debug": "node-gyp configure && node-gyp build --debug",
+    "watch": "tsc --watch",
+    "lint": "eslint ./src --ext .ts",
+    "prepack": "yarn build",
+    "generate-types": "node ./scripts/generate-var-types.js"
+  },
+  "packageManager": "yarn@3.1.0",
+  "preferUnplugged": false,
+  "os": [
+    "win32"
+  ],
+  "dependencies": {
+    "@irsdk-node/types": "^3.0.0",
+    "bindings": "^1.5.0",
+    "node-addon-api": "*",
+    "node-gyp": "^8.4.1"
+  },
+  "devDependencies": {
+    "concurrently": "^7.0.0",
+    "node-notifier": "^10.0.0",
+    "typescript": "^4.5.2"
+  }
+}

package/scripts/generate-var-types.js

@@ -0,0 +1,71 @@
+const NativeSDK = require("../build/Debug/irsdk_node.node").iRacingSdkNode;
+const path = require("path");
+const fs = require("fs");
+
+const TARGET_FILE = "_GENERATED_telemetry.ts";
+const OUT_PATH = path.resolve(process.cwd(), "../irsdk-node-types/src/", TARGET_FILE);
+
+console.log("Generating iRacing telemetry variable types.");
+console.log("Make sure the sim is running!");
+
+const sdk = new NativeSDK();
+sdk.startSDK();
+
+// Telemetry command, Start Recording
+sdk.broadcast(10, 1);
+// Wait a max of 5s
+if (!sdk.waitForData(5000)) {
+  process.stderr.write("No data. Make sure the sim is running and try again.");
+  process.exit(1);
+}
+
+const varTypes = [
+  "string",
+  "boolean",
+  "number",
+  "number",
+  "number",
+  "number",
+];
+
+// Get all the types
+const types = sdk.__getTelemetryTypes();
+const out = `
+// ! THIS FILE IS AUTO-GENERATED, EDITS WILL BE OVERRIDDEN !
+// ! Make changes to the generate-var-types in @irsk-node/native !
+
+/**
+ * A variable included in the telemetry.
+ */
+export interface TelemetryVariable<VarType = number[]> {
+  /** The name of the variable. */
+  name: string;
+  /** The description. */
+  description: string;
+  /** The unit of the value (ex. "kg/m^2") */
+  unit: string;
+  /** Should it be treated as a time? */
+  countAsTime: boolean;
+  /** The number of values provided. */
+  length: number;
+  /** The native variable type */
+  varType: number;
+  /** The current value of this variable. */
+  value: VarType;
+}
+
+export interface TelemetryVarList {
+${Object.keys(types).map((varName) => 
+  `  ${varName}: TelemetryVariable<${varTypes[types[varName]]}[]>`
+).join(";\n")};
+}
+`;
+
+fs.writeFile(OUT_PATH, out, "utf-8", (err) => {
+  if (err) {
+    console.error("There was an error creating the file:", err);
+    return;
+  }
+  console.log("Successfully generated types!");
+  process.exit(0);
+});