@symbiote-native/gl 0.0.0-stage → 0.1.0

package/build/core/gl-view.js

@@ -0,0 +1,107 @@
+import { Platform, UnavailabilityError, requireNativeViewManager, } from 'expo-modules-core';
+import { el } from '@symbiote-native/components';
+import { defineExpoNativeView, getNativeTag, isDevBuild, isSymbioteNode, } from '@symbiote-native/engine';
+import { GL_MODULE_NAME, GL_PACKAGE_NAME } from './constants.js';
+import { getGl, takeSnapshotAsync, unregisterGLContext } from './gl-context.js';
+import { glNativeModule } from './native-module.js';
+// Registered on render: a barrel side effect is lost in a release build
+const glView = defineExpoNativeView(requireNativeViewManager, GL_MODULE_NAME);
+export const glViewName = glView.name;
+export const ensureGLViewRegistered = glView.ensureRegistered;
+const DEFAULT_MSAA_SAMPLES = 4;
+function isSurfaceCreated(value) {
+    return typeof Reflect.get(Object(value), 'exglCtxId') === 'number';
+}
+function isContextCallback(value) {
+    return typeof value === 'function';
+}
+// Adapters hand over the props they hold, a missing callback is a view nobody listens to
+function toViewProps(props) {
+    const onContextCreate = Reflect.get(props, 'onContextCreate');
+    return {
+        ...props,
+        onContextCreate: isContextCallback(onContextCreate)
+            ? onContextCreate
+            : () => undefined,
+    };
+}
+function nativeTagOf(camera) {
+    const tag = isSymbioteNode(camera) ? getNativeTag(camera) : camera;
+    if (typeof tag !== 'number')
+        throw new Error('The camera view has no native tag yet');
+    return tag;
+}
+/** One per mounted view, `getNode` is kept for the shape the adapters share */
+export function createGLView(_getNode) {
+    let exglCtxId;
+    let latestProps;
+    let hasWorkletSupport;
+    const onSurfaceCreate = (event) => {
+        if (!isSurfaceCreated(event.nativeEvent))
+            return;
+        exglCtxId = event.nativeEvent.exglCtxId;
+        latestProps?.onContextCreate(getGl(exglCtxId));
+    };
+    function warnOnWorkletChange(enabled) {
+        if (hasWorkletSupport !== undefined && hasWorkletSupport !== enabled) {
+            console.warn('Updating prop enableExperimentalWorkletSupport is not supported');
+        }
+        hasWorkletSupport = enabled;
+    }
+    const handle = {
+        get exglCtxId() {
+            return exglCtxId;
+        },
+        async createCameraTextureAsync(camera) {
+            if (!glNativeModule.createCameraTextureAsync) {
+                throw new UnavailabilityError(GL_PACKAGE_NAME, 'createCameraTextureAsync');
+            }
+            if (!exglCtxId)
+                throw new Error("GLView's surface is not created yet!");
+            const { exglObjId } = await glNativeModule.createCameraTextureAsync(exglCtxId, nativeTagOf(camera));
+            const texture = { id: exglObjId };
+            return texture;
+        },
+        async destroyObjectAsync(glObject) {
+            if (!glNativeModule.destroyObjectAsync) {
+                throw new UnavailabilityError(GL_PACKAGE_NAME, 'destroyObjectAsync');
+            }
+            return glNativeModule.destroyObjectAsync(glObject.id);
+        },
+        takeSnapshotAsync: (options) => takeSnapshotAsync(exglCtxId, options),
+    };
+    return {
+        handle,
+        dispose: () => {
+            if (exglCtxId)
+                unregisterGLContext(exglCtxId);
+        },
+        render: props => {
+            if (!ensureGLViewRegistered()) {
+                if (isDevBuild())
+                    console.warn("'GLView' is not available.");
+                return null;
+            }
+            latestProps = toViewProps(props);
+            const { onContextCreate, msaaSamples = DEFAULT_MSAA_SAMPLES, enableExperimentalWorkletSupport = false, ...viewProps } = latestProps;
+            warnOnWorkletChange(enableExperimentalWorkletSupport);
+            return el('view', viewProps, [
+                el(glViewName(), {
+                    style: {
+                        flex: 1,
+                        ...Platform.select({
+                            ios: { backgroundColor: 'transparent' },
+                            default: {},
+                        }),
+                    },
+                    onSurfaceCreate,
+                    enableExperimentalWorkletSupport,
+                    msaaSamples: Platform.select({
+                        ios: msaaSamples,
+                        default: undefined,
+                    }),
+                }),
+            ]);
+        },
+    };
+}

