@directivegames/genesys.js 3.1.24

package/src/components/voxel/MagicaVoxelLoader.ts

@@ -0,0 +1,184 @@
+// MagicaVoxelLoader.ts
+// -----------------------------------------------------------------------------
+// Lightweight, dependency‑free loader for Ephtracy’s MagicaVoxel *.vox* format.
+// Produces a ready‑to‑render VoxelMesh (see VoxelMesh.ts in the same folder).
+// -----------------------------------------------------------------------------
+import * as THREE from 'three';
+
+import { resolvePath } from '../../storage/projectContext.js';
+import { AssetPath } from '../../storage/storageProvider.js';
+
+import { VoxelMeshComponent } from './VoxelMeshComponent.js';
+
+import type { Palette } from './VoxelMeshComponent.js';
+
+
+/** Orientation mapping from .vox (X,Y,Z) to VoxelMesh (X,Y,Z).
+ *  By default we keep X the same, treat Magica Y (up) as Z (depth) and Z as Y (up) so
+ *  the model stands upright in Three.js’s Y‑up world. Flip to (x,y,z)=>[x,y,z] if you
+ *  prefer original orientation. */
+export type OrientationFn = (x: number, y: number, z: number) => [number, number, number];
+
+export interface MagicaVoxelLoaderOptions {
+  voxelSize?: number;          // world units per voxel (default 1)
+  orientation?: OrientationFn; // coordinate swizzle (see above)
+  material?: THREE.Material;   // material to use for the voxel mesh (default is a basic mesh normal material)
+}
+
+export class MagicaVoxelLoader {
+  /**
+   * Fetches and parses a *.vox* file, returns a VoxelMesh ready to add to the scene.
+   */
+  async load(url: string, opts: MagicaVoxelLoaderOptions = {}): Promise<VoxelMeshComponent> {
+    const path = await resolvePath(AssetPath.fromString(url));
+    const { voxelSize = 1, orientation = defaultOrientation } = opts;
+
+    const buf = await fetch(path.getResolvedPath()).then(r => {
+      if (!r.ok) throw new Error(`Failed to fetch ${url}: ${r.statusText}`);
+      return r.arrayBuffer();
+    });
+
+    const parseBeginTime = performance.now();
+    const { size, voxels, palette } = parseVOX(buf);
+    const parseDurationSeconds = (performance.now() - parseBeginTime) / 1000;
+    console.log(`${url} (${size.x}x${size.y}x${size.z}) parsed in ${parseDurationSeconds} seconds`);
+
+    const [sizeX, sizeY, sizeZ] = orientation(size.x, size.y, size.z);
+
+    const paletteMap: Palette = {};
+    palette.forEach((c, i) => (paletteMap[i + 1] = c)); // Magica indices start at 1
+
+    const voxelMeshComponent = new VoxelMeshComponent({});
+    voxelMeshComponent.initializeVoxel(sizeX, sizeY, sizeZ, voxelSize, paletteMap);
+
+    for (const v of voxels) {
+      const [vx, vy, vz] = orientation(v.x, v.y, v.z);
+      voxelMeshComponent.setVoxel(vx, vy, vz, v.color);
+    }
+    const buildBeginTime = performance.now();
+    voxelMeshComponent.buildMesh(opts.material);
+    const buildDurationSeconds = (performance.now() - buildBeginTime) / 1000;
+    console.log(`${url} (${sizeX}x${sizeY}x${sizeZ}) built in ${buildDurationSeconds} seconds`);
+    return voxelMeshComponent;
+  }
+}
+
+// -----------------------------------------------------------------------------
+// Internal *.vox* parser  (spec v150)
+// -----------------------------------------------------------------------------
+interface VOXModel {
+  size: { x: number; y: number; z: number };
+  voxels: { x: number; y: number; z: number; color: number }[];
+  palette: THREE.Color[];
+}
+
+function parseVOX(buffer: ArrayBuffer): VOXModel {
+  const dv = new DataView(buffer);
+  const text = (o: number) => String.fromCharCode(dv.getUint8(o), dv.getUint8(o + 1), dv.getUint8(o + 2), dv.getUint8(o + 3));
+
+  // Header ----------------------------------------------------------
+  if (text(0) !== 'VOX ') throw new Error('Not a VOX file');
+  const version = dv.getUint32(4, true);
+  if (version !== 150) console.warn(`VOX version ${version} (expected 150)`);
+
+  let ptr = 8;
+  const readChunk = () => {
+    const id = text(ptr); ptr += 4;
+    const size = dv.getUint32(ptr, true); ptr += 4;
+    const childrenSize = dv.getUint32(ptr, true); ptr += 4;
+    const chunkStart = ptr;
+    ptr += size; // skip to children
+    return { id, size, chunkStart, childrenEnd: chunkStart + size + childrenSize };
+  };
+
+  const state: VOXModel = {
+    size: { x: 0, y: 0, z: 0 },
+    voxels: [],
+    palette: defaultPalette.map(c => new THREE.Color(c)),
+  };
+
+  const main = readChunk();
+  if (main.id !== 'MAIN') throw new Error('Invalid VOX: no MAIN chunk');
+  const stop = main.childrenEnd;
+
+  while (ptr < stop) {
+    const { id, size, chunkStart } = readChunk();
+    switch (id) {
+      case 'SIZE': {
+        state.size.x = dv.getInt32(chunkStart, true);
+        state.size.y = dv.getInt32(chunkStart + 4, true);
+        state.size.z = dv.getInt32(chunkStart + 8, true);
+        break;
+      }
+      case 'XYZI': {
+        const n = dv.getUint32(chunkStart, true);
+        let off = chunkStart + 4;
+        for (let i = 0; i < n; i++) {
+          const x = dv.getUint8(off++);
+          const y = dv.getUint8(off++);
+          const z = dv.getUint8(off++);
+          const color = dv.getUint8(off++); // 1‑255
+          state.voxels.push({ x, y, z, color });
+        }
+        break;
+      }
+      case 'RGBA': {
+        let off = chunkStart;
+        for (let i = 0; i < 256; i++) {
+          const r = dv.getUint8(off++);
+          const g = dv.getUint8(off++);
+          const b = dv.getUint8(off++);
+          const a = dv.getUint8(off++); // unused (Magica stores 0 or 255)
+          state.palette[i] = new THREE.Color(r / 255, g / 255, b / 255);
+        }
+        break;
+      }
+      // ignore MATL, nTRN, etc. – static meshes only
+    }
+  }
+  return state;
+}
+
+// -----------------------------------------------------------------------------
+// Helpers & defaults
+// -----------------------------------------------------------------------------
+const defaultOrientation: OrientationFn = (x, y, z) => [x, z, y];
+
+// Original MagicaVoxel default palette (hex, length 256)
+// prettier‑ignore
+const defaultPalette: number[] = [
+  0x00000000,0xffffffff,0xffccffff,0xff99ffff,0xff66ffff,0xff33ffff,0xff00ffff,0xffffccff,
+  0xffccccff,0xff99ccff,0xff66ccff,0xff33ccff,0xff00ccff,0xffff99ff,0xffcc99ff,0xff9999ff,
+  0xff6699ff,0xff3399ff,0xff0099ff,0xffff66ff,0xffcc66ff,0xff9966ff,0xff6666ff,0xff3366ff,
+  0xff0066ff,0xffff33ff,0xffcc33ff,0xff9933ff,0xff6633ff,0xff3333ff,0xff0033ff,0xffff00ff,
+  0xffcc00ff,0xff9900ff,0xff6600ff,0xff3300ff,0xff0000ff,0xffffffcc,0xffccffcc,0xff99ffcc,
+  0xff66ffcc,0xff33ffcc,0xff00ffcc,0xffffcccc,0xffcccccc,0xff99cccc,0xff66cccc,0xff33cccc,
+  0xff00cccc,0xffff99cc,0xffcc99cc,0xff9999cc,0xff6699cc,0xff3399cc,0xff0099cc,0xffff66cc,
+  0xffcc66cc,0xff9966cc,0xff6666cc,0xff3366cc,0xff0066cc,0xffff33cc,0xffcc33cc,0xff9933cc,
+  0xff6633cc,0xff3333cc,0xff0033cc,0xffff00cc,0xffcc00cc,0xff9900cc,0xff6600cc,0xff3300cc,
+  0xff0000cc,0xffffff99,0xffccff99,0xff99ff99,0xff66ff99,0xff33ff99,0xff00ff99,0xffffcc99,
+  0xffcccc99,0xff99cc99,0xff66cc99,0xff33cc99,0xff00cc99,0xffff9999,0xffcc9999,0xff999999,
+  0xff669999,0xff339999,0xff009999,0xffff6699,0xffcc6699,0xff996699,0xff666699,0xff336699,
+  0xff006699,0xffff3399,0xffcc3399,0xff993399,0xff663399,0xff333399,0xff003399,0xffff0099,
+  0xffcc0099,0xff990099,0xff660099,0xff330099,0xff000099,0xffffff66,0xffccff66,0xff99ff66,
+  0xff66ff66,0xff33ff66,0xff00ff66,0xffffcc66,0xffcccc66,0xff99cc66,0xff66cc66,0xff33cc66,
+  0xff00cc66,0xffff9966,0xffcc9966,0xff999966,0xff669966,0xff339966,0xff009966,0xffff6666,
+  0xffcc6666,0xff996666,0xff666666,0xff336666,0xff006666,0xffff3366,0xffcc3366,0xff993366,
+  0xff663366,0xff333366,0xff003366,0xffff0066,0xffcc0066,0xff990066,0xff660066,0xff330066,
+  0xff000066,0xffffff33,0xffccff33,0xff99ff33,0xff66ff33,0xff33ff33,0xff00ff33,0xffffcc33,
+  0xffcccc33,0xff99cc33,0xff66cc33,0xff33cc33,0xff00cc33,0xffff9933,0xffcc9933,0xff999933,
+  0xff669933,0xff339933,0xff009933,0xffff6633,0xffcc6633,0xff996633,0xff666633,0xff336633,
+  0xff006633,0xffff3333,0xffcc3333,0xff993333,0xff663333,0xff333333,0xff003333,0xffff0033,
+  0xffcc0033,0xff990033,0xff660033,0xff330033,0xff000033,0xffffff00,0xffccff00,0xff99ff00,
+  0xff66ff00,0xff33ff00,0xff00ff00,0xffffcc00,0xffcccc00,0xff99cc00,0xff66cc00,0xff33cc00,
+  0xff00cc00,0xffff9900,0xffcc9900,0xff999900,0xff669900,0xff339900,0xff009900,0xffff6600,
+  0xffcc6600,0xff996600,0xff666600,0xff336600,0xff006600,0xffff3300,0xffcc3300,0xff993300,
+  0xff663300,0xff333300,0xff003300,0xffff0000,0xffcc0000,0xff990000,0xff660000,0xff330000,
+  0xff0000ee,0xff0000dd,0xff0000bb,0xff0000aa,0xff000088,0xff000077,0xff000055,0xff000044,
+  0xff000022,0xff000011,0xff110000,0xff220000,0xff440000,0xff550000,0xff770000,0xff880000,
+  0xffaa0000,0xffbb0000,0xffdd0000,0xffee0000,0xffff0000,0xffee1100,0xffdd2200,0xffbb4400,
+  0xffaa5500,0xff885500,0xff774400,0xff553300,0xff442200,0xff221100,0xff113300,0xff225500,
+  0xff447700,0xff559900,0xff66aa00,0xff77bb00,0xff88cc00,0xff99dd00,0xffbbee00,0xffccff00,
+  0xffddff00,0xffeeff00,0xffffff00,0xff0000,
+];
+// -----------------------------------------------------------------------------

