@nativewrappers/redm-codegen 0.0.2

package/src/namespaces/Zone.ts

@@ -0,0 +1,50 @@
+import { Vector2 } from '../types/Vector2';
+import { Vector3 } from '../types/Vector3';
+import { Vector4 } from '../types/Vector4';
+import { Color } from '../types/Color';
+import { createFromHandle } from '../types/HandleRegistry';
+import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f } from '../types/NativeAliases';
+
+export class Zone {
+  /**
+   * Returns the zone's name hash if its type matches one of the following:
+   *
+   * @param pos 
+   * @returns
+   */
+  static getWaterMapZoneAtCoords(pos: Vector3): string | number {
+    return (inv<number>('0x5BA7A68A346A5A91', f(pos.x), f(pos.y), f(pos.z), rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * Returns name hash, see common:/data/levels/rdr3/mapzones.meta type (-1 matches any type):
+   * class CMapZone
+   * {
+   * public:
+   * enum class Type
+   * {
+   * STATE,
+   * TOWN,
+   * LAKE,
+   * RIVER,
+   * OIL_SPILL,
+   * SWAMP,
+   * OCEAN,
+   * CREEK,
+   * POND,
+   * GLACIER,
+   * DISTRICT,
+   * TEXT_PRINTED,
+   * TEXT_WRITTEN
+   * };
+   * }; https://github.com/femga/rdr3_discoveries/tree/master/zones & https://alloc8or.re/rdr3/doc/enums/CMapZone__Type.txt
+   *
+   * @param pos 
+   * @param type 
+   * @returns
+   */
+  static getMapZoneAtCoords(pos: Vector3, type: number): string | number {
+    return (inv<number>('0x43AD8FC02B429D33', f(pos.x), f(pos.y), f(pos.z), type, rai())) & 0xFFFFFFFF;
+  }
+
+}

package/src/structs/BufferedClass.ts

@@ -0,0 +1,14 @@
+export abstract class BufferedClass {
+  buffer: ArrayBuffer;
+  view: DataView;
+
+  constructor(bufferSize: number, existingBuffer?: ArrayBuffer, offset?: number) {
+    if (existingBuffer !== undefined && offset !== undefined) {
+      this.buffer = existingBuffer;
+      this.view = new DataView(existingBuffer, offset, bufferSize);
+    } else {
+      this.buffer = new ArrayBuffer(bufferSize);
+      this.view = new DataView(this.buffer);
+    }
+  }
+}

package/src/structs/HorsePeltIn.ts

@@ -0,0 +1,26 @@
+import { BufferedClass } from './BufferedClass';
+import { HorsePeltOut } from './HorsePeltOut';
+
+/**
+ * Used by:
+ * - [0x6F43C351A5D51E2F](https://natives.avarian.dev/?native=0x6F43C351A5D51E2F&game=rdr3)
+ */
+export class HorsePeltIn extends BufferedClass {
+  static readonly SIZE = 0x80;
+
+  constructor(existingBuffer?: ArrayBuffer, offset?: number) {
+    super(0x80, existingBuffer, offset);
+  }
+  set NumPelts(value: number) {
+    this.view.setUint8(0, value);
+  }
+
+  /**
+   * @param index Array index (0-2)
+   * @throws {RangeError} If index is out of bounds
+   */
+  Data(index: number): HorsePeltOut {
+    if (index < 0 || index >= 3) throw new RangeError('Index out of bounds');
+    return new HorsePeltOut(this.buffer, 8 + index * HorsePeltOut.SIZE);
+  }
+  }

package/src/structs/HorsePeltOut.ts

@@ -0,0 +1,21 @@
+import { BufferedClass } from './BufferedClass';
+
+export class HorsePeltOut extends BufferedClass {
+  static readonly SIZE = 0x18;
+
+  constructor(existingBuffer?: ArrayBuffer, offset?: number) {
+    super(0x18, existingBuffer, offset);
+  }
+
+  get ItemHash(): number {
+    return this.view.getUint32(0, true);
+  }
+
+  get AlbedoHash(): number {
+    return this.view.getUint32(8, true);
+  }
+
+  get NormalHash(): number {
+    return this.view.getUint32(16, true);
+  }
+  }

package/src/types/BufferedClass.ts

@@ -0,0 +1,14 @@
+export abstract class BufferedClass {
+  buffer: ArrayBuffer;
+  view: DataView;
+
+  constructor(bufferSize: number, existingBuffer?: ArrayBuffer, offset?: number) {
+    if (existingBuffer !== undefined && offset !== undefined) {
+      this.buffer = existingBuffer;
+      this.view = new DataView(existingBuffer, offset, bufferSize);
+    } else {
+      this.buffer = new ArrayBuffer(bufferSize);
+      this.view = new DataView(this.buffer);
+    }
+  }
+}

package/src/types/Color.ts

@@ -0,0 +1,32 @@
+export class Color {
+  constructor(
+    public r: number = 0,
+    public g: number = 0,
+    public b: number = 0,
+    public a: number = 255
+  ) {}
+
+  static fromRgb(r: number, g: number, b: number): Color {
+    return new Color(r, g, b, 255);
+  }
+
+  static fromRgba(r: number, g: number, b: number, a: number): Color {
+    return new Color(r, g, b, a);
+  }
+
+  static fromHex(hex: string): Color {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i.exec(hex);
+    if (!result) return new Color();
+    return new Color(
+      parseInt(result[1], 16),
+      parseInt(result[2], 16),
+      parseInt(result[3], 16),
+      result[4] ? parseInt(result[4], 16) : 255
+    );
+  }
+
+  toHex(): string {
+    const toHex = (n: number) => n.toString(16).padStart(2, '0');
+    return `#${toHex(this.r)}${toHex(this.g)}${toHex(this.b)}${this.a < 255 ? toHex(this.a) : ''}`;
+  }
+}

package/src/types/HandleRegistry.ts

@@ -0,0 +1,12 @@
+type HandleConstructor<T> = { fromHandle(handle: number): T | null };
+
+const registry = new Map<string, HandleConstructor<unknown>>();
+
+export function registerHandle<T>(name: string, ctor: HandleConstructor<T>): void {
+  registry.set(name, ctor);
+}
+
+export function createFromHandle<T>(name: string, handle: number): T | null {
+  const ctor = registry.get(name) as HandleConstructor<T> | undefined;
+  return ctor ? ctor.fromHandle(handle) : null;
+}

package/src/types/IHandle.ts

@@ -0,0 +1,3 @@
+export interface IHandle {
+  handle: number;
+}

package/src/types/NativeAliases.ts

@@ -0,0 +1,36 @@
+// CFX runtime globals - these are provided by the FiveM/RedM runtime
+declare const Citizen: {
+    invokeNative<T = void>(hash: string, ...args: any[]): T;
+    resultAsInteger(): any;
+    resultAsFloat(): any;
+    resultAsString(): any;
+    resultAsVector(): any;
+    pointerValueInt(): any;
+    pointerValueFloat(): any;
+    pointerValueVector(): any;
+    pointerValueIntInitialized(value: number): any;
+    pointerValueFloatInitialized(value: number): any;
+};
+// GetHashKey accepts string|number since hashes can be pre-computed
+declare function GetHashKey(str: string | number): number;
+
+export const inv = Citizen.invokeNative;
+export const rai = Citizen.resultAsInteger;
+export const raf = Citizen.resultAsFloat;
+export const ras = Citizen.resultAsString;
+export const rav = Citizen.resultAsVector;
+export const pvi = Citizen.pointerValueInt;
+export const pvf = Citizen.pointerValueFloat;
+export const pvv = Citizen.pointerValueVector;
+export const pvii = Citizen.pointerValueIntInitialized;
+export const pvfi = Citizen.pointerValueFloatInitialized;
+export const _h = typeof GetHashKey !== 'undefined' ? GetHashKey : (s: string | number) => typeof s === 'number' ? s : 0;
+export const f = (n: number) => n + 0.00000001;
+
+// Non-class handle type aliases (these are just numbers at runtime)
+export type ScrHandle = number;
+export type Prompt = number;
+export type FireId = number;
+export type Blip = number;
+export type PopZone = number;
+export type PedGroup = number;

package/src/types/Vector2.ts

@@ -0,0 +1,40 @@
+export class Vector2 {
+  constructor(
+    public x: number = 0,
+    public y: number = 0
+  ) {}
+
+  static fromArray(arr: number[]): Vector2 {
+    return new Vector2(arr[0], arr[1]);
+  }
+
+  toArray(): [number, number] {
+    return [this.x, this.y];
+  }
+
+  add(other: Vector2): Vector2 {
+    return new Vector2(this.x + other.x, this.y + other.y);
+  }
+
+  subtract(other: Vector2): Vector2 {
+    return new Vector2(this.x - other.x, this.y - other.y);
+  }
+
+  multiply(scalar: number): Vector2 {
+    return new Vector2(this.x * scalar, this.y * scalar);
+  }
+
+  length(): number {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+
+  normalize(): Vector2 {
+    const len = this.length();
+    if (len === 0) return new Vector2();
+    return this.multiply(1 / len);
+  }
+
+  distance(other: Vector2): number {
+    return this.subtract(other).length();
+  }
+}

package/src/types/Vector3.ts

@@ -0,0 +1,41 @@
+export class Vector3 {
+  constructor(
+    public x: number = 0,
+    public y: number = 0,
+    public z: number = 0
+  ) {}
+
+  static fromArray(arr: number[]): Vector3 {
+    return new Vector3(arr[0], arr[1], arr[2]);
+  }
+
+  toArray(): [number, number, number] {
+    return [this.x, this.y, this.z];
+  }
+
+  add(other: Vector3): Vector3 {
+    return new Vector3(this.x + other.x, this.y + other.y, this.z + other.z);
+  }
+
+  subtract(other: Vector3): Vector3 {
+    return new Vector3(this.x - other.x, this.y - other.y, this.z - other.z);
+  }
+
+  multiply(scalar: number): Vector3 {
+    return new Vector3(this.x * scalar, this.y * scalar, this.z * scalar);
+  }
+
+  length(): number {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+
+  normalize(): Vector3 {
+    const len = this.length();
+    if (len === 0) return new Vector3();
+    return this.multiply(1 / len);
+  }
+
+  distance(other: Vector3): number {
+    return this.subtract(other).length();
+  }
+}

package/src/types/Vector4.ts

@@ -0,0 +1,42 @@
+export class Vector4 {
+  constructor(
+    public x: number = 0,
+    public y: number = 0,
+    public z: number = 0,
+    public w: number = 0
+  ) {}
+
+  static fromArray(arr: number[]): Vector4 {
+    return new Vector4(arr[0], arr[1], arr[2], arr[3]);
+  }
+
+  toArray(): [number, number, number, number] {
+    return [this.x, this.y, this.z, this.w];
+  }
+
+  add(other: Vector4): Vector4 {
+    return new Vector4(this.x + other.x, this.y + other.y, this.z + other.z, this.w + other.w);
+  }
+
+  subtract(other: Vector4): Vector4 {
+    return new Vector4(this.x - other.x, this.y - other.y, this.z - other.z, this.w - other.w);
+  }
+
+  multiply(scalar: number): Vector4 {
+    return new Vector4(this.x * scalar, this.y * scalar, this.z * scalar, this.w * scalar);
+  }
+
+  length(): number {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+  }
+
+  normalize(): Vector4 {
+    const len = this.length();
+    if (len === 0) return new Vector4();
+    return this.multiply(1 / len);
+  }
+
+  distance(other: Vector4): number {
+    return this.subtract(other).length();
+  }
+}