@dayme/bunraylib 0.1.0 → 1.0.0

package/src/modules/color/ColorModule.ts

@@ -0,0 +1,65 @@
+import { getSymbols } from '../../symbols';
+import { bufs as b, f, i } from '../../utils';
+import type { Color } from '../../types';
+
+const r = () => getSymbols();
+
+export class ColorModule {
+  static colorToInt(c: Color): number {
+    return r().symbols.ColorToInt(i(c));
+  }
+  static colorNormalize(c: Color): { x: number; y: number; z: number; w: number } {
+    r().symbols.ColorNormalizeW(b._vec4Buf, i(c));
+    return {
+      x: b._vec4Buf[0]!,
+      y: b._vec4Buf[1]!,
+      z: b._vec4Buf[2]!,
+      w: b._vec4Buf[3]!,
+    };
+  }
+  static colorFromNormalized(normalized: { x: number; y: number; z: number; w: number }): Color {
+    return r().symbols.ColorFromNormalizedW(
+      f(normalized.x),
+      f(normalized.y),
+      f(normalized.z),
+      f(normalized.w),
+    );
+  }
+  static colorToHSV(c: Color): { h: number; s: number; v: number } {
+    r().symbols.ColorToHSVW(b._vec3Buf2, i(c));
+    return { h: b._vec3Buf2[0]!, s: b._vec3Buf2[1]!, v: b._vec3Buf2[2]! };
+  }
+  static colorFromHSV(hue: number, saturation: number, value: number): Color {
+    return r().symbols.ColorFromHSV(f(hue), f(saturation), f(value));
+  }
+  static colorTint(color: Color, tint: Color): Color {
+    return r().symbols.ColorTint(i(color), i(tint));
+  }
+  static colorBrightness(color: Color, factor: number): Color {
+    return r().symbols.ColorBrightness(i(color), f(factor));
+  }
+  static colorContrast(color: Color, contrast: number): Color {
+    return r().symbols.ColorContrast(i(color), f(contrast));
+  }
+  static colorAlpha(color: Color, alpha: number): Color {
+    return r().symbols.ColorAlpha(i(color), f(alpha));
+  }
+  static colorAlphaBlend(dst: Color, src: Color, tint: Color): Color {
+    return r().symbols.ColorAlphaBlend(i(dst), i(src), i(tint));
+  }
+  static colorLerp(color1: Color, color2: Color, factor: number): Color {
+    return r().symbols.ColorLerp(i(color1), i(color2), f(factor));
+  }
+  static getColor(hexValue: number): Color {
+    return r().symbols.GetColor(i(hexValue));
+  }
+  static fade(color: Color, alpha: number): Color {
+    return r().symbols.Fade(i(color), f(alpha));
+  }
+  static colorIsEqual(col1: Color, col2: Color): boolean {
+    return r().symbols.ColorIsEqual(i(col1), i(col2));
+  }
+  static getPixelDataSize(width: number, height: number, format: number): number {
+    return r().symbols.GetPixelDataSize(i(width), i(height), i(format));
+  }
+}

package/src/modules/color/symbols.ts

@@ -0,0 +1,26 @@
+import { FFIType } from 'bun:ffi';
+const { i32, bool, ptr } = FFIType;
+
+export const colorSymbols = {
+  ColorNormalizeW: { args: [ptr, i32], returns: FFIType.void },
+  ColorToHSVW: { args: [ptr, i32], returns: FFIType.void },
+  ColorFromNormalizedW: {
+    args: [FFIType.f32, FFIType.f32, FFIType.f32, FFIType.f32],
+    returns: i32,
+  },
+} as const;
+
+export const colorDirectSymbols = {
+  ColorIsEqual: { args: [i32, i32], returns: bool },
+  ColorToInt: { args: [i32], returns: i32 },
+  GetPixelDataSize: { args: [i32, i32, i32], returns: i32 },
+  ColorTint: { args: [i32, i32], returns: i32 },
+  ColorBrightness: { args: [i32, FFIType.f32], returns: i32 },
+  ColorContrast: { args: [i32, FFIType.f32], returns: i32 },
+  ColorAlpha: { args: [i32, FFIType.f32], returns: i32 },
+  ColorAlphaBlend: { args: [i32, i32, i32], returns: i32 },
+  ColorLerp: { args: [i32, i32, FFIType.f32], returns: i32 },
+  GetColor: { args: [i32], returns: i32 },
+  Fade: { args: [i32, FFIType.f32], returns: i32 },
+  ColorFromHSV: { args: [FFIType.f32, FFIType.f32, FFIType.f32], returns: i32 },
+} as const;

