@dayme/bunraylib 0.1.0 → 1.0.0

package/src/{c/model.c → modules/model/wrapper.c}

@@ -1,4 +1,4 @@
-#include "common.h"
+#include "../../c/common.h"
 
 int LoadModelW(const char* fileName) {
     int slot = modelAlloc();
@@ -70,84 +70,84 @@ bool ExportMeshAsCodeW(int id, const char* fileName) {
     return ExportMeshAsCode(meshRegistry[id], fileName);
 }
 
-int GenMeshPolyW(int sides, int radius) {
+int GenMeshPolyW(int sides, float radius) {
     int slot = meshAlloc();
     if (slot < 0) return -1;
-    meshRegistry[slot] = GenMeshPoly(sides, i2f(radius));
+    meshRegistry[slot] = GenMeshPoly(sides, radius);
     return slot;
 }
 
-int GenMeshPlaneW(int width, int length, int resX, int resZ) {
+int GenMeshPlaneW(float width, float length, int resX, int resZ) {
     int slot = meshAlloc();
     if (slot < 0) return -1;
-    meshRegistry[slot] = GenMeshPlane(i2f(width), i2f(length), resX, resZ);
+    meshRegistry[slot] = GenMeshPlane(width, length, resX, resZ);
     return slot;
 }
 
-int GenMeshCubeW(int width, int height, int length) {
+int GenMeshCubeW(float width, float height, float length) {
     int slot = meshAlloc();
     if (slot < 0) return -1;
-    meshRegistry[slot] = GenMeshCube(i2f(width), i2f(height), i2f(length));
+    meshRegistry[slot] = GenMeshCube(width, height, length);
     return slot;
 }
 
-int GenMeshSphereW(int radius, int rings, int slices) {
+int GenMeshSphereW(float radius, int rings, int slices) {
     int slot = meshAlloc();
     if (slot < 0) return -1;
-    meshRegistry[slot] = GenMeshSphere(i2f(radius), rings, slices);
+    meshRegistry[slot] = GenMeshSphere(radius, rings, slices);
     return slot;
 }
 
-int GenMeshHemiSphereW(int radius, int rings, int slices) {
+int GenMeshHemiSphereW(float radius, int rings, int slices) {
     int slot = meshAlloc();
     if (slot < 0) return -1;
-    meshRegistry[slot] = GenMeshHemiSphere(i2f(radius), rings, slices);
+    meshRegistry[slot] = GenMeshHemiSphere(radius, rings, slices);
     return slot;
 }
 
-int GenMeshCylinderW(int radius, int height, int slices) {
+int GenMeshCylinderW(float radius, float height, int slices) {
     int slot = meshAlloc();
     if (slot < 0) return -1;
-    meshRegistry[slot] = GenMeshCylinder(i2f(radius), i2f(height), slices);
+    meshRegistry[slot] = GenMeshCylinder(radius, height, slices);
     return slot;
 }
 
-int GenMeshConeW(int radius, int height, int slices) {
+int GenMeshConeW(float radius, float height, int slices) {
     int slot = meshAlloc();
     if (slot < 0) return -1;
-    meshRegistry[slot] = GenMeshCone(i2f(radius), i2f(height), slices);
+    meshRegistry[slot] = GenMeshCone(radius, height, slices);
     return slot;
 }
 
-int GenMeshTorusW(int radius, int size, int radSeg, int sides) {
+int GenMeshTorusW(float radius, float size, int radSeg, int sides) {
     int slot = meshAlloc();
     if (slot < 0) return -1;
-    meshRegistry[slot] = GenMeshTorus(i2f(radius), i2f(size), radSeg, sides);
+    meshRegistry[slot] = GenMeshTorus(radius, size, radSeg, sides);
     return slot;
 }
 
-int GenMeshKnotW(int radius, int size, int radSeg, int sides) {
+int GenMeshKnotW(float radius, float size, int radSeg, int sides) {
     int slot = meshAlloc();
     if (slot < 0) return -1;
-    meshRegistry[slot] = GenMeshKnot(i2f(radius), i2f(size), radSeg, sides);
+    meshRegistry[slot] = GenMeshKnot(radius, size, radSeg, sides);
     return slot;
 }
 
-int GenMeshHeightmapW(int imageId, int sizeX, int sizeY, int sizeZ) {
+int GenMeshHeightmapW(int imageId, float sizeX, float sizeY, float sizeZ) {
     if (imageId < 0 || imageId >= MAX_IMAGES || !imageUsed[imageId]) return -1;
     int slot = meshAlloc();
     if (slot < 0) return -1;
     meshRegistry[slot] = GenMeshHeightmap(imageRegistry[imageId],
-        (Vector3){i2f(sizeX), i2f(sizeY), i2f(sizeZ)});
+        (Vector3){sizeX, sizeY, sizeZ});
     return slot;
 }
 
-int GenMeshCubicmapW(int imageId, int sizeX, int sizeY, int sizeZ) {
+int GenMeshCubicmapW(int imageId, float sizeX, float sizeY, float sizeZ) {
     if (imageId < 0 || imageId >= MAX_IMAGES || !imageUsed[imageId]) return -1;
     int slot = meshAlloc();
     if (slot < 0) return -1;
     meshRegistry[slot] = GenMeshCubicmap(imageRegistry[imageId],
-        (Vector3){i2f(sizeX), i2f(sizeY), i2f(sizeZ)});
+        (Vector3){sizeX, sizeY, sizeZ});
     return slot;
 }
 
@@ -176,7 +176,7 @@ void UnloadMaterialW(int id) {
 
 void SetMaterialTextureW(int id, int mapType, unsigned int texId, int texW, int texH) {
     if (id < 0 || id >= MAX_MATERIALS || !materialUsed[id]) return;
-    Texture2D tex = { texId, texW, texH, 1, 7 };
+    Texture2D tex = {texId, texW, texH, 1, 7};
     SetMaterialTexture(&materialRegistry[id], mapType, tex);
 }
 
@@ -210,21 +210,21 @@ void LoadModelAnimationsW(int* outSlotStart, int* outAnimCount, const char* file
     if (anims && count > 0) UnloadModelAnimations(anims, count);
 }
 
-void UpdateModelAnimationW(int modelId, int animId, int frame) {
+void UpdateModelAnimationW(int modelId, int animId, float frame) {
     if (modelId < 0 || modelId >= MAX_MODELS || !modelUsed[modelId]) return;
     if (animId < 0 || animId >= MAX_ANIMATIONS || !animUsed[animId]) return;
-    UpdateModelAnimation(modelRegistry[modelId], animRegistry[animId], i2f(frame));
+    UpdateModelAnimation(modelRegistry[modelId], animRegistry[animId], frame);
 }
 
-void UpdateModelAnimationExW(int modelId, int animAId, int frameA, int animBId, int frameB, int blend) {
+void UpdateModelAnimationExW(int modelId, int animAId, float frameA, int animBId, float frameB, float blend) {
     if (modelId < 0 || modelId >= MAX_MODELS || !modelUsed[modelId]) return;
     if (animAId < 0 || animAId >= MAX_ANIMATIONS || !animUsed[animAId]) return;
     if (animBId < 0 || animBId >= MAX_ANIMATIONS || !animUsed[animBId]) return;
     UpdateModelAnimationEx(
         modelRegistry[modelId],
-        animRegistry[animAId], i2f(frameA),
-        animRegistry[animBId], i2f(frameB),
-        i2f(blend));
+        animRegistry[animAId], frameA,
+        animRegistry[animBId], frameB,
+        blend);
 }
 
 void UnloadModelAnimationsW(int startSlot, int count) {

package/src/modules/shader/ShaderModule.ts

@@ -0,0 +1,78 @@
+import { getSymbols } from '../../symbols';
+import { cstr, i } from '../../utils';
+import type { Shader, Texture2D } from '../../types';
+
+const r = () => getSymbols();
+
+export class ShaderModule {
+  static loadShader(vsFileName: string | null, fsFileName: string | null): Shader {
+    return r().symbols.LoadShaderW(
+      vsFileName ? cstr(vsFileName) : null,
+      fsFileName ? cstr(fsFileName) : null,
+    );
+  }
+  static loadShaderFromMemory(vsCode: string | null, fsCode: string | null): Shader {
+    return r().symbols.LoadShaderFromMemoryW(
+      vsCode ? cstr(vsCode) : null,
+      fsCode ? cstr(fsCode) : null,
+    );
+  }
+  static isShaderValid(shader: Shader): boolean {
+    return r().symbols.IsShaderValidW(i(shader));
+  }
+  static getShaderLocation(shader: Shader, uniformName: string): number {
+    return r().symbols.GetShaderLocationW(i(shader), cstr(uniformName));
+  }
+  static getShaderLocationAttrib(shader: Shader, attribName: string): number {
+    return r().symbols.GetShaderLocationAttribW(i(shader), cstr(attribName));
+  }
+  static setShaderValue(
+    shader: Shader,
+    locIndex: number,
+    value: Buffer | Uint8Array | ArrayBufferView,
+    uniformType: number,
+  ): void {
+    r().symbols.SetShaderValueW(i(shader), i(locIndex), value as unknown as Buffer, i(uniformType));
+  }
+  static setShaderValueV(
+    shader: Shader,
+    locIndex: number,
+    value: Buffer | Uint8Array | ArrayBufferView,
+    uniformType: number,
+    count: number,
+  ): void {
+    r().symbols.SetShaderValueVW(
+      i(shader),
+      i(locIndex),
+      value as unknown as Buffer,
+      i(uniformType),
+      i(count),
+    );
+  }
+  static setShaderValueMatrix(shader: Shader, locIndex: number, mat: Float32Array): void {
+    if (mat.length !== 16) {
+      throw new Error(
+        `setShaderValueMatrix: mat must have exactly 16 elements (got ${mat.length})`,
+      );
+    }
+    r().symbols.SetShaderValueMatrixW(i(shader), i(locIndex), mat);
+  }
+  static setShaderValueTexture(shader: Shader, locIndex: number, texture: Texture2D): void {
+    r().symbols.SetShaderValueTextureW(
+      i(shader),
+      i(locIndex),
+      i(texture.id),
+      i(texture.width),
+      i(texture.height),
+    );
+  }
+  static unloadShader(shader: Shader): void {
+    r().symbols.UnloadShaderW(i(shader));
+  }
+  static beginShaderMode(shader: Shader): void {
+    r().symbols.BeginShaderModeW(i(shader));
+  }
+  static endShaderMode(): void {
+    r().symbols.EndShaderModeW();
+  }
+}

package/src/{symbols/shader.ts → modules/shader/symbols.ts}

@@ -1,4 +1,4 @@
-import { FFIType } from "bun:ffi";
+import { FFIType } from 'bun:ffi';
 const { i32, cstring, bool, ptr } = FFIType;
 
 export const shaderSymbols = {
@@ -7,6 +7,8 @@ export const shaderSymbols = {
   IsShaderValidW: { args: [i32], returns: bool },
   GetShaderLocationW: { args: [i32, cstring], returns: i32 },
   GetShaderLocationAttribW: { args: [i32, cstring], returns: i32 },
+  SetShaderValueW: { args: [i32, i32, ptr, i32], returns: FFIType.void },
+  SetShaderValueVW: { args: [i32, i32, ptr, i32, i32], returns: FFIType.void },
   SetShaderValueMatrixW: { args: [i32, i32, ptr], returns: FFIType.void },
   SetShaderValueTextureW: { args: [i32, i32, i32, i32, i32], returns: FFIType.void },
   UnloadShaderW: { args: [i32], returns: FFIType.void },

package/src/{c/shader.c → modules/shader/wrapper.c}

@@ -1,4 +1,4 @@
-#include "common.h"
+#include "../../c/common.h"
 
 int LoadShaderW(const char* vsFileName, const char* fsFileName) {
     int slot = shaderAlloc();
@@ -29,6 +29,16 @@ int GetShaderLocationAttribW(int id, const char* attribName) {
     return GetShaderLocationAttrib(shaderRegistry[id], attribName);
 }
 
+void SetShaderValueW(int id, int locIndex, const void* value, int uniformType) {
+    if (id < 0 || id >= MAX_SHADERS || !shaderUsed[id]) return;
+    SetShaderValue(shaderRegistry[id], locIndex, value, uniformType);
+}
+
+void SetShaderValueVW(int id, int locIndex, const void* value, int uniformType, int count) {
+    if (id < 0 || id >= MAX_SHADERS || !shaderUsed[id]) return;
+    SetShaderValueV(shaderRegistry[id], locIndex, value, uniformType, count);
+}
+
 void SetShaderValueMatrixW(int id, int locIndex, const float* mat) {
     if (id < 0 || id >= MAX_SHADERS || !shaderUsed[id]) return;
     Matrix m;