pixel-daylight-switch-gsvegetable 3.0.0 → 3.1.1

package/index.d.ts

@@ -1,38 +1,52 @@
 export interface ScenePalette {
   [symbol: string]: `#${string}`;
 }
-
-export interface SceneTimeStop {
-  /** Local scene time in hours, from 0 through 24. */
-  at: number;
-  /** Key in SceneManifest.palettes. */
-  palette: string;
+export interface SceneTimeStop { at: number; palette: string; }
+export interface ScenePixelAsset {
+  width: number;
+  height: number;
+  /** One printable-ASCII character per pixel. A dot is transparent when used as a layer. */
+  pixels: string[];
 }
-
-export interface SceneManifest {
-  schemaVersion: 1;
-  /** Unique lowercase community scene identifier (3-64 characters). */
+export interface SceneLayerAnimation {
+  /** drift and bob are deterministic sinusoidal motion tracks. */
+  type: 'drift' | 'bob';
+  axis: 'x' | 'y';
+  /** Angular speed in radians per second, from 0 to 4. */
+  speed: number;
+  /** Motion amplitude in scene pixels, from 1 to 64. */
+  distance: number;
+  /** Optional phase in radians, from 0 to 2π. */
+  phase?: number;
+}
+export interface SceneLayer {
+  id: string;
+  asset: string;
+  x: number;
+  y: number;
+  animation?: SceneLayerAnimation;
+}
+export interface SceneManifestBase {
   id: string;
   name: string;
   author: string;
-  /** SPDX identifier or a clearly stated license label. */
   license: string;
   canvas: { width: number; height: number };
-  /** One printable-ASCII character per pixel; rows match canvas dimensions. */
   pixels: string[];
-  /** Each palette maps every used pixel symbol to a #RGB or #RRGGBB color. */
   palettes: Record<string, ScenePalette>;
-  /** Strictly increasing palette stops; must begin at 0 and end at 24. */
   timeCycle: SceneTimeStop[];
 }
-
-export interface SceneValidationResult {
-  valid: boolean;
-  errors: string[];
+/** Manifest v1 preserves the original single pixel-matrix format. */
+export interface SceneManifestV1 extends SceneManifestBase { schemaVersion: 1; }
+/** Manifest v2 adds reusable pixel assets, compositing layers and declarative motion. */
+export interface SceneManifestV2 extends SceneManifestBase {
+  schemaVersion: 2;
+  assets: Record<string, ScenePixelAsset>;
+  layers: SceneLayer[];
 }
-
+export type SceneManifest = SceneManifestV1 | SceneManifestV2;
+export interface SceneValidationResult { valid: boolean; errors: string[]; }
 export type UnregisterScene = () => boolean;
-
 export interface PixelDaylightSwitchAPI {
   mount(root: Element | null): (() => void) | null;
   unmount(root: Element | null): void;
@@ -40,8 +54,8 @@ export interface PixelDaylightSwitchAPI {
   validateScene(manifest: unknown): SceneValidationResult;
   getScene(id: string): SceneManifest | null;
   listScenes(): SceneManifest[];
+  createGlass: typeof createGlass;
 }
-
 declare const PixelDaylightSwitch: PixelDaylightSwitchAPI;
 export declare const mount: PixelDaylightSwitchAPI['mount'];
 export declare const unmount: PixelDaylightSwitchAPI['unmount'];
@@ -50,3 +64,22 @@ export declare const validateScene: PixelDaylightSwitchAPI['validateScene'];
 export declare const getScene: PixelDaylightSwitchAPI['getScene'];
 export declare const listScenes: PixelDaylightSwitchAPI['listScenes'];
 export default PixelDaylightSwitch;
+
+export type GlassSource = HTMLCanvasElement | OffscreenCanvas | HTMLImageElement | HTMLVideoElement | ImageBitmap | (() => GlassSource);
+export interface GlassEngineOptions {
+  source?: GlassSource;
+  width?: number | string; height?: number | string;
+  left?: number | string; top?: number | string;
+  radius?: number | string; refraction?: number; dispersion?: number;
+  bezel?: number; shine?: number; opacity?: number; edgeDark?: number;
+  ink?: [number, number, number]; light?: [number, number, number];\n  shellDay?: [number, number, number]; shellNight?: [number, number, number];\n  hiNight?: [number, number, number]; loNight?: [number, number, number]; night?: number;
+  dpr?: number; continuous?: boolean;
+}
+export interface GlassEngineInstance {
+  canvas: HTMLCanvasElement;
+  setSource(source: GlassSource): this;
+  setOptions(options: Partial<GlassEngineOptions>): this;
+  render(): this;
+  destroy(): void;
+}
+export declare function createGlass(container: HTMLElement, options?: GlassEngineOptions): GlassEngineInstance;

package/index.mjs

@@ -1,4 +1,5 @@
 import api from './index.cjs';
+import { createGlass } from './glass-engine.mjs';
 
 export const mount = api.mount;
 export const unmount = api.unmount;
@@ -6,4 +7,5 @@ export const registerScene = api.registerScene;
 export const validateScene = api.validateScene;
 export const getScene = api.getScene;
 export const listScenes = api.listScenes;
+export { createGlass };
 export default api;

package/llms.txt

@@ -42,11 +42,17 @@ CommonJS: `const PixelDaylightSwitch = require('pixel-daylight-switch-gsvegetabl
 
 The package is safe to import during SSR; mount only after the target DOM element exists. `mount(element)` is idempotent and returns a cleanup function on success (or null on failure). `unmount(element)` stops rendering and removes observers/listeners; it does not remove the DOM root or forcibly invalidate the canvas context.
 
-Framework lifecycle examples are in [INTEGRATIONS.md](INTEGRATIONS.md). Scene plugin authoring, manifest constraints and API examples are in [SCENE_PLUGINS.md](SCENE_PLUGINS.md).
+Framework lifecycle examples are in [INTEGRATIONS.md](docs/INTEGRATIONS.md). Scene plugin authoring, manifest constraints and API examples are in [SCENE_PLUGINS.md](docs/SCENE_PLUGINS.md).
 
-## Community scene plugins (v3.0.0)
+## Standalone refractive glass engine (v3.1.1)
 
-The optional `scene-plugin.js` registry exposes `registerScene(manifest)`, `validateScene(manifest)`, `getScene(id)` and `listScenes()`. Load the registry before `app.js` in a browser, or import `registerScene` from the npm package. Register a scene before mounting its root. Manifest v1 uses a 1–192 by 1–112 printable-ASCII pixel map, up to 8 named palettes, and a 24-hour timeline that starts at 0 and ends at 24. Every used pixel symbol must have a valid `#RGB` or `#RRGGBB` color in every palette. Data is copied and deeply frozen on registration. Arbitrary plugin JavaScript is never executed. External image/sprite assets, layered tile maps and custom animation tracks are not supported in v1; they are reserved for a future schema extension. See [SCENE_PLUGINS.md](SCENE_PLUGINS.md), the [v1 JSON Schema](schemas/scene-manifest.v1.schema.json), and the [Sakura example](examples/scenes/sakura-evening.json).
+Import `createGlass` from `pixel-daylight-switch-gsvegetable/glass-engine`, or load `glass-engine.js` directly and use `PixelGlassEngine.createGlass(container, options)`. The independent WebGL2 overlay has configurable width, height, position, radius, refraction, dispersion, bezel, shine, opacity, source and lifecycle methods. Sources are origin-clean canvas, image, video, ImageBitmap or a callback returning one. WebGL cannot sample arbitrary DOM pixels; host applications must supply a renderable background source. See [GLASS_ENGINE.md](docs/GLASS_ENGINE.md) and [the demo](https://gsvegetable.github.io/pixel-daylight-switch/demos/glass-engine.html).
+
+## Community scene plugins (current: Manifest v2)
+
+The optional `scene-plugin.js` registry exposes `registerScene(manifest)`, `validateScene(manifest)`, `getScene(id)` and `listScenes()`. Register a data-only JSON manifest before mounting the scene. Manifest v2 supports up to 24 reusable pixel-matrix assets, up to 16 ordered layers, transparent overlay pixels (.), and bounded deterministic drift/bob motion tracks. Manifest v1 remains supported and its schema is unchanged. Every symbol in the base matrix and assets must be defined in each palette. Registration validates, copies and freezes the data; arbitrary JavaScript, remote image downloads and executable callbacks are not run.
+
+For npm, import `registerScene` from the package. In a browser, load `scene-plugin.js` before `app.js` and register the manifest before mounting. See [the scene authoring guide](docs/SCENE_PLUGINS.md), [Manifest v2 Schema](schemas/scene-manifest.v2.schema.json), [v1 compatibility schema](schemas/scene-manifest.v1.schema.json) and [Floating Island v2 example](examples/scenes/floating-island.v2.json).
 
 ## Scenes and weather
 
@@ -93,19 +99,19 @@ Invalid values fall back to defaults; documented numeric ranges are clamped.
 ## Links
 
 - [Live demo](https://gsvegetable.github.io/pixel-daylight-switch/)
-- [Interactive Playground](https://gsvegetable.github.io/pixel-daylight-switch/playground.html)
-- [Preview](https://gsvegetable.github.io/pixel-daylight-switch/preview.html)
-- [Integration recipes](INTEGRATIONS.md)
+- [Interactive Playground](https://gsvegetable.github.io/pixel-daylight-switch/demos/playground.html)
+- [Preview](https://gsvegetable.github.io/pixel-daylight-switch/demos/preview.html)
+- [Integration recipes](docs/INTEGRATIONS.md)
 - [English README](README.md) · [简体中文](README.zh-CN.md) · [日本語](README.ja.md)
-- [Changelog](CHANGELOG.md)
+- [Changelog](docs/CHANGELOG.md)
 
 
-## Scene plugins (v3.0.0)
+## Scene plugins — current Manifest v2
 
-- Public API: registerScene(manifest), validateScene(manifest), getScene(id), listScenes().
-- Manifest schema: schemas/scene-manifest.v1.schema.json.
-- Example: examples/scenes/sakura-evening.json.
-- Manifest v1: printable-ASCII pixel matrix (up to 192x112), named palettes, 24-hour palette interpolation.
-- Scene registration is data-only; arbitrary plugin JavaScript is not executed.
-- Browser script order: scene-plugin.js, register the manifest, then app.js. The one-line embed loader loads the registry before the renderer.
-- Existing built-in scenes and their custom live animation code remain unchanged.
+- Current schema: `schemas/scene-manifest.v2.schema.json`.
+- Example: `examples/scenes/floating-island.v2.json`.
+- Reusable assets: up to 24 pixel matrices; ordered layers: up to 16.
+- Overlay dot (.) is transparent; later layers appear above earlier layers.
+- Motion tracks: bounded deterministic `drift` and `bob`, on x or y.
+- Manifest v1 remains backward compatible; its schema is retained.
+- No arbitrary remote image loading, eval, or executable plugin callbacks.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pixel-daylight-switch-gsvegetable",
-  "version": "3.0.0",
-  "description": "A draggable pixel-art day/night switch with a community-extensible scene plugin system.",
+  "version": "3.1.1",
+  "description": "A pixel-art day/night switch plus a standalone reusable WebGL2 refractive glass engine.",
   "keywords": [
     "pixel-art",
     "day-night",
@@ -17,7 +17,11 @@
     "scene-plugin",
     "pixel-world",
     "scene-manifest",
-    "pixel-art-scenes"
+    "pixel-art-scenes",
+    "refractive-glass",
+    "glass-engine",
+    "webgl2-glass",
+    "lens-shader"
   ],
   "author": "GSvegetable",
   "license": "Unlicense",
@@ -44,6 +48,11 @@
     "./scene-plugin": {
       "import": "./scene-plugin.js",
       "require": "./scene-plugin.js"
+    },
+    "./glass-engine": {
+      "types": "./index.d.ts",
+      "import": "./glass-engine.mjs",
+      "require": "./glass-engine.js"
     }
   },
   "files": [
@@ -53,13 +62,17 @@
     "README.md",
     "LICENSE",
     "llms.txt",
-    "INTEGRATIONS.md",
-    "SCENE_PLUGINS.md",
+    "docs/INTEGRATIONS.md",
+    "docs/SCENE_PLUGINS.md",
     "scene-plugin.js",
     "schemas",
     "examples",
     "browser.mjs",
-    "index.d.ts"
+    "index.d.ts",
+    "docs/CHANGELOG.md",
+    "glass-engine.js",
+    "docs/GLASS_ENGINE.md",
+    "glass-engine.mjs"
   ],
   "sideEffects": [
     "./app.js"
@@ -71,8 +84,8 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node tests/package-smoke.cjs && node tests/scene-plugin-smoke.cjs && node tests/mobile-smoke.cjs && node tests/embed-smoke.cjs",
-    "test:browser": "playwright test",
+    "test": "node tests/package-smoke.cjs && node tests/scene-plugin-smoke.cjs && node tests/mobile-smoke.cjs && node tests/embed-smoke.cjs && node tests/glass-engine-smoke.cjs",
+    "test:browser": "playwright test --config config/playwright.config.cjs",
     "mobile:prepare": "node scripts/prepare-mobile.cjs",
     "mobile:android": "npm run mobile:prepare && cap sync android && node scripts/set-android-version.cjs android/app/build.gradle",
     "mobile:ios": "npm run mobile:prepare && cap sync ios",

package/scene-plugin.js

@@ -8,7 +8,7 @@
 })(typeof globalThis !== 'undefined' ? globalThis : this, function () {
   'use strict';
   const registry = new Map();
-  const MAX_WIDTH = 192, MAX_HEIGHT = 112, MAX_PALETTES = 8, MAX_SYMBOLS = 64, MAX_TIME_STOPS = 48;
+  const MAX_WIDTH = 192, MAX_HEIGHT = 112, MAX_PALETTES = 8, MAX_SYMBOLS = 64, MAX_TIME_STOPS = 48, MAX_ASSETS = 24, MAX_LAYERS = 16, MAX_TOTAL_CELLS = 430080;
   const ID_RE = /^[a-z0-9][a-z0-9._-]{1,62}[a-z0-9]$/;
   const COLOR_RE = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
   const SYMBOL_RE = /^[\x20-\x7E]$/;
@@ -24,8 +24,10 @@
   function validateScene(input) {
     const errors = [];
     if (!isPlainObject(input)) return { valid:false, errors:['Scene manifest must be a plain object.'] };
-    unknownKeys(input, new Set(['schemaVersion','id','name','author','license','canvas','pixels','palettes','timeCycle']), 'manifest', errors);
-    if (input.schemaVersion !== 1) errors.push('schemaVersion must be 1.');
+    unknownKeys(input, new Set(['schemaVersion','id','name','author','license','canvas','pixels','palettes','timeCycle','assets','layers']), 'manifest', errors);
+    if (input.schemaVersion !== 1 && input.schemaVersion !== 2) errors.push('schemaVersion must be 1 or 2.');
+    if (input.schemaVersion === 1 && (input.assets !== undefined || input.layers !== undefined)) errors.push('assets and layers require schemaVersion 2.');
+    if (input.schemaVersion !== 1 && input.schemaVersion !== 2) errors.push('schemaVersion must be 1 or 2.');
     if (typeof input.id !== 'string' || !ID_RE.test(input.id)) errors.push('id must be 3-64 lowercase letters, numbers, dots, underscores or hyphens.');
     if (BUILT_INS.has(input.id)) errors.push('Built-in scene IDs are reserved.');
     if (typeof input.name !== 'string' || !input.name.trim() || input.name.length > 80) errors.push('name must be a non-empty string of at most 80 characters.');
@@ -65,6 +67,49 @@
         }
       });
     }
+    const assets = input.assets;
+    if (input.schemaVersion === 2) {
+      if (!isPlainObject(assets) || Object.keys(assets).length < 1) errors.push('schemaVersion 2 requires at least one named pixel asset.');
+      else {
+        const names = Object.keys(assets);
+        if (names.length > MAX_ASSETS) errors.push('assets may contain at most 24 pixel assets.');
+        names.forEach(name => {
+          const asset = assets[name];
+          if (!/^[a-z0-9][a-z0-9._-]{0,47}$/.test(name)) errors.push('Asset names must be lowercase identifiers.');
+          if (!isPlainObject(asset)) { errors.push('Asset "' + name + '" must be an object.'); return; }
+          unknownKeys(asset, new Set(['width','height','pixels']), 'assets.' + name, errors);
+          if (!Number.isInteger(asset.width) || asset.width < 1 || asset.width > MAX_WIDTH) errors.push('Asset "' + name + '" width must be 1-192.');
+          if (!Number.isInteger(asset.height) || asset.height < 1 || asset.height > MAX_HEIGHT) errors.push('Asset "' + name + '" height must be 1-112.');
+          if (!Array.isArray(asset.pixels) || asset.pixels.length !== asset.height) errors.push('Asset "' + name + '" pixels must match its height.');
+          else asset.pixels.forEach((row,index) => {
+            if (typeof row !== 'string' || row.length !== asset.width || !Array.from(row).every(symbol => SYMBOL_RE.test(symbol))) errors.push('Asset "' + name + '" row ' + index + ' must be printable ASCII and match its width.');
+          });
+        });
+      }
+      if (!Array.isArray(input.layers) || input.layers.length < 1 || input.layers.length > MAX_LAYERS) errors.push('layers must contain 1-16 layer definitions.');
+      else input.layers.forEach((layer,index) => {
+        if (!isPlainObject(layer)) { errors.push('layers[' + index + '] must be an object.'); return; }
+        unknownKeys(layer, new Set(['id','asset','x','y','animation']), 'layers[' + index + ']', errors);
+        if (typeof layer.id !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,47}$/.test(layer.id)) errors.push('layers[' + index + '].id must be a lowercase identifier.');
+        if (!isPlainObject(assets) || typeof layer.asset !== 'string' || !Object.prototype.hasOwnProperty.call(assets,layer.asset)) errors.push('layers[' + index + '] references an unknown asset.');
+        if (!Number.isInteger(layer.x) || layer.x < -MAX_WIDTH || layer.x > MAX_WIDTH) errors.push('layers[' + index + '].x must be an integer from -192 to 192.');
+        if (!Number.isInteger(layer.y) || layer.y < -MAX_HEIGHT || layer.y > MAX_HEIGHT) errors.push('layers[' + index + '].y must be an integer from -112 to 112.');
+        if (layer.animation !== undefined) {
+          const animation = layer.animation;
+          if (!isPlainObject(animation)) errors.push('layers[' + index + '].animation must be an object.');
+          else {
+            unknownKeys(animation,new Set(['type','axis','speed','distance','phase']),'layers[' + index + '].animation',errors);
+            if (animation.type !== 'drift' && animation.type !== 'bob') errors.push('Animation type must be drift or bob.');
+            if (animation.axis !== 'x' && animation.axis !== 'y') errors.push('Animation axis must be x or y.');
+            if (!Number.isFinite(animation.speed) || animation.speed < 0 || animation.speed > 4) errors.push('Animation speed must be between 0 and 4.');
+            if (!Number.isInteger(animation.distance) || animation.distance < 1 || animation.distance > 64) errors.push('Animation distance must be an integer from 1 to 64.');
+            if (animation.phase !== undefined && (!Number.isFinite(animation.phase) || animation.phase < 0 || animation.phase > 6.2832)) errors.push('Animation phase must be between 0 and 2π.');
+          }
+        }
+      });
+      const totalCells = Object.values(assets || {}).reduce((sum,asset) => sum + (asset && Number.isInteger(asset.width) && Number.isInteger(asset.height) ? asset.width * asset.height : 0),0);
+      if (totalCells > MAX_TOTAL_CELLS) errors.push('Total pixel asset area exceeds the scene budget.');
+    }
     const timeCycle = input.timeCycle;
     if (!Array.isArray(timeCycle) || timeCycle.length < 2) errors.push('timeCycle must contain at least two time stops.');
     else {
@@ -83,6 +128,7 @@
     if (Array.isArray(input.pixels) && isPlainObject(palettes)) {
       const symbols = new Set();
       input.pixels.forEach(row => { if (typeof row === 'string') for (const symbol of row) symbols.add(symbol); });
+      if (input.schemaVersion === 2 && isPlainObject(assets)) Object.values(assets).forEach(asset => { if (asset && Array.isArray(asset.pixels)) asset.pixels.forEach(row => { if (typeof row === 'string') for (const symbol of row) symbols.add(symbol); }); });
       if (symbols.size > MAX_SYMBOLS) errors.push('pixels cannot use more than 64 unique symbols.');
       Object.keys(palettes).forEach(name => {
         const palette = palettes[name];

package/schemas/scene-manifest.v2.schema.json

@@ -0,0 +1,229 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://gsvegetable.github.io/pixel-daylight-switch/schemas/scene-manifest.v2.schema.json",
+  "title": "Pixel Daylight Switch Scene Manifest v2",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "id",
+    "name",
+    "author",
+    "license",
+    "canvas",
+    "pixels",
+    "palettes",
+    "timeCycle",
+    "assets",
+    "layers"
+  ],
+  "properties": {
+    "schemaVersion": {
+      "const": 2
+    },
+    "id": {
+      "type": "string",
+      "minLength": 3,
+      "maxLength": 64,
+      "pattern": "^[a-z0-9][a-z0-9._-]{1,62}[a-z0-9]$"
+    },
+    "name": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 80
+    },
+    "author": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 80
+    },
+    "license": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 64
+    },
+    "canvas": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "width",
+        "height"
+      ],
+      "properties": {
+        "width": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 192
+        },
+        "height": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 112
+        }
+      }
+    },
+    "pixels": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 112,
+      "items": {
+        "type": "string",
+        "minLength": 1,
+        "maxLength": 192,
+        "pattern": "^[\\x20-\\x7E]+$"
+      }
+    },
+    "palettes": {
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 8,
+      "additionalProperties": {
+        "type": "object",
+        "maxProperties": 64,
+        "propertyNames": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 1,
+          "pattern": "^[\\u0020-\\u007E]$"
+        },
+        "additionalProperties": {
+          "type": "string",
+          "pattern": "^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$"
+        }
+      }
+    },
+    "timeCycle": {
+      "type": "array",
+      "minItems": 2,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "at",
+          "palette"
+        ],
+        "properties": {
+          "at": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 24
+          },
+          "palette": {
+            "type": "string"
+          }
+        }
+      },
+      "maxItems": 48
+    },
+    "assets": {
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 24,
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "width",
+          "height",
+          "pixels"
+        ],
+        "properties": {
+          "width": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 192
+          },
+          "height": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 112
+          },
+          "pixels": {
+            "type": "array",
+            "minItems": 1,
+            "maxItems": 112,
+            "items": {
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 192,
+              "pattern": "^[\\x20-\\x7E]+$"
+            }
+          }
+        }
+      }
+    },
+    "layers": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 16,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "id",
+          "asset",
+          "x",
+          "y"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[a-z0-9][a-z0-9._-]{0,47}$"
+          },
+          "asset": {
+            "type": "string"
+          },
+          "x": {
+            "type": "integer",
+            "minimum": -192,
+            "maximum": 192
+          },
+          "y": {
+            "type": "integer",
+            "minimum": -112,
+            "maximum": 112
+          },
+          "animation": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "type",
+              "axis",
+              "speed",
+              "distance"
+            ],
+            "properties": {
+              "type": {
+                "enum": [
+                  "drift",
+                  "bob"
+                ]
+              },
+              "axis": {
+                "enum": [
+                  "x",
+                  "y"
+                ]
+              },
+              "speed": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 4
+              },
+              "distance": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 64
+              },
+              "phase": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 6.2832
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}