@dayme/bunraylib 0.1.0 → 1.0.0

package/src/modules/collision/CollisionModule.ts

@@ -0,0 +1,363 @@
+import { getSymbols } from '../../symbols';
+import { bufs as b, f, i, validatePoints } from '../../utils';
+import type { Vec2, Vec3, Rectangle, Ray, BoundingBox, Mesh, RayCollision } from '../../types';
+
+const r = () => getSymbols();
+
+export class CollisionModule {
+  /** Check collision between two rectangles */
+  static checkCollisionRecs(rec1: Rectangle, rec2: Rectangle): boolean {
+    return r().symbols.CheckCollisionRecsW(
+      f(rec1.x),
+      f(rec1.y),
+      f(rec1.width),
+      f(rec1.height),
+      f(rec2.x),
+      f(rec2.y),
+      f(rec2.width),
+      f(rec2.height),
+    );
+  }
+  /** Check collision between two circles */
+  static checkCollisionCircles(
+    center1: Vec2,
+    radius1: number,
+    center2: Vec2,
+    radius2: number,
+  ): boolean {
+    return r().symbols.CheckCollisionCirclesW(
+      f(center1.x),
+      f(center1.y),
+      f(radius1),
+      f(center2.x),
+      f(center2.y),
+      f(radius2),
+    );
+  }
+  /** Check collision between circle and rectangle */
+  static checkCollisionCircleRec(center: Vec2, radius: number, rec: Rectangle): boolean {
+    return r().symbols.CheckCollisionCircleRecW(
+      f(center.x),
+      f(center.y),
+      f(radius),
+      f(rec.x),
+      f(rec.y),
+      f(rec.width),
+      f(rec.height),
+    );
+  }
+  /** Check if circle collides with a line created between two points [p1] and [p2] */
+  static checkCollisionCircleLine(center: Vec2, radius: number, p1: Vec2, p2: Vec2): boolean {
+    return r().symbols.CheckCollisionCircleLineW(
+      f(center.x),
+      f(center.y),
+      f(radius),
+      f(p1.x),
+      f(p1.y),
+      f(p2.x),
+      f(p2.y),
+    );
+  }
+  /** Check if point is inside rectangle */
+  static checkCollisionPointRec(point: Vec2, rec: Rectangle): boolean {
+    return r().symbols.CheckCollisionPointRecW(
+      f(point.x),
+      f(point.y),
+      f(rec.x),
+      f(rec.y),
+      f(rec.width),
+      f(rec.height),
+    );
+  }
+  /** Check if point is inside circle */
+  static checkCollisionPointCircle(point: Vec2, center: Vec2, radius: number): boolean {
+    return r().symbols.CheckCollisionPointCircleW(
+      f(point.x),
+      f(point.y),
+      f(center.x),
+      f(center.y),
+      f(radius),
+    );
+  }
+  /** Check if point is inside a triangle */
+  static checkCollisionPointTriangle(point: Vec2, p1: Vec2, p2: Vec2, p3: Vec2): boolean {
+    return r().symbols.CheckCollisionPointTriangleW(
+      f(point.x),
+      f(point.y),
+      f(p1.x),
+      f(p1.y),
+      f(p2.x),
+      f(p2.y),
+      f(p3.x),
+      f(p3.y),
+    );
+  }
+  /** Check if point belongs to line created between two points [p1] and [p2] with defined margin [threshold] */
+  static checkCollisionPointLine(point: Vec2, p1: Vec2, p2: Vec2, threshold: number): boolean {
+    return r().symbols.CheckCollisionPointLineW(
+      f(point.x),
+      f(point.y),
+      f(p1.x),
+      f(p1.y),
+      f(p2.x),
+      f(p2.y),
+      i(threshold),
+    );
+  }
+  /**
+   * Check if point is within a polygon described by array of vertices.
+   * Points are packed as [x0,y0, x1,y1, ...] in Float32Array.
+   */
+  static checkCollisionPointPoly(point: Vec2, points: Float32Array): boolean {
+    validatePoints('checkCollisionPointPoly', points, 2, 3);
+    return r().symbols.CheckCollisionPointPolyW(
+      f(point.x),
+      f(point.y),
+      points,
+      i(points.length / 2),
+    );
+  }
+  /**
+   * Check collision between two lines defined by two points each.
+   * @returns Object with `collides` boolean and `collisionPoint` Vec2 (valid only if collides is true)
+   */
+  static checkCollisionLines(
+    startPos1: Vec2,
+    endPos1: Vec2,
+    startPos2: Vec2,
+    endPos2: Vec2,
+  ): { collides: boolean; collisionPoint: Vec2 } {
+    const collides = r().symbols.CheckCollisionLinesW(
+      b._colPtBuf,
+      f(startPos1.x),
+      f(startPos1.y),
+      f(endPos1.x),
+      f(endPos1.y),
+      f(startPos2.x),
+      f(startPos2.y),
+      f(endPos2.x),
+      f(endPos2.y),
+    );
+    return { collides, collisionPoint: { x: b._colPtBuf[0]!, y: b._colPtBuf[1]! } };
+  }
+  /** Get collision rectangle for two rectangles collision. Returns null if no overlap */
+  static getCollisionRec(rec1: Rectangle, rec2: Rectangle): Rectangle {
+    r().symbols.GetCollisionRecW(
+      b._recBuf,
+      f(rec1.x),
+      f(rec1.y),
+      f(rec1.width),
+      f(rec1.height),
+      f(rec2.x),
+      f(rec2.y),
+      f(rec2.width),
+      f(rec2.height),
+    );
+    return {
+      x: b._recBuf[0]!,
+      y: b._recBuf[1]!,
+      width: b._recBuf[2]!,
+      height: b._recBuf[3]!,
+    };
+  }
+  static checkCollisionSpheres(
+    center1: Vec3,
+    radius1: number,
+    center2: Vec3,
+    radius2: number,
+  ): boolean {
+    return r().symbols.CheckCollisionSpheresW(
+      f(center1.x),
+      f(center1.y),
+      f(center1.z),
+      f(radius1),
+      f(center2.x),
+      f(center2.y),
+      f(center2.z),
+      f(radius2),
+    );
+  }
+  static checkCollisionBoxes(box1: BoundingBox, box2: BoundingBox): boolean {
+    return r().symbols.CheckCollisionBoxesW(
+      f(box1.min.x),
+      f(box1.min.y),
+      f(box1.min.z),
+      f(box1.max.x),
+      f(box1.max.y),
+      f(box1.max.z),
+      f(box2.min.x),
+      f(box2.min.y),
+      f(box2.min.z),
+      f(box2.max.x),
+      f(box2.max.y),
+      f(box2.max.z),
+    );
+  }
+  static checkCollisionBoxSphere(box: BoundingBox, center: Vec3, radius: number): boolean {
+    return r().symbols.CheckCollisionBoxSphereW(
+      f(box.min.x),
+      f(box.min.y),
+      f(box.min.z),
+      f(box.max.x),
+      f(box.max.y),
+      f(box.max.z),
+      f(center.x),
+      f(center.y),
+      f(center.z),
+      f(radius),
+    );
+  }
+  static getRayCollisionSphere(ray: Ray, center: Vec3, radius: number): RayCollision {
+    r().symbols.GetRayCollisionSphereW(
+      b._rcHit,
+      b._rcDist,
+      b._rcPt,
+      b._rcNorm,
+      f(ray.position.x),
+      f(ray.position.y),
+      f(ray.position.z),
+      f(ray.direction.x),
+      f(ray.direction.y),
+      f(ray.direction.z),
+      f(center.x),
+      f(center.y),
+      f(center.z),
+      f(radius),
+    );
+    return {
+      hit: b._rcHit[0]! !== 0,
+      distance: b._rcDist[0]!,
+      point: { x: b._rcPt[0]!, y: b._rcPt[1]!, z: b._rcPt[2]! },
+      normal: { x: b._rcNorm[0]!, y: b._rcNorm[1]!, z: b._rcNorm[2]! },
+    };
+  }
+  static getRayCollisionBox(ray: Ray, box: BoundingBox): RayCollision {
+    r().symbols.GetRayCollisionBoxW(
+      b._rcHit,
+      b._rcDist,
+      b._rcPt,
+      b._rcNorm,
+      f(ray.position.x),
+      f(ray.position.y),
+      f(ray.position.z),
+      f(ray.direction.x),
+      f(ray.direction.y),
+      f(ray.direction.z),
+      f(box.min.x),
+      f(box.min.y),
+      f(box.min.z),
+      f(box.max.x),
+      f(box.max.y),
+      f(box.max.z),
+    );
+    return {
+      hit: b._rcHit[0]! !== 0,
+      distance: b._rcDist[0]!,
+      point: { x: b._rcPt[0]!, y: b._rcPt[1]!, z: b._rcPt[2]! },
+      normal: { x: b._rcNorm[0]!, y: b._rcNorm[1]!, z: b._rcNorm[2]! },
+    };
+  }
+  static getRayCollisionTriangle(ray: Ray, p1: Vec3, p2: Vec3, p3: Vec3): RayCollision {
+    r().symbols.GetRayCollisionTriangleW(
+      b._rcHit,
+      b._rcDist,
+      b._rcPt,
+      b._rcNorm,
+      f(ray.position.x),
+      f(ray.position.y),
+      f(ray.position.z),
+      f(ray.direction.x),
+      f(ray.direction.y),
+      f(ray.direction.z),
+      f(p1.x),
+      f(p1.y),
+      f(p1.z),
+      f(p2.x),
+      f(p2.y),
+      f(p2.z),
+      f(p3.x),
+      f(p3.y),
+      f(p3.z),
+    );
+    return {
+      hit: b._rcHit[0]! !== 0,
+      distance: b._rcDist[0]!,
+      point: { x: b._rcPt[0]!, y: b._rcPt[1]!, z: b._rcPt[2]! },
+      normal: { x: b._rcNorm[0]!, y: b._rcNorm[1]!, z: b._rcNorm[2]! },
+    };
+  }
+  static getRayCollisionQuad(ray: Ray, p1: Vec3, p2: Vec3, p3: Vec3, p4: Vec3): RayCollision {
+    r().symbols.GetRayCollisionQuadW(
+      b._rcHit,
+      b._rcDist,
+      b._rcPt,
+      b._rcNorm,
+      f(ray.position.x),
+      f(ray.position.y),
+      f(ray.position.z),
+      f(ray.direction.x),
+      f(ray.direction.y),
+      f(ray.direction.z),
+      f(p1.x),
+      f(p1.y),
+      f(p1.z),
+      f(p2.x),
+      f(p2.y),
+      f(p2.z),
+      f(p3.x),
+      f(p3.y),
+      f(p3.z),
+      f(p4.x),
+      f(p4.y),
+      f(p4.z),
+    );
+    return {
+      hit: b._rcHit[0]! !== 0,
+      distance: b._rcDist[0]!,
+      point: { x: b._rcPt[0]!, y: b._rcPt[1]!, z: b._rcPt[2]! },
+      normal: { x: b._rcNorm[0]!, y: b._rcNorm[1]!, z: b._rcNorm[2]! },
+    };
+  }
+  static getRayCollisionMesh(
+    ray: Ray,
+    mesh: Mesh,
+    transform: { m: Float32Array } | Float32Array,
+  ): RayCollision {
+    const m = transform instanceof Float32Array ? transform : transform.m;
+    r().symbols.GetRayCollisionMeshW(
+      b._rcHit,
+      b._rcDist,
+      b._rcPt,
+      b._rcNorm,
+      f(ray.position.x),
+      f(ray.position.y),
+      f(ray.position.z),
+      f(ray.direction.x),
+      f(ray.direction.y),
+      f(ray.direction.z),
+      i(mesh),
+      f(m[0]!),
+      f(m[4]!),
+      f(m[8]!),
+      f(m[12]!),
+      f(m[1]!),
+      f(m[5]!),
+      f(m[9]!),
+      f(m[13]!),
+      f(m[2]!),
+      f(m[6]!),
+      f(m[10]!),
+      f(m[14]!),
+      f(m[3]!),
+      f(m[7]!),
+      f(m[11]!),
+      f(m[15]!),
+    );
+    return {
+      hit: b._rcHit[0]! !== 0,
+      distance: b._rcDist[0]!,
+      point: { x: b._rcPt[0]!, y: b._rcPt[1]!, z: b._rcPt[2]! },
+      normal: { x: b._rcNorm[0]!, y: b._rcNorm[1]!, z: b._rcNorm[2]! },
+    };
+  }
+}