package/build/core/index.d.ts

@@ -0,0 +1,6 @@
+export { GL_MODULE_NAME } from './constants';
+export { createContextAsync, destroyContextAsync, getGl, getWorkletContext, takeSnapshotAsync, } from './gl-context';
+export { configureLogging } from './gl-utils';
+export { createGLView, ensureGLViewRegistered, glViewName, type IGLView, } from './gl-view';
+export { GLLoggingOption } from './types';
+export type { IExpoWebGLRenderingContext, IGLNodeOrTag, IGLObject, IGLSnapshot, IGLSnapshotOptions, IGLSurfaceCreateEvent, IGLViewHandle, IGLViewProps, } from './types';

package/build/core/index.js

@@ -0,0 +1,5 @@
+export { GL_MODULE_NAME } from './constants.js';
+export { createContextAsync, destroyContextAsync, getGl, getWorkletContext, takeSnapshotAsync, } from './gl-context.js';
+export { configureLogging } from './gl-utils.js';
+export { createGLView, ensureGLViewRegistered, glViewName, } from './gl-view.js';
+export { GLLoggingOption } from './types.js';

package/build/core/native-module.d.ts

@@ -0,0 +1,15 @@
+import type { IGLSnapshot, IGLSnapshotOptions } from './types';
+export type INativeGLModule = {
+    createContextAsync(): Promise<{
+        exglCtxId: number;
+    }>;
+    destroyContextAsync(exglCtxId: number): Promise<boolean>;
+    takeSnapshotAsync(exglCtxId: number, options: IGLSnapshotOptions): Promise<IGLSnapshot>;
+    /** Absent where there is no camera texture support */
+    createCameraTextureAsync?(exglCtxId: number, cameraTag: number): Promise<{
+        exglObjId: number;
+    }>;
+    /** Absent where objects cannot be destroyed one by one */
+    destroyObjectAsync?(exglObjId: number): Promise<boolean>;
+};
+export declare const glNativeModule: INativeGLModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+import { GL_MODULE_NAME } from './constants.js';
+export const glNativeModule = requireNativeModule(GL_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,75 @@
+import type { IAccessibilityProps, IAriaProps, IResponderProps } from '@symbiote-native/components';
+import type { IStyleProp, ISymbioteEvent, ISymbioteNode, IViewStyle } from '@symbiote-native/engine';
+export type IGLObject = {
+    id: number;
+};
+export type IGLSurfaceCreateEvent = {
+    nativeEvent: {
+        exglCtxId: number;
+    };
+};
+export type IGLSnapshotOptions = {
+    /** @default false */
+    flip?: boolean;
+    /** Defaults to the framebuffer shown in the view, or the current one of a headless context */
+    framebuffer?: WebGLFramebuffer;
+    /** Passed to `glReadPixels` */
+    rect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** PNG is lossless but slower, iOS writes a PNG instead of WebP. @default 'jpeg' */
+    format?: 'jpeg' | 'png' | 'webp';
+    /** From `0` (most compressed) to `1.0` (none). @default 1.0 */
+    compress?: number;
+};
+export type IGLSnapshot = {
+    uri: string | Blob | null;
+    /** Same as `uri`, which makes a snapshot usable in `texImage2D` */
+    localUri: string;
+    width: number;
+    height: number;
+};
+export type IExpoWebGLRenderingContext = WebGL2RenderingContext & {
+    contextId: number;
+    endFrameEXP(): void;
+    flushEXP(): void;
+    __expoSetLogging(option: GLLoggingOption): void;
+};
+/** A native tag, or the host node of a view such as a camera */
+export type IGLNodeOrTag = number | ISymbioteNode | null;
+export type IGLViewProps = IAccessibilityProps & IAriaProps & IResponderProps & {
+    style?: IStyleProp<IViewStyle>;
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: ISymbioteEvent) => void;
+    /** Called with the context once the surface exists */
+    onContextCreate(gl: IExpoWebGLRenderingContext): void;
+    /** Multisampling, `0` turns it off. @default 4 @platform ios */
+    msaaSamples?: number;
+    /** Lets the Reanimated worklet thread use the `gl` object. @default false */
+    enableExperimentalWorkletSupport?: boolean;
+};
+export declare enum GLLoggingOption {
+    DISABLED = 0,
+    /** Logs calls, their parameters and results */
+    METHOD_CALLS = 1,
+    /** Calls `getError` after each call, which blocks and slows drawing down */
+    GET_ERRORS = 2,
+    /** Prints the name of the constant a numeric parameter holds */
+    RESOLVE_CONSTANTS = 4,
+    /** Cuts long strings such as shaders */
+    TRUNCATE_STRINGS = 8,
+    ALL = 15
+}
+/** What a ref to the view hands out */
+export type IGLViewHandle = {
+    /** The id of the context of the view, `undefined` until the surface exists */
+    readonly exglCtxId: number | undefined;
+    createCameraTextureAsync(camera: IGLNodeOrTag): Promise<WebGLTexture>;
+    destroyObjectAsync(glObject: IGLObject): Promise<boolean>;
+    /** A snapshot of the context of this view */
+    takeSnapshotAsync(options?: IGLSnapshotOptions): Promise<IGLSnapshot>;
+};

