@nativewrappers/redm-codegen 0.0.2

package/src/classes/BaseModel.ts

@@ -0,0 +1,189 @@
+import { Vector2 } from '../types/Vector2';
+import { Vector3 } from '../types/Vector3';
+import { Vector4 } from '../types/Vector4';
+import { Color } from '../types/Color';
+import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f } from '../types/NativeAliases';
+
+export class BaseModel {
+  protected hash: number;
+
+  constructor(hash: number) {
+    this.hash = hash;
+  }
+
+  /**
+   * @returns
+   */
+  hasNamedPtfxAssetLoaded(): boolean {
+    return inv<boolean>('0x65BB72F29138F5D6', this.hash, rai());
+  }
+
+  /**
+   * _SET_E* or _SET_F*
+   */
+  N_0x032A14D082A9B269(): void {
+    inv<void>('0x032A14D082A9B269', this.hash);
+  }
+
+  /**
+   * Marks the model as no longer needed.
+   */
+  setModelAsNoLongerNeeded(): void {
+    inv<void>('0x4AD96EF928BD4F9A', this.hash);
+  }
+
+  /**
+   * Old name: _REQUEST_IMAP_2
+   */
+  requestIplByHash(): void {
+    inv<void>('0x9E211A378F95C97C', this.hash);
+  }
+
+  /**
+   * Request a model to be loaded into streaming memory. You should make sure to check that the model exists with [native: IS_MODEL_IN_CDIMAGE]
+   *
+   * @param p1 
+   */
+  requestModel(p1: boolean): void {
+    inv<void>('0xFA28FE3A6246FC30', this.hash, p1);
+  }
+
+  /**
+   * Old name: _IS_IMAP_ACTIVE_2
+   *
+   * @returns
+   */
+  isIplActiveByHash(): boolean {
+    return inv<boolean>('0x93AC1B91CB6D9913', this.hash, rai());
+  }
+
+  requestClipSetByHash(): void {
+    inv<void>('0xAC37644A538F7524', this.hash);
+  }
+
+  /**
+   * @returns
+   */
+  isModelAnObject(): any {
+    return inv<number>('0x274EE1B90CFA669E', this.hash);
+  }
+
+  /**
+   * Old name: _REQUEST_IMAP
+   */
+  requestIplHash(): void {
+    inv<void>('0x59767C5A7A9AE6DA', this.hash);
+  }
+
+  /**
+   * Returns whether the specified model is valid
+   *
+   * @returns
+   */
+  isModelValid(): boolean {
+    return inv<boolean>('0x392C8D8E07B70EFC', this.hash, rai());
+  }
+
+  /**
+   * Returns true if IPL is streamed in (?)
+   *
+   * @param pos 
+   * @returns
+   */
+  isPositionInsideIplStreamingExtents(pos: Vector3): any {
+    return inv<number>('0x73B40D97D7BAAD77', this.hash, f(pos.x), f(pos.y), f(pos.z));
+  }
+
+  /**
+   * Old name: _REMOVE_IMAP_2
+   */
+  removeIplByHash(): void {
+    inv<void>('0x431E3AB760629B34', this.hash);
+  }
+
+  removeNamedPtfxAsset(): void {
+    inv<void>('0xF20866829E1C81A2', this.hash);
+  }
+
+  requestCollisionForModel(): void {
+    inv<void>('0xF1767BE37F661551', this.hash);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @returns
+   */
+  requestScenarioType(p1: number, p2: any, p3: any): number {
+    return inv<number>('0x19A6BE7D9C6884D3', this.hash, p1, p2, p3, rai());
+  }
+
+  /**
+   * @returns
+   */
+  removeScenarioAsset(): any {
+    return inv<number>('0x4EDDD9E9CA5AF985', this.hash);
+  }
+
+  /**
+   * @returns
+   */
+  hasCollisionForModelLoaded(): boolean {
+    return inv<boolean>('0x210A79C9EC89778F', this.hash, rai());
+  }
+
+  /**
+   * @returns Returns `true` if the specified model has been loaded into streaming memory, `false` otherwise.
+   */
+  hasModelLoaded(): boolean {
+    return inv<boolean>('0x1283B8B89DD5D1B6', this.hash, rai());
+  }
+
+  /**
+   * @param p1 
+   * @returns
+   */
+  hasScenarioTypeLoaded(p1: boolean): any {
+    return inv<number>('0x9427C94D2E4094A4', this.hash, p1);
+  }
+
+  /**
+   * Old name: _REMOVE_IMAP
+   */
+  removeIplHash(): void {
+    inv<void>('0x5A3E5CF7B4014B96', this.hash);
+  }
+
+  /**
+   * @returns Returns whether the specified model exists in the game.
+   */
+  isModelInCdimage(): boolean {
+    return inv<boolean>('0xD6F3B6D7716CFF8E', this.hash, rai());
+  }
+
+  requestNamedPtfxAsset(): void {
+    inv<void>('0xF2B2353BBC0D4E8F', this.hash);
+  }
+
+  /**
+   * Outputs IPL position and radius (previously wrongly named heading)
+   * https://github.com/femga/rdr3_discoveries/blob/master/imaps/imaps_with_coords_and_heading.lua
+   *
+   * @returns position; radius
+   */
+  getIplBoundingSphere(): [any, Vector3, number] {
+    const result = inv<[number, number[], number]>('0x9C77964B0E07B633', this.hash, pvv(), pvf());
+    return [result[0], Vector3.fromArray(result[1]), result[2]];
+  }
+
+  /**
+   * Old name: _IS_IMAP_ACTIVE
+   *
+   * @returns
+   */
+  isIplActiveHash(): boolean {
+    return inv<boolean>('0xD779B9B910BD3B7C', this.hash, rai());
+  }
+
+}

package/src/classes/BaseTask.ts

@@ -0,0 +1,154 @@
+import type { Ped } from '../classes/Ped';
+import { Vector2 } from '../types/Vector2';
+import { Vector3 } from '../types/Vector3';
+import { Vector4 } from '../types/Vector4';
+import { Color } from '../types/Color';
+import type { Entity } from './Entity';
+import { createFromHandle } from '../types/HandleRegistry';
+import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f } from '../types/NativeAliases';
+
+export class BaseTask {
+  protected entity: Entity;
+
+  constructor(entity: Entity) {
+    this.entity = entity;
+  }
+
+  /**
+   * @param p1 
+   */
+  N_0xF3C3503276F4A034(p1: any): void {
+    inv<void>('0xF3C3503276F4A034', this.entity.handle, p1);
+  }
+
+  /**
+   * Returns m_eContainerState
+   *
+   * @returns
+   */
+  getScenarioContainerOpeningState(): any {
+    return inv<number>('0xB219612B5568E9EC', this.entity.handle);
+  }
+
+  /**
+   * Returns scenario
+   *
+   * @param scenarioHash 
+   * @param pos 
+   * @param heading 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @returns
+   */
+  createScenarioPointHashAttachedToEntity(scenarioHash: string | number, pos: Vector3, heading: number, p6: any, p7: any, p8: boolean): number {
+    return inv<number>('0x794AB1379A74064D', this.entity.handle, _h(scenarioHash), f(pos.x), f(pos.y), f(pos.z), f(heading), p6, p7, p8, rai());
+  }
+
+  /**
+   * @returns args
+   */
+  playEntityScriptedAnim(): number {
+    const result = inv<number>('0x77A1EEC547E7FCF1', this.entity.handle, pvi());
+    return result;
+  }
+
+  /**
+   * Returns the entity coverpoint with offset.
+   *
+   * @param offset 
+   * @param heading 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @returns
+   */
+  getCoverpointFromEntityWithOffset(offset: Vector3, heading: number, p5: number, p6: number, p7: number, p8: number): any {
+    return inv<number>('0x59872EA4CBD11C56', this.entity.handle, f(offset.x), f(offset.y), f(offset.z), f(heading), p5, p6, p7, p8);
+  }
+
+  /**
+   * carriableSlot:
+   * 7 > Back of a horse
+   * 6 > Right side of a horse
+   * 5 > Left side of a horse
+   * flags:
+   * 512: enables the prompt being the name of the item when using a generic item
+   *
+   * @param carryConfig 
+   * @param carrier 
+   * @param carriableSlot 
+   * @param flags 
+   */
+  carriable(carryConfig: string | number, carrier: Ped, carriableSlot: number, flags: number): void {
+    inv<void>('0xF0B4F759F35CC7F5', this.entity.handle, _h(carryConfig), carrier.handle, carriableSlot, flags);
+  }
+
+  /**
+   * @returns
+   */
+  getIsCarriableEntity(): any {
+    return inv<number>('0x0CCFE72B43C9CF96', this.entity.handle);
+  }
+
+  /**
+   * @returns This value decreases as items are looted. Before opening, it may return `0` because contents are not always loaded until the container is opened.
+   */
+  getRansackScenarioContainerRemainingLootCount(): number {
+    return inv<number>('0x01AF8A3729231A43', this.entity.handle, rai());
+  }
+
+  /**
+   * @returns Returns the total number of compartments (drawers, lids, etc.) the specific scenarion container has. For example a chest has `1` compartment, while a cabinet with `3` drawers returns `3`
+   */
+  getRansackScenarioContainerNumCompartments(): number {
+    return inv<number>('0x640A602946A8C972', this.entity.handle, rai());
+  }
+
+  /**
+   * @param targetEntity 
+   * @param duration 
+   * @param firingPattern 
+   * @param affectCockedState 
+   */
+  shootAtEntity(targetEntity: Entity, duration: number, firingPattern: string | number, affectCockedState: boolean): void {
+    inv<void>('0x08DA95E8298AE772', this.entity.handle, targetEntity.handle, duration, _h(firingPattern), affectCockedState);
+  }
+
+  /**
+   * Opens/closes containers: ChestDugUp
+   *
+   * @param open 
+   */
+  setScenarioContainerOpeningState(open: boolean): void {
+    inv<void>('0x188F8071F244B9B8', this.entity.handle, open);
+  }
+
+  /**
+   * @returns If the container is not cloesable (like a chest or safe that cannt be closed again) it will return `0`.
+   */
+  getRansackScenarioContainerNumOpenCompartments(): number {
+    return inv<number>('0x849791EBBDBA0362', this.entity.handle, rai());
+  }
+
+  /**
+   * @param filterName 
+   * @param priority 
+   * @param secondary 
+   */
+  setAnimFilter(filterName: string | null, priority: number, secondary: boolean): void {
+    inv<void>('0x87B66D77D545DB66', this.entity.handle, filterName, priority, secondary);
+  }
+
+  /**
+   * @param targetEntity 
+   * @param duration 
+   * @param p3 
+   * @param p4 
+   */
+  N_0x2416EC2F31F75266(targetEntity: Entity, duration: number, p3: any, p4: any): void {
+    inv<void>('0x2416EC2F31F75266', this.entity.handle, targetEntity.handle, duration, p3, p4);
+  }
+
+}