package/src/modules/collision/symbols.ts

@@ -0,0 +1,149 @@
+import { FFIType } from 'bun:ffi';
+const { i32, bool, ptr, f32 } = FFIType;
+
+export const collisionSymbols = {
+  CheckCollisionRecsW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  CheckCollisionCirclesW: {
+    args: [f32, f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  CheckCollisionCircleRecW: {
+    args: [f32, f32, f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  CheckCollisionCircleLineW: {
+    args: [f32, f32, f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  CheckCollisionPointRecW: {
+    args: [f32, f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  CheckCollisionPointCircleW: {
+    args: [f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  CheckCollisionPointTriangleW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  CheckCollisionPointLineW: {
+    args: [f32, f32, f32, f32, f32, f32, i32],
+    returns: bool,
+  },
+  CheckCollisionPointPolyW: { args: [f32, f32, ptr, i32], returns: bool },
+  CheckCollisionLinesW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  GetCollisionRecW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  CheckCollisionSpheresW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  CheckCollisionBoxesW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  CheckCollisionBoxSphereW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: bool,
+  },
+  GetRayCollisionSphereW: {
+    args: [ptr, ptr, ptr, ptr, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  GetRayCollisionBoxW: {
+    args: [ptr, ptr, ptr, ptr, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  GetRayCollisionTriangleW: {
+    args: [
+      ptr,
+      ptr,
+      ptr,
+      ptr,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+    ],
+    returns: FFIType.void,
+  },
+  GetRayCollisionQuadW: {
+    args: [
+      ptr,
+      ptr,
+      ptr,
+      ptr,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+    ],
+    returns: FFIType.void,
+  },
+  GetRayCollisionMeshW: {
+    args: [
+      ptr,
+      ptr,
+      ptr,
+      ptr,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      i32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+    ],
+    returns: FFIType.void,
+  },
+} as const;

package/src/modules/collision/wrapper.c

@@ -0,0 +1,176 @@
+#include "../../c/common.h"
+
+bool CheckCollisionRecsW(float x1, float y1, float w1, float h1, float x2, float y2, float w2, float h2) {
+    Rectangle r1 = {x1, y1, w1, h1};
+    Rectangle r2 = {x2, y2, w2, h2};
+    return CheckCollisionRecs(r1, r2);
+}
+
+bool CheckCollisionCirclesW(float cx1, float cy1, float r1, float cx2, float cy2, float r2) {
+    return CheckCollisionCircles((Vector2){cx1, cy1}, r1, (Vector2){cx2, cy2}, r2);
+}
+
+bool CheckCollisionCircleRecW(float cx, float cy, float radius, float rx, float ry, float rw, float rh) {
+    return CheckCollisionCircleRec((Vector2){cx, cy}, radius, (Rectangle){rx, ry, rw, rh});
+}
+
+bool CheckCollisionCircleLineW(float cx, float cy, float radius, float p1x, float p1y, float p2x, float p2y) {
+    return CheckCollisionCircleLine((Vector2){cx, cy}, radius, (Vector2){p1x, p1y}, (Vector2){p2x, p2y});
+}
+
+bool CheckCollisionPointRecW(float px, float py, float rx, float ry, float rw, float rh) {
+    return CheckCollisionPointRec((Vector2){px, py}, (Rectangle){rx, ry, rw, rh});
+}
+
+bool CheckCollisionPointCircleW(float px, float py, float cx, float cy, float radius) {
+    return CheckCollisionPointCircle((Vector2){px, py}, (Vector2){cx, cy}, radius);
+}
+
+bool CheckCollisionPointTriangleW(float px, float py, float p1x, float p1y, float p2x, float p2y, float p3x, float p3y) {
+    return CheckCollisionPointTriangle((Vector2){px, py}, (Vector2){p1x, p1y}, (Vector2){p2x, p2y}, (Vector2){p3x, p3y});
+}
+
+bool CheckCollisionPointLineW(float px, float py, float p1x, float p1y, float p2x, float p2y, int threshold) {
+    return CheckCollisionPointLine((Vector2){px, py}, (Vector2){p1x, p1y}, (Vector2){p2x, p2y}, threshold);
+}
+
+bool CheckCollisionPointPolyW(float px, float py, const float* points, int pointCount) {
+    return CheckCollisionPointPoly((Vector2){px, py}, (const Vector2*)points, pointCount);
+}
+
+bool CheckCollisionLinesW(float* out, float s1x, float s1y, float e1x, float e1y, float s2x, float s2y, float e2x, float e2y) {
+    Vector2 cp;
+    bool result = CheckCollisionLines((Vector2){s1x, s1y}, (Vector2){e1x, e1y}, (Vector2){s2x, s2y}, (Vector2){e2x, e2y}, &cp);
+    out[0] = cp.x;
+    out[1] = cp.y;
+    return result;
+}
+
+void GetCollisionRecW(float* out, float x1, float y1, float w1, float h1, float x2, float y2, float w2, float h2) {
+    Rectangle r1 = {x1, y1, w1, h1};
+    Rectangle r2 = {x2, y2, w2, h2};
+    Rectangle result = GetCollisionRec(r1, r2);
+    out[0] = result.x;
+    out[1] = result.y;
+    out[2] = result.width;
+    out[3] = result.height;
+}
+
+bool CheckCollisionSpheresW(float cx1, float cy1, float cz1, float r1, float cx2, float cy2, float cz2, float r2) {
+    return CheckCollisionSpheres(
+        (Vector3){cx1, cy1, cz1}, r1,
+        (Vector3){cx2, cy2, cz2}, r2);
+}
+
+bool CheckCollisionBoxesW(
+    float minX1, float minY1, float minZ1, float maxX1, float maxY1, float maxZ1,
+    float minX2, float minY2, float minZ2, float maxX2, float maxY2, float maxZ2) {
+    BoundingBox bb1 = {
+        {minX1, minY1, minZ1},
+        {maxX1, maxY1, maxZ1}
+    };
+    BoundingBox bb2 = {
+        {minX2, minY2, minZ2},
+        {maxX2, maxY2, maxZ2}
+    };
+    return CheckCollisionBoxes(bb1, bb2);
+}
+
+bool CheckCollisionBoxSphereW(
+    float minX, float minY, float minZ, float maxX, float maxY, float maxZ,
+    float cx, float cy, float cz, float radius) {
+    BoundingBox bb = {
+        {minX, minY, minZ},
+        {maxX, maxY, maxZ}
+    };
+    return CheckCollisionBoxSphere(bb,
+        (Vector3){cx, cy, cz}, radius);
+}
+
+void GetRayCollisionSphereW(bool* outHit, float* outDist, float* outPt, float* outNorm,
+    float rPx, float rPy, float rPz, float rDx, float rDy, float rDz,
+    float cx, float cy, float cz, float radius) {
+    Ray ray = {
+        {rPx, rPy, rPz},
+        {rDx, rDy, rDz}
+    };
+    RayCollision rc = GetRayCollisionSphere(ray,
+        (Vector3){cx, cy, cz}, radius);
+    *outHit = rc.hit;
+    outDist[0] = rc.distance;
+    outPt[0] = rc.point.x; outPt[1] = rc.point.y; outPt[2] = rc.point.z;
+    outNorm[0] = rc.normal.x; outNorm[1] = rc.normal.y; outNorm[2] = rc.normal.z;
+}
+
+void GetRayCollisionBoxW(bool* outHit, float* outDist, float* outPt, float* outNorm,
+    float rPx, float rPy, float rPz, float rDx, float rDy, float rDz,
+    float minX, float minY, float minZ, float maxX, float maxY, float maxZ) {
+    Ray ray = {
+        {rPx, rPy, rPz},
+        {rDx, rDy, rDz}
+    };
+    BoundingBox bb = {
+        {minX, minY, minZ},
+        {maxX, maxY, maxZ}
+    };
+    RayCollision rc = GetRayCollisionBox(ray, bb);
+    *outHit = rc.hit;
+    outDist[0] = rc.distance;
+    outPt[0] = rc.point.x; outPt[1] = rc.point.y; outPt[2] = rc.point.z;
+    outNorm[0] = rc.normal.x; outNorm[1] = rc.normal.y; outNorm[2] = rc.normal.z;
+}
+
+void GetRayCollisionTriangleW(bool* outHit, float* outDist, float* outPt, float* outNorm,
+    float rPx, float rPy, float rPz, float rDx, float rDy, float rDz,
+    float p1x, float p1y, float p1z, float p2x, float p2y, float p2z, float p3x, float p3y, float p3z) {
+    Ray ray = {
+        {rPx, rPy, rPz},
+        {rDx, rDy, rDz}
+    };
+    RayCollision rc = GetRayCollisionTriangle(ray,
+        (Vector3){p1x, p1y, p1z},
+        (Vector3){p2x, p2y, p2z},
+        (Vector3){p3x, p3y, p3z});
+    *outHit = rc.hit;
+    outDist[0] = rc.distance;
+    outPt[0] = rc.point.x; outPt[1] = rc.point.y; outPt[2] = rc.point.z;
+    outNorm[0] = rc.normal.x; outNorm[1] = rc.normal.y; outNorm[2] = rc.normal.z;
+}
+
+void GetRayCollisionQuadW(bool* outHit, float* outDist, float* outPt, float* outNorm,
+    float rPx, float rPy, float rPz, float rDx, float rDy, float rDz,
+    float p1x, float p1y, float p1z, float p2x, float p2y, float p2z,
+    float p3x, float p3y, float p3z, float p4x, float p4y, float p4z) {
+    Ray ray = {
+        {rPx, rPy, rPz},
+        {rDx, rDy, rDz}
+    };
+    RayCollision rc = GetRayCollisionQuad(ray,
+        (Vector3){p1x, p1y, p1z},
+        (Vector3){p2x, p2y, p2z},
+        (Vector3){p3x, p3y, p3z},
+        (Vector3){p4x, p4y, p4z});
+    *outHit = rc.hit;
+    outDist[0] = rc.distance;
+    outPt[0] = rc.point.x; outPt[1] = rc.point.y; outPt[2] = rc.point.z;
+    outNorm[0] = rc.normal.x; outNorm[1] = rc.normal.y; outNorm[2] = rc.normal.z;
+}
+
+void GetRayCollisionMeshW(bool* outHit, float* outDist, float* outPt, float* outNorm,
+    float rPx, float rPy, float rPz, float rDx, float rDy, float rDz,
+    int meshId,
+    float im0, float im4, float im8, float im12,
+    float im1, float im5, float im9, float im13,
+    float im2, float im6, float im10, float im14,
+    float im3, float im7, float im11, float im15) {
+    Ray ray = { {rPx, rPy, rPz}, {rDx, rDy, rDz} };
+    Matrix transform = {im0, im1, im2, im3, im4, im5, im6, im7, im8, im9, im10, im11, im12, im13, im14, im15};
+    if (meshId < 0 || meshId >= MAX_MESHES || !meshUsed[meshId]) {
+        *outHit = false; *outDist = 0; return;
+    }
+    RayCollision rc = GetRayCollisionMesh(ray, meshRegistry[meshId], transform);
+    *outHit = rc.hit;
+    outDist[0] = rc.distance;
+    outPt[0] = rc.point.x; outPt[1] = rc.point.y; outPt[2] = rc.point.z;
+    outNorm[0] = rc.normal.x; outNorm[1] = rc.normal.y; outNorm[2] = rc.normal.z;
+}