From dbaca8686d126293436ff32d62b35c862af6d51a Mon Sep 17 00:00:00 2001
From: Alezia Kurdis <60075796+AleziaKurdis@users.noreply.github.com>
Date: Fri, 22 Dec 2023 22:53:36 -0500
Subject: [PATCH] Add "Replica" application.

Specifically for users who do 'Full Body Tracking', this application generates a double of your avatar that only you can see. This is useful to master your avatar moves. Good to have for dancing.

Basically, it is a modified Dopple-ganger app, but able to do the room scale translations inst5ead to be stationary. This is really for 'Full Body Tracking'.
---
 applications/metadata.js                     |   9 +
 applications/replica/replica-a.png           | Bin 0 -> 1813 bytes
 applications/replica/replica-app.js          |  90 ++++
 applications/replica/replica-doppleganger.js | 534 +++++++++++++++++++
 applications/replica/replica-i.png           | Bin 0 -> 1814 bytes
 5 files changed, 633 insertions(+)
 create mode 100644 applications/replica/replica-a.png
 create mode 100644 applications/replica/replica-app.js
 create mode 100644 applications/replica/replica-doppleganger.js
 create mode 100644 applications/replica/replica-i.png

diff --git a/applications/metadata.js b/applications/metadata.js
index f46eb39..16803f0 100644
--- a/applications/metadata.js
+++ b/applications/metadata.js
@@ -296,6 +296,15 @@ var metadata = { "applications":
             "jsfile": "flyCam/flyCamera.js",
             "icon": "flyCam/flyCam-i.png",
             "caption": "FLY-CAM"
+        },
+        {
+            "isActive": true,
+            "directory": "replica",
+            "name": "Replica",
+            "description": "Specifically for users who do 'Full Body Tracking', this application generates a double of your avatar that only you can see. This is useful to master your avatar moves. Good to have for dancing.",
+            "jsfile": "replica/replica-app.js",
+            "icon": "replica/replica-i.png",
+            "caption": "REPLICA"
         }
     ]
 };
\ No newline at end of file
diff --git a/applications/replica/replica-a.png b/applications/replica/replica-a.png
new file mode 100644
index 0000000000000000000000000000000000000000..19e5299902dad43877e3188dcc3de3505de1271c
GIT binary patch
literal 1813
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

literal 0
HcmV?d00001

