@gg-web-engine/core 0.0.59 → 0.0.60

package/dist/2d/gg-2d-world.js

@@ -37,6 +37,59 @@ export class Gg2dWorld extends GgWorld {
     }
     registerConsoleCommands(ggstatic) {
         super.registerConsoleCommands(ggstatic);
+        ggstatic.registerConsoleCommand(this, 'set_position', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [name, x, y] = args;
+            if (!name) {
+                throw new Error('usage: set_position <name> <x> <y>');
+            }
+            const entity = this.getEntityByName(name);
+            if (!('position' in entity)) {
+                throw new Error(`Entity "${name}" (${entity.constructor.name}) has no position`);
+            }
+            if ([x, y].some(v => v === undefined || isNaN(+v))) {
+                throw new Error('usage: set_position <name> <x> <y>');
+            }
+            entity.position = { x: +x, y: +y };
+            return JSON.stringify(entity.position);
+        }), 'args: [ string, float, float ]; Teleport a named entity to world-space coordinates. Use ' +
+            '"entities"/"entity <name>" to find entity names and their current position');
+        ggstatic.registerConsoleCommand(this, 'set_rotation', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [name, angle] = args;
+            if (!name) {
+                throw new Error('usage: set_rotation <name> <angleRadians>');
+            }
+            const entity = this.getEntityByName(name);
+            if (!('rotation' in entity)) {
+                throw new Error(`Entity "${name}" (${entity.constructor.name}) has no rotation`);
+            }
+            if (angle === undefined || isNaN(+angle)) {
+                throw new Error('usage: set_rotation <name> <angleRadians>');
+            }
+            entity.rotation = +angle;
+            return JSON.stringify(entity.rotation);
+        }), 'args: [ string, float ]; Rotate a named entity to the given angle, in radians');
+        ggstatic.registerConsoleCommand(this, 'spawn', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [shapeArg, x, y, dynamicArg] = args;
+            if ([x, y].some(v => v === undefined || isNaN(+v))) {
+                throw new Error('usage: spawn <SQUARE|CIRCLE> <x> <y> [dynamic=0|1]');
+            }
+            const dynamic = dynamicArg === undefined ? true : dynamicArg === '1';
+            let shape;
+            switch ((shapeArg || '').toUpperCase()) {
+                case 'SQUARE':
+                    shape = { shape: 'SQUARE', dimensions: { x: 1, y: 1 } };
+                    break;
+                case 'CIRCLE':
+                    shape = { shape: 'CIRCLE', radius: 0.5 };
+                    break;
+                default:
+                    throw new Error(`Unknown shape "${shapeArg}". Use SQUARE|CIRCLE`);
+            }
+            const entity = this.addPrimitiveRigidBody({ shape, body: { dynamic } }, { x: +x, y: +y });
+            return `spawned "${entity.name}" (${shape.shape}) at ${JSON.stringify(entity.position)}`;
+        }), 'args: [ SQUARE|CIRCLE, float, float, 0|1? ]; Spawn a default-sized primitive rigid body at ' +
+            'world-space coordinates, for probing physics. dynamic (last arg) defaults to 1 (falls ' +
+            'under gravity); pass 0 for a static prop');
         if (this.physicsWorld) {
             ggstatic.registerConsoleCommand(this, 'gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
                 if (args.length == 1) {

package/dist/3d/gg-3d-world.js

@@ -37,6 +37,79 @@ export class Gg3dWorld extends GgWorld {
     }
     registerConsoleCommands(ggstatic) {
         super.registerConsoleCommands(ggstatic);
+        ggstatic.registerConsoleCommand(this, 'set_position', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [name, x, y, z] = args;
+            if (!name) {
+                throw new Error('usage: set_position <name> <x> <y> <z>');
+            }
+            const entity = this.getEntityByName(name);
+            if (!('position' in entity)) {
+                throw new Error(`Entity "${name}" (${entity.constructor.name}) has no position`);
+            }
+            if ([x, y, z].some(v => v === undefined || isNaN(+v))) {
+                throw new Error('usage: set_position <name> <x> <y> <z>');
+            }
+            entity.position = { x: +x, y: +y, z: +z };
+            return JSON.stringify(entity.position);
+        }), 'args: [ string, float, float, float ]; Teleport a named entity to world-space coordinates. ' +
+            'Use "entities"/"entity <name>" to find entity names and their current position');
+        ggstatic.registerConsoleCommand(this, 'set_rotation', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [name, ...rest] = args;
+            if (!name) {
+                throw new Error('usage: set_rotation <name> <x> <y> <z> [w]');
+            }
+            const entity = this.getEntityByName(name);
+            if (!('rotation' in entity)) {
+                throw new Error(`Entity "${name}" (${entity.constructor.name}) has no rotation`);
+            }
+            const nums = rest.map(Number);
+            if (nums.length !== 3 && nums.length !== 4) {
+                throw new Error('usage: set_rotation <name> <x> <y> <z> (euler, radians) OR set_rotation <name> <x> <y> <z> <w> (quaternion)');
+            }
+            if (nums.some(Number.isNaN)) {
+                throw new Error('Wrong arguments');
+            }
+            const rotation = nums.length === 4
+                ? { x: nums[0], y: nums[1], z: nums[2], w: nums[3] }
+                : Qtrn.fromEuler({ x: nums[0], y: nums[1], z: nums[2] });
+            entity.rotation = rotation;
+            return JSON.stringify(entity.rotation);
+        }), 'args: [ string, float, float, float, float? ]; Rotate a named entity. 3 numbers are euler ' +
+            'angles in radians, 4 numbers are a raw quaternion (x y z w)');
+        ggstatic.registerConsoleCommand(this, 'spawn', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [shapeArg, x, y, z, dynamicArg] = args;
+            if ([x, y, z].some(v => v === undefined || isNaN(+v))) {
+                throw new Error('usage: spawn <BOX|SPHERE|CYLINDER|CONE|CAPSULE|PLANE> <x> <y> <z> [dynamic=0|1]');
+            }
+            const dynamic = dynamicArg === undefined ? true : dynamicArg === '1';
+            let shape;
+            switch ((shapeArg || '').toUpperCase()) {
+                case 'BOX':
+                    shape = { shape: 'BOX', dimensions: { x: 1, y: 1, z: 1 } };
+                    break;
+                case 'SPHERE':
+                    shape = { shape: 'SPHERE', radius: 0.5 };
+                    break;
+                case 'CYLINDER':
+                    shape = { shape: 'CYLINDER', radius: 0.5, height: 1 };
+                    break;
+                case 'CONE':
+                    shape = { shape: 'CONE', radius: 0.5, height: 1 };
+                    break;
+                case 'CAPSULE':
+                    shape = { shape: 'CAPSULE', radius: 0.5, centersDistance: 1 };
+                    break;
+                case 'PLANE':
+                    shape = { shape: 'PLANE' };
+                    break;
+                default:
+                    throw new Error(`Unknown shape "${shapeArg}". Use BOX|SPHERE|CYLINDER|CONE|CAPSULE|PLANE`);
+            }
+            const entity = this.addPrimitiveRigidBody({ shape, body: { dynamic } }, { x: +x, y: +y, z: +z });
+            return `spawned "${entity.name}" (${shape.shape}) at ${JSON.stringify(entity.position)}`;
+        }), 'args: [ BOX|SPHERE|CYLINDER|CONE|CAPSULE|PLANE, float, float, float, 0|1? ]; Spawn a ' +
+            'default-sized primitive rigid body at world-space coordinates, for probing physics. ' +
+            'dynamic (last arg) defaults to 1 (falls under gravity); pass 0 for a static prop');
         if (this.physicsWorld) {
             ggstatic.registerConsoleCommand(this, 'gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
                 if (args.length == 1) {

package/dist/3d/loader.js

@@ -7,6 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { GG_META_SUPPORTED_FORMAT_VERSION } from './models/gg-meta';
 import { Entity3d } from './entities/entity-3d';
 import { GroupEntity, Pnt3, Qtrn } from '../base';
 import { Gg3dLevelLoader } from './level-loader';
@@ -71,7 +72,15 @@ export class Gg3dLoader extends Gg3dLevelLoader {
                 fetch(`${path}.glb`).then(r => r.arrayBuffer()),
                 fetch(`${path}.meta`)
                     .then(r => r.text())
-                    .then(r => JSON.parse(r)),
+                    .then(r => JSON.parse(r))
+                    .then((meta) => {
+                    if (meta.formatVersion !== undefined && meta.formatVersion > GG_META_SUPPORTED_FORMAT_VERSION) {
+                        console.warn(`${path}.meta declares formatVersion ${meta.formatVersion}, but this build of ` +
+                            `@gg-web-engine/core only understands up to ${GG_META_SUPPORTED_FORMAT_VERSION}. ` +
+                            `Update @gg-web-engine/core, or re-export with an older version of the GG Web Engine Exporter add-on.`);
+                    }
+                    return meta;
+                }),
             ]);
             if (useCache) {
                 this.filesCache.set(path, loadPromise);

package/dist/3d/models/gg-meta.d.ts

@@ -16,7 +16,17 @@ export type GgRigidBody = {
     rotation: Point4;
 } & BodyShape3DDescriptor;
 export type GgMeta = {
+    /**
+     * Written by the Blender exporter (`GG_META_FORMAT_VERSION` in
+     * `blender-addon/gg_web_engine_exporter/exporter.py`) since it started declaring one. Absent on
+     * `.meta` files exported before that, which is fine - the shape hasn't actually changed yet, so
+     * there is nothing to migrate; this only matters once a future export starts writing a `.meta`
+     * this loader's current version doesn't understand.
+     */
+    formatVersion?: number;
     dummies: GgDummy[];
     curves: GgCurve[];
     rigidBodies: GgRigidBody[];
 };
+/** Highest `.meta` `formatVersion` this loader understands - see `GgMeta.formatVersion`. */
+export declare const GG_META_SUPPORTED_FORMAT_VERSION = 1;

package/dist/3d/models/gg-meta.js

@@ -1 +1,2 @@
-export {};
+/** Highest `.meta` `formatVersion` this loader understands - see `GgMeta.formatVersion`. */
+export const GG_META_SUPPORTED_FORMAT_VERSION = 1;

package/dist/base/clock/pausable-clock.d.ts

@@ -61,6 +61,18 @@ export declare class PausableClock extends IClock {
      * Pauses the clock.
      */
     pause(): void;
+    /**
+     * Fires exactly one tick with the given delta while the clock is paused, without resuming it -
+     * useful for frame-by-frame debugging. `elapsedTime` (and everything derived from it - child
+     * clocks, animations, anything reading `this.elapsedTime`) advances by exactly `delta`, same as
+     * it would over `delta` worth of normal ticking, and stays at that new instant once `step`
+     * returns (the clock is still paused, it just moved its frozen instant forward). A manual step
+     * is never throttled by `tickRateLimit`, and resuming afterwards continues seamlessly from the
+     * stepped-to instant rather than losing or double-counting the stepped time.
+     * @param delta - tick delta to report to subscribers, in milliseconds
+     * @throws if the clock isn't currently paused
+     */
+    step(delta: number): void;
     /**
      * Resumes the clock.
      */

package/dist/base/clock/pausable-clock.js

@@ -126,6 +126,30 @@ export class PausableClock extends IClock {
         this.pausedByTimescale = false;
         this.paused$.next(true);
     }
+    /**
+     * Fires exactly one tick with the given delta while the clock is paused, without resuming it -
+     * useful for frame-by-frame debugging. `elapsedTime` (and everything derived from it - child
+     * clocks, animations, anything reading `this.elapsedTime`) advances by exactly `delta`, same as
+     * it would over `delta` worth of normal ticking, and stays at that new instant once `step`
+     * returns (the clock is still paused, it just moved its frozen instant forward). A manual step
+     * is never throttled by `tickRateLimit`, and resuming afterwards continues seamlessly from the
+     * stepped-to instant rather than losing or double-counting the stepped time.
+     * @param delta - tick delta to report to subscribers, in milliseconds
+     * @throws if the clock isn't currently paused
+     */
+    step(delta) {
+        if (!this.isPaused) {
+            throw new Error('Clock must be paused to step it manually');
+        }
+        // advance the frozen instant so `elapsedTime` (= timeScale * (pausedAt - startedAt)) grows by
+        // exactly `delta`, matching what `delta` means for every other tick consumer
+        this.pausedAt += this._timeScale !== 0 ? delta / this._timeScale : delta;
+        // keep the internal relative-time bookkeeping in step, so the first real tick after resume
+        // reports a normal-sized delta instead of one that swallows the whole stepped duration
+        this.oldRelativeTime += delta;
+        this.lastFiredTickElapsed = this.oldRelativeTime;
+        this._tick$.next([this.elapsedTime, delta]);
+    }
     /**
      * Resumes the clock.
      */

package/dist/base/gg-world.js

@@ -196,6 +196,19 @@ export class GgWorld {
             }
             return this.worldClock.tickRateLimit.toString();
         }), 'args: [ int? ]; Get current tick rate limit of selected world clock or set it. 0 means no limit applied');
+        ggstatic.registerConsoleCommand(this, 'step', (...args) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.worldClock.isPaused) {
+                throw new Error('World must be paused first (run "timescale 0") before it can be stepped');
+            }
+            const ms = args[0] === undefined ? 1000 / 120 : +args[0];
+            if (isNaN(ms) || ms <= 0) {
+                throw new Error('usage: step [ms]; ms must be a positive number');
+            }
+            this.worldClock.step(ms);
+            return `stepped ${ms} ms`;
+        }), 'args: [ float? ]; Advance a paused world clock by exactly one tick of the given duration ' +
+            'in milliseconds (default 8, i.e. 1000/120). Only works while the world is paused via ' +
+            '"timescale 0"; rejects otherwise');
         ggstatic.registerConsoleCommand(this, 'renderers', () => __awaiter(this, void 0, void 0, function* () {
             return this.renderers.map(r => r.name).join('\n');
         }), 'no args; Print all renderers in selected world');
