moonscratch 0.1.1 → 0.1.2

package/js/render/webgl.ts

@@ -1,274 +0,0 @@
-import type { CanvasLike } from '../assets/types.ts'
-import type {
-  RenderFrame,
-  RenderImageData,
-  RenderWithWebGLOptions,
-  RenderWithWebGLResult,
-} from './types.ts'
-import { normalizeRenderFrame } from './utils.ts'
-
-const normalizeCanvas = (width: number, height: number): CanvasLike | null => {
-  const global = globalThis as {
-    OffscreenCanvas?: new (width: number, height: number) => CanvasLike
-    document?: { createElement(tag: string): CanvasLike }
-  }
-  if (global.OffscreenCanvas) {
-    return new global.OffscreenCanvas(width, height)
-  }
-  if (global.document?.createElement) {
-    return global.document.createElement('canvas')
-  }
-  return null
-}
-
-const createWebGLContext = (canvas: CanvasLike): unknown => {
-  const raw = canvas.getContext as (type: string, options?: unknown) => unknown
-  return (
-    raw('webgl2', { preserveDrawingBuffer: true }) ??
-    raw('webgl', { preserveDrawingBuffer: true })
-  )
-}
-
-const isWebGLContext = (
-  context: unknown,
-): context is WebGLRenderingContextLike =>
-  typeof context === 'object' &&
-  context !== null &&
-  'createTexture' in context &&
-  'createBuffer' in context &&
-  'createProgram' in context &&
-  'drawArrays' in context
-
-type WebGLRenderingContextLike = {
-  ARRAY_BUFFER: number
-  CLAMP_TO_EDGE: number
-  COLOR_BUFFER_BIT: number
-  COMPILE_STATUS: number
-  FRAGMENT_SHADER: number
-  FLOAT: number
-  LINK_STATUS: number
-  NEAREST: number
-  RGBA: number
-  STATIC_DRAW: number
-  TEXTURE0: number
-  TEXTURE_WRAP_S: number
-  TEXTURE_WRAP_T: number
-  TEXTURE_2D: number
-  TEXTURE_MIN_FILTER: number
-  TEXTURE_MAG_FILTER: number
-  TRIANGLE_STRIP: number
-  UNSIGNED_BYTE: number
-  VERTEX_SHADER: number
-  activeTexture(texture: number): void
-  attachShader(program: unknown, shader: unknown): void
-  bindBuffer(target: number, buffer: unknown): void
-  bindTexture(target: number, texture: unknown): void
-  clear(mask: number): void
-  clearColor(r: number, g: number, b: number, a: number): void
-  compileShader(shader: unknown): void
-  createBuffer(): unknown
-  createProgram(): unknown
-  createShader(type: number): unknown
-  createTexture(): unknown
-  createFramebuffer?(): unknown
-  drawArrays(mode: number, first: number, count: number): void
-  enableVertexAttribArray(location: number): void
-  bufferData(target: number, data: ArrayBufferView, usage: number): void
-  getAttribLocation(program: unknown, name: string): number
-  getError?(): number
-  getProgramInfoLog(program: unknown): string | null
-  getProgramParameter(program: unknown, pname: number): unknown
-  getShaderInfoLog(shader: unknown): string | null
-  getShaderParameter(shader: unknown, pname: number): unknown
-  getUniformLocation(program: unknown, name: string): unknown
-  linkProgram(program: unknown): void
-  pixelStorei(...args: unknown[]): void
-  readPixels(
-    x: number,
-    y: number,
-    width: number,
-    height: number,
-    format: number,
-    type: number,
-    pixels: Uint8Array,
-  ): void
-  shaderSource(shader: unknown, source: string): void
-  uniform1i(location: unknown, value: number): void
-  useProgram(program: unknown): void
-  vertexAttribPointer(
-    index: number,
-    size: number,
-    type: number,
-    normalized: boolean,
-    stride: number,
-    offset: number,
-  ): void
-  viewport(x: number, y: number, width: number, height: number): void
-  texParameteri(target: number, pname: number, param: number): void
-  texImage2D(
-    target: number,
-    level: number,
-    internalformat: number,
-    width: number,
-    height: number,
-    border: number,
-    format: number,
-    type: number,
-    pixels: Uint8Array | null,
-  ): void
-  bindVertexArray?(vertexArray: unknown): void
-  createVertexArray?(): unknown
-}
-
-const createProgram = (gl: WebGLRenderingContextLike): unknown => {
-  const vertexShader = gl.createShader(gl.VERTEX_SHADER)
-  const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER)
-  if (!vertexShader || !fragmentShader) {
-    throw new Error('Unable to create WebGL shaders')
-  }
-
-  const vertexSource = `
-attribute vec2 a_position;
-attribute vec2 a_tex_coord;
-varying vec2 v_tex_coord;
-void main() {
-  v_tex_coord = a_tex_coord;
-  gl_Position = vec4(a_position, 0.0, 1.0);
-}`
-  const fragmentSource = `
-precision mediump float;
-varying vec2 v_tex_coord;
-uniform sampler2D u_texture;
-void main() {
-  gl_FragColor = texture2D(u_texture, v_tex_coord);
-}`
-
-  gl.shaderSource(vertexShader, vertexSource)
-  gl.compileShader(vertexShader)
-  if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
-    throw new Error('Unable to compile WebGL vertex shader')
-  }
-
-  gl.shaderSource(fragmentShader, fragmentSource)
-  gl.compileShader(fragmentShader)
-  if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
-    throw new Error('Unable to compile WebGL fragment shader')
-  }
-
-  const program = gl.createProgram()
-  if (!program) {
-    throw new Error('Unable to create WebGL program')
-  }
-  gl.attachShader(program, vertexShader)
-  gl.attachShader(program, fragmentShader)
-  gl.linkProgram(program)
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const message = gl.getProgramInfoLog(program) ?? 'linking failed'
-    throw new Error(`Unable to link WebGL program: ${message}`)
-  }
-  return program
-}
-
-export const renderWithWebGL = (
-  input: RenderFrame,
-  options: RenderWithWebGLOptions = {},
-): RenderWithWebGLResult => {
-  const frame = normalizeRenderFrame(input)
-  const canvas = options.canvas ?? normalizeCanvas(frame.width, frame.height)
-  if (!canvas) {
-    throw new Error(
-      'renderWithWebGL requires a canvas and an environment that supports canvas',
-    )
-  }
-
-  canvas.width = frame.width
-  canvas.height = frame.height
-  const rawContext = createWebGLContext(canvas)
-  if (!isWebGLContext(rawContext)) {
-    throw new Error('renderWithWebGL requires a webgl-capable canvas')
-  }
-  const gl = rawContext
-
-  const program = createProgram(gl)
-  gl.useProgram(program)
-
-  const positions = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1])
-  const texCoords = new Float32Array([0, 1, 1, 1, 0, 0, 1, 0])
-  const buffer = gl.createBuffer()
-  const texBuffer = gl.createBuffer()
-  if (!buffer || !texBuffer) {
-    throw new Error('Unable to allocate WebGL buffers')
-  }
-
-  gl.bindBuffer(gl.ARRAY_BUFFER, buffer)
-  gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STATIC_DRAW)
-  const positionLocation = gl.getAttribLocation(program, 'a_position')
-  gl.enableVertexAttribArray(positionLocation)
-  gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0)
-
-  gl.bindBuffer(gl.ARRAY_BUFFER, texBuffer)
-  gl.bufferData(gl.ARRAY_BUFFER, texCoords, gl.STATIC_DRAW)
-  const texCoordLocation = gl.getAttribLocation(program, 'a_tex_coord')
-  gl.enableVertexAttribArray(texCoordLocation)
-  gl.vertexAttribPointer(texCoordLocation, 2, gl.FLOAT, false, 0, 0)
-
-  const texture = gl.createTexture()
-  gl.activeTexture(gl.TEXTURE0)
-  gl.bindTexture(gl.TEXTURE_2D, texture)
-  gl.pixelStorei(0x9240, true)
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
-  gl.texImage2D(
-    gl.TEXTURE_2D,
-    0,
-    gl.RGBA,
-    frame.width,
-    frame.height,
-    0,
-    gl.RGBA,
-    gl.UNSIGNED_BYTE,
-    frame.pixels,
-  )
-  const sampler = gl.getUniformLocation(program, 'u_texture')
-  gl.uniform1i(sampler, 0)
-
-  gl.viewport(0, 0, frame.width, frame.height)
-  gl.clearColor(0, 0, 0, 0)
-  gl.clear(gl.COLOR_BUFFER_BIT)
-  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4)
-
-  let imageDataCache: RenderImageData | null = null
-  const readback = (): RenderImageData => {
-    if (imageDataCache !== null) {
-      return imageDataCache
-    }
-    const out = new Uint8Array(frame.width * frame.height * 4)
-    if (frame.width > 0 && frame.height > 0) {
-      gl.readPixels(
-        0,
-        0,
-        frame.width,
-        frame.height,
-        gl.RGBA,
-        gl.UNSIGNED_BYTE,
-        out,
-      )
-    }
-    imageDataCache = {
-      width: frame.width,
-      height: frame.height,
-      data: new Uint8ClampedArray(out),
-    }
-    return imageDataCache
-  }
-
-  const imageElement = () => canvas
-
-  return {
-    canvas,
-    toImageData: readback,
-    toImageElement: imageElement,
-  }
-}

