bun-memory 1.1.22 → 1.1.24

package/README.md

@@ -97,6 +97,8 @@ cs2.i32Array(0x12345678n, new Int32Array([1, 2, 3, 4]));
 
 ## Example: Using Scratches (Recommended)
 
+Scratches let you reuse buffers and typed arrays for repeated memory operations, avoiding unnecessary allocations and maximizing performance. This is the most efficient way to read or write large or frequent data.
+
 ```ts
 const buffer = Buffer.allocUnsafe(256);
 const array = new Uint64Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 8);

package/example/trigger-bot.ts

@@ -1,4 +1,4 @@
-import { CString, FFIType, dlopen, ptr } from 'bun:ffi';
+import { FFIType, dlopen } from 'bun:ffi';
 import { sleep } from 'bun';
 
 import Memory from '../index.ts';
@@ -28,16 +28,15 @@ const { C_BaseEntity, C_BasePlayerPawn, C_BasePlayerWeapon, C_CSPlayerPawn, C_CS
 };
 
 // Load the needed offsets as bigints…
-const { dwEntityList, dwGlobalVars, dwLocalPlayerController, dwLocalPlayerPawn } = Object.fromEntries(
-  Object.entries(OffsetsJSON['client.dll']).map(([key, value]) => [key, BigInt(value)]) //
+const {
+  'client.dll': { dwEntityList, dwGlobalVars, dwLocalPlayerController, dwLocalPlayerPawn },
+  'engine2.dll': {},
+} = Object.fromEntries(
+  Object.entries(OffsetsJSON).map(([name, section]) => [name, Object.fromEntries(Object.entries(section).map(([key, value]) => [key, BigInt(value as number)]))]) //
 ) as {
-  [K in keyof (typeof OffsetsJSON)['client.dll']]: bigint;
+  [M in keyof typeof OffsetsJSON]: { [K in keyof (typeof OffsetsJSON)[M]]: bigint };
 };
 
-const a: bigint[] = [1n];
-
-console.log(typeof a);
-
 // Open a handle to cs2.exe…
 const cs2 = new Memory('cs2.exe');
 
@@ -107,9 +106,7 @@ async function tick(ClientPtr: bigint) {
       return;
     } else if (Local_NextPrimaryAttackTick > Local_TickBase) {
       return;
-    } else if (Local_WeaponType === 0 || Local_WeaponType === 9) {
-      return;
-    } else if (Local_WeaponType === 5 && !(Local_IsScoped && Local_ZoomLevel !== 0)) {
+    } else if (Local_WeaponType === 0 || (Local_WeaponType === 5 && !(Local_IsScoped && Local_ZoomLevel !== 0)) || Local_WeaponType === 7 || Local_WeaponType === 9) {
       return;
     }
 

package/package.json

@@ -3,7 +3,7 @@
   "bugs": {
     "url": "https://github.com/obscuritysrl/bun-memory/issues"
   },
-  "description": "Fast Windows process memory utilities for Bun using bun:ffi.",
+  "description": "Blazing fast, high-performance Windows process memory manipulation for Bun.",
   "devDependencies": {
     "@types/bun": "latest"
   },
@@ -22,7 +22,7 @@
     "url": "git://github.com/obscuritysrl/bun-memory.git"
   },
   "type": "module",
-  "version": "1.1.22",
+  "version": "1.1.24",
   "main": "./index.ts",
   "keywords": [
     "bun",

package/structs/Memory.ts

@@ -1,14 +1,13 @@
-import { CString, FFIType, dlopen, read } from 'bun:ffi';
+import { CString, FFIType, dlopen } from 'bun:ffi';
 
 import type { Module, NetworkUtlVector, Point, QAngle, Quaternion, Region, RGB, RGBA, Scratch, UPtr, UPtrArray, Vector2, Vector3, Vector4 } from '../types/Memory';
 import Win32Error from './Win32Error';
 
-const { f32, f64, i16, i32, i64, i8, u16, u32, u64, u8 } = read;
-
 const { symbols: Kernel32 } = dlopen('kernel32.dll', {
   CloseHandle: { args: [FFIType.u64], returns: FFIType.bool },
   CreateToolhelp32Snapshot: { args: [FFIType.u32, FFIType.u32], returns: FFIType.u64 },
   GetLastError: { returns: FFIType.u32 },
+  IsWow64Process2: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.bool },
   Module32FirstW: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.bool },
   Module32NextW: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.bool },
   OpenProcess: { args: [FFIType.u32, FFIType.bool, FFIType.u32], returns: FFIType.u64 },
@@ -25,6 +24,10 @@ const { symbols: Kernel32 } = dlopen('kernel32.dll', {
  *
  * Use this class to read and write memory, access modules, and work with common data structures in external processes.
  *
+ * Many scalar reads utilize `TypedArray` scratches to avoid a second FFI hop, such as calling `bun:ffi.read.*`.
+ *
+ * @todo Add support for 32 or 64-bit processes using IsWow64Process2 (Windows 10+).
+ *
  * @example
  * ```ts
  * import Memory from './structs/Memory';
