@gg-web-engine/core 0.0.1

package/.prettierrc

@@ -0,0 +1,8 @@
+{
+  "semi": true,
+  "trailingComma": "all",
+  "singleQuote": true,
+  "bracketSameLine":true,
+  "printWidth": 120,
+  "arrowParens": "avoid"
+}

package/README.md

@@ -0,0 +1,8 @@
+<p align="center">
+  <img src="../../documentation/assets/logo.png" style="height: 400px; width:400px;" alt=''/>
+</p>
+
+## Core package for [gg-web-engine](https://github.com/AndyGura/gg-web-engine)
+
+### Installation:
+1) `npm install --save @gg-web-engine/core`

package/blender_exporter/build_blender_scene.py

@@ -0,0 +1,180 @@
+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_colors=True,
+                          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

@@ -0,0 +1,116 @@
+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)

package/dist/2d/entities/gg-2d-entity.d.ts

@@ -0,0 +1,20 @@
+import { Subject } from 'rxjs';
+import { GgPositionable2dEntity } from './gg-positionable-2d-entity';
+import { ITickListener } from '../../base/entities/interfaces/i-tick-listener';
+import { Point2 } from '../../base/models/points';
+import { IGg2dBody, IGg2dObject } from '../interfaces';
+import { Gg2dWorld } from '../gg-2d-world';
+export declare class Gg2dEntity extends GgPositionable2dEntity implements ITickListener {
+    readonly object2D: IGg2dObject | null;
+    readonly objectBody: IGg2dBody | null;
+    readonly tick$: Subject<[number, number]>;
+    readonly tickOrder = 750;
+    private tickSub;
+    set position(value: Point2);
+    set rotation(value: number);
+    set scale(value: Point2);
+    constructor(object2D: IGg2dObject | null, objectBody: IGg2dBody | null);
+    onSpawned(world: Gg2dWorld): void;
+    onRemoved(): void;
+    dispose(): void;
+}