package/js/sharp-optional.d.ts

@@ -1,16 +0,0 @@
-declare module 'sharp' {
-  type SharpPipeline = {
-    ensureAlpha(): SharpPipeline
-    raw(): SharpPipeline
-    toBuffer(options: { resolveWithObject: true }): Promise<{
-      data: Uint8Array
-      info: {
-        width: number
-        height: number
-      }
-    }>
-  }
-
-  const sharp: (input?: unknown) => SharpPipeline
-  export default sharp
-}

package/js/test/helpers.ts

@@ -1,116 +0,0 @@
-import type { Project } from 'hikkaku'
-import { createHeadlessVMFromProject } from '../index.ts'
-import type {
-  FrameReport,
-  HeadlessVM,
-  JsonValue,
-  RenderFrame,
-  VMSnapshotTarget,
-} from '../vm/index.ts'
-
-export const createVmFromProject = (project: Project): HeadlessVM => {
-  return createHeadlessVMFromProject({
-    projectJson: project.toScratch(),
-    initialNowMs: 0,
-  })
-}
-
-export const stepMany = (
-  vm: HeadlessVM,
-  count: number,
-  frameMs = 33,
-): FrameReport => {
-  if (count <= 0) {
-    throw new Error('count must be positive')
-  }
-  let report: FrameReport | null = null
-  let nowMs = vm.snapshot().nowMs
-  for (let index = 0; index < count; index += 1) {
-    nowMs += frameMs
-    vm.setTime(nowMs)
-    report = vm.stepFrame()
-  }
-  if (!report) {
-    throw new Error('stepMany did not execute any frames')
-  }
-  return report
-}
-
-export const runUntilFinished = (
-  vm: HeadlessVM,
-  maxFrames = 180,
-  frameMs = 33,
-): FrameReport => {
-  let nowMs = vm.snapshot().nowMs
-  for (let index = 0; index < maxFrames; index += 1) {
-    nowMs += frameMs
-    vm.setTime(nowMs)
-    const report = vm.stepFrame()
-    if (report.stopReason === 'finished') {
-      return report
-    }
-  }
-  throw new Error(`VM did not finish within ${String(maxFrames)} frames`)
-}
-
-export const getTargetByName = (
-  vm: HeadlessVM,
-  name: string,
-): VMSnapshotTarget => {
-  const target = vm.snapshot().targets.find((item) => item.name === name)
-  if (!target) {
-    throw new Error(`target "${name}" was not found in snapshot`)
-  }
-  return target
-}
-
-export const getStageTarget = (vm: HeadlessVM): VMSnapshotTarget => {
-  const stage = vm.snapshot().targets.find((target) => target.isStage)
-  if (!stage) {
-    throw new Error('stage target was not found in snapshot')
-  }
-  return stage
-}
-
-export const getStageVariable = (vm: HeadlessVM, id: string): JsonValue => {
-  const value = getStageTarget(vm).variables[id]
-  if (value === undefined) {
-    throw new Error(`stage variable "${id}" was not found in snapshot`)
-  }
-  return value
-}
-
-export const countNonTransparentPixels = (frame: RenderFrame): number => {
-  let count = 0
-  for (let index = 0; index < frame.pixels.length; index += 4) {
-    if ((frame.pixels[index + 3] ?? 0) > 0) {
-      count += 1
-    }
-  }
-  return count
-}
-
-export const hasApproxColor = (
-  frame: RenderFrame,
-  rgb: readonly [number, number, number],
-  tolerance = 24,
-  minAlpha = 32,
-): boolean => {
-  for (let index = 0; index < frame.pixels.length; index += 4) {
-    const r = frame.pixels[index] ?? 0
-    const g = frame.pixels[index + 1] ?? 0
-    const b = frame.pixels[index + 2] ?? 0
-    const a = frame.pixels[index + 3] ?? 0
-    if (a < minAlpha) {
-      continue
-    }
-    if (
-      Math.abs(r - rgb[0]) <= tolerance &&
-      Math.abs(g - rgb[1]) <= tolerance &&
-      Math.abs(b - rgb[2]) <= tolerance
-    ) {
-      return true
-    }
-  }
-  return false
-}

