@symbiote-native/gl 0.0.0-stage → 0.1.0

package/src/core/gl-context.ts

@@ -0,0 +1,79 @@
+import { CodedError } from 'expo-modules-core';
+import { GL_CONTEXTS_GLOBAL } from './constants';
+import { configureLogging } from './gl-utils';
+import { glNativeModule } from './native-module';
+import type {
+  IExpoWebGLRenderingContext,
+  IGLSnapshot,
+  IGLSnapshotOptions,
+} from './types';
+import { createWorkletContextManager } from './worklet-context-manager';
+
+const workletContextManager = createWorkletContextManager();
+
+function isContext(value: unknown): value is IExpoWebGLRenderingContext {
+  return typeof value === 'object' && value !== null;
+}
+
+/** The context of a worklet, `exgl` has to be created with worklet support */
+export function getWorkletContext(
+  contextId: number,
+): IExpoWebGLRenderingContext | undefined {
+  'worklet';
+  return workletContextManager.getContext(contextId);
+}
+
+export function unregisterGLContext(exglCtxId: number): void {
+  const contexts: unknown = 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: number): IExpoWebGLRenderingContext {
+  const contexts: unknown = 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: unknown = 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?: IExpoWebGLRenderingContext | number,
+): number {
+  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(): Promise<IExpoWebGLRenderingContext> {
+  const { exglCtxId } = await glNativeModule.createContextAsync();
+  return getGl(exglCtxId);
+}
+
+/** For a headless context made by `createContextAsync` */
+export async function destroyContextAsync(
+  exgl?: IExpoWebGLRenderingContext | number,
+): Promise<boolean> {
+  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?: IExpoWebGLRenderingContext | number,
+  options: IGLSnapshotOptions = {},
+): Promise<IGLSnapshot> {
+  return glNativeModule.takeSnapshotAsync(getContextId(exgl), options);
+}

package/src/core/gl-errors.ts

@@ -0,0 +1,8 @@
+export const GL_ERRORS: Readonly<Record<number, string>> = {
+  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.',
+};

package/src/core/gl-utils.ts

@@ -0,0 +1,106 @@
+import { GL_ERRORS } from './gl-errors';
+import { GLLoggingOption } from './types';
+import type { IExpoWebGLRenderingContext } from './types';
+
+type ILoggableGL = Pick<IExpoWebGLRenderingContext, '__expoSetLogging'>;
+
+type IGLFunction = (...args: unknown[]) => unknown;
+
+const MAX_STRING_LENGTH = 20;
+
+const SET_LOGGING_KEY = '__expoSetLogging';
+
+const wrappers = new WeakSet<IGLFunction>();
+
+function isGLFunction(value: unknown): value is IGLFunction {
+  return typeof value === 'function';
+}
+
+function constantNameOf(gl: object, value: number): string | undefined {
+  for (const name in gl) {
+    if (Reflect.get(gl, name) === value) return name;
+  }
+  return undefined;
+}
+
+// Numbers get the name of a constant that holds them, which can mislead for a size, so the
+// number stays. Strings are cut because a shader is long and logging it blocks the bridge
+function describeArg(gl: object, option: number, arg: unknown): string {
+  if (option & GLLoggingOption.RESOLVE_CONSTANTS && typeof arg === 'number') {
+    const name = constantNameOf(gl, arg);
+    if (name) return `${arg} (${name})`;
+  }
+  const isLong = typeof arg === 'string' && arg.length > MAX_STRING_LENGTH;
+  if (option & GLLoggingOption.TRUNCATE_STRINGS && isLong) {
+    const lastSpace = arg.lastIndexOf(' ', MAX_STRING_LENGTH);
+    return `${arg.slice(0, lastSpace >= 0 ? lastSpace : MAX_STRING_LENGTH)}...`;
+  }
+  return String(arg);
+}
+
+// The original `getError`, a wrapped one would log itself
+function reportError(gl: object): void {
+  const getError: unknown = Reflect.get(
+    Reflect.getPrototypeOf(gl) ?? {},
+    'getError',
+  );
+  if (!isGLFunction(getError)) return;
+  const error = getError.call(gl);
+  if (typeof error !== 'number' || error === Reflect.get(gl, 'NO_ERROR'))
+    return;
+  console.warn(`\x1b[31mExpoGL: Error ${GL_ERRORS[error]}\x1b[0m`);
+}
+
+function wrapMethod(
+  gl: object,
+  key: string,
+  original: IGLFunction,
+  getOption: () => number,
+): void {
+  const wrapper: IGLFunction = (...args) => {
+    const option = getOption();
+    if (option & GLLoggingOption.METHOD_CALLS) {
+      const params = args.map(arg => describeArg(gl, option, arg));
+      console.warn(`ExpoGL: ${key}(${params.join(', ')})`);
+    }
+    const result = original.apply(gl, args);
+    if (option & GLLoggingOption.METHOD_CALLS)
+      console.warn(`ExpoGL:   = ${String(result)}`);
+    if (option & GLLoggingOption.GET_ERRORS && key !== 'getError')
+      reportError(gl);
+    return result;
+  };
+  wrappers.add(wrapper);
+  Reflect.set(gl, key, wrapper);
+}
+
+function wrapMethods(gl: object, getOption: () => number): void {
+  for (const [key, original] of Object.entries(
+    Reflect.getPrototypeOf(gl) ?? {},
+  )) {
+    if (isGLFunction(original) && key !== SET_LOGGING_KEY) {
+      wrapMethod(gl, key, original, getOption);
+    }
+  }
+}
+
+function unwrapMethods(gl: object): void {
+  for (const [key, value] of Object.entries(gl)) {
+    if (isGLFunction(value) && wrappers.has(value))
+      Reflect.deleteProperty(gl, key);
+  }
+}
+
+/** Adds `__expoSetLogging` to the context, for the logging options useful in debugging GL calls */
+export function configureLogging(gl: ILoggableGL): void {
+  let loggingOption: number = GLLoggingOption.DISABLED;
+
+  gl.__expoSetLogging = (option: GLLoggingOption): void => {
+    // Both on or both off needs no wrapping or unwrapping, only the new option
+    if (!loggingOption !== !option) {
+      if (option) wrapMethods(gl, () => loggingOption);
+      else unwrapMethods(gl);
+    }
+    loggingOption = option;
+  };
+}

package/src/core/gl-view.ts

@@ -0,0 +1,160 @@
+import {
+  Platform,
+  UnavailabilityError,
+  requireNativeViewManager,
+} from 'expo-modules-core';
+import { el } from '@symbiote-native/components';
+import type { IDescriptor } from '@symbiote-native/components';
+import {
+  defineExpoNativeView,
+  getNativeTag,
+  isDevBuild,
+  isSymbioteNode,
+} from '@symbiote-native/engine';
+import type { ISymbioteEvent, ISymbioteNode } from '@symbiote-native/engine';
+import { GL_MODULE_NAME, GL_PACKAGE_NAME } from './constants';
+import { getGl, takeSnapshotAsync, unregisterGLContext } from './gl-context';
+import { glNativeModule } from './native-module';
+import type {
+  IGLNodeOrTag,
+  IGLObject,
+  IGLSnapshotOptions,
+  IGLViewHandle,
+  IGLViewProps,
+} from './types';
+
+// 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;
+
+export type IGLView = {
+  handle: IGLViewHandle;
+  /** `null` means the view cannot register and the caller renders nothing */
+  render(props: object): IDescriptor | null;
+  /** Forgets the context of the surface, called when the view unmounts */
+  dispose(): void;
+};
+
+type IGetNode = () => ISymbioteNode | null | undefined;
+
+function isSurfaceCreated(value: unknown): value is { exglCtxId: number } {
+  return typeof Reflect.get(Object(value), 'exglCtxId') === 'number';
+}
+
+function isContextCallback(
+  value: unknown,
+): value is IGLViewProps['onContextCreate'] {
+  return typeof value === 'function';
+}
+
+// Adapters hand over the props they hold, a missing callback is a view nobody listens to
+function toViewProps(props: object): IGLViewProps {
+  const onContextCreate: unknown = Reflect.get(props, 'onContextCreate');
+  return {
+    ...props,
+    onContextCreate: isContextCallback(onContextCreate)
+      ? onContextCreate
+      : () => undefined,
+  };
+}
+
+function nativeTagOf(camera: IGLNodeOrTag): number {
+  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: IGetNode): IGLView {
+  let exglCtxId: number | undefined;
+  let latestProps: IGLViewProps | undefined;
+  let hasWorkletSupport: boolean | undefined;
+
+  const onSurfaceCreate = (event: ISymbioteEvent): void => {
+    if (!isSurfaceCreated(event.nativeEvent)) return;
+    exglCtxId = event.nativeEvent.exglCtxId;
+    latestProps?.onContextCreate(getGl(exglCtxId));
+  };
+
+  function warnOnWorkletChange(enabled: boolean): void {
+    if (hasWorkletSupport !== undefined && hasWorkletSupport !== enabled) {
+      console.warn(
+        'Updating prop enableExperimentalWorkletSupport is not supported',
+      );
+    }
+    hasWorkletSupport = enabled;
+  }
+
+  const handle: IGLViewHandle = {
+    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: WebGLTexture = { id: exglObjId };
+      return texture;
+    },
+    async destroyObjectAsync(glObject: IGLObject) {
+      if (!glNativeModule.destroyObjectAsync) {
+        throw new UnavailabilityError(GL_PACKAGE_NAME, 'destroyObjectAsync');
+      }
+      return glNativeModule.destroyObjectAsync(glObject.id);
+    },
+    takeSnapshotAsync: (options?: IGLSnapshotOptions) =>
+      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/src/core/index.ts

@@ -0,0 +1,26 @@
+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/src/core/native-module.ts

@@ -0,0 +1,22 @@
+import { requireNativeModule } from 'expo-modules-core';
+import { GL_MODULE_NAME } from './constants';
+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 const glNativeModule =
+  requireNativeModule<INativeGLModule>(GL_MODULE_NAME);

package/src/core/types.ts

@@ -0,0 +1,95 @@
+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 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 = METHOD_CALLS | GET_ERRORS | RESOLVE_CONSTANTS | TRUNCATE_STRINGS,
+}
+
+/** 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/src/core/worklet-context-manager.ts

@@ -0,0 +1,52 @@
+import { GL_CONTEXTS_GLOBAL } from './constants';
+import type { IExpoWebGLRenderingContext } from './types';
+
+export type IWorkletContextManager = {
+  getContext(contextId: number): IExpoWebGLRenderingContext | undefined;
+  unregister?(contextId: number): void;
+};
+
+type IRunOnUI = (
+  worklet: (contextId: number) => void,
+) => (contextId: number) => void;
+
+function isRunOnUI(value: unknown): value is IRunOnUI {
+  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(): IWorkletContextManager {
+  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: unknown = 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/src/react/gl-view.ts

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

package/src/react/index.ts

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

package/src/solid/gl-view.ts

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

package/src/solid/index.ts

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

package/src/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/src/svelte/index.ts

@@ -0,0 +1,4 @@
+// @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';

package/src/svelte/svelte-ambient.d.ts

@@ -0,0 +1,3 @@
+// Pulls in svelte's ambient globals ($state/$effect/...) for this package's tsc program
+// This package has no value import from 'svelte', so a triple-slash reference does it explicitly
+/// <reference types="svelte" />

package/src/svelte/svelte-compile.test-helper.ts

@@ -0,0 +1,6 @@
+// Re-exports the existing harness instead of another copy
+export {
+  createSvelteHarness,
+  loadComponent,
+  type ISvelteHarness,
+} from '../../../sqlite/src/svelte/svelte-compile.test-helper';

package/src/vue/gl-view.ts

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

package/src/vue/index.ts

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