@@ -87,6 +90,7 @@ class Memory {
       }
 
       this._modules = {};
+
       this.hProcess = hProcess;
       this.th32ProcessID = th32ProcessID;
 
@@ -118,29 +122,38 @@ class Memory {
   private _modules: { [key: string]: Module };
 
   private readonly Scratch1 = new Uint8Array(0x01);
+  private readonly Scratch1Int8Array = new Int8Array(this.Scratch1.buffer, this.Scratch1.byteOffset, 0x01);
+
   private readonly Scratch2 = new Uint8Array(0x02);
+  private readonly Scratch2Int16Array = new Int16Array(this.Scratch2.buffer, this.Scratch2.byteOffset, 0x01);
+  private readonly Scratch2Uint16Array = new Uint16Array(this.Scratch2.buffer, this.Scratch2.byteOffset, 0x01);
+
   private readonly Scratch3 = new Uint8Array(0x03);
+
   private readonly Scratch4 = new Uint8Array(0x04);
+  private readonly Scratch4Float32Array = new Float32Array(this.Scratch4.buffer, this.Scratch4.byteOffset, 0x01);
+  private readonly Scratch4Int32Array = new Int32Array(this.Scratch4.buffer, this.Scratch4.byteOffset, 0x01);
+  private readonly Scratch4Uint32Array = new Uint32Array(this.Scratch4.buffer, this.Scratch4.byteOffset, 0x01);
+
   private readonly Scratch8 = new Uint8Array(0x08);
+  private readonly Scratch8BigInt64Array = new BigInt64Array(this.Scratch8.buffer, this.Scratch8.byteOffset, 0x01);
+  private readonly Scratch8BigUint64Array = new BigUint64Array(this.Scratch8.buffer, this.Scratch8.byteOffset, 0x01);
+  private readonly Scratch8Float32Array = new Float32Array(this.Scratch8.buffer, this.Scratch8.byteOffset, 0x02);
+  private readonly Scratch8Float64Array = new Float64Array(this.Scratch8.buffer, this.Scratch8.byteOffset, 0x01);
+
   private readonly Scratch12 = new Uint8Array(0x0c);
-  private readonly Scratch16 = new Uint8Array(0x10);
+  private readonly Scratch12Float32Array = new Float32Array(this.Scratch12.buffer, this.Scratch12.byteOffset, 0x03);
 
-  private readonly Scratch1Buffer = Buffer.from(this.Scratch1.buffer, this.Scratch1.byteOffset, this.Scratch1.byteLength);
-  private readonly Scratch2Buffer = Buffer.from(this.Scratch2.buffer, this.Scratch2.byteOffset, this.Scratch2.byteLength);
-  private readonly Scratch3Buffer = Buffer.from(this.Scratch3.buffer, this.Scratch3.byteOffset, this.Scratch3.byteLength);
-  private readonly Scratch4Buffer = Buffer.from(this.Scratch4.buffer, this.Scratch4.byteOffset, this.Scratch4.byteLength);
-  private readonly Scratch8Buffer = Buffer.from(this.Scratch8.buffer, this.Scratch8.byteOffset, this.Scratch8.byteLength);
-  private readonly Scratch12Buffer = Buffer.from(this.Scratch12.buffer, this.Scratch12.byteOffset, this.Scratch12.byteLength);
-  private readonly Scratch16Buffer = Buffer.from(this.Scratch16.buffer, this.Scratch16.byteOffset, this.Scratch16.byteLength);
+  private readonly Scratch16 = new Uint8Array(0x10);
+  private readonly Scratch16Float32Array = new Float32Array(this.Scratch16.buffer, this.Scratch16.byteOffset, 0x04);
 
   private readonly ScratchMemoryBasicInformation = Buffer.allocUnsafe(0x30 /* sizeof(MEMORY_BASIC_INFORMATION) */);
   private readonly ScratchModuleEntry32W = Buffer.allocUnsafe(0x438 /* sizeof(MODULEENTRY32W) */);
 
-  private static readonly TextDecoderUTF16 = new TextDecoder('utf-16');
-  private static readonly TextDecoderUTF8 = new TextDecoder('utf-8');
+  private static TextDecoderUTF16 = new TextDecoder('utf-16');
+  private static TextDecoderUTF8 = new TextDecoder('utf-8');
 
   private readonly hProcess: bigint;
-
   private readonly th32ProcessID: number;
 
   /**
@@ -149,7 +162,7 @@ class Memory {
    * @example
    * ```ts
    * const cs2 = new Memory('cs2.exe');
-   * const modules = cs2.modules;
+   * const client = cs2.modules['client.dll'];
    * ```
    */
   public get modules(): Memory['_modules'] {
@@ -345,15 +358,15 @@ class Memory {
   public bool(address: bigint): boolean;
   public bool(address: bigint, value: boolean): this;
   public bool(address: bigint, value?: boolean): boolean | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch1);
+    const Scratch1 = this.Scratch1;
 
-      return u8(this.Scratch1.ptr) !== 0;
+    if (value === undefined) {
+      return this.read(address, Scratch1)[0x00] !== 0;
     }
 
-    this.Scratch1Buffer.writeUInt8(+value);
+    Scratch1[0x00] = value ? 1 : 0;
 
-    this.write(address, this.Scratch1);
+    this.write(address, Scratch1);
 
     return this;
   }
@@ -375,12 +388,9 @@ class Memory {
   public buffer(address: bigint, lengthOrValue: number | Buffer): Buffer | this {
     if (typeof lengthOrValue === 'number') {
       const length = lengthOrValue;
-
       const scratch = Buffer.allocUnsafe(length);
 
-      this.read(address, scratch);
-
-      return scratch;
+      return this.read(address, scratch);
     }
 
     const value = lengthOrValue;
@@ -435,15 +445,15 @@ class Memory {
   public f32(address: bigint): number;
   public f32(address: bigint, value: number): this;
   public f32(address: bigint, value?: number): number | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch4);
+    const Scratch4Float32Array = this.Scratch4Float32Array; // prettier-ignore
 
-      return f32(this.Scratch4.ptr);
+    if (value === undefined) {
+      return this.read(address, Scratch4Float32Array)[0x00];
     }
 
-    this.Scratch4Buffer.writeFloatLE(value);
+    Scratch4Float32Array[0x00] = value;
 
-    this.write(address, this.Scratch4);
+    this.write(address, Scratch4Float32Array);
 
     return this;
   }
@@ -494,15 +504,15 @@ class Memory {
   public f64(address: bigint): number;
   public f64(address: bigint, value: number): this;
   public f64(address: bigint, value?: number): number | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch8);
+    const Scratch8Float64Array = this.Scratch8Float64Array; // prettier-ignore
 
-      return f64(this.Scratch8.ptr);
+    if (value === undefined) {
+      return this.read(address, Scratch8Float64Array)[0x00];
     }
 
-    this.Scratch8Buffer.writeDoubleLE(value);
+    Scratch8Float64Array[0x00] = value;
 
-    this.write(address, this.Scratch8);
+    this.write(address, Scratch8Float64Array);
 
     return this;
   }
@@ -553,15 +563,15 @@ class Memory {
   public i16(address: bigint): number;
   public i16(address: bigint, value: number): this;
   public i16(address: bigint, value?: number): number | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch2);
+    const Scratch2Int16Array = this.Scratch2Int16Array; // prettier-ignore
 
-      return i16(this.Scratch2.ptr);
+    if (value === undefined) {
+      return this.read(address, Scratch2Int16Array)[0x00];
     }
 
-    this.Scratch2Buffer.writeInt16LE(value);
+    Scratch2Int16Array[0x00] = value;
 
-    this.write(address, this.Scratch2);
+    this.write(address, Scratch2Int16Array);
 
     return this;
   }