package/dist/2d/entities/gg-2d-entity.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg2dEntity = void 0;
+const rxjs_1 = require("rxjs");
+const gg_positionable_2d_entity_1 = require("./gg-positionable-2d-entity");
+class Gg2dEntity extends gg_positionable_2d_entity_1.GgPositionable2dEntity {
+    constructor(object2D, objectBody) {
+        super();
+        this.object2D = object2D;
+        this.objectBody = objectBody;
+        this.tick$ = new rxjs_1.Subject();
+        this.tickOrder = 750;
+        this.tickSub = null;
+        if (objectBody && object2D) {
+            this.tickSub = this.tick$.subscribe(() => {
+                // bind physics body transform to object transform
+                const pos = objectBody.position;
+                const rot = objectBody.rotation;
+                object2D.position = pos;
+                object2D.rotation = rot;
+                this._position$.next(pos);
+                this._rotation$.next(rot);
+            });
+        }
+        else if (!objectBody && !object2D) {
+            throw new Error('Cannot create entity without a sprite and a body');
+        }
+        if (objectBody) {
+            objectBody.entity = this;
+        }
+    }
+    set position(value) {
+        if (this.object2D) {
+            this.object2D.position = value;
+        }
+        if (this.objectBody) {
+            this.objectBody.position = value;
+        }
+        super.position = value;
+    }
+    set rotation(value) {
+        if (this.object2D) {
+            this.object2D.rotation = value;
+        }
+        if (this.objectBody) {
+            this.objectBody.rotation = value;
+        }
+        super.rotation = value;
+    }
+    set scale(value) {
+        if (this.object2D) {
+            this.object2D.scale = value;
+        }
+        if (this.objectBody) {
+            this.objectBody.scale = value;
+        }
+        super.scale = value;
+    }
+    onSpawned(world) {
+        var _a, _b;
+        super.onSpawned(world);
+        (_a = this.object2D) === null || _a === void 0 ? void 0 : _a.addToWorld(world.visualScene);
+        (_b = this.objectBody) === null || _b === void 0 ? void 0 : _b.addToWorld(world.physicsWorld);
+    }
+    onRemoved() {
+        var _a, _b;
+        (_a = this.object2D) === null || _a === void 0 ? void 0 : _a.removeFromWorld(this.world.visualScene);
+        (_b = this.objectBody) === null || _b === void 0 ? void 0 : _b.removeFromWorld(this.world.physicsWorld);
+        super.onRemoved();
+    }
+    dispose() {
+        var _a;
+        super.dispose();
+        (_a = this.tickSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.tickSub = null;
+        if (this.object2D) {
+            this.object2D.dispose();
+        }
+        if (this.objectBody) {
+            this.objectBody.dispose();
+        }
+    }
+}
+exports.Gg2dEntity = Gg2dEntity;

package/dist/2d/entities/gg-2d-trigger.entity.d.ts

@@ -0,0 +1,10 @@
+import { IGg2dTrigger } from '../interfaces';
+import { Gg2dEntity } from './gg-2d-entity';
+import { Observable } from 'rxjs';
+import { GgPositionable2dEntity } from './gg-positionable-2d-entity';
+export declare class Gg2dTriggerEntity extends Gg2dEntity {
+    readonly objectBody: IGg2dTrigger;
+    get onEntityEntered(): Observable<GgPositionable2dEntity>;
+    get onEntityLeft(): Observable<GgPositionable2dEntity | null>;
+    constructor(objectBody: IGg2dTrigger);
+}

package/dist/2d/entities/gg-2d-trigger.entity.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg2dTriggerEntity = void 0;
+const gg_2d_entity_1 = require("./gg-2d-entity");
+class Gg2dTriggerEntity extends gg_2d_entity_1.Gg2dEntity {
+    constructor(objectBody) {
+        super(null, objectBody);
+        this.objectBody = objectBody;
+    }
+    get onEntityEntered() {
+        return this.objectBody.onEntityEntered;
+    }
+    get onEntityLeft() {
+        return this.objectBody.onEntityLeft;
+    }
+}
+exports.Gg2dTriggerEntity = Gg2dTriggerEntity;

package/dist/2d/entities/gg-positionable-2d-entity.d.ts

@@ -0,0 +1,7 @@
+import { Point2 } from '../../base/models/points';
+import { GgPositionableEntity } from '../../base/entities/gg-positionable-entity';
+export declare abstract class GgPositionable2dEntity extends GgPositionableEntity<Point2, number> {
+    getDefaultPosition(): Point2;
+    getDefaultRotation(): number;
+    getDefaultScale(): Point2;
+}

package/dist/2d/entities/gg-positionable-2d-entity.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GgPositionable2dEntity = void 0;
+const gg_positionable_entity_1 = require("../../base/entities/gg-positionable-entity");
+class GgPositionable2dEntity extends gg_positionable_entity_1.GgPositionableEntity {
+    getDefaultPosition() {
+        return { x: 0, y: 0 };
+    }
+    getDefaultRotation() {
+        return 0;
+    }
+    getDefaultScale() {
+        return { x: 1, y: 1 };
+    }
+}
+exports.GgPositionable2dEntity = GgPositionable2dEntity;

package/dist/2d/factories.d.ts

@@ -0,0 +1,18 @@
+import { BodyShape2DDescriptor, Shape2DDescriptor } from './models/shapes';
+import { Point2 } from '../base/models/points';
+import { IGg2dBody, IGg2dObject, IGg2dTrigger } from './interfaces';
+export declare abstract class IGg2dObjectFactory<T extends IGg2dObject = IGg2dObject> {
+    abstract createPrimitive(descriptor: Shape2DDescriptor): T;
+    createSquare(dimensions: Point2): T;
+    createCircle(radius: number): T;
+}
+export interface IGg2dBodyFactory<T extends IGg2dBody = IGg2dBody, K extends IGg2dTrigger = IGg2dTrigger> {
+    createRigidBody(descriptor: BodyShape2DDescriptor, transform?: {
+        position?: Point2;
+        rotation?: number;
+    }): T;
+    createTrigger(descriptor: Shape2DDescriptor, transform?: {
+        position?: Point2;
+        rotation?: number;
+    }): K;
+}

package/dist/2d/factories.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGg2dObjectFactory = void 0;
+class IGg2dObjectFactory {
+    // shortcuts
+    createSquare(dimensions) {
+        return this.createPrimitive({ shape: 'SQUARE', dimensions });
+    }
+    createCircle(radius) {
+        return this.createPrimitive({ shape: 'CIRCLE', radius });
+    }
+}
+exports.IGg2dObjectFactory = IGg2dObjectFactory;

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

@@ -0,0 +1,9 @@
+import { GgWorld } from '../base/gg-world';
+import { Point2 } from '../base/models/points';
+import { IGg2dPhysicsWorld, IGg2dVisualScene } from './interfaces';
+export declare class Gg2dWorld<V extends IGg2dVisualScene = IGg2dVisualScene, P extends IGg2dPhysicsWorld = IGg2dPhysicsWorld> extends GgWorld<Point2, number, V, P> {
+    readonly visualScene: V;
+    readonly physicsWorld: P;
+    protected readonly consoleEnabled: boolean;
+    constructor(visualScene: V, physicsWorld: P, consoleEnabled?: boolean);
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg2dWorld = void 0;
+const gg_world_1 = require("../base/gg-world");
+class Gg2dWorld extends gg_world_1.GgWorld {
+    constructor(visualScene, physicsWorld, consoleEnabled = false) {
+        super(visualScene, physicsWorld, consoleEnabled);
+        this.visualScene = visualScene;
+        this.physicsWorld = physicsWorld;
+        this.consoleEnabled = consoleEnabled;
+        if (consoleEnabled) {
+            this.registerConsoleCommand('ph_gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
+                if (args.length == 1) {
+                    args = ['0', args[0]]; // mean Y axis
+                }
+                if (args.length > 0) {
+                    this.physicsWorld.gravity = { x: +args[0], y: +args[1] };
+                }
+                return JSON.stringify(this.physicsWorld.gravity);
+            }), 'args: [float] or [float float]; change 2D world gravity vector. 1 argument means ' +
+                '{x: 0, y: value}, 2 arguments set the whole vector. Default value is "9.82" or "0 9.82"');
+        }
+    }
+}
+exports.Gg2dWorld = Gg2dWorld;