package/js/test/hikkaku-sample.test.ts

@@ -1,37 +0,0 @@
-import { Project } from 'hikkaku'
-import { setVariableTo, whenFlagClicked } from 'hikkaku/blocks'
-import { describe, expect, test } from 'vite-plus/test'
-import { createHeadlessVM, createProgramModuleFromProject } from '../index.ts'
-
-describe('moonscratch/js/test/hikkaku-sample.test.ts', () => {
-  test('runs a project generated with hikkaku', () => {
-    const project = new Project()
-    const score = project.stage.createVariable('score', 0)
-
-    project.stage.run(() => {
-      whenFlagClicked(() => {
-        setVariableTo(score, 42)
-      })
-    })
-
-    const program = createProgramModuleFromProject({
-      projectJson: project.toScratch(),
-    })
-    const vm = createHeadlessVM({
-      program,
-      initialNowMs: 0,
-    })
-
-    vm.greenFlag()
-    const report = vm.stepFrame()
-
-    expect(report.stopReason).toBe('finished')
-
-    const stage = vm.snapshot().targets.find((target) => target.isStage)
-    if (!stage) {
-      throw new Error('stage target was not found in snapshot')
-    }
-
-    expect(stage.variables[score.id]).toBe(42)
-  })
-})

package/js/test/rubik-components.input-motion.test.ts

