@dayme/bunraylib 0.1.0 → 1.0.0

package/src/c/common.h

@@ -4,8 +4,6 @@
 #include <string.h>
 #include <raylib.h>
 
-static inline float i2f(int i) { float f; memcpy(&f, &i, sizeof(float)); return f; }
-
 #ifndef CONFIG_H
 #define MAX_MODELS 64
 #define MAX_FONTS 32

package/src/constants.ts

@@ -1,6 +1,6 @@
-import { color } from "./utils";
+import { color } from './utils';
 
-export const PI = 3.141592653589793;
+export const PI = Math.PI;
 export const DEG2RAD = PI / 180;
 export const RAD2DEG = 180 / PI;
 

package/src/index.ts

@@ -1,7 +1,7 @@
-export { Raylib } from "./Raylib";
-export { configure, getSymbols } from "./symbols";
-export type { RaylibConfig } from "./symbols";
-export { cstr, color } from "./utils";
+export { Raylib } from './Raylib';
+export { configure, getSymbols } from './symbols';
+export type { RaylibConfig } from './symbols';
+export { cstr, color } from './utils';
 export type {
   CameraProjection,
   Vec2,
@@ -25,5 +25,5 @@ export type {
   ModelAnimation,
   RayCollision,
   GlyphInfo,
-} from "./types";
-export * from "./constants";
+} from './types';
+export * from './constants';

package/src/main.c

@@ -12,4 +12,3 @@
 #include "c/input.c"
 #include "c/audio.c"
 #include "c/shader.c"
-#include "c/filesystem.c"

package/src/main.d.ts

