@dayme/bunraylib 0.1.0 → 1.0.0

package/src/modules/camera/CameraModule.ts

@@ -0,0 +1,239 @@
+import { getSymbols } from '../../symbols';
+import { bufs as b, f, i } from '../../utils';
+import type { Vec2, Vec3, Camera2D, Camera3D, Ray } from '../../types';
+
+const r = () => getSymbols();
+
+export class CameraModule {
+  static beginMode2D(camera: Camera2D): void {
+    r().symbols.BeginMode2DW(
+      f(camera.offset.x),
+      f(camera.offset.y),
+      f(camera.target.x),
+      f(camera.target.y),
+      f(camera.rotation),
+      f(camera.zoom),
+    );
+  }
+  static endMode2D(): void {
+    r().symbols.EndMode2D();
+  }
+  static beginMode3D(camera: Camera3D): void {
+    r().symbols.BeginMode3DW(
+      f(camera.position.x),
+      f(camera.position.y),
+      f(camera.position.z),
+      f(camera.target.x),
+      f(camera.target.y),
+      f(camera.target.z),
+      f(camera.up.x),
+      f(camera.up.y),
+      f(camera.up.z),
+      f(camera.fovy),
+      i(camera.projection),
+    );
+  }
+  static endMode3D(): void {
+    r().symbols.EndMode3D();
+  }
+
+  static updateCamera(camera: Camera3D, mode: number): Camera3D {
+    const pos = new Float32Array([camera.position.x, camera.position.y, camera.position.z]);
+    const tar = new Float32Array([camera.target.x, camera.target.y, camera.target.z]);
+    const up = new Float32Array([camera.up.x, camera.up.y, camera.up.z]);
+    const fovy = new Float32Array([camera.fovy]);
+    const proj = new Int32Array([camera.projection]);
+    r().symbols.UpdateCameraW(pos, tar, up, fovy, proj, i(mode));
+    return {
+      position: { x: pos[0]!, y: pos[1]!, z: pos[2]! },
+      target: { x: tar[0]!, y: tar[1]!, z: tar[2]! },
+      up: { x: up[0]!, y: up[1]!, z: up[2]! },
+      fovy: fovy[0]!,
+      projection: proj[0]! as Camera3D['projection'],
+    };
+  }
+
+  static updateCameraPro(camera: Camera3D, movement: Vec3, rotation: Vec3, zoom: number): Camera3D {
+    const pos = new Float32Array([camera.position.x, camera.position.y, camera.position.z]);
+    const tar = new Float32Array([camera.target.x, camera.target.y, camera.target.z]);
+    const up = new Float32Array([camera.up.x, camera.up.y, camera.up.z]);
+    const fovy = new Float32Array([camera.fovy]);
+    const proj = new Int32Array([camera.projection]);
+    r().symbols.UpdateCameraProW(
+      pos,
+      tar,
+      up,
+      fovy,
+      proj,
+      f(movement.x),
+      f(movement.y),
+      f(movement.z),
+      f(rotation.x),
+      f(rotation.y),
+      f(rotation.z),
+      f(zoom),
+    );
+    return {
+      position: { x: pos[0]!, y: pos[1]!, z: pos[2]! },
+      target: { x: tar[0]!, y: tar[1]!, z: tar[2]! },
+      up: { x: up[0]!, y: up[1]!, z: up[2]! },
+      fovy: fovy[0]!,
+      projection: proj[0]! as Camera3D['projection'],
+    };
+  }
+
+  static getScreenToWorldRay(position: Vec2, camera: Camera3D): Ray {
+    const outPos = new Float32Array(3);
+    const outDir = new Float32Array(3);
+    r().symbols.GetScreenToWorldRayW(
+      outPos,
+      outDir,
+      i(position.x),
+      i(position.y),
+      f(camera.position.x),
+      f(camera.position.y),
+      f(camera.position.z),
+      f(camera.target.x),
+      f(camera.target.y),
+      f(camera.target.z),
+      f(camera.up.x),
+      f(camera.up.y),
+      f(camera.up.z),
+      f(camera.fovy),
+      i(camera.projection),
+    );
+    return {
+      position: { x: outPos[0]!, y: outPos[1]!, z: outPos[2]! },
+      direction: { x: outDir[0]!, y: outDir[1]!, z: outDir[2]! },
+    };
+  }
+  static getWorldToScreen(position: Vec3, camera: Camera3D): Vec2 {
+    r().symbols.GetWorldToScreenW(
+      b._vec2Buf,
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(camera.position.x),
+      f(camera.position.y),
+      f(camera.position.z),
+      f(camera.target.x),
+      f(camera.target.y),
+      f(camera.target.z),
+      f(camera.up.x),
+      f(camera.up.y),
+      f(camera.up.z),
+      f(camera.fovy),
+      i(camera.projection),
+    );
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getWorldToScreen2D(position: Vec2, camera: Camera2D): Vec2 {
+    r().symbols.GetWorldToScreen2DW(
+      b._vec2Buf,
+      f(position.x),
+      f(position.y),
+      f(camera.offset.x),
+      f(camera.offset.y),
+      f(camera.target.x),
+      f(camera.target.y),
+      f(camera.rotation),
+      f(camera.zoom),
+    );
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getScreenToWorld2D(position: Vec2, camera: Camera2D): Vec2 {
+    r().symbols.GetScreenToWorld2DW(
+      b._vec2Buf,
+      f(position.x),
+      f(position.y),
+      f(camera.offset.x),
+      f(camera.offset.y),
+      f(camera.target.x),
+      f(camera.target.y),
+      f(camera.rotation),
+      f(camera.zoom),
+    );
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getScreenToWorldRayEx(
+    position: Vec2,
+    camera: Camera3D,
+    width: number,
+    height: number,
+  ): Ray {
+    r().symbols.GetScreenToWorldRayExW(
+      b._rayPosBuf2,
+      b._rayDirBuf2,
+      i(position.x),
+      i(position.y),
+      i(width),
+      i(height),
+      f(camera.position.x),
+      f(camera.position.y),
+      f(camera.position.z),
+      f(camera.target.x),
+      f(camera.target.y),
+      f(camera.target.z),
+      f(camera.up.x),
+      f(camera.up.y),
+      f(camera.up.z),
+      f(camera.fovy),
+      i(camera.projection),
+    );
+    return {
+      position: { x: b._rayPosBuf2[0]!, y: b._rayPosBuf2[1]!, z: b._rayPosBuf2[2]! },
+      direction: { x: b._rayDirBuf2[0]!, y: b._rayDirBuf2[1]!, z: b._rayDirBuf2[2]! },
+    };
+  }
+  static getWorldToScreenEx(position: Vec3, camera: Camera3D, width: number, height: number): Vec2 {
+    r().symbols.GetWorldToScreenExW(
+      b._vec2Buf,
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(camera.position.x),
+      f(camera.position.y),
+      f(camera.position.z),
+      f(camera.target.x),
+      f(camera.target.y),
+      f(camera.target.z),
+      f(camera.up.x),
+      f(camera.up.y),
+      f(camera.up.z),
+      f(camera.fovy),
+      i(camera.projection),
+      i(width),
+      i(height),
+    );
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getCameraMatrix(camera: Camera3D): Float32Array {
+    r().symbols.GetCameraMatrixW(
+      b._matBuf,
+      f(camera.position.x),
+      f(camera.position.y),
+      f(camera.position.z),
+      f(camera.target.x),
+      f(camera.target.y),
+      f(camera.target.z),
+      f(camera.up.x),
+      f(camera.up.y),
+      f(camera.up.z),
+      f(camera.fovy),
+      i(camera.projection),
+    );
+    return new Float32Array(b._matBuf);
+  }
+  static getCameraMatrix2D(camera: Camera2D): Float32Array {
+    r().symbols.GetCameraMatrix2DW(
+      b._matBuf,
+      camera.offset.x,
+      camera.offset.y,
+      camera.target.x,
+      camera.target.y,
+      f(camera.rotation),
+      f(camera.zoom),
+    );
+    return new Float32Array(b._matBuf);
+  }
+}

package/src/modules/camera/symbols.ts

@@ -0,0 +1,49 @@
+import { FFIType } from 'bun:ffi';
+const { i32, ptr, f32 } = FFIType;
+
+export const cameraWrapperSymbols = {
+  BeginMode2DW: { args: [f32, f32, f32, f32, f32, f32], returns: FFIType.void },
+  BeginMode3DW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  UpdateCameraW: { args: [ptr, ptr, ptr, ptr, ptr, i32], returns: FFIType.void },
+  UpdateCameraProW: {
+    args: [ptr, ptr, ptr, ptr, ptr, f32, f32, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  GetScreenToWorldRayW: {
+    args: [ptr, ptr, i32, i32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  GetWorldToScreenW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  GetWorldToScreen2DW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  GetScreenToWorld2DW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  GetScreenToWorldRayExW: {
+    args: [ptr, ptr, i32, i32, i32, i32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  GetWorldToScreenExW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, i32, i32, i32],
+    returns: FFIType.void,
+  },
+  GetCameraMatrixW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  GetCameraMatrix2DW: { args: [ptr, f32, f32, f32, f32, f32, f32], returns: FFIType.void },
+} as const;
+
+export const cameraDirectSymbols = {
+  EndMode3D: { args: [], returns: FFIType.void },
+  EndMode2D: { args: [], returns: FFIType.void },
+} as const;

package/src/modules/camera/wrapper.c

@@ -0,0 +1,141 @@
+#include "../../c/common.h"
+
+void BeginMode2DW(float offX, float offY, float tarX, float tarY, float rotation, float zoom) {
+    Camera2D cam = { {offX, offY}, {tarX, tarY}, rotation, zoom };
+    BeginMode2D(cam);
+}
+
+void BeginMode3DW(float posX, float posY, float posZ, float tarX, float tarY, float tarZ, float upX, float upY, float upZ, float fovy, int projection) {
+    Camera3D cam = { {posX, posY, posZ}, {tarX, tarY, tarZ}, {upX, upY, upZ}, fovy, projection };
+    BeginMode3D(cam);
+}
+
+void UpdateCameraW(float* pos, float* tar, float* up, float* fovy, int* projection, int mode) {
+    Camera3D cam = {
+        {pos[0], pos[1], pos[2]},
+        {tar[0], tar[1], tar[2]},
+        {up[0], up[1], up[2]},
+        fovy[0],
+        projection[0]
+    };
+    UpdateCamera(&cam, mode);
+    pos[0] = cam.position.x; pos[1] = cam.position.y; pos[2] = cam.position.z;
+    tar[0] = cam.target.x;   tar[1] = cam.target.y;   tar[2] = cam.target.z;
+    up[0]  = cam.up.x;       up[1]  = cam.up.y;       up[2]  = cam.up.z;
+    fovy[0] = cam.fovy;
+    projection[0] = cam.projection;
+}
+
+void UpdateCameraProW(float* pos, float* tar, float* up, float* fovy, int* projection,
+                      float mx, float my, float mz, float rx, float ry, float rz, float zoom) {
+    Camera3D cam = {
+        {pos[0], pos[1], pos[2]},
+        {tar[0], tar[1], tar[2]},
+        {up[0], up[1], up[2]},
+        fovy[0],
+        projection[0]
+    };
+    UpdateCameraPro(&cam, (Vector3){mx, my, mz}, (Vector3){rx, ry, rz}, zoom);
+    pos[0] = cam.position.x; pos[1] = cam.position.y; pos[2] = cam.position.z;
+    tar[0] = cam.target.x;   tar[1] = cam.target.y;   tar[2] = cam.target.z;
+    up[0]  = cam.up.x;       up[1]  = cam.up.y;       up[2]  = cam.up.z;
+    fovy[0] = cam.fovy;
+    projection[0] = cam.projection;
+}
+
+void GetScreenToWorldRayW(float* outPos, float* outDir, int screenX, int screenY,
+    float camPosX, float camPosY, float camPosZ, float camTarX, float camTarY, float camTarZ,
+    float camUpX, float camUpY, float camUpZ, float camFovy, int camProj) {
+    Camera3D cam = {
+        {camPosX, camPosY, camPosZ},
+        {camTarX, camTarY, camTarZ},
+        {camUpX, camUpY, camUpZ},
+        camFovy, camProj
+    };
+    Ray r = GetScreenToWorldRay((Vector2){screenX, screenY}, cam);
+    outPos[0] = r.position.x; outPos[1] = r.position.y; outPos[2] = r.position.z;
+    outDir[0] = r.direction.x; outDir[1] = r.direction.y; outDir[2] = r.direction.z;
+}
+
+void GetWorldToScreenW(float* out, float posX, float posY, float posZ,
+    float camPosX, float camPosY, float camPosZ, float camTarX, float camTarY, float camTarZ,
+    float camUpX, float camUpY, float camUpZ, float camFovy, int camProj) {
+    Camera3D cam = {
+        {camPosX, camPosY, camPosZ},
+        {camTarX, camTarY, camTarZ},
+        {camUpX, camUpY, camUpZ},
+        camFovy, camProj
+    };
+    Vector2 v = GetWorldToScreen((Vector3){posX, posY, posZ}, cam);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetWorldToScreen2DW(float* out, float posX, float posY,
+    float offX, float offY, float tarX, float tarY, float rotation, float zoom) {
+    Camera2D cam = { {offX, offY}, {tarX, tarY}, rotation, zoom };
+    Vector2 v = GetWorldToScreen2D((Vector2){posX, posY}, cam);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetScreenToWorld2DW(float* out, float posX, float posY,
+    float offX, float offY, float tarX, float tarY, float rotation, float zoom) {
+    Camera2D cam = { {offX, offY}, {tarX, tarY}, rotation, zoom };
+    Vector2 v = GetScreenToWorld2D((Vector2){posX, posY}, cam);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetScreenToWorldRayExW(float* outPos, float* outDir,
+    int screenX, int screenY, int screenW, int screenH,
+    float camPosX, float camPosY, float camPosZ,
+    float camTarX, float camTarY, float camTarZ,
+    float camUpX, float camUpY, float camUpZ,
+    float camFovy, int camProj) {
+    Camera3D cam = {
+        {camPosX, camPosY, camPosZ},
+        {camTarX, camTarY, camTarZ},
+        {camUpX, camUpY, camUpZ},
+        camFovy, camProj
+    };
+    Ray r = GetScreenToWorldRayEx((Vector2){screenX, screenY}, cam, screenW, screenH);
+    outPos[0] = r.position.x; outPos[1] = r.position.y; outPos[2] = r.position.z;
+    outDir[0] = r.direction.x; outDir[1] = r.direction.y; outDir[2] = r.direction.z;
+}
+
+void GetWorldToScreenExW(float* out,
+    float posX, float posY, float posZ,
+    float camPosX, float camPosY, float camPosZ,
+    float camTarX, float camTarY, float camTarZ,
+    float camUpX, float camUpY, float camUpZ,
+    float camFovy, int camProj,
+    int screenW, int screenH) {
+    Camera3D cam = {
+        {camPosX, camPosY, camPosZ},
+        {camTarX, camTarY, camTarZ},
+        {camUpX, camUpY, camUpZ},
+        camFovy, camProj
+    };
+    Vector2 v = GetWorldToScreenEx((Vector3){posX, posY, posZ}, cam, screenW, screenH);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetCameraMatrixW(float* out,
+    float camPosX, float camPosY, float camPosZ,
+    float camTarX, float camTarY, float camTarZ,
+    float camUpX, float camUpY, float camUpZ,
+    float camFovy, int camProj) {
+    Camera3D cam = {
+        {camPosX, camPosY, camPosZ},
+        {camTarX, camTarY, camTarZ},
+        {camUpX, camUpY, camUpZ},
+        camFovy, camProj
+    };
+    Matrix m = GetCameraMatrix(cam);
+    memcpy(out, &m, sizeof(Matrix));
+}
+
+void GetCameraMatrix2DW(float* out,
+    float offX, float offY, float tarX, float tarY, float rotation, float zoom) {
+    Camera2D cam = { {offX, offY}, {tarX, tarY}, rotation, zoom };
+    Matrix m = GetCameraMatrix2D(cam);
+    memcpy(out, &m, sizeof(Matrix));
+}