package/build/core/types.js

@@ -0,0 +1,13 @@
+export var GLLoggingOption;
+(function (GLLoggingOption) {
+    GLLoggingOption[GLLoggingOption["DISABLED"] = 0] = "DISABLED";
+    /** Logs calls, their parameters and results */
+    GLLoggingOption[GLLoggingOption["METHOD_CALLS"] = 1] = "METHOD_CALLS";
+    /** Calls `getError` after each call, which blocks and slows drawing down */
+    GLLoggingOption[GLLoggingOption["GET_ERRORS"] = 2] = "GET_ERRORS";
+    /** Prints the name of the constant a numeric parameter holds */
+    GLLoggingOption[GLLoggingOption["RESOLVE_CONSTANTS"] = 4] = "RESOLVE_CONSTANTS";
+    /** Cuts long strings such as shaders */
+    GLLoggingOption[GLLoggingOption["TRUNCATE_STRINGS"] = 8] = "TRUNCATE_STRINGS";
+    GLLoggingOption[GLLoggingOption["ALL"] = 15] = "ALL";
+})(GLLoggingOption || (GLLoggingOption = {}));

package/build/core/worklet-context-manager.d.ts

@@ -0,0 +1,6 @@
+import type { IExpoWebGLRenderingContext } from './types';
+export type IWorkletContextManager = {
+    getContext(contextId: number): IExpoWebGLRenderingContext | undefined;
+    unregister?(contextId: number): void;
+};
+export declare function createWorkletContextManager(): IWorkletContextManager;

package/build/core/worklet-context-manager.js