@@ -612,15 +622,15 @@ class Memory {
   public i32(address: bigint): number;
   public i32(address: bigint, value: number): this;
   public i32(address: bigint, value?: number): number | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch4);
+    const Scratch4Int32Array = this.Scratch4Int32Array;
 
-      return i32(this.Scratch4.ptr);
+    if (value === undefined) {
+      return this.read(address, Scratch4Int32Array)[0x00];
     }
 
-    this.Scratch4Buffer.writeInt32LE(value);
+    Scratch4Int32Array[0x00] = value;
 
-    this.write(address, this.Scratch4);
+    this.write(address, Scratch4Int32Array);
 
     return this;
   }
@@ -671,15 +681,15 @@ class Memory {
   public i64(address: bigint): bigint;
   public i64(address: bigint, value: bigint): this;
   public i64(address: bigint, value?: bigint): bigint | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch8);
+    const Scratch8BigInt64Array = this.Scratch8BigInt64Array;
 
-      return i64(this.Scratch8.ptr);
+    if (value === undefined) {
+      return this.read(address, Scratch8BigInt64Array)[0x00];
     }
 
-    this.Scratch8Buffer.writeBigInt64LE(value);
+    Scratch8BigInt64Array[0x00] = value;
 
-    this.write(address, this.Scratch8);
+    this.write(address, Scratch8BigInt64Array);
 
     return this;
   }
