@geastack/native-webgl-angle 0.1.6

package/native/audio_uwp.h

@@ -0,0 +1,116 @@
+#pragma once
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#include <xaudio2.h>
+#include <mfapi.h>
+#include <mfidl.h>
+#include <mfreadwrite.h>
+#include <wrl/client.h>
+#include <array>
+#include <string>
+#include <vector>
+
+// The WebAudio graph remains in audio_host.mm. This adapter only delivers its
+// planar float output to XAudio2 and decodes packaged audio through Media Foundation.
+class GeaUwpAudioOutput final : public IXAudio2VoiceCallback {
+  // Two 10 ms blocks bound queued audio to 20 ms at 48 kHz. The previous
+  // three 1024-frame blocks delayed gain changes and new sounds by up to 64 ms.
+  static constexpr size_t frames = 480;
+  Microsoft::WRL::ComPtr<IXAudio2> engine;
+  IXAudio2MasteringVoice *master = nullptr;
+  IXAudio2SourceVoice *voice = nullptr;
+  std::array<std::array<float, frames * 2>, 2> buffers{};
+  std::array<float, frames> left{}, right{};
+  void *context = nullptr;
+  void (*render)(void *, size_t, float *, float *) = nullptr;
+
+  HRESULT submit(float *data) {
+    XAUDIO2_BUFFER buffer{};
+    buffer.AudioBytes = static_cast<UINT32>(frames * 2 * sizeof(float));
+    buffer.pAudioData = reinterpret_cast<const BYTE *>(data);
+    buffer.pContext = data;
+    return voice->SubmitSourceBuffer(&buffer);
+  }
+
+public:
+  ~GeaUwpAudioOutput() {
+    if (voice) voice->DestroyVoice();
+    if (master) master->DestroyVoice();
+  }
+  bool start(void *ctx, void (*pull)(void *, size_t, float *, float *)) {
+    context = ctx;
+    render = pull;
+    if (FAILED(XAudio2Create(engine.GetAddressOf(), 0, XAUDIO2_DEFAULT_PROCESSOR))) return false;
+    if (FAILED(engine->CreateMasteringVoice(&master, 2, 48000))) return false;
+    WAVEFORMATEX format{};
+    format.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
+    format.nChannels = 2;
+    format.nSamplesPerSec = 48000;
+    format.wBitsPerSample = 32;
+    format.nBlockAlign = 8;
+    format.nAvgBytesPerSec = 48000 * 8;
+    if (FAILED(engine->CreateSourceVoice(&voice, &format, 0, 1.0f, this))) return false;
+    for (auto &buffer : buffers) if (FAILED(submit(buffer.data()))) return false;
+    return SUCCEEDED(voice->Start());
+  }
+
+  void STDMETHODCALLTYPE OnBufferEnd(void *data) override {
+    render(context, frames, left.data(), right.data());
+    auto *output = static_cast<float *>(data);
+    for (size_t i = 0; i < frames; ++i) {
+      output[i * 2] = left[i];
+      output[i * 2 + 1] = right[i];
+    }
+    if (FAILED(submit(output))) OutputDebugStringA("[gea-audio] XAudio2 buffer submission failed\n");
+  }
+  void STDMETHODCALLTYPE OnStreamEnd() override {}
+  void STDMETHODCALLTYPE OnVoiceProcessingPassEnd() override {}
+  void STDMETHODCALLTYPE OnVoiceProcessingPassStart(UINT32) override {}
+  void STDMETHODCALLTYPE OnBufferStart(void *) override {}
+  void STDMETHODCALLTYPE OnLoopEnd(void *) override {}
+  void STDMETHODCALLTYPE OnVoiceError(void *, HRESULT) override {
+    OutputDebugStringA("[gea-audio] XAudio2 voice failed\n");
+  }
+};
+
+inline bool geaUwpDecodeAudio(const std::wstring &path, std::vector<std::vector<float>> &channels, double &rate) {
+  using Microsoft::WRL::ComPtr;
+  static const HRESULT startup = MFStartup(MF_VERSION);
+  if (FAILED(startup)) return false;
+  ComPtr<IMFSourceReader> reader;
+  if (FAILED(MFCreateSourceReaderFromURL(path.c_str(), nullptr, reader.GetAddressOf()))) return false;
+  ComPtr<IMFMediaType> requested;
+  if (FAILED(MFCreateMediaType(requested.GetAddressOf()))) return false;
+  requested->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio);
+  requested->SetGUID(MF_MT_SUBTYPE, MFAudioFormat_Float);
+  if (FAILED(reader->SetCurrentMediaType(MF_SOURCE_READER_FIRST_AUDIO_STREAM, nullptr, requested.Get()))) return false;
+  ComPtr<IMFMediaType> actual;
+  if (FAILED(reader->GetCurrentMediaType(MF_SOURCE_READER_FIRST_AUDIO_STREAM, actual.GetAddressOf()))) return false;
+  UINT32 count = 0, sampleRate = 0;
+  if (FAILED(actual->GetUINT32(MF_MT_AUDIO_NUM_CHANNELS, &count)) || count == 0 || count > 2) return false;
+  if (FAILED(actual->GetUINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, &sampleRate)) || sampleRate == 0) return false;
+  rate = sampleRate;
+  channels.resize(count);
+  for (;;) {
+    DWORD flags = 0;
+    ComPtr<IMFSample> sample;
+    if (FAILED(reader->ReadSample(MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, nullptr, &flags, nullptr, sample.GetAddressOf()))) return false;
+    if (flags & MF_SOURCE_READERF_ERROR) return false;
+    if (sample) {
+      ComPtr<IMFMediaBuffer> buffer;
+      if (FAILED(sample->ConvertToContiguousBuffer(buffer.GetAddressOf()))) return false;
+      BYTE *bytes = nullptr;
+      DWORD length = 0;
+      if (FAILED(buffer->Lock(&bytes, nullptr, &length))) return false;
+      const auto *pcm = reinterpret_cast<const float *>(bytes);
+      const size_t frames = length / (sizeof(float) * count);
+      for (size_t i = 0; i < frames; ++i)
+        for (UINT32 ch = 0; ch < count; ++ch) channels[ch].push_back(pcm[i * count + ch]);
+      buffer->Unlock();
+    }
+    if (flags & MF_SOURCE_READERF_ENDOFSTREAM) break;
+  }
+  return !channels[0].empty();
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@geastack/native-webgl-angle",
+  "version": "0.1.6",
+  "description": "Typed native WebGL compatibility layer backed by ANGLE/Metal",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/geastack/native-webgl-angle.git"
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/nativeWebGL.ts",
+    "./nativeWebGL": "./src/nativeWebGL.ts",
+    "./nativeWebGLHost": "./src/nativeWebGLHost.ts",
+    "./nativeAudioHost": "./src/nativeAudioHost.ts",
+    "./nativeWebGLAnimation": "./src/nativeWebGLAnimation.ts",
+    "./nativeThreeUtils": "./src/nativeThreeUtils.ts",
+    "./nativeWebXRManager": "./src/nativeWebXRManager.ts",
+    "./troika-three-text": "./src/troika-three-text.ts",
+    "./geatsc-plugin": "./geatsc-plugin.mjs",
+    "./native/*": "./native/*",
+    "./package.json": "./package.json",
+    "./native-text-types": "./src/text/native-text-types.ts",
+    "./text/native-text-types": "./src/text/native-text-types.ts",
+    "./geatsc-plugin-batched-probe": "./geatsc-plugin-batched-probe.mjs",
+    "./test/batched-render-scene": "./test/batched-render-scene.ts",
+    "./test/auto-instanced-render-scene": "./test/auto-instanced-render-scene.ts"
+  },
+  "files": [
+    "src",
+    "native",
+    "geatsc-plugin.mjs",
+    "geatsc-plugin-uploads.mjs",
+    "geatsc-plugin-uniforms.mjs",
+    "geatsc-plugin-instancing.mjs",
+    "geatsc-plugin-batched-probe.mjs",
+    "test/batched-render-scene.ts",
+    "test/auto-instanced-render-scene.ts"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "test:event-dispatch": "node test/native-event-dispatch-contract.test.mjs",
+    "test:host-effects": "node test/native-host-effects-contract.test.mjs",
+    "test:allocation-contracts": "node test/render-sort-contract.test.mjs && node test/upload-array-contract.test.mjs && node test/draw-dispatch-contract.test.mjs && node test/native-upload-transport.test.mjs && node test/fixed-uniform-contract.test.mjs && node test/uniform-binding-contract.test.mjs && node test/buffer-streaming-contract.test.mjs",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "node test/native-blending-contract.test.mjs && node test/native-transform-contract.test.mjs && node test/troika-three-text.test.mjs && node test/typed-void-contract.test.mjs && node test/instancing-transport-contract.test.mjs && node test/automatic-instancing-contract.test.mjs && node test/jsdoc-fold-contract.test.mjs",
+    "test:package": "node --experimental-vm-modules test/package.test.mjs"
+  },
+  "dependencies": {
+    "@geastack/apple": ">=0.1.0"
+  },
+  "peerDependencies": {
+    "three": "^0.185.0",
+    "@geastack/compiler": "^1.0.9"
+  },
+  "devDependencies": {
+    "@geastack/compiler": "^1.0.9",
+    "@geastack/core": "^0.1.12",
+    "@geastack/engine": "^0.1.0",
+    "@types/three": "^0.185.0",
+    "three": "^0.185.0",
+    "typescript": "latest"
+  }
+}

