client/api/camera overrides

src/core/client/api/index.ts

@@ -1,4 +1,3 @@
-/** @ignore */
 export * as camera from '@AthenaClient/camera';
 export * as menu from '@AthenaClient/menus';
 export * as rmlui from '@AthenaClient/rmlui';

src/core/client/camera/cinematic.ts

@@ -303,10 +303,18 @@ const InternalFunctions = {
  *
  */
 export async function destroy(): Promise<void> {
+ if (Overrides.destroy) {
+ return Overrides.destroy();
+ }
+
  return await InternalFunctions.destroy();
 }
 
 export async function overrideNodes(_nodes: Array<iCameraNode>) {
+ if (Overrides.overrideNodes) {
+ return Overrides.overrideNodes(_nodes);
+ }
+
  nodes = _nodes;
 }
 
@@ -317,6 +325,10 @@ export async function overrideNodes(_nodes: Array<iCameraNode>) {
  *
  */
 export async function addNode(node: iCameraNode) {
+ if (Overrides.addNode) {
+ return Overrides.addNode(node);
+ }
+
  if (!node.pos) {
  throw new Error(`Camera Node -> Error: Position was not set for camera node.`);
  }
@@ -343,6 +355,10 @@ export async function addNode(node: iCameraNode) {
  *
  */
 export async function next(removeFromArray = true): Promise<boolean> {
+ if (Overrides.next) {
+ return Overrides.next(removeFromArray);
+ }
+
  if (nodes.length <= 0) {
  return false;
  }
@@ -372,9 +388,32 @@ export async function next(removeFromArray = true): Promise<boolean> {
  *
  */
 export async function play() {
+ if (Overrides.play) {
+ return Overrides.play();
+ }
+
  const cameraNodes = [...nodes];
  for (let i = 0; i < cameraNodes.length; i++) {
  await InternalFunctions.isCameraUpdating();
  await InternalFunctions.next(cameraNodes[i]);
  }
 }
+
+interface CinematicCamFuncs {
+ addNode: typeof addNode;
+ destroy: typeof destroy;
+ overrideNodes: typeof overrideNodes;
+ next: typeof next;
+ play: typeof play;
+}
+
+const Overrides: Partial<CinematicCamFuncs> = {};
+
+export function override(functionName: 'addNode', callback: typeof addNode);
+export function override(functionName: 'destroy', callback: typeof destroy);
+export function override(functionName: 'overrideNodes', callback: typeof overrideNodes);
+export function override(functionName: 'next', callback: typeof next);
+export function override(functionName: 'play', callback: typeof play);
+export function override(functionName: keyof CinematicCamFuncs, callback: any): void {
+ Overrides[functionName] = callback;
+}

src/core/client/camera/gameplay.ts

@@ -18,10 +18,14 @@ const Internal = {
 /**
  * Disable the gameplay camera from moving
  *
- * 
+ *
  * @return {void}
  */
 export function disable() {
+ if (Overrides.disable) {
+ return Overrides.disable();
+ }
+
  if (typeof interval !== 'undefined') {
  return;
  }
@@ -32,14 +36,31 @@ export function disable() {
 /**
  * Enable the gameplay camera
  *
- * 
+ *
  * @return {void}
  */
 export function enable() {
+ if (Overrides.enable) {
+ return Overrides.enable();
+ }
+
  if (typeof interval === 'undefined') {
  return;
  }
 
  alt.clearInterval(interval);
  interval = undefined;
 }
+
+interface GameplayCamFuncs {
+ enable: typeof enable;
+ disable: typeof disable;
+}
+
+const Overrides: Partial<GameplayCamFuncs> = {};
+
+export function override(functionName: 'enable', callback: typeof enable);
+export function override(functionName: 'disable', callback: typeof disable);
+export function override(functionName: keyof GameplayCamFuncs, callback: any): void {
+ Overrides[functionName] = callback;
+}

src/core/client/camera/pedEdit.ts

@@ -24,6 +24,10 @@ let isQueueReady = false;
  *
  */
 export async function create(_scriptID: number, offset: alt.IVector3 = null, _isLocalPlayer = false): Promise<void> {
+ if (Overrides.create) {
+ return Overrides.create(_scriptID, offset, _isLocalPlayer);
+ }
+
  scriptID = _scriptID;
  isLocalPlayer = _isLocalPlayer;
  startPosition = native.getEntityCoords(scriptID, false);
@@ -80,6 +84,10 @@ export async function create(_scriptID: number, offset: alt.IVector3 = null, _is
  *
  */
 export function calculateCamOffset(offset: alt.IVector3): alt.IVector3 {
+ if (Overrides.calculateCamOffset) {
+ return Overrides.calculateCamOffset(offset);
+ }
+
  return native.getOffsetFromEntityInWorldCoords(
  isLocalPlayer ? alt.Player.local.scriptID : scriptID,
  offset.x,
@@ -95,6 +103,10 @@ export function calculateCamOffset(offset: alt.IVector3): alt.IVector3 {
  *
  */
 export function setCameraOffset(offset: alt.IVector3) {
+ if (Overrides.setCameraOffset) {
+ return Overrides.setCameraOffset(offset);
+ }
+
  startPosition = calculateCamOffset(offset) as alt.Vector3;
  native.pointCamAtCoord(camera, startPosition.x, startPosition.y, startPosition.z);
  native.setCamActive(camera, true);
@@ -108,6 +120,10 @@ export function setCameraOffset(offset: alt.IVector3) {
  *
  */
 export function exists() {
+ if (Overrides.exists) {
+ return Overrides.exists();
+ }
+
  return camera !== null;
 }
 
@@ -117,6 +133,10 @@ export function exists() {
  *
  */
 export async function destroy() {
+ if (Overrides.destroy) {
+ return Overrides.destroy();
+ }
+
  if (cameraControlsInterval !== undefined && cameraControlsInterval !== null) {
  alt.clearInterval(cameraControlsInterval);
  cameraControlsInterval = null;
@@ -149,6 +169,10 @@ export async function destroy() {
  *
  */
 export function disableControls(status: boolean): void {
+ if (Overrides.disableControls) {
+ return Overrides.disableControls(status);
+ }
+
  controlStatus = status;
 }
 
@@ -159,6 +183,10 @@ export function disableControls(status: boolean): void {
  *
  */
 export function setCamParams(_zpos: number = null, _fov: number = null, _easeTime: number = 500) {
+ if (Overrides.setCamParams) {
+ return Overrides.setCamParams(_zpos, _fov, _easeTime);
+ }
+
  if (_zpos === null) {
  _zpos = zpos;
  }
@@ -171,6 +199,10 @@ export function setCamParams(_zpos: number = null, _fov: number = null, _easeTim
 }
 
 export async function runQueue() {
+ if (Overrides.runQueue) {
+ return Overrides.runQueue();
+ }
+
  if (camUpdateQueue.length <= 0) {
  return;
  }
@@ -222,10 +254,18 @@ export async function runQueue() {
  *
  */
 export function update(id: number) {
+ if (Overrides.update) {
+ return Overrides.update(id);
+ }
+
  scriptID = id;
 }
 
 export function handleControls() {
+ if (Overrides.handleControls) {
+ return Overrides.handleControls();
+ }
+
  native.hideHudAndRadarThisFrame();
  native.disableAllControlActions(0);
  native.disableAllControlActions(1);
@@ -365,3 +405,31 @@ alt.on('connectionComplete', () => {
 alt.on('disconnect', () => {
  destroy();
 });
+
+interface PedEditCamFuncs {
+ calculateCamOffset: typeof calculateCamOffset;
+ create: typeof create;
+ destroy: typeof destroy;
+ disableControls: typeof disableControls;
+ update: typeof update;
+ handleControls: typeof handleControls;
+ exists: typeof exists;
+ runQueue: typeof runQueue;
+ setCameraOffset: typeof setCameraOffset;
+ setCamParams: typeof setCamParams;
+}
+
+const Overrides: Partial<PedEditCamFuncs> = {};
+
+export function override(functionName: 'create', callback: typeof create);
+export function override(functionName: 'destroy', callback: typeof destroy);
+export function override(functionName: 'disableControls', callback: typeof disableControls);
+export function override(functionName: 'update', callback: typeof update);
+export function override(functionName: 'handleControls', callback: typeof handleControls);
+export function override(functionName: 'exists', callback: typeof exists);
+export function override(functionName: 'runQueue', callback: typeof runQueue);
+export function override(functionName: 'setCameraOffset', callback: typeof setCameraOffset);
+export function override(functionName: 'setCamParams', callback: typeof setCamParams);
+export function override(functionName: keyof PedEditCamFuncs, callback: any): void {
+ Overrides[functionName] = callback;
+}

src/core/client/camera/switch.ts

@@ -15,6 +15,10 @@ export async function switchToMultiSecondpart(
  timeInMs: number,
  switchType: SWITCHOUT_TYPES = SWITCHOUT_TYPES.THREE_STEPS,
 ): Promise<boolean> {
+ if (Overrides.switchToMultiSecondpart) {
+ return Overrides.switchToMultiSecondpart(timeInMs, switchType);
+ }
+
  if (!native.isPlayerSwitchInProgress()) {
  native.switchToMultiFirstpart(alt.Player.local.scriptID, 0, switchType);
  }
@@ -24,3 +28,14 @@ export async function switchToMultiSecondpart(
  native.switchToMultiSecondpart(alt.Player.local.scriptID);
  return true;
 }
+
+interface SwitchCameraFuncs {
+ switchToMultiSecondpart: typeof switchToMultiSecondpart;
+}
+
+const Overrides: Partial<SwitchCameraFuncs> = {};
+
+export function override(functionName: 'switchToMultiSecondpart', callback: typeof switchToMultiSecondpart);
+export function override(functionName: keyof SwitchCameraFuncs, callback: any): void {
+ Overrides[functionName] = callback;
+}