@@ -0,0 +1,35 @@
+import { GL_CONTEXTS_GLOBAL } from './constants.js';
+function isRunOnUI(value) {
+    return typeof value === 'function';
+}
+// Reanimated stays optional, and an import of it in a try block in the module that also holds the
+// view breaks with `inlineRequires`, so the manager lives in its own file
+export function createWorkletContextManager() {
+    try {
+        // Reanimated has to load before any workletized code is created
+        // eslint-disable-next-line @typescript-eslint/no-require-imports -- optional dependency, see above
+        const reanimated = require('react-native-reanimated');
+        const runOnUI = Reflect.get(Object(reanimated), 'runOnUI');
+        if (!isRunOnUI(runOnUI))
+            throw new Error('react-native-reanimated has no runOnUI');
+        return {
+            getContext: contextId => {
+                'worklet';
+                return Reflect.get(Object(Reflect.get(globalThis, GL_CONTEXTS_GLOBAL)), String(contextId));
+            },
+            unregister: contextId => {
+                runOnUI(id => {
+                    'worklet';
+                    Reflect.deleteProperty(Object(Reflect.get(globalThis, GL_CONTEXTS_GLOBAL)), String(id));
+                })(contextId);
+            },
+        };
+    }
+    catch {
+        return {
+            getContext: () => {
+                throw new Error('Worklet runtime is not available');
+            },
+        };
+    }
+}

package/build/react/gl-view.d.ts

@@ -0,0 +1,8 @@
+import type { ReactElement, Ref } from 'react';
+import type { IGLViewHandle, IGLViewProps } from '../core';
+export type IGLViewReactProps = IGLViewProps & {
+    ref?: Ref<IGLViewHandle>;
+    className?: string;
+};
+/** React twin of `expo-gl`'s `GLView` */
+export declare function GLView({ ref, ...props }: IGLViewReactProps): ReactElement | null;

package/build/react/gl-view.js

@@ -0,0 +1,6 @@
+import { useNativeViewController } from '@symbiote-native/react';
+import { createGLView } from '../core/index.js';
+/** React twin of `expo-gl`'s `GLView` */
+export function GLView({ ref, ...props }) {
+    return useNativeViewController(ref, createGLView, props);
+}

package/build/react/index.d.ts

@@ -0,0 +1,3 @@
+export { GLView } from './gl-view';
+export type { IGLViewReactProps } from './gl-view';
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/gl/react: a GLView that gives a WebGL context to draw into, on a shared core
+export { GLView } from './gl-view.js';
+export * from '../core/index.js';

package/build/solid/gl-view.d.ts

@@ -0,0 +1,13 @@
+import type { IGLViewHandle } from '../core';
+/** Solid twin of `expo-gl`'s `GLView`, `ref` gets the handle of the view */
+export declare const GLView: (props: import("@symbiote-native/components").IAccessibilityProps & import("@symbiote-native/components").IAriaProps & import("@symbiote-native/components").IResponderProps & {
+    style?: import("@symbiote-native/engine").IStyleProp<import("@symbiote-native/engine").IViewStyle>;
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: import("@symbiote-native/engine").ISymbioteEvent) => void;
+    onContextCreate(gl: import(".").IExpoWebGLRenderingContext): void;
+    msaaSamples?: number;
+    enableExperimentalWorkletSupport?: boolean;
+} & {
+    ref?: ((handle: IGLViewHandle) => void) | undefined;
+}) => import("@symbiote-native/engine").ISymbioteNode | null;

package/build/solid/gl-view.js

@@ -0,0 +1,4 @@
+import { defineNativeViewComponent } from '@symbiote-native/solid';
+import { createGLView } from '../core/index.js';
+/** Solid twin of `expo-gl`'s `GLView`, `ref` gets the handle of the view */
+export const GLView = defineNativeViewComponent(createGLView);

package/build/solid/index.d.ts

@@ -0,0 +1,2 @@
+export { GLView } from './gl-view';
+export * from '../core';

package/build/solid/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/gl/solid: a GLView that gives a WebGL context to draw into, on a shared core
+export { GLView } from './gl-view.js';
+export * from '../core/index.js';

