react-native-tgfx 0.0.0 → 0.0.2-alpha.0

package/src/compiler/sksl.test.ts

@@ -0,0 +1,219 @@
+import { expect, test } from 'bun:test'
+import { transpileShader } from './sksl'
+
+const PLAIN = `
+uniform float2 uSize;
+half4 main(float2 pos) {
+  return half4(pos.x / uSize.x, 0.0, 0.0, 1.0);
+}
+`
+
+test('a source with no child is unchanged and reports none', () => {
+  const t = transpileShader(PLAIN)
+  expect(t.childNames).toEqual([])
+  expect(t.uniformNames).toEqual(['uSize'])
+  expect(t.body).not.toContain('TGFX_CHILD')
+})
+
+test('the parse is cached, so a hot commit path does not re-parse', () => {
+  const a = transpileShader(PLAIN)
+  const b = transpileShader(PLAIN)
+  expect(a).toBe(b)
+})
+
+test('a child shader is collected and its eval rewritten', () => {
+  const t = transpileShader(`
+uniform shader tex;
+uniform float4 params;
+half4 main(float2 xy) {
+  half4 c = tex.eval(xy);
+  return c;
+}
+`)
+  expect(t.childNames).toEqual(['tex'])
+  expect(t.uniformNames).toEqual(['params'])
+  expect(t.body).toContain('TGFX_CHILD_0(xy)')
+  expect(t.body).not.toContain('tex.eval')
+})
+
+test('several children are indexed in declaration order', () => {
+  const t = transpileShader(`
+uniform shader a;
+uniform shader b;
+half4 main(float2 p) {
+  return a.eval(p) + b.eval(p);
+}
+`)
+  expect(t.childNames).toEqual(['a', 'b'])
+  expect(t.body).toContain('TGFX_CHILD_0(p)')
+  expect(t.body).toContain('TGFX_CHILD_1(p)')
+})
+
+test('whitespace around eval is tolerated', () => {
+  const t = transpileShader(`
+uniform shader tex;
+half4 main(float2 p) { return tex . eval ( p ); }
+`)
+  expect(t.body).toContain('TGFX_CHILD_0( p )')
+})
+
+// `sample(child, coord)` is the common SkSL spelling, and Skia treats it as `child.eval(coord)`.
+test('sample(child, coord) is the same thing as child.eval(coord)', () => {
+  const alias = transpileShader(`
+uniform shader tex;
+half4 main(float2 p) { return sample(tex, p); }
+`)
+  const method = transpileShader(`
+uniform shader tex;
+half4 main(float2 p) { return tex.eval(p); }
+`)
+  expect(alias.body).toBe(method.body)
+  expect(alias.body).toContain('TGFX_CHILD_0(p)')
+})
+
+test('sample() tolerates whitespace and reaches the preamble too', () => {
+  const t = transpileShader(`
+uniform shader a;
+uniform shader b;
+half4 tint(float2 p) { return sample( a , p ) * 0.5; }
+half4 main(float2 p) { return tint(p) + sample(b, p); }
+`)
+  expect(t.preamble).toContain('TGFX_CHILD_0(p )')
+  expect(t.body).toContain('TGFX_CHILD_1(p)')
+})
+
+test('a child used other than through eval is rejected, not silently emitted', () => {
+  expect(() =>
+    transpileShader(`
+uniform shader tex;
+half4 main(float2 p) { return half4(tex); }
+`)
+  ).toThrow(/may only be used as/)
+})
+
+test('a child named in a comment does not trip the eval-only guard', () => {
+  const t = transpileShader(`
+uniform shader tex;
+half4 main(float2 p) {
+  // tex is the backdrop we sample below
+  return tex.eval(p); /* tex done */
+}
+`)
+  expect(t.body).toContain('TGFX_CHILD_0(p)')
+})
+
+test('a commented-out uniform is not given a slot', () => {
+  const t = transpileShader(`
+// uniform float dead;
+/* uniform float alsoDead; */
+uniform float2 uSize;
+half4 main(float2 p) { return half4(p / uSize, 0.0, 1.0); }
+`)
+  expect(t.uniformNames).toEqual(['uSize'])
+})
+
+test('an unsupported uniform type still throws', () => {
+  expect(() =>
+    transpileShader(`
+uniform mat9 weird;
+half4 main(float2 p) { return half4(0.0); }
+`)
+  ).toThrow(/unsupported uniform type/)
+})
+
+// GLSL ES has no nested functions, so a helper in the body is a driver error at draw time.
+test('a helper function is routed to the preamble, not into the body', () => {
+  const t = transpileShader(`
+float sdCircle(float2 p, float r) { return length(p) - r; }
+
+half4 main(float2 pos) {
+  return sdCircle(pos, 40.0) < 0.0 ? half4(1.0) : half4(0.0);
+}
+`)
+  expect(t.functionNames).toEqual(['sdCircle'])
+  expect(t.preamble).toContain('float sdCircle(vec2 p, float r)')
+  expect(t.body).not.toContain('float sdCircle(')
+  expect(t.body).toContain('sdCircle(pos, 40.0)')
+})
+
+test('several helpers keep declaration order, including one calling another', () => {
+  const t = transpileShader(`
+float box(float2 p) { return max(p.x, p.y); }
+float ring(float2 p) { return abs(box(p)) - 2.0; }
+half4 main(float2 p) { return half4(ring(p)); }
+`)
+  expect(t.functionNames).toEqual(['box', 'ring'])
+  expect(t.preamble).toContain('float box(vec2 p)')
+  expect(t.preamble).toContain('abs(box(p))')
+  expect(t.body).toContain('ring(p)')
+})
+
+// The helper is at file scope, so a `const` left in the body would be invisible to it.
+test('a helper can read a top-level const, because both go to file scope', () => {
+  const t = transpileShader(`
+const float PI = 3.14159;
+float twice(float x) { return x * PI; }
+half4 main(float2 p) { return half4(twice(p.x)); }
+`)
+  expect(t.functionNames).toEqual(['PI', 'twice'])
+  expect(t.preamble).toContain('const float PI = 3.14159;')
+  expect(t.preamble).toContain('float twice(float x)')
+  expect(t.body).not.toContain('PI = 3.14159')
+})
+
+test('a top-level struct is lifted and named, not left in the body', () => {
+  const t = transpileShader(`
+struct Ray { float2 o; float2 d; };
+float2 at(Ray r, float t) { return r.o + r.d * t; }
+half4 main(float2 p) { return half4(at(Ray(p, p), 1.0), 0.0, 1.0); }
+`)
+  expect(t.functionNames).toEqual(['Ray', 'at'])
+  expect(t.preamble).toContain('struct Ray')
+  expect(t.body).not.toContain('struct Ray')
+})
+
+test('two names in one statement are rejected, not half-mangled', () => {
+  expect(() =>
+    transpileShader(`
+const float A = 1.0, B = 2.0;
+half4 main(float2 p) { return half4(A, B, 0.0, 1.0); }
+`)
+  ).toThrow(/one name per statement/)
+})
+
+// Everything after main's brace was silently discarded, so the body called an undeclared helper.
+test('a helper declared below main is rejected, not dropped', () => {
+  expect(() =>
+    transpileShader(`
+half4 main(float2 p) { return half4(k(p.x)); }
+float k(float x) { return x * 2.0; }
+`)
+  ).toThrow(/must come before main/)
+})
+
+test('a source with no helper reports an empty preamble', () => {
+  const t = transpileShader(PLAIN)
+  expect(t.preamble).toBe('')
+  expect(t.functionNames).toEqual([])
+})
+
+test('a helper may sample a child, and the eval is rewritten there too', () => {
+  const t = transpileShader(`
+uniform shader tex;
+half4 tint(float2 p) { return tex.eval(p) * 0.5; }
+half4 main(float2 p) { return tint(p); }
+`)
+  expect(t.functionNames).toEqual(['tint'])
+  expect(t.preamble).toContain('TGFX_CHILD_0(p)')
+  expect(t.preamble).not.toContain('tex.eval')
+})
+
+// The uniform regex cannot match `weights[5];`, so it used to fail in the driver instead.
+test('an array uniform is rejected in JavaScript, not in the driver', () => {
+  expect(() =>
+    transpileShader(`
+uniform float weights[5];
+half4 main(float2 p) { return half4(weights[0]); }
+`)
+  ).toThrow(/not arrays/)
+})

