@gg-web-engine/core 0.0.58 → 0.0.60

package/dist/base/level-loader.js

@@ -0,0 +1,258 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { GroupEntity } from './entities/group.entity';
+import { IEntity, TickOrder } from './entities/i-entity';
+import { Blueprint } from './blueprint/blueprint';
+import { RemoveEntityBlueprintNode } from './blueprint/nodes/remove-entity.node';
+/**
+ * Base class for level loaders: parses a {@link LevelJson} document into world entities by
+ * dispatching each `EntityJson.class` to a generator function registered with {@link registerClass}.
+ *
+ * A generator is required to return an `IEntity`. Every `IEntity` a generator produces is parented
+ * under one {@link GroupEntity} per `loadLevel`/`loadLevelFromUrl` call (added to the world
+ * immediately, and handed back once loading completes) - so a whole level can be torn down in one
+ * shot with `world.removeEntity(level, true)`, which cascades removal/disposal to every child, and
+ * any named entity can be found afterwards with `level.getChildEntityByName(name)`. If a generator
+ * returns anything other than an `IEntity` (including `null`/`undefined`), `loadLevel` logs a
+ * `console.warn` and skips that entity - it's never parented, named, or tracked.
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ */
+export class LevelLoader {
+    /**
+     * Constructor
+     * @param world - The world instance
+     */
+    constructor(world) {
+        this.world = world;
+        /**
+         * Map of class aliases to generator functions
+         */
+        this.generators = new Map();
+        /**
+         * Map of blueprint node type aliases to node factory functions - see {@link registerBlueprintNode}.
+         */
+        this.blueprintNodes = new Map();
+        /**
+         * Map of blueprint node type aliases to their default input pin name, for node types registered
+         * with one - see {@link registerBlueprintNode}.
+         */
+        this.blueprintNodeDefaultInputs = new Map();
+        this.registerBlueprintNode('RemoveEntity', (w, settings) => new RemoveEntityBlueprintNode(w, settings), 'entity');
+    }
+    /**
+     * Register a generator function for a class alias
+     * @param classAlias - The class alias
+     * @param generator - The generator function
+     */
+    registerClass(classAlias, generator) {
+        this.generators.set(classAlias, generator);
+    }
+    /**
+     * Register a {@link BlueprintNode} factory for a node type alias, so a `BlueprintJson`'s
+     * `nodes` can reference it by `type` (e.g. the built-in `"RemoveEntity"`, registered by every
+     * `LevelLoader` out of the box). Same pattern as {@link registerClass}, one level down (node
+     * types within a blueprint graph, rather than entity classes within a level).
+     * @param typeAlias - The node type alias
+     * @param factory - Builds a node instance from its baked-in settings
+     * @param defaultInputPin - This node type's sole "trigger me" input pin name, if it has one
+     * canonical one (e.g. `"RemoveEntity"`'s `"entity"`). Enables the node type to be used directly
+     * as an `EntityJson.events` binding (`{ "eventName": "TypeAlias" }` or
+     * `{ "eventName": { "type": "TypeAlias", "settings": {...} } }`) without declaring a full
+     * `BlueprintJson` graph in `blueprints` - see {@link EntityEventBinding}. Omit for a node type
+     * with zero or multiple input pins, or one with no single obviously-correct default; it remains
+     * usable from a full graph either way.
+     */
+    registerBlueprintNode(typeAlias, factory, defaultInputPin) {
+        this.blueprintNodes.set(typeAlias, factory);
+        if (defaultInputPin !== undefined) {
+            this.blueprintNodeDefaultInputs.set(typeAlias, defaultInputPin);
+        }
+        else {
+            this.blueprintNodeDefaultInputs.delete(typeAlias);
+        }
+    }
+    /**
+     * Load a level from an already-parsed JSON document. Every `IEntity` the level's entities
+     * produce is parented under - and, on failure, torn down along with - the returned
+     * {@link GroupEntity}, already added to the world.
+     * @param levelJson - The level JSON
+     * @param levelName - Optional name for the returned group entity (e.g. so a debugger/console
+     * listing entities by name shows something more meaningful than the default auto-generated one)
+     * @returns The level's root group entity
+     */
+    loadLevel(levelJson, levelName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const level = new GroupEntity();
+            if (levelName !== undefined) {
+                level.name = levelName;
+            }
+            this.world.addEntity(level);
+            try {
+                for (const entityJson of levelJson.entities) {
+                    const { class: classAlias, shape, position, rotation, name, config, events } = entityJson;
+                    const generator = this.generators.get(classAlias);
+                    if (!generator) {
+                        console.warn(`No generator registered for class alias "${classAlias}"`);
+                        continue;
+                    }
+                    const settings = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (config !== null && config !== void 0 ? config : {})), (shape !== undefined ? { shape } : {})), (position !== undefined ? { position } : {})), (rotation !== undefined ? { rotation } : {})), (name !== undefined ? { name } : {}));
+                    const entity = yield generator(this.world, settings);
+                    if (!(entity instanceof IEntity)) {
+                        console.warn(`Generator for class alias "${classAlias}" did not return an IEntity - skipping`);
+                        continue;
+                    }
+                    if (name !== undefined) {
+                        entity.name = name;
+                    }
+                    // addChildren reparents the entity under level regardless of whether a generator already
+                    // self-added it to the world (e.g. addPrimitiveRigidBody does) - safe either way.
+                    level.addChildren(entity);
+                    if (events) {
+                        for (const [eventName, eventBinding] of Object.entries(events)) {
+                            const bindingEntity = this.bindEvent(entity, eventName, eventBinding, levelJson.blueprints);
+                            if (bindingEntity) {
+                                level.addChildren(bindingEntity);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                // Don't leave a partially-loaded level (and its already-spawned entities) behind if a
+                // generator throws partway through - the caller never gets `level` back to clean it up itself.
+                this.world.removeEntity(level, true);
+                throw e;
+            }
+            return level;
+        });
+    }
+    /**
+     * Resolve `eventBinding` (see {@link EntityEventBinding}) to a `BlueprintJson`, instantiate a
+     * fresh `Blueprint` from it, and subscribe it to `entity[eventName]` so every value that
+     * observable emits triggers the blueprint's `"in"` entry point. Wrapped in a
+     * `BlueprintBindingEntity` so the subscription (and the blueprint's own node state) is torn down
+     * automatically once that entity is disposed - the caller parents the returned entity under the
+     * level's group for that reason.
+     * @param entity - The entity carrying the observable property
+     * @param eventName - Name of the observable property on `entity`
+     * @param eventBinding - What to run - a `blueprints` name, a bare node type alias, or `{ type,
+     * settings? }`
+     * @param blueprints - The level's top-level blueprint map, if any
+     * @returns The binding entity to parent under the level, or `undefined` if `eventBinding`
+     * couldn't be resolved or the named property isn't an `Observable` (both logged via
+     * `console.warn`)
+     */
+    bindEvent(entity, eventName, eventBinding, blueprints) {
+        const blueprintJson = this.resolveEventBlueprint(eventName, eventBinding, blueprints);
+        if (!blueprintJson) {
+            return undefined;
+        }
+        const observable = entity[eventName];
+        if (!observable || typeof observable.subscribe !== 'function') {
+            console.warn(`Entity has no observable property "${eventName}" to bind a blueprint to`);
+            return undefined;
+        }
+        const blueprint = new Blueprint(this.world, blueprintJson, this.blueprintNodes);
+        return new BlueprintBindingEntity(blueprint, observable);
+    }
+    /**
+     * Turn an `EntityEventBinding` into a `BlueprintJson` to run. An object form (`{ type,
+     * settings? }`) always builds a single-node inline graph via {@link inlineNodeBlueprint}. A
+     * string form is tried first as a key into `blueprints` (a named, possibly multi-node graph),
+     * then - if not found there - as a bare node type alias, same as the object form with no
+     * settings.
+     * @param eventName - Name of the observable property being bound, for warning messages
+     * @param eventBinding - The binding to resolve
+     * @param blueprints - The level's top-level blueprint map, if any
+     * @returns The resolved graph, or `undefined` (logged via `console.warn`) if it couldn't be
+     */
+    resolveEventBlueprint(eventName, eventBinding, blueprints) {
+        if (typeof eventBinding === 'object') {
+            return this.inlineNodeBlueprint(eventName, eventBinding.type, eventBinding.settings);
+        }
+        const named = blueprints === null || blueprints === void 0 ? void 0 : blueprints[eventBinding];
+        if (named) {
+            return named;
+        }
+        if (this.blueprintNodes.has(eventBinding)) {
+            return this.inlineNodeBlueprint(eventName, eventBinding, undefined);
+        }
+        console.warn(`No blueprint or blueprint node type named "${eventBinding}" found for event "${eventName}" - skipping`);
+        return undefined;
+    }
+    /**
+     * Build a single-node `BlueprintJson` wrapping one blueprint node type, wired so the node's
+     * registered default input pin (see {@link registerBlueprintNode}) is reachable as `"in"` - what
+     * powers the `EntityEventBinding` shorthand that skips declaring a `blueprints` entry entirely.
+     * @param eventName - Name of the observable property being bound, for warning messages
+     * @param nodeType - The blueprint node type alias
+     * @param settings - Settings to bake into the node, if any
+     * @returns The single-node graph, or `undefined` (logged via `console.warn`) if `nodeType` isn't
+     * registered, or was registered without a default input pin
+     */
+    inlineNodeBlueprint(eventName, nodeType, settings) {
+        if (!this.blueprintNodes.has(nodeType)) {
+            console.warn(`No blueprint node type registered for "${nodeType}" (event "${eventName}") - skipping`);
+            return undefined;
+        }
+        const inputPin = this.blueprintNodeDefaultInputs.get(nodeType);
+        if (!inputPin) {
+            console.warn(`Blueprint node type "${nodeType}" has no default input pin registered - event "${eventName}" must ` +
+                `reference a full graph declared in "blueprints" instead, addressing the desired pin explicitly`);
+            return undefined;
+        }
+        return {
+            nodes: [{ id: 'n1', type: nodeType, settings }],
+            inputs: { in: { node: 'n1', pin: inputPin } },
+        };
+    }
+    /**
+     * Fetch a level JSON document hosted at `url` and load it, so a whole level/scene can be
+     * shipped and consumed as a single static JSON file.
+     * @param url - URL (or path) of the level JSON document
+     * @param levelName - Optional name for the returned group entity, see {@link loadLevel}
+     * @returns The level's root group entity
+     */
+    loadLevelFromUrl(url, levelName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to load level JSON from "${url}": ${response.status} ${response.statusText}`);
+            }
+            const levelJson = yield response.json();
+            return this.loadLevel(levelJson, levelName);
+        });
+    }
+}
+/**
+ * Plain do-nothing `IEntity` that owns one event-to-blueprint binding created by
+ * `LevelLoader.bindEvent`: subscribes to the bound observable on construction, and unsubscribes
+ * plus disposes the `Blueprint` on `dispose()`. Parented under the level's group entity like any
+ * other level-produced entity, so `world.removeEntity(level, true)` tears the binding down along
+ * with the rest of the level - there is nothing else app code needs to do to clean it up.
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ */
+class BlueprintBindingEntity extends IEntity {
+    constructor(blueprint, observable) {
+        super();
+        this.blueprint = blueprint;
+        this.tickOrder = TickOrder.CONTROLLERS;
+        this.subscription = observable.subscribe(value => this.blueprint.trigger('in', value));
+    }
+    dispose() {
+        this.subscription.unsubscribe();
+        this.blueprint.dispose();
+        super.dispose();
+    }
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.0.58";
+export declare const VERSION = "0.0.60";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.0.58';
+export const VERSION = '0.0.60';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/core",
-  "version": "0.0.58",
+  "version": "0.0.60",
   "description": "An attempt to create open source game engine for browser",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,17 +28,18 @@
   },
   "homepage": "https://github.com/AndyGura/gg-web-engine#readme",
   "dependencies": {
-    "rxjs": "7.8.1",
+    "rxjs": "7.8.2",
     "stats.js": "0.17.0"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.12",
-    "@types/stats.js": "^0.17.3",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "prettier": "^3.3.3",
-    "ts-jest": "^29.2.4",
-    "typescript": "~5.5.4"
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.4.0",
+    "@types/stats.js": "^0.17.4",
+    "jest": "^30.5.0",
+    "jest-environment-jsdom": "^30.5.0",
+    "prettier": "^3.9.6",
+    "ts-jest": "^29.4.12",
+    "typescript": "~6.0.3"
   },
   "jest": {
     "moduleFileExtensions": [

package/tsconfig.json

@@ -2,7 +2,10 @@
   "extends": "./../../tsconfig.base.json",
   "compilerOptions": {
     "baseUrl": "./src/",
-    "outDir": "./dist/"
+    "outDir": "./dist/",
+    "rootDir": "./src/",
+    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo",
+    "types": ["jest", "node"]                            /* TS6 no longer auto-includes every @types/* package found by walking up typeRoots when "types" is unset (TS5 did) — declare what test code under test/ actually needs (jest globals, Node's `global`) explicitly rather than relying on the old implicit-hoisting behavior. */
   },
   "include": ["*.ts", "**/*.ts"],
   "exclude": ["**/*.spec.ts", "node_modules", "dist/**/*", "test/**/*"]

package/blender_exporter/build_blender_scene.py

@@ -1,179 +0,0 @@
-import os
-import sys
-import tempfile
-
-from string import Template
-
-__blender_script_template = Template("""
-import bpy
-import json
-import os
-from rna_prop_ui import rna_idprop_value_to_python
-
-
-def parse_curve_obj(object):
-    curve = bpy.data.curves[object.data.name]
-    spline = curve.splines[0]
-    is_cyclic = spline.use_cyclic_u
-    points = list(map(lambda p: {
-        "x": p.co.x + object.location.x,
-        "y": p.co.y + object.location.y,
-        "z": p.co.z + object.location.z
-    }, spline.points))
-    return {
-        "name": object.name,
-        "cyclic": is_cyclic,
-        "points": points,
-        **{x: rna_idprop_value_to_python(object[x]) for x in object.keys() if x != '_RNA_UI'}
-    }
-
-def parse_dummy_obj(object):
-    object.rotation_mode = 'QUATERNION'
-    return {
-        "name": object.name,
-        "position": {
-            "x": object.location.x,
-            "y": object.location.y,
-            "z": object.location.z,
-        },
-        "rotation": {
-            "x": object.rotation_quaternion.x,
-            "y": object.rotation_quaternion.y,
-            "z": object.rotation_quaternion.z,
-            "w": object.rotation_quaternion.w,
-        },
-        **{x: object[x] for x in object.keys() if x != '_RNA_UI'}
-    }
-    
-def get_rigid_body_description(obj, export_body_parameters=True):
-    body = obj.rigid_body
-    obj.rotation_mode = 'QUATERNION'
-    meta = {
-        "name": obj.name,
-        "position": { 
-            'x': obj.location.x, 
-            'y': obj.location.y, 
-            'z': obj.location.z,
-        },
-        # FIXME relative rotation
-        "rotation": { 'x': obj.rotation_quaternion.x, 'y': obj.rotation_quaternion.y, 'z': obj.rotation_quaternion.z, 'w': obj.rotation_quaternion.w },
-        "shape": {
-            "shape": body.collision_shape,
-        },
-    }
-    if (export_body_parameters):
-        meta['body'] = {
-            "dynamic": body.type == "ACTIVE",
-            "mass": body.mass,
-            "restitution": body.restitution,
-            "friction": body.friction,
-        }
-    parent = obj.parent
-    while parent:
-        meta['position']['x'] -= parent.location.x
-        meta['position']['y'] -= parent.location.y
-        meta['position']['z'] -= parent.location.z
-        parent = parent.parent
-    meta['position']['x'] = round(meta['position']['x'], 6)
-    meta['position']['y'] = round(meta['position']['y'], 6)
-    meta['position']['z'] = round(meta['position']['z'], 6)
-    if meta['shape']['shape'] == 'SPHERE':
-        meta['shape']['radius'] = max(obj.dimensions.x, obj.dimensions.y, obj.dimensions.z) / 2
-    elif meta['shape']['shape'] == 'BOX':
-        meta['shape']['dimensions'] = { 'x': obj.dimensions.x, 'y': obj.dimensions.y, 'z': obj.dimensions.z }
-    elif meta['shape']['shape'] in ['CONE', 'CYLINDER']:
-        meta['shape']['radius'] = max(obj.dimensions.x, obj.dimensions.y) / 2
-        meta['shape']['height'] = obj.dimensions.z
-    elif meta['shape']['shape'] == 'CAPSULE':
-        meta['shape']['radius'] = max(obj.dimensions.x, obj.dimensions.y) / 2
-        meta['shape']['centersDistance'] = obj.dimensions.z - max(obj.dimensions.x, obj.dimensions.y)
-    elif meta['shape']['shape'] == 'CONVEX_HULL':
-        meta['shape']['vertices'] = [{ 'x': v.co.x, 'y': v.co.y, 'z': v.co.z } for v in obj.data.vertices]
-    elif meta['shape']['shape'] == 'MESH':
-        meta['shape']['vertices'] = [{ 'x': v.co.x, 'y': v.co.y, 'z': v.co.z } for v in obj.data.vertices]
-        import bmesh
-        bm = bmesh.new()
-        bm.from_mesh(obj.data)
-        bmesh.ops.triangulate(bm, faces=bm.faces[:])
-        meta['shape']['faces'] = [[v.index for v in f.verts] for f in bm.faces]
-        bm.free()
-    elif meta['shape']['shape'] == 'COMPOUND':
-        meta['shape']['children'] = [get_rigid_body_description(sub_obj, export_body_parameters=False)
-                                    for sub_obj in bpy.context.scene.objects
-                                    if sub_obj.rigid_body is not None and sub_obj.parent == obj]
-    else:
-        raise NotImplementedError(f'GG does not support exporting rigid body {meta["shape"]["shape"]} shape')
-    return meta
-
-if "$src_file":
-    bpy.ops.wm.open_mainfile(filepath="$src_file")
-
-# compound metadata
-metadata = {"curves": [], "dummies": [], "rigidBodies": []}
-for obj in filter(lambda x: x.type == "CURVE", bpy.data.objects):
-    metadata["curves"].append(parse_curve_obj(obj))
-for obj in filter(lambda x: x.type == "EMPTY", bpy.data.objects):
-    metadata["dummies"].append(parse_dummy_obj(obj))
-
-# saving scene
-for obj in bpy.context.scene.objects:
-    include_in_export = obj.type in ["MESH", "LIGHT", "CURVE"]
-    include_in_glb = not obj.hide_render
-    obj.select_set(state=include_in_export and include_in_glb)
-    if not include_in_export:
-        continue
-    for modifier in obj.modifiers:
-        bpy.ops.object.modifier_apply(modifier=modifier.name)
-    if obj.rigid_body is not None and (obj.parent is None or obj.parent.rigid_body is None or obj.parent.rigid_body.collision_shape != 'COMPOUND'):
-        metadata["rigidBodies"].append(get_rigid_body_description(obj))
-    
-bpy.ops.export_scene.gltf(export_format="GLB",
-                          export_copyright="Gurakl Games",
-                          export_texcoords=True,
-                          export_normals=True,
-                          export_tangents=True,
-                          export_materials='$export_materials',
-                          export_cameras=False,
-                          export_lights=True,
-                          export_extras=True,
-                          export_yup=False,
-                          export_apply=False,
-                          export_animations=False,
-                          use_selection=True,
-                          export_skins=False,
-                          export_morph=False,
-                          filepath="$file_name.glb")
-# saving metadata
-with open("$file_name.meta", 'w') as outfile:
-    json.dump(metadata, outfile)""")
-
-
-def construct_blender_export_script(file_name, src_file="", export_materials="EXPORT") -> str:
-    return __blender_script_template.substitute({
-        'src_file': src_file,
-        'file_name': file_name,
-        'export_materials': export_materials
-    })
-
-if __name__ == "__main__":
-    # will be invoked if this module is being run directly, but not via import
-    skip_textures = sys.argv[1] == '--skip-textures'
-    if skip_textures:
-        files = sys.argv[2:]
-    else:
-        files = sys.argv[1:]
-
-    script = ""
-    for file in files:
-        if file.startswith('./'):
-            file = file[2:]
-        full_path = os.path.join(os.getcwd(), file)
-        script += '\n\n\n' + construct_blender_export_script(src_file=full_path,
-                                                             file_name=full_path[:full_path.rindex('.')],
-                                                             export_materials="NONE" if skip_textures else "EXPORT")
-
-    script_file = tempfile.NamedTemporaryFile(delete=False, mode='w')
-    script_file.write(script)
-    script_file.flush()
-    os.system(f"blender --python {script_file.name} --background")
-    os.unlink(script_file.name)

package/blender_exporter/spherical_to_cube_texture.py

@@ -1,116 +0,0 @@
-import sys
-from math import pi, atan2, hypot, floor, ceil
-
-from PIL import Image
-from numpy import clip, average
-
-
-# get x,y,z coords from out image pixels coords
-# i,j are pixel coords
-# face is face number
-# edge is edge length
-def outImgToXYZ(i, j, face, edge):
-    a = 2.0 * float(i) / edge
-    b = 2.0 * float(j) / edge
-    if face == 0:  # back
-        (x, y, z) = (-1.0, 1.0 - a, 3.0 - b)
-    elif face == 1:  # left
-        (x, y, z) = (a - 3.0, -1.0, 3.0 - b)
-    elif face == 2:  # front
-        (x, y, z) = (1.0, a - 5.0, 3.0 - b)
-    elif face == 3:  # right
-        (x, y, z) = (7.0 - a, 1.0, 3.0 - b)
-    elif face == 4:  # top
-        (x, y, z) = (b - 1.0, a - 5.0, 1.0)
-    elif face == 5:  # bottom
-        (x, y, z) = (5.0 - b, a - 5.0, -1.0)
-    return (x, y, z)
-
-
-# convert using an inverse transformation
-def convertBack(imgIn, imgOut):
-    inSize = imgIn.size
-    outSize = imgOut.size
-    inPix = imgIn.load()
-    outPix = imgOut.load()
-    edge = int(inSize[0] / 4)  # the length of each edge in pixels
-    for i in range(outSize[0]):
-        face = int(i / edge)  # 0 - back, 1 - left 2 - front, 3 - right
-        if face == 2:
-            rng = range(0, edge * 3)
-        else:
-            rng = range(edge, edge * 2)
-
-        for j in rng:
-            if j < edge:
-                face2 = 4  # top
-            elif j >= 2 * edge:
-                face2 = 5  # bottom
-            else:
-                face2 = face
-
-            (x, y, z) = outImgToXYZ(i, j, face2, edge)
-            theta = atan2(y, x)  # range -pi to pi
-            r = hypot(x, y)
-            phi = atan2(z, r)  # range -pi/2 to pi/2
-            # source img coords
-            uf = (2.0 * edge * (theta + pi) / pi)
-            vf = (2.0 * edge * (pi / 2 - phi) / pi)
-            # Use bilinear interpolation between the four surrounding pixels
-            ui = floor(uf)  # coord of pixel to bottom left
-            vi = floor(vf)
-            u2 = ui + 1  # coords of pixel to top right
-            v2 = vi + 1
-            mu = uf - ui  # fraction of way across pixel
-            nu = vf - vi
-            # Pixel values of four corners
-            A = inPix[ui % inSize[0], clip(vi, 0, inSize[1] - 1)]
-            B = inPix[u2 % inSize[0], clip(vi, 0, inSize[1] - 1)]
-            C = inPix[ui % inSize[0], clip(v2, 0, inSize[1] - 1)]
-            D = inPix[u2 % inSize[0], clip(v2, 0, inSize[1] - 1)]
-            # interpolate
-            (r, g, b) = (
-                A[0] * (1 - mu) * (1 - nu) + B[0] * (mu) * (1 - nu) + C[0] * (1 - mu) * nu + D[0] * mu * nu,
-                A[1] * (1 - mu) * (1 - nu) + B[1] * (mu) * (1 - nu) + C[1] * (1 - mu) * nu + D[1] * mu * nu,
-                A[2] * (1 - mu) * (1 - nu) + B[2] * (mu) * (1 - nu) + C[2] * (1 - mu) * nu + D[2] * mu * nu)
-
-            outPix[i, j] = (int(round(r)), int(round(g)), int(round(b)))
-
-
-files = sys.argv[1:]
-for file_name in files:
-    imgIn = Image.open(file_name)
-    width, height = imgIn.size
-    if width < height * 2:
-        imgIn = imgIn.resize((height * 2, height), Image.ANTIALIAS)
-    elif width > height * 2:
-        imgIn = imgIn.resize((width, width / 2), Image.ANTIALIAS)
-    imgOut = Image.new("RGB", (imgIn.size[0], int(imgIn.size[0] * 3 / 4)), "black")
-    convertBack(imgIn, imgOut)
-    # imgOut.save('cubemap.png')
-    # split squares
-    file_extension = ".png"
-
-    name_map = [["", "", "pz", ""],
-                ["ny", "nx", "py", "px"],
-                ["", "", "nz", ""]]
-    rotation = [[0, 0, 180, 0],
-                [0, 90, 180, -90],
-                [0, 0, 0, 0]]
-    width, height = imgOut.size
-
-    cube_size = width / 4
-
-    filelist = []
-    for row in range(3):
-        for col in range(4):
-            if name_map[row][col] != "":
-                sx = cube_size * col
-                sy = cube_size * row
-                fn = file_name[:-4] + '_' + name_map[row][col] + file_extension
-                filelist.append(fn)
-                print("%s --> %s" % (str((sx, sy, sx + cube_size, sy + cube_size)), fn))
-                img = imgOut.crop((sx, sy, sx + cube_size, sy + cube_size))
-                if rotation[row][col]:
-                    img = img.rotate(rotation[row][col])
-                img.save(fn)