package/build/svelte/gl-view.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+  import DescriptorHost from '@symbiote-native/svelte/descriptor-host';
+  import { useNativeViewController } from '@symbiote-native/svelte/runes/use-native-view-controller';
+  import { createGLView } from '../core';
+  import type { IGLViewProps } from '../core';
+
+  const props: IGLViewProps = $props();
+  const view = useNativeViewController(createGLView, () => ({ ...props }));
+
+  // The functions of the view are instance members, `bind:this` reaches them
+  export const createCameraTextureAsync = view.handle.createCameraTextureAsync;
+  export const destroyObjectAsync = view.handle.destroyObjectAsync;
+  export const takeSnapshotAsync = view.handle.takeSnapshotAsync;
+  export const getContextId = (): number | undefined => view.handle.exglCtxId;
+</script>
+
+{#if view.descriptor}
+  <DescriptorHost descriptor={view.descriptor} />
+{/if}

package/build/svelte/gl-view.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { IGLViewProps } from '../core';
+declare const GlView: import("svelte").Component<IGLViewProps, {
+    createCameraTextureAsync: (camera: import(".").IGLNodeOrTag) => Promise<WebGLTexture>;
+    destroyObjectAsync: (glObject: import(".").IGLObject) => Promise<boolean>;
+    takeSnapshotAsync: (options?: import(".").IGLSnapshotOptions) => Promise<import(".").IGLSnapshot>;
+    getContextId: () => number | undefined;
+}, "">;
+type GlView = ReturnType<typeof GlView>;
+export default GlView;

package/build/svelte/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GLView } from './gl-view.svelte';
+export * from '../core';

package/build/svelte/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/gl/svelte: a GLView that gives a WebGL context to draw into, on a shared core
+export { default as GLView } from './gl-view.svelte';
+export * from '../core/index.js';

package/build/vue/gl-view.d.ts

@@ -0,0 +1,2 @@
+/** Vue twin of `expo-gl`'s `GLView`, `ref` gets the handle of the view */
+export declare const GLView: import("vue").DefineComponent<{}, () => import("vue").VNode | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/build/vue/gl-view.js

@@ -0,0 +1,4 @@
+import { defineNativeViewComponent } from '@symbiote-native/vue';
+import { createGLView } from '../core/index.js';
+/** Vue twin of `expo-gl`'s `GLView`, `ref` gets the handle of the view */
+export const GLView = defineNativeViewComponent('GLView', createGLView);

package/build/vue/index.d.ts

@@ -0,0 +1,2 @@
+export { GLView } from './gl-view';
+export * from '../core';

package/build/vue/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/gl/vue: a GLView that gives a WebGL context to draw into, on a shared core
+export { GLView } from './gl-view.js';
+export * from '../core/index.js';

package/build-ngc/angular/gl-view/index.d.ts