package/dist/2d/interfaces.d.ts

@@ -0,0 +1,26 @@
+import { GgBody } from '../base/interfaces/gg-body';
+import { Point2 } from '../base/models/points';
+import { GgObject } from '../base/interfaces/gg-object';
+import { GgPhysicsWorld } from '../base/interfaces/gg-physics-world';
+import { GgVisualScene } from '../base/interfaces/gg-visual-scene';
+import { BaseGgRenderer } from '../base/entities/base-gg-renderer';
+import { GgTrigger } from '../base/interfaces/gg-trigger';
+import { Observable } from 'rxjs';
+import { GgPositionable2dEntity } from './entities/gg-positionable-2d-entity';
+import { IGg2dBodyFactory, IGg2dObjectFactory } from './factories';
+export interface IGg2dPhysicsWorld extends GgPhysicsWorld<Point2, number> {
+    readonly factory: IGg2dBodyFactory;
+}
+export declare abstract class Gg2dRenderer extends BaseGgRenderer {
+}
+export interface IGg2dBody extends GgBody<Point2, number> {
+}
+export interface IGg2dTrigger extends GgTrigger<Point2, number> {
+    get onEntityEntered(): Observable<GgPositionable2dEntity>;
+    get onEntityLeft(): Observable<GgPositionable2dEntity | null>;
+}
+export interface IGg2dVisualScene extends GgVisualScene<Point2, number> {
+    readonly factory: IGg2dObjectFactory;
+}
+export interface IGg2dObject extends GgObject<Point2, number> {
+}

package/dist/2d/interfaces.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg2dRenderer = void 0;
+const base_gg_renderer_1 = require("../base/entities/base-gg-renderer");
+class Gg2dRenderer extends base_gg_renderer_1.BaseGgRenderer {
+}
+exports.Gg2dRenderer = Gg2dRenderer;

package/dist/2d/models/body-options.d.ts

@@ -0,0 +1,3 @@
+import { BodyOptions } from '../../base/models/body-options';
+export interface Body2DOptions extends BodyOptions {
+}

package/dist/2d/models/body-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/2d/models/shapes.d.ts

@@ -0,0 +1,13 @@
+import { Point2 } from '../../base/models/points';
+import { Body2DOptions } from './body-options';
+export declare type Shape2DDescriptor = {
+    shape: 'SQUARE';
+    dimensions: Point2;
+} | {
+    shape: 'CIRCLE';
+    radius: number;
+};
+export declare type BodyShape2DDescriptor = {
+    shape: Shape2DDescriptor;
+    body: Partial<Body2DOptions>;
+};

package/dist/2d/models/shapes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/3d/controllers/car-keyboard.controller.d.ts

@@ -0,0 +1,25 @@
+import { BehaviorSubject } from 'rxjs';
+import { IController } from '../../base/controllers/i-controller';
+import { KeyboardController } from '../../base/controllers/keyboard.controller';
+import { Gg3dRaycastVehicleEntity } from '../entities/gg-3d-raycast-vehicle.entity';
+import { DirectionKeymap } from '../../base/controllers/common';
+declare type CarKeyboardControllerOptions = {
+    keymap: DirectionKeymap;
+    gearUpDownKeys: [string, string];
+};
+export declare class CarKeyboardController implements IController {
+    private readonly keyboardController;
+    private readonly options;
+    private readonly x$;
+    private readonly y$;
+    private lastX;
+    private readonly stop$;
+    protected readonly car$: BehaviorSubject<Gg3dRaycastVehicleEntity>;
+    pairTickerPipe: import("rxjs").UnaryFunction<import("rxjs").Observable<number>, import("rxjs").Observable<number>>;
+    set car(value: Gg3dRaycastVehicleEntity);
+    get car(): Gg3dRaycastVehicleEntity;
+    constructor(keyboardController: KeyboardController, car: Gg3dRaycastVehicleEntity, options?: CarKeyboardControllerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export {};