package/src/modules/color/wrapper.c

@@ -0,0 +1,16 @@
+#include <raylib.h>
+
+void ColorNormalizeW(float* out, Color color) {
+    Vector4 v = ColorNormalize(color);
+    out[0] = v.x; out[1] = v.y; out[2] = v.z; out[3] = v.w;
+}
+
+int ColorFromNormalizedW(float x, float y, float z, float w) {
+    Color c = ColorFromNormalized((Vector4){x, y, z, w});
+    return *((int*)&c);
+}
+
+void ColorToHSVW(float* out, Color color) {
+    Vector3 v = ColorToHSV(color);
+    out[0] = v.x; out[1] = v.y; out[2] = v.z;
+}

package/src/modules/draw3d/Draw3DModule.ts

@@ -0,0 +1,441 @@
+import { getSymbols } from '../../symbols';
+import { f, i, validatePoints } from '../../utils';
+import type {
+  Vec2,
+  Vec3,
+  Rectangle,
+  Camera3D,
+  Ray,
+  Texture2D,
+  BoundingBox,
+  Color,
+} from '../../types';
+
+const r = () => getSymbols();
+
+export class Draw3DModule {
+  /** Draw a line in 3D world space */
+  static drawLine3D(startPos: Vec3, endPos: Vec3, col: Color): void {
+    r().symbols.DrawLine3DW(
+      f(startPos.x),
+      f(startPos.y),
+      f(startPos.z),
+      f(endPos.x),
+      f(endPos.y),
+      f(endPos.z),
+      i(col),
+    );
+  }
+  /** Draw a point in 3D space */
+  static drawPoint3D(position: Vec3, col: Color): void {
+    r().symbols.DrawPoint3DW(f(position.x), f(position.y), f(position.z), i(col));
+  }
+  /** Draw a circle in 3D world space */
+  static drawCircle3D(
+    center: Vec3,
+    radius: number,
+    rotationAxis: Vec3,
+    rotationAngle: number,
+    col: Color,
+  ): void {
+    r().symbols.DrawCircle3DW(
+      f(center.x),
+      f(center.y),
+      f(center.z),
+      f(radius),
+      f(rotationAxis.x),
+      f(rotationAxis.y),
+      f(rotationAxis.z),
+      f(rotationAngle),
+      i(col),
+    );
+  }
+  /** Draw a color-filled triangle (vertex in counter-clockwise order!) */
+  static drawTriangle3D(v1: Vec3, v2: Vec3, v3: Vec3, col: Color): void {
+    r().symbols.DrawTriangle3DW(
+      f(v1.x),
+      f(v1.y),
+      f(v1.z),
+      f(v2.x),
+      f(v2.y),
+      f(v2.z),
+      f(v3.x),
+      f(v3.y),
+      f(v3.z),
+      i(col),
+    );
+  }
+  /** Draw a triangle strip defined by points. Points packed as [x0,y0,z0, x1,y1,z1, ...] in Float32Array */
+  static drawTriangleStrip3D(points: Float32Array, col: Color): void {
+    validatePoints('drawTriangleStrip3D', points, 3, 2);
+    r().symbols.DrawTriangleStrip3D(points, i(points.length / 3), i(col));
+  }
+  /** Draw cube */
+  static drawCube(position: Vec3, width: number, height: number, length: number, col: Color): void {
+    r().symbols.DrawCubeW(
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(width),
+      f(height),
+      f(length),
+      i(col),
+    );
+  }
+  /** Draw cube (Vector version) */
+  static drawCubeV(position: Vec3, size: Vec3, col: Color): void {
+    r().symbols.DrawCubeVW(
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(size.x),
+      f(size.y),
+      f(size.z),
+      i(col),
+    );
+  }
+  /** Draw cube wires */
+  static drawCubeWires(
+    position: Vec3,
+    width: number,
+    height: number,
+    length: number,
+    col: Color,
+  ): void {
+    r().symbols.DrawCubeWiresW(
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(width),
+      f(height),
+      f(length),
+      i(col),
+    );
+  }
+  /** Draw cube wires (Vector version) */
+  static drawCubeWiresV(position: Vec3, size: Vec3, col: Color): void {
+    r().symbols.DrawCubeWiresVW(
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(size.x),
+      f(size.y),
+      f(size.z),
+      i(col),
+    );
+  }
+  /** Draw sphere */
+  static drawSphere(centerPos: Vec3, radius: number, col: Color): void {
+    r().symbols.DrawSphereW(f(centerPos.x), f(centerPos.y), f(centerPos.z), f(radius), i(col));
+  }
+  /** Draw sphere with extended parameters */
+  static drawSphereEx(
+    centerPos: Vec3,
+    radius: number,
+    rings: number,
+    slices: number,
+    col: Color,
+  ): void {
+    r().symbols.DrawSphereExW(
+      f(centerPos.x),
+      f(centerPos.y),
+      f(centerPos.z),
+      f(radius),
+      i(rings),
+      i(slices),
+      i(col),
+    );
+  }
+  /** Draw sphere wires */
+  static drawSphereWires(
+    centerPos: Vec3,
+    radius: number,
+    rings: number,
+    slices: number,
+    col: Color,
+  ): void {
+    r().symbols.DrawSphereWiresW(
+      f(centerPos.x),
+      f(centerPos.y),
+      f(centerPos.z),
+      f(radius),
+      i(rings),
+      i(slices),
+      i(col),
+    );
+  }
+  /** Draw a cylinder/cone */
+  static drawCylinder(
+    position: Vec3,
+    radiusTop: number,
+    radiusBottom: number,
+    height: number,
+    slices: number,
+    col: Color,
+  ): void {
+    r().symbols.DrawCylinderW(
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(radiusTop),
+      f(radiusBottom),
+      f(height),
+      i(slices),
+      i(col),
+    );
+  }
+  /** Draw a cylinder with base at startPos and top at endPos */
+  static drawCylinderEx(
+    startPos: Vec3,
+    endPos: Vec3,
+    startRadius: number,
+    endRadius: number,
+    sides: number,
+    col: Color,
+  ): void {
+    r().symbols.DrawCylinderExW(
+      f(startPos.x),
+      f(startPos.y),
+      f(startPos.z),
+      f(endPos.x),
+      f(endPos.y),
+      f(endPos.z),
+      f(startRadius),
+      f(endRadius),
+      i(sides),
+      i(col),
+    );
+  }
+  /** Draw a cylinder/cone wires */
+  static drawCylinderWires(
+    position: Vec3,
+    radiusTop: number,
+    radiusBottom: number,
+    height: number,
+    slices: number,
+    col: Color,
+  ): void {
+    r().symbols.DrawCylinderWiresW(
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(radiusTop),
+      f(radiusBottom),
+      f(height),
+      i(slices),
+      i(col),
+    );
+  }
+  /** Draw a cylinder wires with base at startPos and top at endPos */
+  static drawCylinderWiresEx(
+    startPos: Vec3,
+    endPos: Vec3,
+    startRadius: number,
+    endRadius: number,
+    sides: number,
+    col: Color,
+  ): void {
+    r().symbols.DrawCylinderWiresExW(
+      f(startPos.x),
+      f(startPos.y),
+      f(startPos.z),
+      f(endPos.x),
+      f(endPos.y),
+      f(endPos.z),
+      f(startRadius),
+      f(endRadius),
+      i(sides),
+      i(col),
+    );
+  }
+  /** Draw a capsule with the center of its sphere caps at startPos and endPos */
+  static drawCapsule(
+    startPos: Vec3,
+    endPos: Vec3,
+    radius: number,
+    slices: number,
+    rings: number,
+    col: Color,
+  ): void {
+    r().symbols.DrawCapsuleW(
+      f(startPos.x),
+      f(startPos.y),
+      f(startPos.z),
+      f(endPos.x),
+      f(endPos.y),
+      f(endPos.z),
+      f(radius),
+      i(slices),
+      i(rings),
+      i(col),
+    );
+  }
+  /** Draw capsule wireframe */
+  static drawCapsuleWires(
+    startPos: Vec3,
+    endPos: Vec3,
+    radius: number,
+    slices: number,
+    rings: number,
+    col: Color,
+  ): void {
+    r().symbols.DrawCapsuleWiresW(
+      f(startPos.x),
+      f(startPos.y),
+      f(startPos.z),
+      f(endPos.x),
+      f(endPos.y),
+      f(endPos.z),
+      f(radius),
+      i(slices),
+      i(rings),
+      i(col),
+    );
+  }
+  /** Draw a plane XZ */
+  static drawPlane(centerPos: Vec3, size: Vec2, col: Color): void {
+    r().symbols.DrawPlaneW(
+      f(centerPos.x),
+      f(centerPos.y),
+      f(centerPos.z),
+      f(size.x),
+      f(size.y),
+      i(col),
+    );
+  }
+  /** Draw a ray line */
+  static drawRay(ray: Ray, col: Color): void {
+    r().symbols.DrawRayW(
+      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(col),
+    );
+  }
+  /** Draw a grid */
+  static drawGrid(slices: number, spacing: number): void {
+    r().symbols.DrawGrid(i(slices), f(spacing));
+  }
+  static drawBoundingBox(box: BoundingBox, color: Color): void {
+    r().symbols.DrawBoundingBoxW(
+      f(box.min.x),
+      f(box.min.y),
+      f(box.min.z),
+      f(box.max.x),
+      f(box.max.y),
+      f(box.max.z),
+      i(color),
+    );
+  }
+  static drawBillboard(
+    camera: Camera3D,
+    texture: Texture2D,
+    position: Vec3,
+    scale: number,
+    tint: Color,
+  ): void {
+    r().symbols.DrawBillboardW(
+      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(texture.id),
+      i(texture.width),
+      i(texture.height),
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(scale),
+      i(tint),
+    );
+  }
+  static drawBillboardRec(
+    camera: Camera3D,
+    texture: Texture2D,
+    source: Rectangle,
+    position: Vec3,
+    size: Vec2,
+    tint: Color,
+  ): void {
+    r().symbols.DrawBillboardRecW(
+      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(texture.id),
+      i(texture.width),
+      i(texture.height),
+      i(source.x),
+      i(source.y),
+      i(source.width),
+      i(source.height),
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(size.x),
+      f(size.y),
+      i(tint),
+    );
+  }
+  static drawBillboardPro(
+    camera: Camera3D,
+    texture: Texture2D,
+    source: Rectangle,
+    position: Vec3,
+    up: Vec3,
+    size: Vec2,
+    origin: Vec2,
+    rotation: number,
+    tint: Color,
+  ): void {
+    r().symbols.DrawBillboardProW(
+      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(texture.id),
+      i(texture.width),
+      i(texture.height),
+      i(source.x),
+      i(source.y),
+      i(source.width),
+      i(source.height),
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(up.x),
+      f(up.y),
+      f(up.z),
+      f(size.x),
+      f(size.y),
+      f(origin.x),
+      f(origin.y),
+      f(rotation),
+      i(tint),
+    );
+  }
+}