@bigmistqke/view.gl 0.1.1 → 0.1.3

package/src/index.ts

@@ -17,13 +17,35 @@ import type {
 } from './types'
 import {
   assertedNotNullish,
+  createUpsertMap,
   isMatKind,
   isSamplerKind,
   kindToSize,
   kindToUniformFnName,
-  mapObject,
+  ObjectUtils,
 } from './utils'
 
+/**********************************************************************************/
+/*                                                                                */
+/*                                      To ID                                     */
+/*                                                                                */
+/**********************************************************************************/
+
+let index = 0
+const PREFIX = 'VIEW_GL_ALIAS'
+
+const SYMBOL_MAP = createUpsertMap(WeakMap<symbol, string>)
+
+export function toID(key: string | number | symbol) {
+  if (typeof key === 'string') {
+    return key
+  }
+  if (typeof key === 'symbol') {
+    return SYMBOL_MAP.getOrInsert(key, () => `${PREFIX}_${index++}`)
+  }
+  return key.toString()
+}
+
 /**********************************************************************************/
 /*                                                                                */
 /*                                      View                                      */
@@ -59,7 +81,9 @@ export function uniformView<T extends UniformSchema>(
   program: WebGLProgram,
   schema: T,
 ): InferUniformView<T> {
-  return mapObject(schema, ({ kind, size }, name) => {
+  return ObjectUtils.map(schema, ({ kind, size }, key) => {
+    const name = toID(key)
+
     const location = gl.getUniformLocation(program, name)
 
     if (isSamplerKind(kind)) {
@@ -123,12 +147,14 @@ export function attributeView<T extends AttributeSchema>(
   schema: T,
   { signal }: ViewOptions = {},
 ): AttributeView<T> {
-  const attributes = mapObject(
+  const attributes = ObjectUtils.map(
     schema,
     (
       { kind, instanced, buffer = assertedNotNullish(gl.createBuffer()) },
-      name,
+      key,
     ): AttributeMethods => {
+      const name = toID(key)
+
       const location = gl.getAttribLocation(program, name)
       if (location < 0) {
         throw new Error(`Attribute '${name}' not found`)
@@ -156,9 +182,7 @@ export function attributeView<T extends AttributeSchema>(
   )
 
   signal?.addEventListener('abort', function dispose() {
-    for (const name in attributes) {
-      attributes[name].dispose()
-    }
+    ObjectUtils.forEach(attributes, value => value.dispose())
   })
 
   return attributes
@@ -177,16 +201,18 @@ export function interleavedAttributeView<T extends InterleavedAttributeSchema>(
   { signal }: ViewOptions = {},
 ): InterleavedAttributeView<T> {
   // Initialize interleaved attributes
-  const interleavedAttributes = mapObject(schema, ({ layout, instanced }) => {
+  const interleavedAttributes = ObjectUtils.map(schema, ({ layout, instanced }) => {
     // Increment number to keep track of offset
     let index = 0
 
     // Calculate layout information
     const handles = layout.map(layout => {
-      const location = gl.getAttribLocation(program, layout.name)
+      const name = toID(layout.key)
+
+      const location = gl.getAttribLocation(program, name)
 
       if (location < 0) {
-        throw new Error(`Attribute '${layout.name}' not found`)
+        throw new Error(`Attribute '${name}' not found`)
       }
 
       const size = kindToSize(layout.kind)
@@ -267,9 +293,7 @@ export function interleavedAttributeView<T extends InterleavedAttributeSchema>(
   })
 
   signal?.addEventListener('abort', function dispose() {
-    for (const name in interleavedAttributes) {
-      interleavedAttributes[name].dispose()
-    }
+    ObjectUtils.forEach(interleavedAttributes, value => value.dispose())
   })
 
   return interleavedAttributes
@@ -287,7 +311,7 @@ export function bufferView<T extends BufferSchema>(
   { signal }: ViewOptions = {},
 ): BufferView<T> {
   // Initialize buffers
-  const buffers = mapObject(schema, ({ target = 'ARRAY_BUFFER', usage = 'STATIC_DRAW' }) => {
+  const buffers = ObjectUtils.map(schema, ({ target = 'ARRAY_BUFFER', usage = 'STATIC_DRAW' }) => {
     const buffer = assertedNotNullish(gl.createBuffer())
     return {
       bind() {
@@ -304,9 +328,7 @@ export function bufferView<T extends BufferSchema>(
   })
 
   signal?.addEventListener('abort', function dispose() {
-    for (const name in buffers) {
-      buffers[name].dispose()
-    }
+    ObjectUtils.forEach(buffers, value => value.dispose())
   })
 
   return buffers

package/src/tag.ts

@@ -1,3 +1,4 @@
+import { toID } from '.'
 import type {
   AttributeKind,
   AttributeOptions,
@@ -20,11 +21,11 @@ import { createProgram } from './utils'
 /**********************************************************************************/
 
 interface UniformTagFn<TKind extends UniformKind> {
-  <const TName extends string, const TOptions extends Omit<UniformOptions, 'kind'>>(
-    name: TName,
+  <const TKey extends string | symbol, const TOptions extends Omit<UniformOptions, 'kind'>>(
+    key: TKey,
     TOptions: TOptions,
-  ): Prettify<UniformTag<TName, TKind, TOptions>>
-  <const TName extends string>(name: TName): Prettify<UniformTag<TName, TKind>>
+  ): Prettify<UniformTag<TKey, TKind, TOptions>>
+  <const TName extends string | symbol>(key: TName): Prettify<UniformTag<TName, TKind>>
 }
 
 export const uniform = new Proxy(
@@ -35,9 +36,9 @@ export const uniform = new Proxy(
     get(target, property) {
       // @ts-expect-error
       if (typeof property === 'symbol') return target[property]
-      return (name: string, options?: Omit<UniformOptions, 'kind'>) => ({
+      return (key: string, options?: Omit<UniformOptions, 'kind'>) => ({
         type: 'uniform',
-        name,
+        key,
         kind: property,
         ...options,
       })
@@ -53,9 +54,9 @@ export const attribute = new Proxy(
     get(target, property) {
       // @ts-expect-error
       if (typeof property === 'symbol') return target[property]
-      return (name: string, options?: Omit<AttributeOptions, 'kind'>) => ({
+      return (key: string, options?: Omit<AttributeOptions, 'kind'>) => ({
         type: 'attribute',
-        name,
+        key,
         kind: property,
         ...options,
       })
@@ -64,30 +65,30 @@ export const attribute = new Proxy(
 )
 
 export function interleave<
-  const TName extends string,
-  const TLayout extends Array<AttributeTag<string, AttributeKind, undefined>>,
+  const TKey extends string | symbol,
+  const TLayout extends Array<AttributeTag<string | symbol, AttributeKind, undefined>>,
   const TOptions extends Omit<AttributeOptions, 'kind'>,
->(name: TName, layout: TLayout, instanced: TOptions): InterleaveTag<TName, TLayout, TOptions>
+>(key: TKey, layout: TLayout, instanced: TOptions): InterleaveTag<TKey, TLayout, TOptions>
 export function interleave<
-  const TName extends string,
-  const TLayout extends Array<AttributeTag<string, AttributeKind, undefined>>,
->(name: TName, layout: TLayout): InterleaveTag<TName, TLayout, { instanced: false }>
+  const TKey extends string | symbol,
+  const TLayout extends Array<AttributeTag<string | symbol, AttributeKind, undefined>>,
+>(key: TKey, layout: TLayout): InterleaveTag<TKey, TLayout, { instanced: false }>
 export function interleave<
-  const TName extends string,
-  const TLayout extends Array<AttributeTag<string, AttributeKind, undefined>>,
+  const TKey extends string | symbol,
+  const TLayout extends Array<AttributeTag<string | symbol, AttributeKind, undefined>>,
   const TOptions extends Omit<AttributeOptions, 'kind'>,
->(name: TName, layout: TLayout, { instanced, buffer }: Partial<TOptions> = {}) {
+>(key: TKey, layout: TLayout, { instanced, buffer }: Partial<TOptions> = {}) {
   return {
     type: 'interleavedAttribute',
-    name,
+    key,
     // remove instanced- and type-property
-    layout: layout.map(({ name, kind }) => ({
-      name,
+    layout: layout.map(({ key, kind }) => ({
+      key,
       kind,
     })),
     instanced: !!instanced,
     buffer,
-  } as InterleaveTag<TName, TLayout, TOptions>
+  } as unknown as InterleaveTag<TKey, TLayout, TOptions>
 }
 
 /**********************************************************************************/
@@ -99,34 +100,43 @@ export function interleave<
 export function glsl<
   Elem extends string,
   Template extends ReadonlyArray<Elem>,
-  Hole extends UniformTag | AttributeTag | InterleaveTag | string | number,
+  Hole extends UniformTag | AttributeTag | InterleaveTag | string | number | symbol,
   Holes extends Hole[],
 >([initial, ...rest]: Template, ...holes: [...Holes]) {
   const v300 = initial?.startsWith('#version 300 es')
+
   const template = rest.reduce((out, templatePart, index) => {
     const hole = holes[index]
     const holePart =
-      typeof hole === 'string' || typeof hole === 'number'
-        ? hole
+      typeof hole === 'string' || typeof hole === 'number' || typeof hole === 'symbol'
+        ? toID(hole)
         : hole.type === 'interleavedAttribute'
-        ? hole.layout.reduce(
-            (a, v) =>
-              v300 ? `${a}in ${v.kind} ${v.name};\n` : `${a}attribute ${v.kind} ${v.name};\n`,
-            '',
-          )
-        : typeof hole === 'object' && hole.type === 'uniform' && 'size' in hole
-        ? `${hole.type} ${hole.kind} ${hole.name}[${hole.size}];`
-        : `${hole.type === 'attribute' && v300 ? 'in' : hole.type} ${hole.kind} ${hole.name};`
+          ? hole.layout.reduce(
+              (a, v) =>
+                v300
+                  ? `${a}in ${v.kind} ${toID(v.key)};\n`
+                  : `${a}attribute ${v.kind} ${toID(v.key)};\n`,
+              '',
+            )
+          : typeof hole === 'object' && hole.type === 'uniform' && 'size' in hole
+            ? `${hole.type} ${hole.kind} ${toID(hole.key)}[${hole.size}];`
+            : `${hole.type === 'attribute' && v300 ? 'in' : hole.type} ${hole.kind} ${toID(hole.key)};`
     return out + holePart + templatePart
   }, initial || '')
 
   return holes.reduce(
     (resources, resource) => {
-      if (typeof resource === 'string' || typeof resource === 'number') {
+      if (
+        typeof resource === 'string' ||
+        typeof resource === 'number' ||
+        typeof resource === 'symbol'
+      ) {
         return resources
       }
       // @ts-expect-error
-      resources[`${resource.type}s`][resource.name] = resource
+      const { key: name, type, ...rest } = resource
+      // @ts-expect-error
+      resources[`${type}s`][name] = rest
       return resources
     },
     {
@@ -137,15 +147,13 @@ export function glsl<
     } as {
       template: string
       uniforms: {
-        [K in Extract<Holes[number], UniformTag> as K['name']]: Prettify<Omit<K, 'name' | 'type'>>
+        [K in Extract<Holes[number], UniformTag> as K['key']]: Prettify<Omit<K, 'name' | 'type'>>
       }
       attributes: {
-        [K in Extract<Holes[number], AttributeTag> as K['name']]: Prettify<Omit<K, 'name' | 'type'>>
+        [K in Extract<Holes[number], AttributeTag> as K['key']]: Prettify<Omit<K, 'name' | 'type'>>
       }
       interleavedAttributes: {
-        [K in Extract<Holes[number], InterleaveTag> as K['name']]: Prettify<
-          Omit<K, 'name' | 'type'>
-        >
+        [K in Extract<Holes[number], InterleaveTag> as K['key']]: Prettify<Omit<K, 'name' | 'type'>>
       }
     },
   )

package/src/types.ts

@@ -4,8 +4,8 @@ export type Merge<A, B> = {
       ? A[K] | B[K]
       : A[K]
     : K extends keyof B
-    ? B[K]
-    : never
+      ? B[K]
+      : never
 }
 
 export type Prettify<T> = {
@@ -358,7 +358,7 @@ export interface UniformOptions {
   size?: number
 }
 
-export type UniformSchema = Record<string, UniformOptions>
+export type UniformSchema = Record<string | symbol, UniformOptions>
 
 export type UniformMethods<TOptions extends UniformOptions> = TOptions['size'] extends number
   ? {
@@ -426,7 +426,7 @@ export interface AttributeOptions {
   buffer?: WebGLBuffer
 }
 
-export type AttributeSchema = Record<string, AttributeOptions>
+export type AttributeSchema = Record<string | symbol, AttributeOptions>
 
 export interface AttributeMethods<T = AttributeKind> {
   buffer: WebGLBuffer
@@ -446,7 +446,7 @@ export type AttributeView<T extends AttributeSchema> = {
 /**********************************************************************************/
 
 export interface InterleavedAttributeLayout {
-  name: string
+  key: string | symbol
   kind: AttributeKind
 }
 
@@ -455,7 +455,7 @@ export interface InterleavedAttributeOptions {
   instanced?: boolean
 }
 
-export type InterleavedAttributeSchema = Record<string, InterleavedAttributeOptions>
+export type InterleavedAttributeSchema = Record<string | symbol, InterleavedAttributeOptions>
 
 export interface InterleavedAttributeMethods<
   T extends InterleavedAttributeLayout[] = InterleavedAttributeLayout[],
@@ -481,7 +481,7 @@ export interface BufferOptions {
   usage?: GLUsage
 }
 
-export type BufferSchema = Record<string, BufferOptions>
+export type BufferSchema = Record<string | symbol, BufferOptions>
 
 export interface BufferMethods {
   set(data: Float32Array | Uint16Array | Uint32Array): void
@@ -537,7 +537,7 @@ export type TextureTarget =
   | 'TEXTURE_3D' // WebGL2 only
   | 'TEXTURE_2D_ARRAY' // WebGL2 only
 
-export type TextureSchema = Record<string, TextureOptions>
+export type TextureSchema = Record<string | symbol, TextureOptions>
 
 export interface TextureMethods {
   texture: WebGLTexture
@@ -662,57 +662,57 @@ export type View<T extends ViewSchema = ViewSchema> = {
 
 export interface GLSL {
   template: string
-  uniforms: Record<string, UniformOptions>
-  attributes: Record<string, AttributeOptions>
-  interleavedAttributes: Record<string, InterleavedAttributeOptions>
+  uniforms: Record<string | symbol, UniformOptions>
+  attributes: Record<string | symbol, AttributeOptions>
+  interleavedAttributes: Record<string | symbol, InterleavedAttributeOptions>
 }
 
 export type UniformTag<
-  TName extends string = string,
+  TKey extends string | symbol = string | symbol,
   TKind extends UniformKind = UniformKind,
   TOptions extends Partial<UniformOptions> = UniformOptions,
 > = TOptions extends { size: infer TSize }
   ? {
       type: 'uniform'
       kind: TKind
-      name: TName
+      key: TKey
       size: TSize
     }
   : {
       type: 'uniform'
       kind: TKind
-      name: TName
+      key: TKey
     }
 
 export interface AttributeTag<
-  TName extends string = string,
+  TKey extends string | symbol = string | symbol,
   TKind extends AttributeKind = AttributeKind,
   TInstanced extends boolean | undefined = boolean | undefined,
 > {
   type: 'attribute'
   kind: TKind
   instanced: TInstanced
-  name: TName
+  key: TKey
 }
 
 export interface AttributeTagFn<TKey extends AttributeKind> {
-  <TName extends string, TOptions extends Omit<AttributeOptions, 'kind'>>(
-    name: TName,
+  <TName extends string | symbol, TOptions extends Omit<AttributeOptions, 'kind'>>(
+    key: TName,
     options: TOptions,
   ): Prettify<AttributeTag<TName, TKey, TOptions['instanced']>>
-  <TName extends string>(name: TName): Prettify<AttributeTag<TName, TKey, undefined>>
+  <TName extends string | symbol>(key: TName): Prettify<AttributeTag<TName, TKey, undefined>>
 }
 
 export type InterleaveTag<
-  TName extends string = string,
-  TLayout extends Array<AttributeTag<string, AttributeKind, undefined>> = Array<
-    AttributeTag<string, AttributeKind, undefined>
+  TKey extends string | symbol = string | symbol,
+  TLayout extends Array<AttributeTag<string | symbol, AttributeKind, undefined>> = Array<
+    AttributeTag<string | symbol, AttributeKind, undefined>
   >,
   TOptions extends Omit<AttributeOptions, 'kind'> = Omit<AttributeOptions, 'kind'>,
 > = TOptions & {
-  name: TName
+  key: TKey
   type: 'interleavedAttribute'
   layout: {
-    [TKey in keyof TLayout]: Prettify<Pick<TLayout[TKey], 'kind' | 'name'>>
+    [TKey in keyof TLayout]: Prettify<Pick<TLayout[TKey], 'kind' | 'key'>>
   }
 }

package/src/{utils.ts → utils/index.ts}

@@ -6,16 +6,9 @@ import type {
   KIND_TO_UNIFORM_FN_NAME_MAP,
   TextureOptions,
   UniformKind,
-} from './types'
-
-export function mapObject<T extends Record<string, any>, TReturn>(
-  value: T,
-  callback: (value: T[keyof T], key: Extract<keyof T, string>, index: number) => TReturn,
-): { [TKey in keyof T]: TReturn } {
-  return Object.fromEntries(
-    Object.entries(value).map(([key, value], index) => [key, callback(value, key, index)]),
-  )
-}
+} from '../types'
+
+export * as ObjectUtils from './object'
 
 export function assertedNotNullish<T>(value: T, message?: string): NonNullable<T> {
   if (value === undefined || value === null) throw new Error(message)
@@ -111,12 +104,16 @@ export const kindToUniformFnName = <T extends UniformKind>(
 export const kindToSize = <T extends UniformKind>(kind: T): KIND_TO_SIZE_MAP[T] => {
   switch (kind[0]) {
     case 'm':
-      const [a, b] = kind.match(/\d+/g)!.map(Number)
-      return a * (b || a)
+      const [a, b] = kind.match(/\d+/g)!.map(Number) as [number, number?]
+      return (a * (b ?? a)) as KIND_TO_SIZE_MAP[T]
     case 'v':
-      return +kind.match(/\d/)![0]
+    case 'i':
+    case 'b':
+    case 'u':
+      const match = kind.match(/\d/) as [string] | undefined
+      return (match ? +match[0] : 1) as KIND_TO_SIZE_MAP[T]
     default:
-      return 1
+      return 1 as KIND_TO_SIZE_MAP[T]
   }
 }
 
@@ -264,3 +261,31 @@ export function createFramebuffer(gl: GL, { attachment, texture, ...options }: F
     framebuffer,
   }
 }
+
+/**********************************************************************************/
+/*                                                                                */
+/*                                  Create Upsert                                 */
+/*                                                                                */
+/**********************************************************************************/
+
+type UpsertMapKind<T, U> = Map<T, U> | WeakMap<T, U>
+
+export function createUpsertMap<T extends UpsertMapKind<any, any> = Map<any, any>>(
+  constructor?: new () => T,
+) {
+  const map = new (constructor ?? Map)() as T
+  return Object.assign(map, {
+    getOrInsert(
+      key: T extends UpsertMapKind<infer U, any> ? U : never,
+      value: T extends UpsertMapKind<any, infer U> ? () => U : never,
+    ) {
+      let result = map.get(key)
+      if (result) {
+        return result
+      }
+      result = value()
+      map.set(key, result)
+      return result
+    },
+  })
+}

package/src/utils/object.ts

@@ -0,0 +1,27 @@
+export function forEach<T extends Record<string, any>>(
+  value: T,
+  callback: (value: T[keyof T], key: keyof T, index: number) => void,
+) {
+  let index = 0
+  for (const key in value) {
+    callback(value[key], key, index)
+    index++
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    callback(value[key as keyof T], key as keyof T, index)
+    index++
+  }
+}
+
+export function map<T extends Record<string, any>, TReturn>(
+  value: T,
+  callback: (value: T[keyof T], key: keyof T, index: number) => TReturn,
+): { [TKey in keyof T]: TReturn } {
+  const result = {} as { [TKey in keyof T]: TReturn }
+
+  forEach(value, (value, key, index) => {
+    result[key] = callback(value, key, index)
+  })
+
+  return result
+}