package/src/compiler/sksl.ts

@@ -0,0 +1,218 @@
+/** Cached and shared between callers, so every field is read-only. */
+export interface TranspiledShader {
+  readonly body: string
+  readonly preamble: string
+  readonly functionNames: readonly string[]
+  readonly uniformNames: readonly string[]
+  readonly uniformSizes: Readonly<Record<string, number>>
+  readonly childNames: readonly string[]
+}
+
+const TYPES: Record<string, { glsl: string; size: number }> = {
+  half: { glsl: 'float', size: 1 },
+  half2: { glsl: 'vec2', size: 2 },
+  half3: { glsl: 'vec3', size: 3 },
+  half4: { glsl: 'vec4', size: 4 },
+  float: { glsl: 'float', size: 1 },
+  float2: { glsl: 'vec2', size: 2 },
+  float3: { glsl: 'vec3', size: 3 },
+  float4: { glsl: 'vec4', size: 4 },
+  vec2: { glsl: 'vec2', size: 2 },
+  vec3: { glsl: 'vec3', size: 3 },
+  vec4: { glsl: 'vec4', size: 4 },
+  int: { glsl: 'int', size: 1 },
+  float2x2: { glsl: 'mat2', size: 4 },
+  float3x3: { glsl: 'mat3', size: 9 },
+  float4x4: { glsl: 'mat4', size: 16 },
+}
+
+function toGlslTypes(src: string): string {
+  return src
+    .replace(/\bhalf([234])\b/g, 'vec$1')
+    .replace(/\bhalf\b/g, 'float')
+    .replace(/\bfloat([234])x\1\b/g, (_, n) => `mat${n}`)
+    .replace(/\bfloat([234])\b/g, 'vec$1')
+}
+
+function blockAt(src: string, open: number): string {
+  let depth = 0
+  for (let i = open; i < src.length; i++) {
+    if (src[i] === '{') {
+      depth++
+    } else if (src[i] === '}') {
+      depth--
+      if (depth === 0) {
+        return src.slice(open + 1, i)
+      }
+    }
+  }
+  throw new Error('[tgfx] shader: unbalanced braces')
+}
+
+function hasBareComma(src: string): boolean {
+  let depth = 0
+  for (const c of src) {
+    if (c === '(') {
+      depth++
+    } else if (c === ')') {
+      depth--
+    } else if (c === ',' && depth === 0) {
+      return true
+    }
+  }
+  return false
+}
+
+function topLevelChunks(src: string): string[] {
+  const chunks: string[] = []
+  let depth = 0
+  let start = 0
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i]
+    if (c === '{') {
+      depth++
+      continue
+    }
+    if (c === '}') {
+      depth--
+    } else if (c !== ';') {
+      continue
+    }
+    // A `}` the `struct` grammar follows with `;` is closed by that `;`.
+    if (depth > 0 || (c === '}' && /^\s*;/.test(src.slice(i + 1)))) {
+      continue
+    }
+    chunks.push(src.slice(start, i + 1))
+    start = i + 1
+  }
+  if (src.slice(start).trim() !== '') {
+    throw new Error(
+      `[tgfx] shader: unterminated declaration above main(): '${src
+        .slice(start)
+        .trim()}'`
+    )
+  }
+  return chunks
+}
+
+function declaredName(chunk: string): string {
+  const struct = /\bstruct\s+(\w+)/.exec(chunk)
+  if (struct != null) {
+    return struct[1] as string
+  }
+  const paren = chunk.indexOf('(')
+  const assign = chunk.indexOf('=')
+  const declarator =
+    /^\s*(?:const\s+)?\w+\s+(\w+)\s*(?:\[[^\]]*\])?\s*(?:\(|=|;)/.exec(chunk)
+  if (declarator == null) {
+    throw new Error(
+      `[tgfx] shader: unsupported declaration above main(): '${chunk.trim()}'`
+    )
+  }
+  // `float a = 1.0, b = 2.0;` would leave `b` unmangled and silently colliding.
+  if ((paren < 0 || assign < paren) && hasBareComma(chunk)) {
+    throw new Error(
+      `[tgfx] shader: declare one name per statement above main(): '${chunk.trim()}'`
+    )
+  }
+  return declarator[1] as string
+}
+
+const CACHE = new Map<string, TranspiledShader>()
+
+export function transpileShader(source: string): TranspiledShader {
+  const hit = CACHE.get(source)
+  if (hit !== undefined) {
+    return hit
+  }
+  const result = transpile(source)
+  if (CACHE.size >= 64) {
+    CACHE.clear()
+  }
+  CACHE.set(source, result)
+  return result
+}
+
+function transpile(source: string): TranspiledShader {
+  const uniformNames: string[] = []
+  const uniformSizes: Record<string, number> = {}
+  const childNames: string[] = []
+  // Stripped first, so a commented-out `uniform` is not collected and prose cannot trip the guard.
+  const withoutComments = source.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, ' ')
+  const withoutUniforms = withoutComments.replace(
+    /\buniform\s+(\w+)\s+(\w+)\s*;/g,
+    (_all, type: string, name: string) => {
+      if (type === 'shader') {
+        childNames.push(name)
+        return ''
+      }
+      const info = TYPES[type]
+      if (info == null) {
+        throw new Error(`[tgfx] shader: unsupported uniform type '${type}'`)
+      }
+      uniformNames.push(name)
+      uniformSizes[name] = info.size
+      return ''
+    }
+  )
+
+  const signature = /\b(?:half4|float4|vec4)\s+main\s*\(([^)]*)\)\s*\{/.exec(
+    withoutUniforms
+  )
+  if (signature == null) {
+    throw new Error(
+      "[tgfx] shader: expected a 'vec4 main(vec2 pos)' entry point"
+    )
+  }
+  const open = signature.index + signature[0].length - 1
+  const body = blockAt(withoutUniforms, open)
+  const before = withoutUniforms.slice(0, signature.index)
+  const after = withoutUniforms.slice(open + body.length + 2)
+  // Only what precedes `main` is lifted, so a helper below it would be dropped.
+  if (after.trim() !== '') {
+    throw new Error(
+      `[tgfx] shader: declarations must come before main(), found after it: '${after.trim()}'`
+    )
+  }
+
+  const param = /\b(?:half2|float2|vec2)\s+(\w+)/.exec(signature[1] ?? '')
+  const bind = param != null ? `vec2 ${param[1]} = fragCoord;\n` : ''
+
+  // A declaration the uniform pass could not consume would be emitted verbatim and fail in the driver.
+  if (/\buniform\b/.test(before)) {
+    throw new Error(
+      '[tgfx] shader: unsupported uniform declaration — only scalar, vector and square-matrix uniforms are supported, not arrays'
+    )
+  }
+  const chunks = topLevelChunks(before)
+  const names = chunks.map(declaredName)
+
+  let glsl = toGlslTypes(`${bind}${body}`).trim()
+  let functions = toGlslTypes(chunks.join('')).trim()
+  // Both spellings become `TGFX_CHILD_0(coord)`, after the type rewrite so a child cannot be mangled.
+  childNames.forEach((name, index) => {
+    const calls = [
+      new RegExp(`\\b${name}\\s*\\.\\s*eval\\s*\\(`, 'g'),
+      new RegExp(`\\bsample\\s*\\(\\s*${name}\\s*,\\s*`, 'g'),
+    ]
+    for (const call of calls) {
+      glsl = glsl.replace(call, `TGFX_CHILD_${index}(`)
+      functions = functions.replace(call, `TGFX_CHILD_${index}(`)
+    }
+  })
+  for (const name of childNames) {
+    if (new RegExp(`\\b${name}\\b`).test(glsl + functions)) {
+      throw new Error(
+        `[tgfx] shader: child '${name}' may only be used as '${name}.eval(coord)' or 'sample(${name}, coord)'`
+      )
+    }
+  }
+  return {
+    body: glsl,
+    preamble: functions,
+    functionNames: names,
+    uniformNames,
+    uniformSizes,
+    childNames,
+  }
+}