@@ -1,60 +0,0 @@
-import { Project } from 'hikkaku'
-import {
-  getKeyPressed,
-  getMouseDown,
-  getMouseX,
-  getMouseY,
-  gotoXY,
-  ifThen,
-  setDragMode,
-  setVariableTo,
-  whenFlagClicked,
-} from 'hikkaku/blocks'
-import { describe, expect, test } from 'vite-plus/test'
-import {
-  createVmFromProject,
-  getStageVariable,
-  getTargetByName,
-  runUntilFinished,
-} from './helpers.ts'
-
-describe('rubik components: input and motion', () => {
-  test('reads key/mouse input and moves sprite with motion_gotoxy', () => {
-    const project = new Project()
-    const sprite = project.createSprite('pointer')
-    const mouseX = project.stage.createVariable('mouseX', 0)
-    const mouseY = project.stage.createVariable('mouseY', 0)
-    const mouseDown = project.stage.createVariable('mouseDown', 0)
-    const keyPressed = project.stage.createVariable('keyPressed', 0)
-
-    sprite.run(() => {
-      whenFlagClicked(() => {
-        setDragMode('draggable')
-        setVariableTo(mouseX, getMouseX())
-        setVariableTo(mouseY, getMouseY())
-        ifThen(getMouseDown(), () => {
-          setVariableTo(mouseDown, 1)
-        })
-        ifThen(getKeyPressed('space'), () => {
-          setVariableTo(keyPressed, 1)
-        })
-        gotoXY(getMouseX(), getMouseY())
-      })
-    })
-
-    const vm = createVmFromProject(project)
-    vm.greenFlag()
-    vm.setMouseState({ x: 40, y: -30, isDown: true })
-    vm.setKeysDown(['space'])
-    runUntilFinished(vm)
-
-    expect(getStageVariable(vm, mouseX.id)).toBe(40)
-    expect(getStageVariable(vm, mouseY.id)).toBe(-30)
-    expect(getStageVariable(vm, mouseDown.id)).toBe(1)
-    expect(getStageVariable(vm, keyPressed.id)).toBe(1)
-
-    const moved = getTargetByName(vm, 'pointer')
-    expect(moved.x).toBe(40)
-    expect(moved.y).toBe(-30)
-  })
-})