package/src/components/voxel/VoxelMeshComponent.ts

@@ -0,0 +1,274 @@
+import * as THREE from 'three';
+
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+
+import type { PrimitiveComponentOptions } from '../PrimitiveComponent.js';
+
+export type Palette = Record<number, THREE.ColorRepresentation>;
+
+export type VoxelState = {
+  sizeX: number;
+  sizeY: number;
+  sizeZ: number;
+  voxelSize: number;
+  voxels: Uint16Array;
+  palette: Palette;
+}
+
+/**
+ * A component that renders a voxel-based mesh.
+ * This component allows for creating, manipulating, and rendering 3D voxel structures
+ * using Three.js for visualization.
+ */
+@EngineClass('VoxelMeshComponent')
+export class VoxelMeshComponent extends PrimitiveComponent {
+  private state?: VoxelState;
+  private mesh: THREE.Mesh;
+
+  static override get DEFAULT_OPTIONS(): PrimitiveComponentOptions {
+    return {
+      ...super.DEFAULT_OPTIONS,
+    };
+  }
+
+  constructor(options: PrimitiveComponentOptions = {}) {
+    super(options);
+
+    this.mesh = new THREE.Mesh(
+      new THREE.BufferGeometry(),
+      new THREE.MeshNormalMaterial()
+    );
+    this.add(this.mesh);
+  }
+
+  /**
+   * Initializes the voxel structure with the specified dimensions and properties.
+   *
+   * @param sizeX - Width of the voxel grid in voxel units
+   * @param sizeY - Height of the voxel grid in voxel units
+   * @param sizeZ - Depth of the voxel grid in voxel units
+   * @param voxelSize - Size of each voxel in world units
+   * @param palette - Color palette mapping voxel IDs to colors
+   */
+  public initializeVoxel(sizeX: number, sizeY: number, sizeZ: number, voxelSize: number, palette: Palette) {
+    this.state = {
+      sizeX,
+      sizeY,
+      sizeZ,
+      voxelSize,
+      voxels: new Uint16Array(sizeX * sizeY * sizeZ),
+      palette,
+    };
+    this.mesh.geometry.dispose();
+  }
+
+  /**
+   * Gets the current voxel state.
+   *
+   * @returns The current voxel state, or undefined if the voxel state is not initialized
+   */
+  public getVoxelState(): VoxelState | undefined {
+    return this.state;
+  }
+
+  /**
+   * Gets the voxel ID at the specified coordinates.
+   *
+   * @param x - X coordinate in the voxel grid
+   * @param y - Y coordinate in the voxel grid
+   * @param z - Z coordinate in the voxel grid
+   * @returns The voxel ID at the specified location, or 0 if the location is invalid
+   */
+  public getVoxel(x: number, y: number, z: number): number {
+    if (!isValidLocation(x, y, z, this.state)) {
+      return 0;
+    }
+    const index = getIndex(x, y, z, this.state, false);
+    return this.state!.voxels[index];
+  }
+
+  /**
+   * Sets the voxel ID at the specified coordinates.
+   *
+   * @param x - X coordinate in the voxel grid
+   * @param y - Y coordinate in the voxel grid
+   * @param z - Z coordinate in the voxel grid
+   * @param id - The voxel ID to set
+   * @returns True if the voxel was set successfully, false if the location is invalid
+   */
+  public setVoxel(x: number, y: number, z: number, id: number): boolean {
+    if (!isValidLocation(x, y, z, this.state)) {
+      return false;
+    }
+    const index = getIndex(x, y, z, this.state, false);
+    this.state!.voxels[index] = id;
+    return true;
+  }
+
+  /**
+   * Builds the mesh representation of the current voxel state.
+   * Uses a greedy meshing algorithm to optimize the geometry.
+   *
+   * @param materialOverride - Optional material to use instead of the default
+   */
+  public buildMesh(materialOverride?: THREE.Material) {
+    if (!this.state) {
+      return;
+    }
+
+    const { geometry, material } = greedyMesh(
+      this.state!.voxels,
+      this.state!.sizeX,
+      this.state!.sizeY,
+      this.state!.sizeZ,
+      this.state!.voxelSize,
+      this.state!.palette,
+      materialOverride ?? this.mesh.material as THREE.Material
+    );
+
+    this.mesh.geometry.dispose();
+    this.mesh.geometry = geometry;
+    this.mesh.material = material;
+  }
+
+  //====================================================================================================
+  // Editor Functions
+  //====================================================================================================
+
+  public override getEditorClassIcon(): string | null {
+    return 'Icon_VoxelMesh';
+  }
+}
+
+//====================================================================================================
+
+function isValidLocation(x: number, y: number, z: number, state?: VoxelState): boolean {
+  if (!state) {
+    return false;
+  }
+  return x >= 0 && y >= 0 && z >= 0 && x < state.sizeX && y < state.sizeY && z < state.sizeZ;
+}
+
+function getIndex(x: number, y: number, z: number, state?: VoxelState, validateLocation: boolean = true): number {
+  if (validateLocation && !isValidLocation(x, y, z, state)) {
+    return 0;
+  }
+  return x + state!.sizeX * (y + state!.sizeY * z);
+}
+
+function greedyMesh(
+  voxels: Uint16Array,
+  sx: number,
+  sy: number,
+  sz: number,
+  scale: number,
+  palette: Palette,
+  material: THREE.Material
+) {
+  const pos: number[] = [];
+  const nrm: number[] = [];
+  const col: number[] = [];
+  const uv: number[] = [];
+  const idx: number[] = [];
+  let vert = 0;
+
+  const dims = [sx, sy, sz] as const;
+  const coord = [0, 0, 0] as number[];
+  const q = [0, 0, 0] as number[];
+
+  for (let d = 0; d < 3; d++) {
+    const u = (d + 1) % 3;
+    const v = (d + 2) % 3;
+    q[0] = q[1] = q[2] = 0; q[d] = 1;
+
+    const mask = new Int32Array(dims[u] * dims[v]);
+
+    for (coord[d] = -1; coord[d] < dims[d]; coord[d]++) {
+      // 1. build mask for current slice
+      let m = 0;
+      for (coord[v] = 0; coord[v] < dims[v]; coord[v]++) {
+        for (coord[u] = 0; coord[u] < dims[u]; coord[u]++, m++) {
+          const a = sample(coord[0], coord[1], coord[2]);
+          coord[d] += 1;
+          const b = sample(coord[0], coord[1], coord[2]);
+          coord[d] -= 1;
+          mask[m] = a && b ? 0 : a ? a : -b;
+        }
+      }
+
+      // 2. generate quads
+      for (let j = 0; j < dims[v]; j++) {
+        for (let i = 0; i < dims[u];) {
+          const c = mask[j * dims[u] + i];
+          if (!c) { i++; continue; }
+
+          // width & height
+          let w = 1; while (i + w < dims[u] && mask[j * dims[u] + i + w] === c) w++;
+          let h = 1; outer: for (; j + h < dims[v]; h++) {
+            for (let k = 0; k < w; k++)
+              if (mask[(j + h) * dims[u] + i + k] !== c) break outer;
+          }
+
+          // zero mask
+          for (let jj = 0; jj < h; jj++)
+            for (let ii = 0; ii < w; ii++)
+              mask[(j + jj) * dims[u] + i + ii] = 0;
+
+          const du = [0, 0, 0]; du[u] = w;
+          const dv = [0, 0, 0]; dv[v] = h;
+          const x0 = [coord[0], coord[1], coord[2]]; x0[u] = i; x0[v] = j;
+
+          // corners
+          const p0 = world(add(x0, q));
+          const p1 = world(add(add(x0, q), du));
+          const p2 = world(add(add(add(x0, q), du), dv));
+          const p3 = world(add(add(x0, q), dv));
+
+          // outward normal
+          const normal = [0, 0, 0]; normal[d] = c > 0 ? 1 : -1;
+          const colour = new THREE.Color(palette[Math.abs(c)] ?? 0xffffff).toArray();
+
+          if (c > 0) {
+            // CCW when looking along +d
+            pushQuad(p0, p1, p2, p3, normal, colour);
+          } else {
+            // CCW when looking along –d (reverse order)
+            pushQuad(p0, p3, p2, p1, normal, colour);
+          }
+
+          i += w;
+        }
+      }
+    }
+  }
+
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+  geometry.setAttribute('normal', new THREE.Float32BufferAttribute(nrm, 3));
+  geometry.setAttribute('color', new THREE.Float32BufferAttribute(col, 3));
+  geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+  geometry.setIndex(idx);
+  geometry.computeBoundingSphere();
+
+  return { geometry, material };
+
+  // ------------------------- helpers -------------------------
+  function pushQuad(a: number[], b: number[], c: number[], d: number[], N: number[], C: number[]) {
+    pos.push(...a, ...b, ...c, ...a, ...c, ...d);
+    nrm.push(...repeat(N, 6));
+    col.push(...repeat(C, 6));
+    uv.push(0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1);
+    idx.push(vert, vert + 1, vert + 2, vert + 3, vert + 4, vert + 5);
+    vert += 6;
+  }
+
+  function sample(x: number, y: number, z: number) {
+    if (x < 0 || y < 0 || z < 0 || x >= sx || y >= sy || z >= sz) return 0;
+    return voxels[x + sx * (y + sy * z)];
+  }
+
+  function add(a: number[], b: number[]) { return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; }
+  function world(v: number[]) { return [v[0] * scale, v[1] * scale, v[2] * scale]; }
+  function repeat(arr: number[] | number, n: number) { return typeof arr === 'number' ? Array(n).fill(arr) : Array(n).fill(arr).flat(); }
+}