@@ -730,15 +740,15 @@ class Memory {
   public i8(address: bigint): number;
   public i8(address: bigint, value: number): this;
   public i8(address: bigint, value?: number): number | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch1);
+    const Scratch1Int8Array = this.Scratch1Int8Array;
 
-      return i8(this.Scratch1.ptr);
+    if (value === undefined) {
+      return this.read(address, Scratch1Int8Array)[0x00];
     }
 
-    this.Scratch1Buffer.writeInt8(value);
+    Scratch1Int8Array[0x00] = value;
 
-    this.write(address, this.Scratch1);
+    this.write(address, Scratch1Int8Array);
 
     return this;
   }
@@ -919,19 +929,21 @@ class Memory {
   public point(address: bigint): Point;
   public point(address: bigint, value: Point): this;
   public point(address: bigint, value?: Point): Point | this {
+    const Scratch8Float32Array = this.Scratch8Float32Array;
+
     if (value === undefined) {
-      this.read(address, this.Scratch8);
+      this.read(address, Scratch8Float32Array);
 
-      const x = f32(this.Scratch8.ptr);
-      const y = f32(this.Scratch8.ptr, 0x04);
+      const x = Scratch8Float32Array[0x00],
+            y = Scratch8Float32Array[0x01]; // prettier-ignore
 
       return { x, y };
     }
 
-    this.Scratch8Buffer.writeFloatLE(value.x);
-    this.Scratch8Buffer.writeFloatLE(value.y, 0x04);
+    Scratch8Float32Array[0x00] = value.x;
+    Scratch8Float32Array[0x01] = value.y;
 
-    this.write(address, this.Scratch8);
+    this.write(address, Scratch8Float32Array);
 
     return this;
   }
@@ -999,21 +1011,23 @@ class Memory {
   public qAngle(address: bigint): QAngle;
   public qAngle(address: bigint, value: QAngle): this;
   public qAngle(address: bigint, value?: QAngle): QAngle | this {
+    const Scratch12Float32Array = this.Scratch12Float32Array;
+
     if (value === undefined) {
-      this.read(address, this.Scratch12);
+      this.read(address, Scratch12Float32Array);
 
-      const pitch = f32(this.Scratch12.ptr);
-      const roll = f32(this.Scratch12.ptr, 0x08);
-      const yaw = f32(this.Scratch12.ptr, 0x04);
+      const pitch = Scratch12Float32Array[0x00],
+            roll  = Scratch12Float32Array[0x02],
+            yaw   = Scratch12Float32Array[0x01]; // prettier-ignore
 
       return { pitch, roll, yaw };
     }
 
-    this.Scratch12Buffer.writeFloatLE(value.pitch);
-    this.Scratch12Buffer.writeFloatLE(value.roll, 0x08);
-    this.Scratch12Buffer.writeFloatLE(value.yaw, 0x04);
+    Scratch12Float32Array[0x00] = value.pitch;
+    Scratch12Float32Array[0x02] = value.roll;
+    Scratch12Float32Array[0x01] = value.yaw;
 
-    this.write(address, this.Scratch12);
+    this.write(address, Scratch12Float32Array);
 
     return this;
   }
@@ -1082,23 +1096,25 @@ class Memory {
   public quaternion(address: bigint): Quaternion;
   public quaternion(address: bigint, value: Quaternion): this;
   public quaternion(address: bigint, value?: Quaternion): Quaternion | this {
+    const Scratch16Float32Array = this.Scratch16Float32Array;
+
     if (value === undefined) {
-      this.read(address, this.Scratch16);
+      this.read(address, Scratch16Float32Array);
 
-      const w = f32(this.Scratch16.ptr, 0x0c);
-      const x = f32(this.Scratch16.ptr);
-      const y = f32(this.Scratch16.ptr, 0x04);
-      const z = f32(this.Scratch16.ptr, 0x08);
+      const w = Scratch16Float32Array[0x03],
+            x = Scratch16Float32Array[0x00],
+            y = Scratch16Float32Array[0x01],
+            z = Scratch16Float32Array[0x02]; // prettier-ignore
 
       return { w, x, y, z };
     }
 
-    this.Scratch16Buffer.writeFloatLE(value.w, 0x0c);
-    this.Scratch16Buffer.writeFloatLE(value.x);
-    this.Scratch16Buffer.writeFloatLE(value.y, 0x04);
-    this.Scratch16Buffer.writeFloatLE(value.z, 0x08);
+    Scratch16Float32Array[0x03] = value.w;
+    Scratch16Float32Array[0x00] = value.x;
+    Scratch16Float32Array[0x01] = value.y;
+    Scratch16Float32Array[0x02] = value.z;
 
-    this.write(address, this.Scratch16);
+    this.write(address, Scratch16Float32Array);
 
     return this;
   }
@@ -1170,21 +1186,23 @@ class Memory {
   public rgb(address: bigint): RGB;
   public rgb(address: bigint, value: RGB): this;
   public rgb(address: bigint, value?: RGB): RGB | this {
+    const Scratch3 = this.Scratch3;
+
     if (value === undefined) {
-      this.read(address, this.Scratch4);
+      this.read(address, Scratch3);
 
-      const r = this.Scratch3Buffer.readUInt8(),
-            g = this.Scratch3Buffer.readUInt8(0x01),
-            b = this.Scratch3Buffer.readUInt8(0x02); // prettier-ignore
+      const r = Scratch3[0x00],
+            g = Scratch3[0x01],
+            b = Scratch3[0x02]; // prettier-ignore
 
       return { r, g, b };
     }
 
-    this.Scratch3Buffer.writeUInt8(value.r);
-    this.Scratch3Buffer.writeUInt8(value.g, 0x01);
-    this.Scratch3Buffer.writeUInt8(value.b, 0x02);
+    Scratch3[0x00] = value.r;
+    Scratch3[0x01] = value.g;
+    Scratch3[0x02] = value.b;
 
-    return this.write(address, this.Scratch4);
+    return this.write(address, Scratch3);
   }
 
   /**
@@ -1202,23 +1220,25 @@ class Memory {
   public rgba(address: bigint): RGBA;
   public rgba(address: bigint, value: RGBA): this;
   public rgba(address: bigint, value?: RGBA): RGBA | this {
+    const Scratch4 = this.Scratch4;
+
     if (value === undefined) {
-      this.read(address, this.Scratch4);
+      this.read(address, Scratch4);
 
-      const r = this.Scratch4Buffer.readUInt8(),
-            g = this.Scratch4Buffer.readUInt8(0x01),
-            b = this.Scratch4Buffer.readUInt8(0x02),
-            a = this.Scratch4Buffer.readUInt8(0x03); // prettier-ignore
+      const r = Scratch4[0x00],
+            g = Scratch4[0x01],
+            b = Scratch4[0x02],
+            a = Scratch4[0x03]; // prettier-ignore
 
       return { r, g, b, a };
     }
 
-    this.Scratch4Buffer.writeUInt8(value.r);
-    this.Scratch4Buffer.writeUInt8(value.g, 0x01);
-    this.Scratch4Buffer.writeUInt8(value.b, 0x02);
-    this.Scratch4Buffer.writeUInt8(value.a, 0x03);
+    Scratch4[0x00] = value.r;
+    Scratch4[0x01] = value.g;
+    Scratch4[0x02] = value.b;
+    Scratch4[0x03] = value.a;
 
-    return this.write(address, this.Scratch4);
+    return this.write(address, Scratch4);
   }
 
   /**
@@ -1236,15 +1256,15 @@ class Memory {
   public u16(address: bigint): number;
   public u16(address: bigint, value: number): this;
   public u16(address: bigint, value?: number): number | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch2);
+    const Scratch2Uint16Array = this.Scratch2Uint16Array;
 
-      return u16(this.Scratch2.ptr);
+    if (value === undefined) {
+      return this.read(address, Scratch2Uint16Array)[0x00];
     }
 
-    this.Scratch2Buffer.writeUInt16LE(value);
+    Scratch2Uint16Array[0x00] = value;
 
-    this.write(address, this.Scratch2);
+    this.write(address, Scratch2Uint16Array);
 
     return this;
   }
@@ -1295,15 +1315,15 @@ class Memory {
   public u32(address: bigint): number;
   public u32(address: bigint, value: number): this;
   public u32(address: bigint, value?: number): number | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch4);
+    const Scratch4Uint32Array = this.Scratch4Uint32Array;
 
-      return u32(this.Scratch4.ptr);
+    if (value === undefined) {
+      return this.read(address, Scratch4Uint32Array)[0x00];
     }
 
-    this.Scratch4Buffer.writeUInt32LE(value);
+    Scratch4Uint32Array[0x00] = value;
 
-    this.write(address, this.Scratch4);
+    this.write(address, Scratch4Uint32Array);
 
     return this;
   }
@@ -1354,15 +1374,15 @@ class Memory {
   public u64(address: bigint): bigint;
   public u64(address: bigint, value: bigint): this;
   public u64(address: bigint, value?: bigint): bigint | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch8);
+    const Scratch8BigUint64Array = this.Scratch8BigUint64Array;
 
-      return u64(this.Scratch8.ptr);
+    if (value === undefined) {
+      return this.read(address, Scratch8BigUint64Array)[0x00];
     }
 
-    this.Scratch8Buffer.writeBigUInt64LE(value);
+    Scratch8BigUint64Array[0x00] = value;
 
-    this.write(address, this.Scratch8);
+    this.write(address, Scratch8BigUint64Array);
 
     return this;
   }
@@ -1413,15 +1433,15 @@ class Memory {
   public u8(address: bigint): number;
   public u8(address: bigint, value: number): this;
   public u8(address: bigint, value?: number): number | this {
-    if (value === undefined) {
-      this.read(address, this.Scratch1);
+    const Scratch1 = this.Scratch1;
 
-      return u8(this.Scratch1.ptr);
+    if (value === undefined) {
+      return this.read(address, Scratch1)[0x00];
     }
 
-    this.Scratch1Buffer.writeUInt8(value);
+    Scratch1[0x00] = value;
 
-    this.write(address, this.Scratch1);
+    this.write(address, Scratch1);
 
     return this;
   }
@@ -1564,21 +1584,23 @@ class Memory {
   public vector3(address: bigint): Vector3;
   public vector3(address: bigint, value: Vector3): this;
   public vector3(address: bigint, value?: Vector3): Vector3 | this {
+    const Scratch12Float32Array = this.Scratch12Float32Array;
+
     if (value === undefined) {
-      this.read(address, this.Scratch12);
+      this.read(address, Scratch12Float32Array);
 
-      const x = f32(this.Scratch12.ptr);
-      const y = f32(this.Scratch12.ptr, 0x04);
-      const z = f32(this.Scratch12.ptr, 0x08);
+      const x = Scratch12Float32Array[0x00],
+            y = Scratch12Float32Array[0x01],
+            z = Scratch12Float32Array[0x02]; // prettier-ignore
 
       return { x, y, z };
     }
 
-    this.Scratch12Buffer.writeFloatLE(value.x);
-    this.Scratch12Buffer.writeFloatLE(value.y, 0x04);
-    this.Scratch12Buffer.writeFloatLE(value.z, 0x08);
+    Scratch12Float32Array[0x00] = value.x;
+    Scratch12Float32Array[0x01] = value.y;
+    Scratch12Float32Array[0x02] = value.z;
 
-    this.write(address, this.Scratch12);
+    this.write(address, Scratch12Float32Array);
 
     return this;
   }