package/js/test/rubik-components.lists.test.ts

@@ -1,49 +0,0 @@
-import { Project } from 'hikkaku'
-import {
-  changeVariableBy,
-  getItemOfList,
-  getVariable,
-  lengthOfList,
-  replaceItemOfList,
-  setVariableTo,
-  whenFlagClicked,
-} from 'hikkaku/blocks'
-import { describe, expect, test } from 'vite-plus/test'
-import {
-  createVmFromProject,
-  getStageTarget,
-  getStageVariable,
-  runUntilFinished,
-} from './helpers.ts'
-
-describe('rubik components: lists', () => {
-  test('reads, replaces and measures list values', () => {
-    const project = new Project()
-    const values = project.stage.createList('values', [10, 20, 30])
-    const picked = project.stage.createVariable('picked', 0)
-    const length = project.stage.createVariable('length', 0)
-    const total = project.stage.createVariable('total', 0)
-
-    project.stage.run(() => {
-      whenFlagClicked(() => {
-        setVariableTo(picked, getItemOfList(values, 2))
-        replaceItemOfList(values, 2, 99)
-        changeVariableBy(picked, getItemOfList(values, 2))
-        setVariableTo(length, lengthOfList(values))
-        setVariableTo(total, getVariable(length))
-        changeVariableBy(total, getVariable(picked))
-      })
-    })
-
-    const vm = createVmFromProject(project)
-    vm.greenFlag()
-    runUntilFinished(vm)
-
-    expect(getStageVariable(vm, picked.id)).toBe(119)
-    expect(getStageVariable(vm, length.id)).toBe(3)
-    expect(getStageVariable(vm, total.id)).toBe(122)
-
-    const stage = getStageTarget(vm)
-    expect(stage.lists[values.id]).toEqual([10, 99, 30])
-  })
-})

package/js/test/rubik-components.operators.test.ts