package/src/components/voxel/index.ts

@@ -0,0 +1,3 @@
+export * from './VoxelMeshComponent.js';
+export * from './MagicaVoxelLoader.js';
+

package/src/const.ts

@@ -0,0 +1,68 @@
+/**
+ * GameConstants collect baseline values for player actors and world geometry.
+ *
+ * Detailed explanation:
+ * - Supplies standard dimensions, masses, and speeds tuned for Genesys demos.
+ * - Used across character controllers, physics, and camera setup to maintain
+ *   coherent scaling in example scenes.
+ * - Centralizing these numbers prevents magic values from scattering through
+ *   the codebase and clarifies the expected unit system.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Import specific constants when configuring custom components or gameplay
+ *   scripts so behaviors align with the rest of the engine.
+ * - Override carefully if your game has very different proportions or
+ *   movement, keeping in mind many sample systems assume these defaults.
+ */
+export const CHARACTER_HEIGHT = 1.8;
+export const CHARACTER_WIDTH = 0.9;
+export const CHARACTER_MASS = 10;
+export const CHARACTER_MAX_SPEED = 5;
+export const CHARACTER_JUMP_SPEED = 20;
+export const GROUND_SIZE = 500;
+export const GROUND_UV_TILES_PER_UNIT = 0.2;
+export const CAMERA_FOV = 60;
+export const CAMERA_NEAR = 0.1;
+export const CAMERA_FAR = 2000;
+
+// Time to live for net objects, in seconds
+export const NET_OBJECT_TTL_SEC = 30;
+export const NET_HEARTBEAT_INTERVAL_SEC = 5;
+export const NET_PING_INTERVAL_SEC = 1;
+
+export const SerializationVersion = {
+  Legacy: 0,
+  V1: 1,
+} as const;
+export type SerializationVersion = typeof SerializationVersion[keyof typeof SerializationVersion];
+export const CurrentSerializationVersion: SerializationVersion = SerializationVersion.V1;
+
+/***
+ * Below are constants not necessarily used by the engine code but they're defined here to be easily shared between downstream projects
+ */
+export const PROJECT_PATH_PREFIX: string = '@project';
+export const ENGINE_PATH_PREFIX: string = '@engine';
+export const DEFAULT_GAME_NAME: string = 'game.ts';
+export const DEFAULT_GAME_BUNDLE_NAME: string = 'game.js';
+export const BUILT_PROJECT_FOLDER: string = '.dist';
+export const GAME_PROJECT_FILE_EXT: string = '.genesys-project';
+export const DEFAULT_SCENE_KEY: string = 'defaultScene';
+export const DEFAULT_EDITOR_SCENE_KEY: string = 'defaultEditorScene';
+export const ENGINE_VERSION_KEY: string = 'engineVersion';
+export const ASSETS_FOLDER: string = 'assets';
+export const SCENE_NAME_EXT: string = '.genesys-scene';
+export const LIGHTMAP_JSON_EXT: string = '.lightmap.json';
+export const LIGHTMAP_BIN_EXT: string = '.lightmap';
+export const NAVMESH_EXT: string = '.navmesh';
+export const DEFAULT_SCENE_NAME = `default${SCENE_NAME_EXT}`;
+
+export const PREFAB_EXTENSION = '.prefab.json';
+export const MATERIAL_EXTENSION = '.material.json';
+export const VFX_EXTENSION = '.vfx.json';
+export const SKELETON_PROFILE_EXTENSION = '.skeleton-profile.json';
+
+export const UNDEFINED_VALUE = '_udf_';
+
+export const ENABLE_LIGHTMAPS = false;
+export const TEXTURE_EXTENSION: string = '.texture.json';
+export const DISABLE_TEXTURE_FLIP = true;