package/src/gea-native-types.d.ts

@@ -0,0 +1,4 @@
+declare const __gea_native_webgl_angle_f32_brand: unique symbol
+
+type f32 = number & { readonly [__gea_native_webgl_angle_f32_brand]?: never }
+declare function threeGamepadState(channel: number): number

package/src/nativeAudioHost.ts

@@ -0,0 +1,296 @@
+// Native audio host facade — a Web-Audio-shaped wrapper over the
+// `gea_three_audio_*` externs (native/audio_host.mm, registered through
+// geatsc-plugin.mjs). It implements exactly the surface a Web Audio sound
+// design uses: gain / biquad
+// lowpass / buffer source / oscillator nodes, param automation (setValueAtTime,
+// linear/exponential ramps, cancel), synth buffers written via getChannelData,
+// and mp3 decode by asset basename (the native asset stub lowers
+// `import url from './x.mp3'` to the file's basename).
+//
+// Everything here is structural: the classes satisfy the app's
+// AudioContextLike/GainLike/... interfaces without importing them. On the web
+// these classes are never constructed (the real AudioContext wins), so the
+// ambient host externs are never referenced at runtime there.
+
+// Node kinds (native/audio_host.mm NodeKind).
+const NODE_GAIN = 1
+const NODE_BIQUAD = 2
+const NODE_BUFFER_SOURCE = 3
+const NODE_OSCILLATOR = 4
+
+// Param codes (audio_host.mm paramFor).
+const PARAM_GAIN = 0
+const PARAM_FREQUENCY = 1
+const PARAM_Q = 2
+const PARAM_PLAYBACK_RATE = 3
+
+// Param methods (audio_host.mm ParamMethod).
+const METHOD_SET_VALUE = 0
+const METHOD_SET_VALUE_AT_TIME = 1
+const METHOD_LINEAR_RAMP = 2
+const METHOD_EXPONENTIAL_RAMP = 3
+const METHOD_CANCEL = 4
+
+export class NativeAudioParam {
+  readonly __audioNodeId: number
+  readonly __paramCode: number
+
+  constructor(nodeId: number, paramCode: number) {
+    this.__audioNodeId = nodeId
+    this.__paramCode = paramCode
+  }
+
+  get value(): number {
+    return threeAudioParamGet(this.__audioNodeId, this.__paramCode)
+  }
+
+  set value(v: number) {
+    threeAudioParamEvent(this.__audioNodeId, this.__paramCode, METHOD_SET_VALUE, v, 0)
+  }
+
+  setValueAtTime(value: number, time: number): void {
+    threeAudioParamEvent(this.__audioNodeId, this.__paramCode, METHOD_SET_VALUE_AT_TIME, value, time)
+  }
+
+  linearRampToValueAtTime(value: number, time: number): void {
+    threeAudioParamEvent(this.__audioNodeId, this.__paramCode, METHOD_LINEAR_RAMP, value, time)
+  }
+
+  exponentialRampToValueAtTime(value: number, time: number): void {
+    threeAudioParamEvent(this.__audioNodeId, this.__paramCode, METHOD_EXPONENTIAL_RAMP, value, time)
+  }
+
+  cancelScheduledValues(time: number): void {
+    threeAudioParamEvent(this.__audioNodeId, this.__paramCode, METHOD_CANCEL, 0, time)
+  }
+}
+
+export class NativeAudioNode {
+  readonly __audioNodeId: number
+
+  constructor(nodeId: number) {
+    this.__audioNodeId = nodeId
+  }
+
+  // Param connect targets never occur in the reference graph; node targets are
+  // always wrappers from this module, so the id read is direct.
+  connect(node: NativeAudioNode): void {
+    threeAudioConnect(this.__audioNodeId, node.__audioNodeId)
+  }
+}
+
+export class NativeAudioDestination extends NativeAudioNode {}
+
+export class NativeGainNode extends NativeAudioNode {
+  readonly gain: NativeAudioParam
+
+  constructor(nodeId: number) {
+    super(nodeId)
+    this.gain = new NativeAudioParam(nodeId, PARAM_GAIN)
+  }
+}
+
+export class NativeBiquadFilterNode extends NativeAudioNode {
+  readonly frequency: NativeAudioParam
+  readonly Q: NativeAudioParam
+  private __typeName = 'lowpass'
+
+  constructor(nodeId: number) {
+    super(nodeId)
+    this.frequency = new NativeAudioParam(nodeId, PARAM_FREQUENCY)
+    this.Q = new NativeAudioParam(nodeId, PARAM_Q)
+  }
+
+  get type(): string {
+    return this.__typeName
+  }
+
+  set type(value: string) {
+    this.__typeName = value
+    threeAudioSetNodeType(this.__audioNodeId, value)
+  }
+}
+
+export class NativeOscillatorNode extends NativeAudioNode {
+  readonly frequency: NativeAudioParam
+  private __typeName = 'sine'
+
+  constructor(nodeId: number) {
+    super(nodeId)
+    this.frequency = new NativeAudioParam(nodeId, PARAM_FREQUENCY)
+  }
+
+  get type(): string {
+    return this.__typeName
+  }
+
+  set type(value: string) {
+    this.__typeName = value
+    threeAudioSetNodeType(this.__audioNodeId, value)
+  }
+
+  start(when = 0): void {
+    threeAudioSourceStart(this.__audioNodeId, when, 0)
+  }
+
+  stop(when = 0): void {
+    threeAudioSourceStop(this.__audioNodeId, when)
+  }
+}
+
+export class NativeAudioBuffer {
+  __nativeBufferId: number
+  readonly __sampleRate: number
+  readonly __channels: Float32Array[]
+
+  constructor(nativeBufferId: number, channels: number, length: number, sampleRate: number) {
+    this.__nativeBufferId = nativeBufferId
+    this.__sampleRate = sampleRate
+    this.__channels = []
+    if (nativeBufferId === 0) {
+      for (let ch = 0; ch < channels; ch++) this.__channels.push(new Float32Array(length))
+    }
+  }
+
+  // Synth buffers (createBuffer) hand out writable local planes; decoded
+  // buffers live natively and are never read back by the game.
+  getChannelData(channel: number): Float32Array {
+    if (channel >= 0 && channel < this.__channels.length) return this.__channels[channel]
+    return new Float32Array(0)
+  }
+
+  // Push locally written synth planes to the host on first playback.
+  __ensureUploaded(): number {
+    if (this.__nativeBufferId === 0 && this.__channels.length > 0) {
+      const length = this.__channels[0].length
+      const id = threeAudioCreateBuffer(this.__channels.length, length, this.__sampleRate)
+      for (let ch = 0; ch < this.__channels.length; ch++) {
+        threeAudioBufferChannelData(id, ch, this.__channels[ch])
+      }
+      this.__nativeBufferId = id
+    }
+    return this.__nativeBufferId
+  }
+}
+
+export class NativeBufferSourceNode extends NativeAudioNode {
+  buffer: NativeAudioBuffer | null = null
+  loop = false
+  readonly playbackRate: NativeAudioParam
+
+  constructor(nodeId: number) {
+    super(nodeId)
+    this.playbackRate = new NativeAudioParam(nodeId, PARAM_PLAYBACK_RATE)
+  }
+
+  start(when = 0): void {
+    const buffer = this.buffer
+    if (buffer) {
+      const bufferId = buffer.__ensureUploaded()
+      if (bufferId > 0) threeAudioSourceSetBuffer(this.__audioNodeId, bufferId)
+    }
+    threeAudioSourceStart(this.__audioNodeId, when, this.loop ? 1 : 0)
+  }
+
+  stop(when = 0): void {
+    threeAudioSourceStop(this.__audioNodeId, when)
+  }
+}
+
+export class NativeAudioContext {
+  readonly destination: NativeAudioDestination = new NativeAudioDestination(0)
+  readonly state: string = 'running'
+
+  get currentTime(): number {
+    return threeAudioCurrentTime()
+  }
+
+  get sampleRate(): number {
+    return threeAudioSampleRate()
+  }
+
+  createGain(): NativeGainNode {
+    return new NativeGainNode(threeAudioCreateNode(NODE_GAIN))
+  }
+
+  createBiquadFilter(): NativeBiquadFilterNode {
+    return new NativeBiquadFilterNode(threeAudioCreateNode(NODE_BIQUAD))
+  }
+
+  createBufferSource(): NativeBufferSourceNode {
+    return new NativeBufferSourceNode(threeAudioCreateNode(NODE_BUFFER_SOURCE))
+  }
+
+  createOscillator(): NativeOscillatorNode {
+    return new NativeOscillatorNode(threeAudioCreateNode(NODE_OSCILLATOR))
+  }
+
+  createBuffer(channels: number, length: number, sampleRate: number): NativeAudioBuffer {
+    return new NativeAudioBuffer(0, channels, length, sampleRate)
+  }
+
+  // Web-only surface (kept for structural compatibility with the app's
+  // AudioContextLike). Native clip loading goes through
+  // nativeAudioBufferForFile below; this promise never settles.
+  decodeAudioData(_data: ArrayBuffer): Promise<NativeAudioBuffer> {
+    return new Promise<NativeAudioBuffer>(() => {})
+  }
+
+  resume(): void {
+    threeAudioResume()
+  }
+}
+
+let activeNativeAudioContext: NativeAudioContext | null = null
+
+// Create (or return) the native audio context. Only call this when the web
+// AudioContext is absent — on the web the host externs referenced here do not
+// exist at runtime.
+export function createNativeAudioContext(): NativeAudioContext | null {
+  if (activeNativeAudioContext) return activeNativeAudioContext
+  if (!threeAudioSupported()) return null
+  activeNativeAudioContext = new NativeAudioContext()
+  return activeNativeAudioContext
+}
+
+// Decode an audio asset by basename ("coin.mp3" — what the native asset stub
+// lowers an mp3 import to) into a playable buffer. Returns null when no native
+// context is active (web) or the file is missing, letting callers fall through
+// to the fetch + decodeAudioData path.
+export function nativeAudioBufferForFile(name: string): NativeAudioBuffer | null {
+  if (!activeNativeAudioContext) return null
+  const bufferId = threeAudioLoadBuffer(name)
+  if (bufferId <= 0) return null
+  return new NativeAudioBuffer(bufferId, 0, 0, threeAudioSampleRate())
+}
+
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioSupported(): boolean
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioCurrentTime(): number
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioSampleRate(): number
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioResume(): void
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioCreateNode(kind: number): number
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioSetNodeType(node: number, type: string): void
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioConnect(src: number, dst: number): void
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioParamEvent(node: number, param: number, method: number, value: number, time: number): void
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioParamGet(node: number, param: number): number
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioLoadBuffer(name: string): number
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioCreateBuffer(channels: number, length: number, sampleRate: number): number
+/** @gea-host-inert Synchronously copies the typed-array argument into native audio storage; retains no script references or callbacks. */
+declare function threeAudioBufferChannelData(buffer: number, channel: number, data: Float32Array): void
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioSourceSetBuffer(node: number, buffer: number): void
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioSourceStart(node: number, when: number, loop: number): void
+/** @gea-host-inert Reads scalar arguments and updates native audio state only; retains no script references or callbacks. */
+declare function threeAudioSourceStop(node: number, when: number): void

package/src/nativeThreeUtils.ts

@@ -0,0 +1,11 @@
+export * from 'three/src/utils.js'
+
+import { createNativeWebGLCanvas, type NativeWebGLCanvas } from './nativeWebGL'
+
+/** Three's XHTML factory, narrowed to the canvas surface used by the native renderer. */
+export function createElementNS(_name: string): NativeWebGLCanvas {
+  return createNativeWebGLCanvas(300, 150)
+}
+
+/** Three's browser fallback, backed by the real native ANGLE canvas. */
+export function createCanvasElement(): NativeWebGLCanvas { return createElementNS('canvas') }