diff --git a/applications/replica/replica-app.js b/applications/replica/replica-app.js
new file mode 100644
index 0000000..db75564
--- /dev/null
+++ b/applications/replica/replica-app.js
@@ -0,0 +1,90 @@
+//======================================
+//
+//  replica-app.js
+//
+//  Created by Alezia Kurdis, December 22th, 2023. 
+//  (Based on doppleganger-app from Timothy Dedischew, April 21st, 2017)
+//  Copyright 2017 High Fidelity, Inc.
+//  Copyright 2023, Overte e.V.
+//
+//  This application generate an instance of a Doppleganger that can be toggled on/off via tablet button,
+//  but specifically for 'Full Body Tracking' to follow roomscale moves instead of static position. 
+//  The objective is to help the user figuring how the avatar react to his moves.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+var versioncall = Math.floor(Math.random()*50000);
+var DopplegangerClass = Script.require('./replica-doppleganger.js?version=' + versioncall);
+
+var tablet = Tablet.getTablet('com.highfidelity.interface.tablet.system'),
+    button = tablet.addButton({
+        icon: Script.resolvePath('./replica-i.png'),
+        activeIcon: Script.resolvePath('./replica-a.png'),
+        text: 'REPLICA'
+    });
+
+Script.scriptEnding.connect(function() {
+    tablet.removeButton(button);
+    button = null;
+});
+
+var doppleganger = new DopplegangerClass({
+    avatar: MyAvatar,
+    mirrored: false,
+    autoUpdate: true,
+});
+
+// hide the doppleganger if this client script is unloaded
+Script.scriptEnding.connect(doppleganger, doppleganger.stop);
+
+// hide the doppleganger if the user switches domains (which might place them arbitrarily far away in world space)
+function onDomainChanged() {
+    if (doppleganger.active) {
+        doppleganger.stop('domain_changed');
+    }
+}
+Window.domainChanged.connect(onDomainChanged);
+Window.domainConnectionRefused.connect(onDomainChanged);
+Script.scriptEnding.connect(function() {
+    Window.domainChanged.disconnect(onDomainChanged);
+    Window.domainConnectionRefused.disconnect(onDomainChanged);
+});
+
+// toggle on/off via tablet button
+button.clicked.connect(doppleganger, doppleganger.toggle);
+
+// highlight tablet button based on current doppleganger state
+doppleganger.activeChanged.connect(function(active, reason) {
+    if (button) {
+        button.editProperties({ isActive: active });
+        //print('doppleganger.activeChanged', active, reason);
+    }
+});
+
+// alert the user if there was an error applying their skeletonModelURL
+doppleganger.addingEntity.connect(function(error, result) {
+    if (doppleganger.active && error) {
+        Window.alert('doppleganger | ' + error + '\n' + doppleganger.skeletonModelURL);
+    }
+});
+
+// add debug indicators, but only if the user has configured the settings value
+if (Settings.getValue('debug.doppleganger', false)) {
+    DopplegangerClass.addDebugControls(doppleganger);
+}
+
+UserActivityLogger.logAction('doppleganger_app_load');
+doppleganger.activeChanged.connect(function(active, reason) {
+    if (active) {
+        UserActivityLogger.logAction('doppleganger_enable');
+    } else {
+        if (reason === 'stop') {
+            // user intentionally toggled the doppleganger
+            UserActivityLogger.logAction('doppleganger_disable');
+        } else {
+            //print('doppleganger stopped:', reason);
+            UserActivityLogger.logAction('doppleganger_autodisable', { reason: reason });
+        }
+    }
+});
diff --git a/applications/replica/replica-doppleganger.js b/applications/replica/replica-doppleganger.js
new file mode 100644
index 0000000..b5516a4
--- /dev/null
+++ b/applications/replica/replica-doppleganger.js
@@ -0,0 +1,534 @@
+"use strict";
+//======================================
+//
+//  replica-doppleganger.js
+//
+//  Created by Alezia Kurdis, December 22th, 2023. 
+//  (Based on doppleganger.js from Timothy Dedischew, April 21st, 2017)
+//  Copyright 2017 High Fidelity, Inc.
+//  Copyright 2022-2023 Overte e.V.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+//
+/* global module */
+// @module doppleganger
+//
+// This module contains the `Doppleganger` class implementation for creating an inspectable replica of
+// an Avatar (as a model directly in front of and facing them).  Joint positions and rotations are copied
+// over in an update thread, so that the model automatically mirrors the Avatar's joint movements.
+// An Avatar can then for example walk around "themselves" and examine from the back, etc.
+//
+// This should be helpful for inspecting your own look and debugging avatars, etc.
+//
+// The doppleganger is created as an overlay so that others do not see it -- and this also allows for the
+// highest possible update rate when keeping joint data in sync.
+
+module.exports = Doppleganger;
+
+// @property {bool} - when set true, Script.update will be used instead of setInterval for syncing joint data
+Doppleganger.USE_SCRIPT_UPDATE = false;
+
+// @property {int} - the frame rate to target when using setInterval for joint updates
+Doppleganger.TARGET_FPS = 60;
+
+// @property {int} - the maximum time in seconds to wait for the model overlay to finish loading
+Doppleganger.MAX_WAIT_SECS = 10;
+
+// @function - derive mirrored joint names from a list of regular joint names
+// @param {Array} - list of joint names to mirror
+// @return {Array} - list of mirrored joint names (note: entries for non-mirrored joints will be `undefined`)
+
+var Setarry; 
+
+Doppleganger.getMirroredJointNames = function(jointNames) {
+    return jointNames.map(function(name, i) {
+        if (/Left/.test(name)) {
+            return name.replace('Left', 'Right');
+        }
+        if (/Right/.test(name)) {
+            return name.replace('Right', 'Left');
+        }
+        return undefined;
+    });
+};
+
+// @class Doppleganger - Creates a new instance of a Doppleganger.
+// @param {Avatar} [options.avatar=MyAvatar] - Avatar used to retrieve position and joint data.
+// @param {bool}   [options.mirrored=true]   - Apply "symmetric mirroring" of Left/Right joints.
+// @param {bool}   [options.autoUpdate=true] - Automatically sync joint data.
+function Doppleganger(options) {
+    options = options || {};
+    this.avatar = MyAvatar;
+    this.mirrored = 'mirrored' in options ? options.mirrored : false;
+    this.autoUpdate = 'autoUpdate' in options ? options.autoUpdate : true;
+    this.testValue = options.testValue;
+
+    // @public
+    this.active = false;   // whether doppleganger is currently being displayed/updated
+    this.entityID = null; // current doppleganger's Entity id
+    this.frame = 0;        // current joint update frame
+
+    // @signal - emitted when .active state changes
+    this.activeChanged = signal(function(active, reason) {});
+    // @signal - emitted once model overlay is either loaded or errors out
+    this.addingEntity = signal(function(error, result){});
+    // @signal - emitted each time the model overlay's joint data has been synchronized
+    this.jointsUpdated = signal(function(entityID){});
+}
+
+Doppleganger.prototype = {
+    // @public @method - toggles doppleganger on/off
+    toggle: function() {
+        if (this.active) {
+            log('toggling off');
+            this.stop();
+        }else{
+            log('toggling on');
+            this.start();
+        }
+        return this.active;
+    },
+
+    // @public @method - synchronize the joint data between Avatar / doppleganger
+    update: function() {
+        //print("UPDATE before Try");
+        this.frame++;
+        try {
+            //print("UPDATE");
+            if (!this.entityID) {
+                throw new Error('!this.entityID');
+            }
+
+            if (this.avatar.skeletonModelURL !== this.skeletonModelURL) {
+                return this.stop('avatar_changed');
+            }
+
+            var rotations = this.avatar.getJointRotations();
+            var translations = this.avatar.getJointTranslations();
+            var size = rotations.length;
+
+
+            // note: this mismatch can happen when the avatar's model is actively changing
+            if (size !== translations.length ||
+                (this.jointStateCount && size !== this.jointStateCount)) {
+                log('mismatched joint counts (avatar model likely changed)', size, translations.length, this.jointStateCount);
+                this.stop('avatar_changed_joints');
+                return;
+            }
+            this.jointStateCount = size;
+
+
+            if (this.mirrored) {
+                var mirroredIndexes = this.mirroredIndexes;
+                var outRotations = new Array(size);
+                var outTranslations = new Array(size);
+                for (var i=0; i < size; i++) {
+                    var index = mirroredIndexes[i];
+                    if (index < 0 || index === false) {
+                        index = i;
+                    }
+                    var rot = rotations[index];
+                    var trans = translations[index];
+                    trans.x *= -1;
+                    rot.y *= -1;
+                    rot.z *= -1;
+                    outRotations[i] = rot;
+                    outTranslations[i] = trans;
+                }
+                rotations = outRotations;
+                translations = outTranslations;
+            }
+            
+            var currentRotation = MyAvatar.orientation;
+            
+            var delta = Vec3.subtract(this.avatarReferencePosition, MyAvatar.feetPosition);
+            delta.y = -delta.y;
+            var currentPosition = Vec3.sum(this.position, delta);
+
+            Entities.editEntity(this.entityID, {
+                jointRotations: rotations,
+                jointTranslations: translations,
+				jointRotationsSet: Setarry,
+				jointTranslationsSet: Setarry,
+                position: currentPosition,
+                rotation: currentRotation
+            });
+			
+            this.jointsUpdated(this.entityID);
+        } catch (e) {
+            //log('.update error: '+ e, index);
+            this.stop('update_error');
+        }
+    },
+
+    // @public @method - show the doppleganger (and start the update thread, if options.autoUpdate was specified).
+    // @param {vec3} [options.position=(in front of avatar)] - starting position
+    // @param {quat} [options.orientation=avatar.orientation] - starting orientation
+    start: function(options) {
+        options = options || {};
+        if (this.entityID) {
+            //log('start() called but entity model already exists', this.entityID);
+            return;
+        }
+        var avatar = this.avatar;
+        if (!avatar.jointNames.length) {
+            return this.stop('joints_unavailable');
+        }
+
+        this.frame = 0;
+        this.position = options.feetPosition || Vec3.sum(avatar.feetPosition, Quat.getForward(avatar.orientation));
+        this.avatarReferencePosition = MyAvatar.feetPosition;
+        this.orientation = options.orientation || avatar.orientation;
+        this.avatarReferenceRotation = MyAvatar.orientation;
+        this.skeletonModelURL = avatar.skeletonModelURL;
+        this.jointStateCount = 0;
+        this.jointNames = avatar.jointNames;
+        this.mirroredNames = Doppleganger.getMirroredJointNames(this.jointNames);
+		//log(this.mirroredNames);
+        this.mirroredIndexes = this.mirroredNames.map(function(name) {
+            return name ? avatar.getJointIndex(name) : false;
+        });
+		//log(this.mirroredIndexes);
+		var prop = {
+			type: "Model",
+			name: 'Doppelganger', //added
+            visible: false, // normally false
+            modelURL: this.skeletonModelURL, //was field: url
+            position: this.position,
+            rotation: this.orientation,
+            useOriginalPivot: true
+        };
+		
+        this.entityID = Entities.addEntity(prop, "local");
+
+        var allJoints = avatar.getJointRotations();
+        var nbrJoints = allJoints.length;
+		Setarry = Array(nbrJoints);
+		for (var i=0; i < nbrJoints; i++) {
+					Setarry[i] = true;
+		}
+		
+        this.onAddingEntity = function(error, result) {
+            if (error) {
+                return this.stop(error);
+            }
+            log('ModelEntity is ready; # joints == ' + result.jointNames.length);
+            Entities.editEntity(this.entityID, { visible: true });
+            if (!options.position) {
+                //this.syncVerticalPosition(); // UNCLEAR WHAT IT DOES????
+            }
+            if (this.autoUpdate) {
+                this._createUpdateThread();
+            }
+        };
+        this.addingEntity.connect(this, this.onAddingEntity);
+
+        log('doppleganger created; entityID =', this.entityID);
+        
+        // trigger clean up (and stop updates) if the overlay gets deleted
+        this.onDeletedEntity = function(uuid) {
+            if (uuid === this.entityID) {
+                log('onDeletedEntity', uuid);
+                this.stop('entity_deleted');
+            }
+        };
+        Entities.deletingEntity.connect(this, this.onDeletedEntity);
+
+        if ('onLoadComplete' in avatar) {
+            // stop the current doppleganger if Avatar loads a different model URL
+            this.onLoadComplete = function() {
+                if (avatar.skeletonModelURL !== this.skeletonModelURL) {
+                    this.stop('avatar_changed_load');
+                }
+            };
+            avatar.onLoadComplete.connect(this, this.onLoadComplete);
+        }
+
+        this.activeChanged(this.active = true, 'start');
+        this._waitForModel(ModelCache.prefetch(this.skeletonModelURL));
+    },
+
+    // @public @method - hide the doppleganger
+    // @param {String} [reason=stop] - the reason stop was called
+    stop: function(reason) {
+        reason = reason || 'stop';
+        if (this.onUpdate) {
+            Script.update.disconnect(this, this.onUpdate);
+            delete this.onUpdate;
+        }
+        if (this._interval) {
+            Script.clearInterval(this._interval);
+            this._interval = undefined;
+        }
+        if (this.onDeletedEntity) {
+            Entities.deletingEntity.disconnect(this, this.onDeletedEntity);
+            delete this.onDeletedEntity;
+        }
+        if (this.onLoadComplete) {
+            this.avatar.onLoadComplete.disconnect(this, this.onLoadComplete);
+            delete this.onLoadComplete;
+        }
+        if (this.onAddingEntity) {
+            this.addingEntity.disconnect(this, this.onAddingEntity);
+        }
+        if (this.entityID) {
+            Entities.deleteEntity(this.entityID);
+            this.entityID = undefined;
+        }
+        if (this.active) {
+            this.activeChanged(this.active = false, reason);
+        } else if (reason) {
+            log('already stopped so not triggering another activeChanged; latest reason was:', reason);
+        }
+    },
+
+    // @public @method - Reposition the doppleganger so it sees "eye to eye" with the Avatar.
+    // @param {String} [byJointName=Hips] - the reference joint used to align the Doppleganger and Avatar
+    syncVerticalPosition: function(byJointName) {
+        byJointName = byJointName || 'Hips';
+
+		var dopplePosition = Entities.getEntityProperties(this.entityID, ["position"]);    
+		var doppleJointIndex = Entities.getJointIndex( this.entityID, byJointName );
+		var doppleJointPosition = Vec3.sum(Entities.getAbsoluteJointTranslationInObjectFrame( this.entityID, doppleJointIndex ), dopplePosition);
+		
+		//log("Joint Pos = " + JSON.stringify(doppleJointPosition));
+		
+        var avatarPosition = this.avatar.position;
+        var avatarJointIndex = this.avatar.getJointIndex(byJointName);
+		var avatarJointPosition = Vec3.sum(this.avatar.getAbsoluteJointTranslationInObjectFrame(avatarJointIndex), avatarPosition);
+
+		//log("AV Joint Pos = " + JSON.stringify(avatarJointPosition));
+
+        dopplePosition.position.y = avatarJointPosition.y - doppleJointPosition.y; 
+        this.position = dopplePosition.position;
+        Entities.editEntity(this.entityID, { position: this.position });
+    },
+
+    // @private @method - creates the update thread to synchronize joint data
+    _createUpdateThread: function() {
+        if (Doppleganger.USE_SCRIPT_UPDATE) {
+            log('creating Script.update thread');
+            this.onUpdate = this.update;
+            Script.update.connect(this, this.onUpdate);
+        } else {
+            log('creating Script.setInterval thread @ ~', Doppleganger.TARGET_FPS +'fps');
+            var timeout = 1000 / Doppleganger.TARGET_FPS;
+            this._interval = Script.setInterval(bind(this, this.update), timeout);
+        }
+    },
+
+    // @private @method - waits for model to load and handles timeouts
+    // @param {ModelResource} resource - a prefetched resource to monitor loading state against
+    _waitForModel: function(resource) {
+        var RECHECK_MS = 50;
+        var id = this.entityID,
+            watchdogTimer = null;
+
+        function waitForJointNames() {
+            var error = null, result = null;
+            if (!watchdogTimer) {
+                error = 'joints_unavailable_watchodog_fail';
+            } else if (resource.state === Resource.State.FAILED) {
+                error = 'prefetch_failed';
+            } else if (resource.state === Resource.State.FINISHED) {
+                var names = Entities.getJointNames(id);
+                if (Array.isArray(names) && names.length) {
+                    result = { entityID: id, jointNames: names };
+                }
+            }
+            if (error || result !== null) {
+                Script.clearInterval(this._interval);
+                this._interval = null;
+                if (watchdogTimer) {
+                    Script.clearTimeout(watchdogTimer);
+                }
+                this.addingEntity(error, result);
+            }
+        }
+        watchdogTimer = Script.setTimeout(function() {
+            watchdogTimer = null;
+        }, Doppleganger.MAX_WAIT_SECS * 1000);
+        this._interval = Script.setInterval(bind(this, waitForJointNames), RECHECK_MS);
+    }
+};
+
+// @function - bind a function to a `this` context
+// @param {Object} - the `this` context
+// @param {Function|String} - function or method name
+function bind(thiz, method) {
+    method = thiz[method] || method;
+    return function() {
+        return method.apply(thiz, arguments);
+    };
+}
+
+// @function - Qt signal polyfill
+function signal(template) {
+    var callbacks = [];
+    return Object.defineProperties(function() {
+        var args = [].slice.call(arguments);
+        callbacks.forEach(function(obj) {
+            obj.handler.apply(obj.scope, args);
+        });
+    }, {
+        connect: { value: function(scope, handler) {
+            callbacks.push({scope: scope, handler: scope[handler] || handler || scope});
+        }},
+        disconnect: { value: function(scope, handler) {
+            var match = {scope: scope, handler: scope[handler] || handler || scope};
+            callbacks = callbacks.filter(function(obj) {
+                return !(obj.scope === match.scope && obj.handler === match.handler);
+            });
+        }}
+    });
+}
+
+// @function - debug logging
+function log() {
+    //print('doppleganger | ' + [].slice.call(arguments).join(' '));
+}
+
+// -- ADVANCED DEBUGGING --
+// @function - Add debug joint indicators / extra debugging info.
+// @param {Doppleganger} - existing Doppleganger instance to add controls to
+//
+// @note:
+//   * rightclick toggles mirror mode on/off
+//   * shift-rightclick toggles the debug indicators on/off
+//   * clicking on an indicator displays the joint name and mirrored joint name in the debug log.
+//
+// Example use:
+//    var doppleganger = new Doppleganger();
+//    Doppleganger.addDebugControls(doppleganger);
+Doppleganger.addDebugControls = function(doppleganger) {
+    DebugControls.COLOR_DEFAULT = { red: 255, blue: 255, green: 255 };
+    DebugControls.COLOR_SELECTED = { red: 0, blue: 255, green: 0 };
+
+    function DebugControls() {
+        this.enableIndicators = true;
+        this.selectedJointName = null;
+        this.debugEntityIDs = undefined;
+        this.jointSelected = signal(function(result) {});
+    }
+    DebugControls.prototype = {
+        start: function() {
+            if (!this.onMousePressEvent) {
+                this.onMousePressEvent = this._onMousePressEvent;
+                Controller.mousePressEvent.connect(this, this.onMousePressEvent);
+            }
+        },
+
+        stop: function() {
+            this.removeIndicators();
+            if (this.onMousePressEvent) {
+                Controller.mousePressEvent.disconnect(this, this.onMousePressEvent);
+                delete this.onMousePressEvent;
+            }
+        },
+
+        createIndicators: function(jointNames) {
+            this.jointNames = jointNames;
+            return jointNames.map(function(name, i) {
+                return Entities.addEntity({
+                    type: "Shape",
+					shape: 'Icosahedron',
+                    scale: 0.1,
+                    solid: false,
+                    alpha: 0.5
+                });
+            });
+        },
+
+        removeIndicators: function() {
+            if (this.debugEntityIDs) {
+                this.debugEntityIDs.forEach(Entities.deleteEntity);
+                this.debugEntityIDs = undefined;
+            }
+        },
+
+        onJointsUpdated: function(entityID) {
+            if (!this.enableIndicators) {
+                return;
+            }
+            var jointNames = Entities.getJointNames(entityID),
+                jointOrientations = Entities.getEntityProperties(entityID, ['jointRotations']), //was jointOrientations
+                jointPositions = Entities.getEntityProperties(entityID, ['jointTranslations']), //was jointPositions
+                //selectedIndex = jointNames.indexOf(this.selectedJointName); 
+				selectedIndex = Entities.getJointIndex( entityID, this.selectedJointName );
+
+            if (!this.debugEntityIDs) {
+                this.debugEntityIDs = this.createIndicators(jointNames);
+            }
+
+            // batch all updates into a single call (using the editOverlays({ id: {props...}, ... }) API)
+            var updatedOverlays = this.debugEntityIDs.reduce(function(updates, id, i) {
+                updates[id] = {
+                    position: jointPositions.jointTranslations[i],
+                    rotation: jointOrientations.jointRotations[i],
+                    color: i === selectedIndex ? DebugControls.COLOR_SELECTED : DebugControls.COLOR_DEFAULT,
+                    solid: i === selectedIndex
+                };
+                return updates;
+            }, {});
+            //Entities.editOverlays(updatedOverlays);
+        },
+
+        _onMousePressEvent: function(evt) {
+            if (!evt.isLeftButton || !this.enableIndicators || !this.debugEntityIDs) {
+                return;
+            }
+            var ray = Camera.computePickRay(evt.x, evt.y),
+                hit = Entities.findRayIntersection(ray, true, this.debugEntityIDs);
+
+            hit.jointIndex = this.debugEntityIDs.indexOf(hit.entityID);
+            hit.jointName = this.jointNames[hit.jointIndex];
+            this.jointSelected(hit);
+        }
+    };
+
+    if ('$debugControls' in doppleganger) {
+        throw new Error('only one set of debug controls can be added per doppleganger');
+    }
+    var debugControls = new DebugControls();
+    doppleganger.$debugControls = debugControls;
+
+    function onMousePressEvent(evt) {
+        if (evt.isRightButton) {
+            if (evt.isShifted) {
+                debugControls.enableIndicators = !debugControls.enableIndicators;
+                if (!debugControls.enableIndicators) {
+                    debugControls.removeIndicators();
+                }
+            } else {
+                doppleganger.mirrored = !doppleganger.mirrored;
+            }
+        }
+    }
+
+    doppleganger.activeChanged.connect(function(active) {
+        if (active) {
+            debugControls.start();
+            doppleganger.jointsUpdated.connect(debugControls, this.onJointsUpdated);
+            Controller.mousePressEvent.connect(onMousePressEvent);
+        } else {
+            Controller.mousePressEvent.disconnect(onMousePressEvent);
+            doppleganger.jointsUpdated.disconnect(debugControls, this.onJointsUpdated);
+            debugControls.stop();
+        }
+    });
+
+    debugControls.jointSelected.connect(function(hit) {
+        debugControls.selectedJointName = hit.jointName;
+        if (hit.jointIndex < 0) {
+            return;
+        }
+        hit.mirroredJointName = Doppleganger.getMirroredJointNames([hit.jointName])[0];
+        log('selected joint:', JSON.stringify(hit, 0, 2));
+    });
+
+    Script.scriptEnding.connect(debugControls, debugControls.removeIndicators);
+
+    return doppleganger;
+};
diff --git a/applications/replica/replica-i.png b/applications/replica/replica-i.png
new file mode 100644
index 0000000000000000000000000000000000000000..43c27a6a700de99941b7539a4facbd8b7ab72df0
GIT binary patch
literal 1814
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

literal 0
HcmV?d00001