@@ -1,104 +0,0 @@
-import { Project } from 'hikkaku'
-import {
-  add,
-  and,
-  divide,
-  equals,
-  gt,
-  ifThen,
-  lt,
-  mathop,
-  multiply,
-  not,
-  or,
-  setVariableTo,
-  subtract,
-  whenFlagClicked,
-} from 'hikkaku/blocks'
-import { describe, expect, test } from 'vite-plus/test'
-import {
-  createVmFromProject,
-  getStageVariable,
-  runUntilFinished,
-} from './helpers.ts'
-
-describe('rubik components: operators', () => {
-  test('evaluates arithmetic and boolean operator chains', () => {
-    const project = new Project()
-    const arithmetic = project.stage.createVariable('arithmetic', 0)
-    const sine = project.stage.createVariable('sine', 0)
-    const logic = project.stage.createVariable('logic', 0)
-
-    project.stage.run(() => {
-      whenFlagClicked(() => {
-        setVariableTo(arithmetic, add(10, 5))
-        setVariableTo(arithmetic, subtract(arithmetic.get(), 3))
-        setVariableTo(arithmetic, multiply(arithmetic.get(), 4))
-        setVariableTo(arithmetic, divide(arithmetic.get(), 6))
-        setVariableTo(sine, mathop('sin', 30))
-        ifThen(and(or(true, false), not(false)), () => {
-          setVariableTo(logic, 1)
-        })
-      })
-    })
-
-    const vm = createVmFromProject(project)
-    vm.greenFlag()
-    runUntilFinished(vm)
-
-    expect(getStageVariable(vm, arithmetic.id)).toBe(8)
-    expect(getStageVariable(vm, logic.id)).toBe(1)
-    expect(Number(getStageVariable(vm, sine.id))).toBeCloseTo(0.5, 6)
-  })
-
-  test('uses Scratch compare semantics for lt/gt/equals', () => {
-    const project = new Project()
-    const leftA = project.stage.createVariable('leftA', 0)
-    const rightA = project.stage.createVariable('rightA', 0)
-    const leftB = project.stage.createVariable('leftB', 0)
-    const rightB = project.stage.createVariable('rightB', 0)
-    const leftC = project.stage.createVariable('leftC', '')
-    const rightC = project.stage.createVariable('rightC', '')
-    const leftD = project.stage.createVariable('leftD', '')
-    const rightD = project.stage.createVariable('rightD', 0)
-    const numericLt = project.stage.createVariable('numericLt', 0)
-    const numericGt = project.stage.createVariable('numericGt', 0)
-    const stringLt = project.stage.createVariable('stringLt', 0)
-    const whitespaceEq = project.stage.createVariable('whitespaceEq', 0)
-
-    project.stage.run(() => {
-      whenFlagClicked(() => {
-        setVariableTo(leftA, -1)
-        setVariableTo(rightA, -0.05)
-        setVariableTo(leftB, 2)
-        setVariableTo(rightB, 1)
-        setVariableTo(leftC, 'apple')
-        setVariableTo(rightC, 'Banana')
-        setVariableTo(leftD, '   ')
-        setVariableTo(rightD, 0)
-
-        ifThen(lt(leftA.get(), rightA.get()), () => {
-          setVariableTo(numericLt, 1)
-        })
-        ifThen(gt(leftB.get(), rightB.get()), () => {
-          setVariableTo(numericGt, 1)
-        })
-        ifThen(lt(leftC.get(), rightC.get()), () => {
-          setVariableTo(stringLt, 1)
-        })
-        ifThen(equals(leftD.get(), rightD.get()), () => {
-          setVariableTo(whitespaceEq, 1)
-        })
-      })
-    })
-
-    const vm = createVmFromProject(project)
-    vm.greenFlag()
-    runUntilFinished(vm)
-
-    expect(getStageVariable(vm, numericLt.id)).toBe(1)
-    expect(getStageVariable(vm, numericGt.id)).toBe(1)
-    expect(getStageVariable(vm, stringLt.id)).toBe(1)
-    expect(getStageVariable(vm, whitespaceEq.id)).toBe(0)
-  })
-})