@@ -0,0 +1,21 @@
+import { NativeViewBase } from '@symbiote-native/angular';
+import type { IDescriptor } from '@symbiote-native/components';
+import type { IGLViewProps } from '../../core';
+import * as i0 from "@angular/core";
+declare const GL_VIEW_INPUTS: readonly ["onContextCreate", "msaaSamples", "enableExperimentalWorkletSupport"];
+export interface GLView extends Partial<Pick<IGLViewProps, (typeof GL_VIEW_INPUTS)[number]>> {
+}
+/** Angular twin of `expo-gl`'s `GLView` */
+export declare class GLView extends NativeViewBase {
+    private readonly view;
+    readonly createCameraTextureAsync: (camera: import("..").IGLNodeOrTag) => Promise<WebGLTexture>;
+    readonly destroyObjectAsync: (glObject: import("..").IGLObject) => Promise<boolean>;
+    readonly takeSnapshotAsync: (options?: import("..").IGLSnapshotOptions) => Promise<import("..").IGLSnapshot>;
+    get exglCtxId(): number | undefined;
+    protected readonly propNames: readonly ["onContextCreate", "msaaSamples", "enableExperimentalWorkletSupport"];
+    protected renderView(props: object): IDescriptor | null;
+    protected disposeView(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GLView, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GLView, "GLView", never, { "onContextCreate": { "alias": "onContextCreate"; "required": false; }; "msaaSamples": { "alias": "msaaSamples"; "required": false; }; "enableExperimentalWorkletSupport": { "alias": "enableExperimentalWorkletSupport"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/build-ngc/angular/gl-view/index.js

@@ -0,0 +1,46 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { DescriptorOutlet, NativeViewBase } from '@symbiote-native/angular';
+import { createGLView } from '../../core';
+import * as i0 from "@angular/core";
+// One list is the inputs of the component and the props it hands to the native view
+const GL_VIEW_INPUTS = [
+    'onContextCreate',
+    'msaaSamples',
+    'enableExperimentalWorkletSupport',
+];
+/** Angular twin of `expo-gl`'s `GLView` */
+export class GLView extends NativeViewBase {
+    view = createGLView(() => this.hostNode());
+    // The functions of the view are members of the component, a `@ViewChild` reaches them
+    createCameraTextureAsync = this.view.handle.createCameraTextureAsync;
+    destroyObjectAsync = this.view.handle.destroyObjectAsync;
+    takeSnapshotAsync = this.view.handle.takeSnapshotAsync;
+    get exglCtxId() {
+        return this.view.handle.exglCtxId;
+    }
+    propNames = GL_VIEW_INPUTS;
+    renderView(props) {
+        return this.view.render(props);
+    }
+    disposeView() {
+        this.view.dispose();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: GLView, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: GLView, isStandalone: true, selector: "GLView", inputs: { onContextCreate: "onContextCreate", msaaSamples: "msaaSamples", enableExperimentalWorkletSupport: "enableExperimentalWorkletSupport" }, usesInheritance: true, ngImport: i0, template: `@if (descriptor; as node) {
+    <symbiote-descriptor-outlet [node]="node" />
+  }`, isInline: true, dependencies: [{ kind: "component", type: DescriptorOutlet, selector: "symbiote-descriptor-outlet", inputs: ["node"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: GLView, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'GLView',
+                    standalone: true,
+                    imports: [DescriptorOutlet],
+                    inputs: [...GL_VIEW_INPUTS],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `@if (descriptor; as node) {
+    <symbiote-descriptor-outlet [node]="node" />
+  }`,
+                }]
+        }] });
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/gl-view/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/angular/gl-view/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE5E,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;;AAG1C,oFAAoF;AACpF,MAAM,cAAc,GAAG;IACrB,iBAAiB;IACjB,aAAa;IACb,kCAAkC;CAC1B,CAAC;AAOX,2CAA2C;AAW3C,MAAM,OAAO,MAAO,SAAQ,cAAc;IACvB,IAAI,GAAG,YAAY,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;IAE5D,sFAAsF;IAC7E,wBAAwB,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,wBAAwB,CAAC;IACrE,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC;IACzD,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC;IAEhE,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC;IACpC,CAAC;IAE2B,SAAS,GAAG,cAAc,CAAC;IAEpC,UAAU,CAAC,KAAa;QACzC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAEkB,WAAW;QAC5B,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IACtB,CAAC;uGApBU,MAAM;2FAAN,MAAM,2OAJP;;IAER,4DALQ,gBAAgB;;2FAOf,MAAM;kBAVlB,SAAS;mBAAC;oBACT,QAAQ,EAAE,QAAQ;oBAClB,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,gBAAgB,CAAC;oBAC3B,MAAM,EAAE,CAAC,GAAG,cAAc,CAAC;oBAC3B,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,QAAQ,EAAE;;IAER;iBACH"}

package/build-ngc/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { GLView } from './gl-view';
+export * from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/gl/angular: a GLView that gives a WebGL context to draw into, on a shared core
+export { GLView } from './gl-view';
+export * from '../core';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAElG,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,cAAc,SAAS,CAAC"}

package/build-ngc/core/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const GL_MODULE_NAME = "ExpoGL";
+export declare const GL_PACKAGE_NAME = "expo-gl";
+/** Where the native module keeps the contexts it installs on the runtime, by id */
+export declare const GL_CONTEXTS_GLOBAL = "__EXGLContexts";

package/build-ngc/core/constants.js

@@ -0,0 +1,5 @@
+export const GL_MODULE_NAME = 'ExpoGL';
+export const GL_PACKAGE_NAME = 'expo-gl';
+/** Where the native module keeps the contexts it installs on the runtime, by id */
+export const GL_CONTEXTS_GLOBAL = '__EXGLContexts';
+//# sourceMappingURL=constants.js.map

package/build-ngc/core/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/core/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,cAAc,GAAG,QAAQ,CAAC;AAEvC,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC;AAEzC,mFAAmF;AACnF,MAAM,CAAC,MAAM,kBAAkB,GAAG,gBAAgB,CAAC"}

package/build-ngc/core/gl-context.d.ts

@@ -0,0 +1,13 @@
+import type { IExpoWebGLRenderingContext, IGLSnapshot, IGLSnapshotOptions } from './types';
+/** The context of a worklet, `exgl` has to be created with worklet support */
+export declare function getWorkletContext(contextId: number): IExpoWebGLRenderingContext | undefined;
+export declare function unregisterGLContext(exglCtxId: number): void;
+/** The GL interface of a context id the native side created */
+export declare function getGl(exglCtxId: number): IExpoWebGLRenderingContext;
+export declare function getContextId(exgl?: IExpoWebGLRenderingContext | number): number;
+/** A context with no view, which does not present its framebuffer, take a snapshot to see it */
+export declare function createContextAsync(): Promise<IExpoWebGLRenderingContext>;
+/** For a headless context made by `createContextAsync` */
+export declare function destroyContextAsync(exgl?: IExpoWebGLRenderingContext | number): Promise<boolean>;
+/** Saves the framebuffer as a file in the cache directory of the app */
+export declare function takeSnapshotAsync(exgl?: IExpoWebGLRenderingContext | number, options?: IGLSnapshotOptions): Promise<IGLSnapshot>;

package/build-ngc/core/gl-context.js

@@ -0,0 +1,55 @@
+import { CodedError } from 'expo-modules-core';
+import { GL_CONTEXTS_GLOBAL } from './constants';
+import { configureLogging } from './gl-utils';
+import { glNativeModule } from './native-module';
+import { createWorkletContextManager } from './worklet-context-manager';
+const workletContextManager = createWorkletContextManager();
+function isContext(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** The context of a worklet, `exgl` has to be created with worklet support */
+export function getWorkletContext(contextId) {
+    'worklet';
+    return workletContextManager.getContext(contextId);
+}
+export function unregisterGLContext(exglCtxId) {
+    const contexts = Reflect.get(globalThis, GL_CONTEXTS_GLOBAL);
+    if (contexts)
+        Reflect.deleteProperty(Object(contexts), String(exglCtxId));
+    workletContextManager.unregister?.(exglCtxId);
+}
+/** The GL interface of a context id the native side created */
+export function getGl(exglCtxId) {
+    const contexts = Reflect.get(globalThis, GL_CONTEXTS_GLOBAL);
+    if (!contexts) {
+        throw new CodedError('ERR_GL_NOT_AVAILABLE', 'GL is currently not available. (Have you enabled remote debugging? GL is not available while debugging remotely.)');
+    }
+    const gl = Reflect.get(Object(contexts), String(exglCtxId));
+    if (!isContext(gl))
+        throw new Error(`There is no EXGLContext with id ${exglCtxId}`);
+    configureLogging(gl);
+    return gl;
+}
+export function getContextId(exgl) {
+    const exglCtxId = exgl && typeof exgl === 'object' ? exgl.contextId : exgl;
+    if (!exglCtxId || typeof exglCtxId !== 'number') {
+        throw new Error(`Invalid EXGLContext id: ${String(exglCtxId)}`);
+    }
+    return exglCtxId;
+}
+/** A context with no view, which does not present its framebuffer, take a snapshot to see it */
+export async function createContextAsync() {
+    const { exglCtxId } = await glNativeModule.createContextAsync();
+    return getGl(exglCtxId);
+}
+/** For a headless context made by `createContextAsync` */
+export async function destroyContextAsync(exgl) {
+    const exglCtxId = getContextId(exgl);
+    unregisterGLContext(exglCtxId);
+    return glNativeModule.destroyContextAsync(exglCtxId);
+}
+/** Saves the framebuffer as a file in the cache directory of the app */
+export async function takeSnapshotAsync(exgl, options = {}) {
+    return glNativeModule.takeSnapshotAsync(getContextId(exgl), options);
+}
+//# sourceMappingURL=gl-context.js.map

package/build-ngc/core/gl-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gl-context.js","sourceRoot":"","sources":["../../src/core/gl-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAMjD,OAAO,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAExE,MAAM,qBAAqB,GAAG,2BAA2B,EAAE,CAAC;AAE5D,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACrD,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,iBAAiB,CAC/B,SAAiB;IAEjB,SAAS,CAAC;IACV,OAAO,qBAAqB,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,SAAiB;IACnD,MAAM,QAAQ,GAAY,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAC;IACtE,IAAI,QAAQ;QAAE,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IAC1E,qBAAqB,CAAC,UAAU,EAAE,CAAC,SAAS,CAAC,CAAC;AAChD,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,KAAK,CAAC,SAAiB;IACrC,MAAM,QAAQ,GAAY,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAC;IACtE,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,UAAU,CAClB,sBAAsB,EACtB,mHAAmH,CACpH,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,GAAY,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IACrE,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,mCAAmC,SAAS,EAAE,CAAC,CAAC;IAClE,gBAAgB,CAAC,EAAE,CAAC,CAAC;IACrB,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,MAAM,UAAU,YAAY,CAC1B,IAA0C;IAE1C,MAAM,SAAS,GAAG,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3E,IAAI,CAAC,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,2BAA2B,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,gGAAgG;AAChG,MAAM,CAAC,KAAK,UAAU,kBAAkB;IACtC,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,cAAc,CAAC,kBAAkB,EAAE,CAAC;IAChE,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC;AAC1B,CAAC;AAED,0DAA0D;AAC1D,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,IAA0C;IAE1C,MAAM,SAAS,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IACrC,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAC/B,OAAO,cAAc,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;AACvD,CAAC;AAED,wEAAwE;AACxE,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,IAA0C,EAC1C,UAA8B,EAAE;IAEhC,OAAO,cAAc,CAAC,iBAAiB,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AACvE,CAAC"}

package/build-ngc/core/gl-errors.d.ts

@@ -0,0 +1 @@
+export declare const GL_ERRORS: Readonly<Record<number, string>>;

package/build-ngc/core/gl-errors.js

@@ -0,0 +1,9 @@
+export const GL_ERRORS = {
+    1280: 'INVALID ENUM: An unacceptable value has been specified for an enumerated argument.',
+    1281: 'INVALID_VALUE: A numeric argument is out of range.',
+    1282: 'INVALID_OPERATION: The specified command is not allowed for the current state.',
+    1285: 'OUT_OF_MEMORY: Not enough memory is left to execute the command.',
+    1286: 'INVALID_FRAMEBUFFER_OPERATION: The currently bound framebuffer is not complete when trying to render to or to read from it.',
+    37442: 'CONTEXT_LOST_WEBGL: The WebGL context is lost.',
+};
+//# sourceMappingURL=gl-errors.js.map

package/build-ngc/core/gl-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gl-errors.js","sourceRoot":"","sources":["../../src/core/gl-errors.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,SAAS,GAAqC;IACzD,IAAI,EAAE,oFAAoF;IAC1F,IAAI,EAAE,oDAAoD;IAC1D,IAAI,EAAE,gFAAgF;IACtF,IAAI,EAAE,kEAAkE;IACxE,IAAI,EAAE,6HAA6H;IACnI,KAAK,EAAE,gDAAgD;CACxD,CAAC"}

package/build-ngc/core/gl-utils.d.ts

@@ -0,0 +1,5 @@
+import type { IExpoWebGLRenderingContext } from './types';
+type ILoggableGL = Pick<IExpoWebGLRenderingContext, '__expoSetLogging'>;
+/** Adds `__expoSetLogging` to the context, for the logging options useful in debugging GL calls */
+export declare function configureLogging(gl: ILoggableGL): void;
+export {};