package/src/compiler/stringTable.test.ts

@@ -0,0 +1,136 @@
+import { expect, test } from 'bun:test'
+import { HARNESS_TIMEOUT_MS, runCppHarness } from '../testing/cppHarness'
+import { packStringTable } from './writer'
+
+// packStringTable and applyStringTable are one wire format: a mismatch misindexes rather than errors.
+const PAYLOAD = `data:image/png;base64,${'QUJDREVGR0g='.repeat(400)}`
+
+const COMMITS: string[][] = [
+  [PAYLOAD],
+  [PAYLOAD], // the image is unchanged; only geometry moved
+  [PAYLOAD, 'M0 0L10 10'], // a <Path> joins the scene
+  [PAYLOAD, 'M0 0L20 20'], // its data changes
+  [PAYLOAD], // the path leaves; the table shrinks
+  ['other', 'M0 0L20 20'], // the image itself changes
+  [], // nothing references a string any more
+]
+
+const ENTRY_SEP = '\x1f'
+const TABLE_SEP = '\x1e'
+
+function pack(commits: string[][]): string[][] {
+  let prev: string[] = []
+  return commits.map((strings) => {
+    const delta = packStringTable(prev, strings)
+    prev = strings
+    return delta
+  })
+}
+
+function apply(packed: string[][]): string[][] {
+  return run(packed).tables
+}
+
+function allocations(packed: string[][]): string[] {
+  return run(packed).allocations
+}
+
+function run(packed: string[][]): {
+  tables: string[][]
+  allocations: string[]
+  warnings: string
+} {
+  const program = `#include <cstdio>
+#include <memory>
+#include <string>
+#include <vector>
+#include "SceneStrings.hpp"
+
+int main() {
+  const std::vector<tgfxrn::StringTable> packed = {
+    ${packed
+      .map((table) => `{${table.map((s) => JSON.stringify(s)).join(', ')}}`)
+      .join(',\n    ')}
+  };
+  std::shared_ptr<const tgfxrn::StringTable> table =
+      std::make_shared<const tgfxrn::StringTable>();
+  for (const auto& delta : packed) {
+    auto before = table;
+    tgfxrn::applyStringTable(table, delta);
+    printf("%s\\x1f", before.get() == table.get() ? "same" : "new");
+    for (const auto& entry : *table) {
+      printf("%s\\x1f", entry.c_str());
+    }
+    printf("\\x1e");
+  }
+  return 0;
+}
+`
+  const out = runCppHarness('tgfx-string-table', program)
+  const commits = out.stdout
+    .split(TABLE_SEP)
+    .slice(0, -1)
+    .map((table) => table.split(ENTRY_SEP).slice(0, -1))
+  return {
+    tables: commits.map((entries) => entries.slice(1)),
+    allocations: commits.map((entries) => entries[0]!),
+    warnings: out.stderr,
+  }
+}
+
+test(
+  'the engine reconstructs the exact table the compiler produced',
+  () => {
+    expect(apply(pack(COMMITS))).toEqual(COMMITS)
+  },
+  HARNESS_TIMEOUT_MS
+)
+
+test('an unchanged payload crosses the boundary once', () => {
+  const sizes = pack(COMMITS).map((delta) => delta.join('').length)
+  expect(sizes[0]).toBeGreaterThan(PAYLOAD.length)
+  expect(sizes[1]).toBeLessThan(8)
+  expect(sizes[3]).toBeLessThan(PAYLOAD.length)
+})
+
+test(
+  'a carry-over larger than the held table is clamped and reported',
+  () => {
+    // A dropped delta: JS counts from its own cursor, so the count can exceed what the engine holds.
+    const { tables, warnings } = run([['2', 'tail']])
+    expect(tables).toEqual([['tail']])
+    expect(warnings).toContain('carries over 2 entries but only 0 are held')
+  },
+  HARNESS_TIMEOUT_MS
+)
+
+test(
+  'a redundant commit reuses the held table instead of re-copying it',
+  () => {
+    const marks = allocations(pack(COMMITS))
+    expect(marks[1]).toBe('same')
+    expect(marks[0]).toBe('new')
+    expect(marks[2]).toBe('new')
+  },
+  HARNESS_TIMEOUT_MS
+)
+
+test(
+  'a carry-over past 2^32 is compared before it is narrowed',
+  () => {
+    // `size_t` is 32-bit on armeabi-v7a; this 64-bit host documents the reporting, not the narrowing.
+    const { warnings } = run([['4294967296', 'tail']])
+    expect(warnings).toContain('carries over 4294967296 entries')
+  },
+  HARNESS_TIMEOUT_MS
+)
+
+test(
+  'a delta with no header is ignored rather than emptying the table',
+  () => {
+    const { tables, warnings } = run([['0', 'kept'], []])
+    expect(tables).toEqual([['kept'], ['kept']])
+    expect(warnings).toContain('no header')
+  },
+  HARNESS_TIMEOUT_MS
+)