@@ -1,4 +1,4 @@
-declare module "*.c" {
+declare module '*.c' {
   const content: string;
   export default content;
 }

package/src/modules/audio/AudioModule.ts

@@ -0,0 +1,197 @@
+import { getSymbols } from '../../symbols';
+import { cstr, f, i } from '../../utils';
+import type { Wave, Sound, Music, AudioStream } from '../../types';
+const r = () => getSymbols();
+
+export class AudioModule {
+  static initAudioDevice(): void {
+    r().symbols.InitAudioDevice();
+  }
+  static closeAudioDevice(): void {
+    r().symbols.CloseAudioDevice();
+  }
+  static isAudioDeviceReady(): boolean {
+    return r().symbols.IsAudioDeviceReady();
+  }
+  static setMasterVolume(volume: number): void {
+    r().symbols.SetMasterVolume(f(volume));
+  }
+  static getMasterVolume(): number {
+    return r().symbols.GetMasterVolume();
+  }
+  static loadWave(fileName: string): Wave {
+    return r().symbols.LoadWaveW(cstr(fileName));
+  }
+  static loadWaveFromMemory(fileType: string, fileData: Uint8Array, dataSize: number): Wave {
+    return r().symbols.LoadWaveFromMemoryW(cstr(fileType), fileData, i(dataSize));
+  }
+  static isWaveValid(wave: Wave): boolean {
+    return r().symbols.IsWaveValidW(i(wave));
+  }
+  static unloadWave(wave: Wave): void {
+    r().symbols.UnloadWaveW(i(wave));
+  }
+  static exportWave(wave: Wave, fileName: string): boolean {
+    return r().symbols.ExportWaveW(i(wave), cstr(fileName));
+  }
+  static exportWaveAsCode(wave: Wave, fileName: string): boolean {
+    return r().symbols.ExportWaveAsCodeW(i(wave), cstr(fileName));
+  }
+  static waveCopy(wave: Wave): Wave {
+    return r().symbols.WaveCopyW(i(wave));
+  }
+  static waveCrop(wave: Wave, initFrame: number, finalFrame: number): void {
+    r().symbols.WaveCropW(i(wave), i(initFrame), i(finalFrame));
+  }
+  static waveFormat(wave: Wave, sampleRate: number, sampleSize: number, channels: number): void {
+    r().symbols.WaveFormatW(i(wave), i(sampleRate), i(sampleSize), i(channels));
+  }
+  static loadSound(fileName: string): Sound {
+    return r().symbols.LoadSoundW(cstr(fileName));
+  }
+  static loadSoundFromWave(wave: Wave): Sound {
+    return r().symbols.LoadSoundFromWaveW(i(wave));
+  }
+  static loadSoundAlias(source: Sound): Sound {
+    return r().symbols.LoadSoundAliasW(i(source));
+  }
+  static isSoundValid(sound: Sound): boolean {
+    return r().symbols.IsSoundValidW(i(sound));
+  }
+  static unloadSound(sound: Sound): void {
+    r().symbols.UnloadSoundW(i(sound));
+  }
+  static unloadSoundAlias(alias: Sound): void {
+    r().symbols.UnloadSoundAliasW(i(alias));
+  }
+  static playSound(sound: Sound): void {
+    r().symbols.PlaySoundW(i(sound));
+  }
+  static stopSound(sound: Sound): void {
+    r().symbols.StopSoundW(i(sound));
+  }
+  static pauseSound(sound: Sound): void {
+    r().symbols.PauseSoundW(i(sound));
+  }
+  static resumeSound(sound: Sound): void {
+    r().symbols.ResumeSoundW(i(sound));
+  }
+  static isSoundPlaying(sound: Sound): boolean {
+    return r().symbols.IsSoundPlayingW(i(sound));
+  }
+  static setSoundVolume(sound: Sound, volume: number): void {
+    r().symbols.SetSoundVolumeW(i(sound), f(volume));
+  }
+  static setSoundPitch(sound: Sound, pitch: number): void {
+    r().symbols.SetSoundPitchW(i(sound), f(pitch));
+  }
+  static setSoundPan(sound: Sound, pan: number): void {
+    r().symbols.SetSoundPanW(i(sound), f(pan));
+  }
+  static loadMusicStream(fileName: string): Music {
+    return r().symbols.LoadMusicStreamW(cstr(fileName));
+  }
+  static loadMusicStreamFromMemory(fileType: string, data: Uint8Array, dataSize: number): Music {
+    return r().symbols.LoadMusicStreamFromMemoryW(cstr(fileType), data, i(dataSize));
+  }
+  static isMusicValid(music: Music): boolean {
+    return r().symbols.IsMusicValidW(i(music));
+  }
+  static unloadMusicStream(music: Music): void {
+    r().symbols.UnloadMusicStreamW(i(music));
+  }
+  static playMusicStream(music: Music): void {
+    r().symbols.PlayMusicStreamW(i(music));
+  }
+  static isMusicStreamPlaying(music: Music): boolean {
+    return r().symbols.IsMusicStreamPlayingW(i(music));
+  }
+  static updateMusicStream(music: Music): void {
+    r().symbols.UpdateMusicStreamW(i(music));
+  }
+  static stopMusicStream(music: Music): void {
+    r().symbols.StopMusicStreamW(i(music));
+  }
+  static pauseMusicStream(music: Music): void {
+    r().symbols.PauseMusicStreamW(i(music));
+  }
+  static resumeMusicStream(music: Music): void {
+    r().symbols.ResumeMusicStreamW(i(music));
+  }
+  static seekMusicStream(music: Music, position: number): void {
+    r().symbols.SeekMusicStreamW(i(music), f(position));
+  }
+  static setMusicVolume(music: Music, volume: number): void {
+    r().symbols.SetMusicVolumeW(i(music), f(volume));
+  }
+  static setMusicPitch(music: Music, pitch: number): void {
+    r().symbols.SetMusicPitchW(i(music), f(pitch));
+  }
+  static setMusicPan(music: Music, pan: number): void {
+    r().symbols.SetMusicPanW(i(music), f(pan));
+  }
+  static getMusicTimeLength(music: Music): number {
+    return r().symbols.GetMusicTimeLengthW(i(music));
+  }
+  static getMusicTimePlayed(music: Music): number {
+    return r().symbols.GetMusicTimePlayedW(i(music));
+  }
+  static loadAudioStream(sampleRate: number, sampleSize: number, channels: number): AudioStream {
+    return r().symbols.LoadAudioStreamW(i(sampleRate), i(sampleSize), i(channels));
+  }
+  static isAudioStreamValid(stream: AudioStream): boolean {
+    return r().symbols.IsAudioStreamValidW(i(stream));
+  }
+  static unloadAudioStream(stream: AudioStream): void {
+    r().symbols.UnloadAudioStreamW(i(stream));
+  }
+  static isAudioStreamProcessed(stream: AudioStream): boolean {
+    return r().symbols.IsAudioStreamProcessedW(i(stream));
+  }
+  static playAudioStream(stream: AudioStream): void {
+    r().symbols.PlayAudioStreamW(i(stream));
+  }
+  static pauseAudioStream(stream: AudioStream): void {
+    r().symbols.PauseAudioStreamW(i(stream));
+  }
+  static resumeAudioStream(stream: AudioStream): void {
+    r().symbols.ResumeAudioStreamW(i(stream));
+  }
+  static isAudioStreamPlaying(stream: AudioStream): boolean {
+    return r().symbols.IsAudioStreamPlayingW(i(stream));
+  }
+  static stopAudioStream(stream: AudioStream): void {
+    r().symbols.StopAudioStreamW(i(stream));
+  }
+  static setAudioStreamVolume(stream: AudioStream, volume: number): void {
+    r().symbols.SetAudioStreamVolumeW(i(stream), f(volume));
+  }
+  static setAudioStreamPitch(stream: AudioStream, pitch: number): void {
+    r().symbols.SetAudioStreamPitchW(i(stream), f(pitch));
+  }
+  static setAudioStreamPan(stream: AudioStream, pan: number): void {
+    r().symbols.SetAudioStreamPanW(i(stream), f(pan));
+  }
+  static setAudioStreamBufferSizeDefault(size: number): void {
+    r().symbols.SetAudioStreamBufferSizeDefault(i(size));
+  }
+  static loadWaveSamples(wave: Wave): number {
+    return r().symbols.LoadWaveSamplesW(wave) as unknown as number;
+  }
+  static unloadWaveSamples(ptr: number): void {
+    r().symbols.UnloadWaveSamplesW(ptr as unknown as Buffer);
+  }
+  static updateSound(sound: Sound, data: Buffer | Uint8Array, frameCount: number): void {
+    r().symbols.UpdateSoundW(i(sound), data, i(frameCount));
+  }
+  static updateAudioStream(
+    stream: AudioStream,
+    data: Buffer | Uint8Array,
+    frameCount: number,
+  ): void {
+    r().symbols.UpdateAudioStreamW(i(stream), data, i(frameCount));
+  }
+  static setAudioStreamCallback(stream: AudioStream, callback: number): void {
+    r().symbols.SetAudioStreamCallbackW(i(stream), callback as unknown as Buffer);
+  }
+}

package/src/modules/audio/symbols.ts

@@ -0,0 +1,70 @@
+import { FFIType } from 'bun:ffi';
+const { i32, f32, bool } = FFIType;
+
+export const audioDirectSymbols = {
+  InitAudioDevice: { args: [], returns: FFIType.void },
+  CloseAudioDevice: { args: [], returns: FFIType.void },
+  IsAudioDeviceReady: { args: [], returns: bool },
+  SetMasterVolume: { args: [f32], returns: FFIType.void },
+  GetMasterVolume: { args: [], returns: f32 },
+  SetAudioStreamBufferSizeDefault: { args: [i32], returns: FFIType.void },
+} as const;
+
+export const audioWrapperSymbols = {
+  LoadWaveW: { args: [FFIType.cstring], returns: i32 },
+  LoadWaveFromMemoryW: { args: [FFIType.cstring, FFIType.ptr, i32], returns: i32 },
+  IsWaveValidW: { args: [i32], returns: FFIType.bool },
+  UnloadWaveW: { args: [i32], returns: FFIType.void },
+  ExportWaveW: { args: [i32, FFIType.cstring], returns: FFIType.bool },
+  ExportWaveAsCodeW: { args: [i32, FFIType.cstring], returns: FFIType.bool },
+  WaveCopyW: { args: [i32], returns: i32 },
+  WaveCropW: { args: [i32, i32, i32], returns: FFIType.void },
+  WaveFormatW: { args: [i32, i32, i32, i32], returns: FFIType.void },
+  LoadSoundW: { args: [FFIType.cstring], returns: i32 },
+  LoadSoundFromWaveW: { args: [i32], returns: i32 },
+  LoadSoundAliasW: { args: [i32], returns: i32 },
+  IsSoundValidW: { args: [i32], returns: FFIType.bool },
+  UnloadSoundW: { args: [i32], returns: FFIType.void },
+  UnloadSoundAliasW: { args: [i32], returns: FFIType.void },
+  PlaySoundW: { args: [i32], returns: FFIType.void },
+  StopSoundW: { args: [i32], returns: FFIType.void },
+  PauseSoundW: { args: [i32], returns: FFIType.void },
+  ResumeSoundW: { args: [i32], returns: FFIType.void },
+  IsSoundPlayingW: { args: [i32], returns: FFIType.bool },
+  SetSoundVolumeW: { args: [i32, f32], returns: FFIType.void },
+  SetSoundPitchW: { args: [i32, f32], returns: FFIType.void },
+  SetSoundPanW: { args: [i32, f32], returns: FFIType.void },
+  LoadMusicStreamW: { args: [FFIType.cstring], returns: i32 },
+  LoadMusicStreamFromMemoryW: { args: [FFIType.cstring, FFIType.ptr, i32], returns: i32 },
+  IsMusicValidW: { args: [i32], returns: FFIType.bool },
+  UnloadMusicStreamW: { args: [i32], returns: FFIType.void },
+  PlayMusicStreamW: { args: [i32], returns: FFIType.void },
+  IsMusicStreamPlayingW: { args: [i32], returns: FFIType.bool },
+  UpdateMusicStreamW: { args: [i32], returns: FFIType.void },
+  StopMusicStreamW: { args: [i32], returns: FFIType.void },
+  PauseMusicStreamW: { args: [i32], returns: FFIType.void },
+  ResumeMusicStreamW: { args: [i32], returns: FFIType.void },
+  SeekMusicStreamW: { args: [i32, f32], returns: FFIType.void },
+  SetMusicVolumeW: { args: [i32, f32], returns: FFIType.void },
+  SetMusicPitchW: { args: [i32, f32], returns: FFIType.void },
+  SetMusicPanW: { args: [i32, f32], returns: FFIType.void },
+  GetMusicTimeLengthW: { args: [i32], returns: f32 },
+  GetMusicTimePlayedW: { args: [i32], returns: f32 },
+  LoadAudioStreamW: { args: [i32, i32, i32], returns: i32 },
+  IsAudioStreamValidW: { args: [i32], returns: FFIType.bool },
+  UnloadAudioStreamW: { args: [i32], returns: FFIType.void },
+  IsAudioStreamProcessedW: { args: [i32], returns: FFIType.bool },
+  PlayAudioStreamW: { args: [i32], returns: FFIType.void },
+  PauseAudioStreamW: { args: [i32], returns: FFIType.void },
+  ResumeAudioStreamW: { args: [i32], returns: FFIType.void },
+  IsAudioStreamPlayingW: { args: [i32], returns: FFIType.bool },
+  StopAudioStreamW: { args: [i32], returns: FFIType.void },
+  SetAudioStreamVolumeW: { args: [i32, f32], returns: FFIType.void },
+  SetAudioStreamPitchW: { args: [i32, f32], returns: FFIType.void },
+  SetAudioStreamPanW: { args: [i32, f32], returns: FFIType.void },
+  LoadWaveSamplesW: { args: [i32], returns: FFIType.ptr },
+  UnloadWaveSamplesW: { args: [FFIType.ptr], returns: FFIType.void },
+  UpdateSoundW: { args: [i32, FFIType.ptr, i32], returns: FFIType.void },
+  UpdateAudioStreamW: { args: [i32, FFIType.ptr, i32], returns: FFIType.void },
+  SetAudioStreamCallbackW: { args: [i32, FFIType.ptr], returns: FFIType.void },
+} as const;

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

@@ -1,29 +1,4 @@
-#include "common.h"
-
-void InitAudioDeviceW() {
-    InitAudioDevice();
-}
-
-void CloseAudioDeviceW() {
-    CloseAudioDevice();
-}
-
-bool IsAudioDeviceReadyW() {
-    return IsAudioDeviceReady();
-}
-
-void SetMasterVolumeW(int volume) {
-    float f;
-    memcpy(&f, &volume, sizeof(float));
-    SetMasterVolume(f);
-}
-
-int GetMasterVolumeW() {
-    float f = GetMasterVolume();
-    int i;
-    memcpy(&i, &f, sizeof(float));
-    return i;
-}
+#include "../../c/common.h"
 
 int LoadWaveW(const char* fileName) {
     int slot = waveAlloc();
@@ -143,25 +118,19 @@ bool IsSoundPlayingW(int id) {
     return IsSoundPlaying(soundRegistry[id]);
 }
 
-void SetSoundVolumeW(int id, int volume) {
+void SetSoundVolumeW(int id, float volume) {
     if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
-    float f;
-    memcpy(&f, &volume, sizeof(float));
-    SetSoundVolume(soundRegistry[id], f);
+    SetSoundVolume(soundRegistry[id], volume);
 }
 
-void SetSoundPitchW(int id, int pitch) {
+void SetSoundPitchW(int id, float pitch) {
     if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
-    float f;
-    memcpy(&f, &pitch, sizeof(float));
-    SetSoundPitch(soundRegistry[id], f);
+    SetSoundPitch(soundRegistry[id], pitch);
 }
 
-void SetSoundPanW(int id, int pan) {
+void SetSoundPanW(int id, float pan) {
     if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
-    float f;
-    memcpy(&f, &pan, sizeof(float));
-    SetSoundPan(soundRegistry[id], f);
+    SetSoundPan(soundRegistry[id], pan);
 }
 
 int LoadMusicStreamW(const char* fileName) {
@@ -219,48 +188,34 @@ void ResumeMusicStreamW(int id) {
     ResumeMusicStream(musicRegistry[id]);
 }
 
-void SeekMusicStreamW(int id, int position) {
+void SeekMusicStreamW(int id, float position) {
     if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
-    float f;
-    memcpy(&f, &position, sizeof(float));
-    SeekMusicStream(musicRegistry[id], f);
+    SeekMusicStream(musicRegistry[id], position);
 }
 
-void SetMusicVolumeW(int id, int volume) {
+void SetMusicVolumeW(int id, float volume) {
     if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
-    float f;
-    memcpy(&f, &volume, sizeof(float));
-    SetMusicVolume(musicRegistry[id], f);
+    SetMusicVolume(musicRegistry[id], volume);
 }
 
-void SetMusicPitchW(int id, int pitch) {
+void SetMusicPitchW(int id, float pitch) {
     if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
-    float f;
-    memcpy(&f, &pitch, sizeof(float));
-    SetMusicPitch(musicRegistry[id], f);
+    SetMusicPitch(musicRegistry[id], pitch);
 }
 
-void SetMusicPanW(int id, int pan) {
+void SetMusicPanW(int id, float pan) {
     if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
-    float f;
-    memcpy(&f, &pan, sizeof(float));
-    SetMusicPan(musicRegistry[id], f);
+    SetMusicPan(musicRegistry[id], pan);
 }
 
-int GetMusicTimeLengthW(int id) {
+float GetMusicTimeLengthW(int id) {
     if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return 0;
-    float f = GetMusicTimeLength(musicRegistry[id]);
-    int i;
-    memcpy(&i, &f, sizeof(float));
-    return i;
+    return GetMusicTimeLength(musicRegistry[id]);
 }
 
-int GetMusicTimePlayedW(int id) {
+float GetMusicTimePlayedW(int id) {
     if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return 0;
-    float f = GetMusicTimePlayed(musicRegistry[id]);
-    int i;
-    memcpy(&i, &f, sizeof(float));
-    return i;
+    return GetMusicTimePlayed(musicRegistry[id]);
 }
 
 int LoadAudioStreamW(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels) {
@@ -311,29 +266,19 @@ void StopAudioStreamW(int id) {
     StopAudioStream(audioStreamRegistry[id]);
 }
 
-void SetAudioStreamVolumeW(int id, int volume) {
+void SetAudioStreamVolumeW(int id, float volume) {
     if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
-    float f;
-    memcpy(&f, &volume, sizeof(float));
-    SetAudioStreamVolume(audioStreamRegistry[id], f);
+    SetAudioStreamVolume(audioStreamRegistry[id], volume);
 }
 
-void SetAudioStreamPitchW(int id, int pitch) {
+void SetAudioStreamPitchW(int id, float pitch) {
     if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
-    float f;
-    memcpy(&f, &pitch, sizeof(float));
-    SetAudioStreamPitch(audioStreamRegistry[id], f);
+    SetAudioStreamPitch(audioStreamRegistry[id], pitch);
 }
 
-void SetAudioStreamPanW(int id, int pan) {
+void SetAudioStreamPanW(int id, float pan) {
     if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
-    float f;
-    memcpy(&f, &pan, sizeof(float));
-    SetAudioStreamPan(audioStreamRegistry[id], f);
-}
-
-void SetAudioStreamBufferSizeDefaultW(int size) {
-    SetAudioStreamBufferSizeDefault(size);
+    SetAudioStreamPan(audioStreamRegistry[id], pan);
 }
 
 float* LoadWaveSamplesW(int waveId) {
@@ -342,3 +287,18 @@ float* LoadWaveSamplesW(int waveId) {
 }
 
 void UnloadWaveSamplesW(float* samples) { UnloadWaveSamples(samples); }
+
+void UpdateSoundW(int soundId, const void* data, int frameCount) {
+    if (soundId < 0 || soundId >= MAX_SOUNDS || !soundUsed[soundId]) return;
+    UpdateSound(soundRegistry[soundId], data, frameCount);
+}
+
+void UpdateAudioStreamW(int streamId, const void* data, int frameCount) {
+    if (streamId < 0 || streamId >= MAX_AUDIOSTREAMS || !audioStreamUsed[streamId]) return;
+    UpdateAudioStream(audioStreamRegistry[streamId], data, frameCount);
+}
+
+void SetAudioStreamCallbackW(int streamId, void* callback) {
+    if (streamId < 0 || streamId >= MAX_AUDIOSTREAMS || !audioStreamUsed[streamId]) return;
+    SetAudioStreamCallback(audioStreamRegistry[streamId], (AudioCallback)callback);
+}