@@ -258,6 +271,53 @@ export class GgWorld {
         }), 'args: [ int?, avg|peak? ]; Measure how much time was spent per ' +
             'entity in world. Arguments are samples amount (20 by default) and "peak" or "avg" choice, both arguments are ' +
             'optional. "avg" report sorts entities by average time consumed, "peak" records highest value for each entity');
+        ggstatic.registerConsoleCommand(this, 'entities', (...args) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const filter = (_a = args[0]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            const list = this.children.filter(e => !filter || e.name.toLowerCase().includes(filter));
+            if (list.length === 0) {
+                return '<span style="color:#aaa">(no entities)</span>';
+            }
+            return list
+                .map(e => `<span style='color:yellow'>${e.name}</span>\t<span style='color:#aaa'>${e.constructor.name}</span>`)
+                .join('\n');
+        }), 'args: [ string? ]; List all entities in this world (name and class), optionally filtered by ' +
+            'a case-insensitive substring of the name. Use "entity <name>" to inspect one of them');
+        ggstatic.registerConsoleCommand(this, 'entity', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const name = args[0];
+            if (!name) {
+                throw new Error('usage: entity <name>; use "entities" to list available names');
+            }
+            const entity = this.getEntityByName(name);
+            const lines = [
+                `class: ${entity.constructor.name}`,
+                `active: ${entity.active}`,
+                `parent: ${entity.parent ? entity.parent.name : '(none)'}`,
+            ];
+            if ('visible' in entity) {
+                lines.push(`visible: ${entity.visible}`);
+            }
+            if ('position' in entity) {
+                lines.push(`position: ${JSON.stringify(entity.position)}`);
+            }
+            if ('rotation' in entity) {
+                lines.push(`rotation: ${JSON.stringify(entity.rotation)}`);
+            }
+            lines.push(`children: ${entity.children.length === 0 ? '(none)' : entity.children.map(c => c.name).join(', ')}`);
+            return lines.join('\n');
+        }), 'args: [ string ]; Print class, position/rotation (if any) and children of one entity. Use ' +
+            '"entities" to list available names, "set_position"/"set_rotation" to move it');
+        ggstatic.registerConsoleCommand(this, 'remove', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const name = args[0];
+            if (!name) {
+                throw new Error('usage: remove <name> [dispose=0|1]');
+            }
+            const entity = this.getEntityByName(name);
+            const dispose = args[1] === undefined ? true : args[1] === '1';
+            this.removeEntity(entity, dispose);
+            return `removed "${name}"`;
+        }), 'args: [ string, 0|1? ]; Remove the named entity from this world, disposing it by default. ' +
+            'Pass 0 as second arg to detach without disposing (e.g. before re-adding it elsewhere)');
     }
 }
 GgWorld.default_name_counter = 0;

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/core",
-  "version": "0.0.59",
+  "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

@@ -4,7 +4,8 @@
     "baseUrl": "./src/",
     "outDir": "./dist/",
     "rootDir": "./src/",
-    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo"
+    "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)