package/src/classes/Cam.ts

@@ -0,0 +1,342 @@
+import type { eEulerRotationOrder } from '../enums/eEulerRotationOrder';
+import type { Entity } from '../classes/Entity';
+import type { Ped } from '../classes/Ped';
+import { Vector2 } from '../types/Vector2';
+import { Vector3 } from '../types/Vector3';
+import { Vector4 } from '../types/Vector4';
+import { Color } from '../types/Color';
+import { IHandle } from '../types/IHandle';
+import { registerHandle, createFromHandle } from '../types/HandleRegistry';
+import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f } from '../types/NativeAliases';
+
+export class Cam implements IHandle {
+  constructor(public handle: number) {}
+
+  static fromHandle(handle: number): Cam | null {
+    return handle === 0 ? null : new Cam(handle);
+  }
+
+  /**
+   * @returns
+   */
+  getCoord(): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x6B12F11C2A9F0344', this.handle, rav()));
+  }
+
+  detachCam(): void {
+    inv<void>('0x05B41DDBEB559556', this.handle);
+  }
+
+  /**
+   * @param timeDuration 
+   */
+  setSplineDuration(timeDuration: number): void {
+    inv<void>('0xFF6311652CA91015', this.handle, timeDuration);
+  }
+
+  /**
+   * Sets the field of view of the cam. Min: 1.0f
+   * Max: 130.0f
+   *
+   * @param fieldOfView 
+   */
+  setFov(fieldOfView: number): void {
+    inv<void>('0x27666E5988D9D429', this.handle, f(fieldOfView));
+  }
+
+  stopPointing(): void {
+    inv<void>('0xCA1B30A3357C71F1', this.handle);
+  }
+
+  /**
+   * @param p1 
+   */
+  setControlsMiniMapHeading(p1: boolean): void {
+    inv<void>('0x1B8F3CE5A6001298', this.handle, p1);
+  }
+
+  /**
+   * Can use this with SET_CAM_SPLINE_PHASE to set the float it this native returns. (returns 1.0f when no nodes has been added, reached end of non existing spline)
+   *
+   * @returns
+   */
+  getSplinePhase(): number {
+    return inv<number>('0x095EDCD24D90033A', this.handle, raf());
+  }
+
+  /**
+   * @returns
+   */
+  isShaking(): boolean {
+    return inv<boolean>('0x2EEB402BD7320159', this.handle, rai());
+  }
+
+  /**
+   * @returns
+   */
+  getFov(): number {
+    return inv<number>('0x8101D32A0A6B0F60', this.handle, raf());
+  }
+
+  /**
+   * @param type 
+   * @param amplitude 
+   */
+  shakeCam(type: string | null, amplitude: number): void {
+    inv<void>('0xF9A7BCF5D050D4E7', this.handle, type, f(amplitude));
+  }
+
+  /**
+   * @returns
+   */
+  isInterpolating(): boolean {
+    return inv<boolean>('0x578F8F1CAA17BD2B', this.handle, rai());
+  }
+
+  /**
+   * BOOL param indicates whether the cam should be destroyed if it belongs to the calling script.
+   *
+   * @param p1 
+   */
+  destroyCam(p1: boolean): void {
+    inv<void>('0x4E67E0B6D7FD5145', this.handle, p1);
+  }
+
+  /**
+   * @returns
+   */
+  isRendering(): boolean {
+    return inv<boolean>('0x4415F8A6C536D39F', this.handle, rai());
+  }
+
+  /**
+   * Returns whether or not the passed camera handle is active.
+   *
+   * @returns
+   */
+  isActive(): boolean {
+    return inv<boolean>('0x63EFCC7E1810B8E6', this.handle, rai());
+  }
+
+  /**
+   * @param p1 
+   */
+  allowMotionBlurDecay(p1: boolean): void {
+    inv<void>('0x42ED56B02E05D109', this.handle, p1);
+  }
+
+  /**
+   * @param rotationOrder Refer to [enum: eEulerRotationOrder]
+   * @returns
+   */
+  getRot(rotationOrder: eEulerRotationOrder): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x9BF96B57254E7889', this.handle, rotationOrder, rav()));
+  }
+
+  /**
+   * Allows you to aim and shoot at the direction the camera is facing.
+   *
+   * @param toggle 
+   */
+  setAffectsAiming(toggle: boolean): void {
+    inv<void>('0x3CB9E8BDE5E76F33', this.handle, toggle);
+  }
+
+  /**
+   * Set cam DOF and focal settings. TODO: Support structs
+   *
+   * @returns p
+   */
+  setDofParams(): number {
+    const result = inv<number>('0xE4B7945EF4F1BFB2', this.handle, pvi());
+    return result;
+  }
+
+  /**
+   * @param distance 
+   */
+  setFocusDistance(distance: number): void {
+    inv<void>('0x11F32BB61B756732', this.handle, f(distance));
+  }
+
+  /**
+   * Sets the position of the cam.
+   *
+   * @param pos 
+   */
+  setCoord(pos: Vector3): void {
+    inv<void>('0xF9EE7D419EE49DE6', this.handle, f(pos.x), f(pos.y), f(pos.z));
+  }
+
+  /**
+   * @param smoothingStyle 
+   */
+  setSplineSmoothingStyle(smoothingStyle: number): void {
+    inv<void>('0x84B3645618E726B0', this.handle, smoothingStyle);
+  }
+
+  /**
+   * @param farClip 
+   */
+  setFarClip(farClip: number): void {
+    inv<void>('0x5E32817BF6302111', this.handle, f(farClip));
+  }
+
+  /**
+   * @param animName 
+   * @param animDictionary 
+   * @param pos 
+   * @param rot 
+   * @param animFlags 
+   * @param rotOrder 
+   * @returns
+   */
+  playAnim(animName: string | null, animDictionary: string | null, pos: Vector3, rot: Vector3, animFlags: number, rotOrder: number): boolean {
+    return inv<boolean>('0xA263DDF694D563F6', this.handle, animName, animDictionary, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), animFlags, rotOrder, rai());
+  }
+
+  /**
+   * Returns whether or not the passed camera handle exists.
+   *
+   * @returns
+   */
+  doesExist(): boolean {
+    return inv<boolean>('0x153AD457764FD704', this.handle, rai());
+  }
+
+  /**
+   * p7 (length) determines the length of the spline, affects camera path and duration of transition between previous node and this one p8 big values ~100 will slow down the camera movement before reaching this node p9 != 0 seems to override the rotation/pitch (bool?)
+   *
+   * @param pos 
+   * @param rot 
+   * @param length 
+   * @param p8 
+   * @param p9 
+   */
+  addSplineNode(pos: Vector3, rot: Vector3, length: number, p8: number, p9: number): void {
+    inv<void>('0xF1F57F9D230F9CD1', this.handle, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), length, p8, p9);
+  }
+
+  /**
+   * Last param determines if its relative to the Entity
+   *
+   * @param entity 
+   * @param offset 
+   * @param isRelative 
+   */
+  attachToEntity(entity: Entity, offset: Vector3, isRelative: boolean): void {
+    inv<void>('0xFDC0DF7F6FB0A592', this.handle, entity.handle, f(offset.x), f(offset.y), f(offset.z), isRelative);
+  }
+
+  /**
+   * boneIndex: https://github.com/femga/rdr3_discoveries/tree/master/boneNames
+   *
+   * @param ped 
+   * @param boneIndex 
+   * @param pos 
+   * @param heading 
+   */
+  attachToPedBone(ped: Ped, boneIndex: number, pos: Vector3, heading: boolean): void {
+    inv<void>('0xDFC1E4A44C0324CA', this.handle, ped.handle, boneIndex, f(pos.x), f(pos.y), f(pos.z), heading);
+  }
+
+  /**
+   * @param camFrom 
+   * @param duration 
+   * @param easeLocation 
+   * @param easeRotation 
+   */
+  setActiveWithInterp(camFrom: Cam, duration: number, easeLocation: number, easeRotation: number): void {
+    inv<void>('0x8B15AE2987C1AC8F', this.handle, camFrom.handle, duration, easeLocation, easeRotation);
+  }
+
+  /**
+   * @param p1 
+   */
+  setSplinePhase(p1: number): void {
+    inv<void>('0xF1898A68E7C15636', this.handle, f(p1));
+  }
+
+  /**
+   * @param strength 
+   */
+  setMotionBlurStrength(strength: number): void {
+    inv<void>('0x45FD891364181F9E', this.handle, f(strength));
+  }
+
+  /**
+   * @param p1 
+   */
+  stopShaking(p1: boolean): void {
+    inv<void>('0xB78CC4B4706614B0', this.handle, p1);
+  }
+
+  /**
+   * @param nearClip 
+   */
+  setNearClip(nearClip: number): void {
+    inv<void>('0xA924028272A61364', this.handle, f(nearClip));
+  }
+
+  /**
+   * @param pos 
+   */
+  pointAtCoord(pos: Vector3): void {
+    inv<void>('0x948B39341C3A40C2', this.handle, f(pos.x), f(pos.y), f(pos.z));
+  }
+
+  /**
+   * @param entity 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   */
+  pointAtEntity(entity: Entity, p2: number, p3: number, p4: number, p5: boolean): void {
+    inv<void>('0xFC2867E6074D3A61', this.handle, entity.handle, f(p2), f(p3), f(p4), p5);
+  }
+
+  /**
+   * @param pause 
+   */
+  pauseCameraFocus(pause: boolean): void {
+    inv<void>('0x9F97E85EC142255E', this.handle, pause);
+  }
+
+  /**
+   * Set camera as active/inactive.
+   *
+   * @param active 
+   */
+  setActive(active: boolean): void {
+    inv<void>('0x87295BCA613800C8', this.handle, active);
+  }
+
+  /**
+   * @param pos 
+   * @param rot 
+   * @param fieldOfView 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   * @param p13 
+   */
+  setParams(pos: Vector3, rot: Vector3, fieldOfView: number, p8: any, p9: number, p10: number, p11: number, p12: any, p13: any): void {
+    inv<void>('0xA47BBFFFB83D4D0A', this.handle, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(fieldOfView), p8, p9, p10, p11, p12, p13);
+  }
+
+  /**
+   * Sets the rotation of the cam.
+   *
+   * @param rot 
+   * @param rotationOrder 
+   */
+  setRot(rot: Vector3, rotationOrder: number): void {
+    inv<void>('0x63DFA6810AD78719', this.handle, f(rot.x), f(rot.y), f(rot.z), rotationOrder);
+  }
+
+}
+
+registerHandle('Cam', Cam);