/**
 * System takes care of updating all the entities (based on their component data)
 * @param apiSystem GameLib.API.System
 * @param graphics
 * @constructor
 */
GameLib.System.Input = function(
    apiSystem,
    graphics
) {
	GameLib.System.call(
        this,
        apiSystem
    );

    this.graphics = graphics;
    this.graphics.isNotThreeThrow();

	/**
	 * We need new function pointers with scope bound to this so we can remove the
	 * window event handlers when we need to
	 * @type {function()}
	 */

	this.keyDown       	= null;

	this.selectAll 		= false;

	this.controlLeft	= false;

	this.sensitivityCounter = 0;

	this.renderers 	        = [];
	this.editorControls     = [];
	this.touchControls      = [];
	this.keyboardControls   = [];
	this.mouseControls      = [];

    this.touchStart     = this.onTouchStart.bind(this);
    this.touchMove      = this.onTouchMove.bind(this);
    this.touchEnd       = this.onTouchEnd.bind(this);
	this.touchCancel    = this.onTouchCancel.bind(this);

	this.keyboardKeyUp      = this.onKeyboardKeyUp.bind(this);
	this.keyboardKeyDown    = this.onKeyboardKeyDown.bind(this);

    this.mouseDown  = null;
    this.mouseMove  = null;
    this.mouseWheel = null;
    this.mouseUp    = null;

    this.mouseDownEdit  = null;
    this.mouseMoveEdit  = null;
    this.mouseWheelEdit = null;
    this.mouseUpEdit    = null;

    this.keyDown    = this.onKeyDown.bind(this);
    this.keyUp      = this.onKeyUp.bind(this);

    this.delayedInstanceEncounteredSubscription = null;

    this.mouse = new GameLib.Mouse(
        graphics
    )
};

GameLib.System.Input.prototype = Object.create(GameLib.System.prototype);
GameLib.System.Input.prototype.constructor = GameLib.System.Input;

/**
 *
 */
GameLib.System.Input.prototype.start = function() {

    GameLib.System.prototype.start.call(this);

    this.editorControls     = GameLib.EntityManager.Instance.queryComponents(GameLib.D3.Controls.Editor);

    this.touchControls      = GameLib.EntityManager.Instance.queryComponents(GameLib.D3.Controls.Touch);

    this.keyboardControls   = GameLib.EntityManager.Instance.queryComponents(GameLib.D3.Controls.Keyboard);

    this.mouseControls      = GameLib.EntityManager.Instance.queryComponents(GameLib.D3.Controls.Mouse);

    this.delayedInstanceEncounteredSubscription = GameLib.Event.Subscribe(
        GameLib.Event.DELAYED_INSTANCE_ENCOUNTERED,
        function() {
            if (this.editorControls) {
                this.editorControls.map(
                    function(editorControl) {
                        if (editorControl.linked && !editorControl.loaded) {
                            editorControl.createInstance();
                            this.entityCreatedSubscription = GameLib.Event.Subscribe(
                                GameLib.Event.ENTITY_LOADED,
                                function(data){
                                    if (data.entity === editorControl.parentEntity) {
                                        editorControl.dispose();
                                        this.entityCreatedSubscription.remove();
                                        this.restart();
                                    }
                                }.bind(this)
                            )
                        }
                    }.bind(this)
                )
            }
            //this.restart();
        }.bind(this)
    );

    /**
     * If we have touch controls - inject them first so we can override editor controls if necessary
     */
    if (this.touchControls.length > 0) {

        this.sensitivityCounter = 0;

        if (this.touchControls.length > 1) {
            console.warn('too many touch controls - will use ' + this.touchControls[0].name)
        }

        var touchControl = this.touchControls[0];

        this.touchSensitivity = touchControl.sensitivity;

        touchControl.domElement.instance.addEventListener(
            'touchstart',
            this.touchStart,
            false
        );

        touchControl.domElement.instance.addEventListener(
            'touchmove',
            this.touchMove,
            false
        );
        touchControl.domElement.instance.addEventListener(
            'touchend',
            this.touchEnd,
            false
        );
        touchControl.domElement.instance.addEventListener(
            'touchcancel',
            this.touchCancel,
            false
        );
    }

    /**
     * Same for keyboard controls
     */
    if (this.keyboardControls.length > 0) {
        this.keyboardControls.map(
            function(keyboardControl) {
                keyboardControl.domElement.instance.addEventListener(
                    'keyup',
                    this.keyboardKeyUp,
                    false
                );

                keyboardControl.domElement.instance.addEventListener(
                    'keydown',
                    this.keyboardKeyDown,
                    false
                );
            }.bind(this)
        )
    }

    if (this.mouseControls.length > 0) {

        this.mouseDown  = this.onMouseDown.bind(this);
        this.mouseMove  = this.onMouseMove.bind(this);
        this.mouseWheel = this.onMouseWheel.bind(this);
        this.mouseUp    = this.onMouseUp.bind(this);

        /**
         * Do Nothing
         */
        this.mouseControls.map(
            function(mouseControl) {
                mouseControl.domElement.instance.addEventListener(
                    'mousedown',
                    this.mouseDown,
                    false
                );

                mouseControl.domElement.instance.addEventListener(
                    'mousemove',
                    this.mouseMove,
                    false
                );
                mouseControl.domElement.instance.addEventListener(
                    'wheel',
                    this.mouseWheel,
                    false
                );

                mouseControl.domElement.instance.addEventListener(
                    'mouseup',
                    this.mouseUp,
                    false
                );
            }.bind(this)
        )
    }

    if (this.editorControls.length > 0) {
        this.editorControls.map(
            function(editorControl) {
                /**
                 * If we already have mouse controls, we don't want to add another event listener onto the DOM
                 */
//                if (this.mouseControls.length < 1) {

                this.mouseDownEdit  = this.onMouseDownEdit.bind(this);
                this.mouseMoveEdit  = this.onMouseMoveEdit.bind(this);

                editorControl.domElement.instance.addEventListener(
                    'mousedown',
                    this.mouseDownEdit,
                    false
                );

                editorControl.domElement.instance.addEventListener(
                    'mousemove',
                    this.mouseMoveEdit,
                    false
                );
//                }

                /**
                 * If we already have keyboard controls, we don't want to add another event listener onto the DOM
                 */
                if (this.keyboardControls.length > 0) {
                    /**
                     * Do Nothing
                     */
                } else {

                    editorControl.domElement.instance.addEventListener(
                        'keydown',
                        this.keyDown,
                        false
                    );

                    editorControl.domElement.instance.addEventListener(
                        'keyup',
                        this.keyUp,
                        false
                    );

                }

                editorControl.createInstance();

                /**
                 * If we already have mouse controls, we don't want to add another event listener onto the DOM
                 */
//                if (this.mouseControls.length < 1) {

                this.mouseWheelEdit = this.onMouseWheelEdit.bind(this);
                this.mouseUpEdit    = this.onMouseUpEdit.bind(this);

                editorControl.domElement.instance.addEventListener(
                    'wheel',
                    this.mouseWheelEdit,
                    false
                );

                editorControl.domElement.instance.addEventListener(
                    'mouseup',
                    this.mouseUpEdit,
                    false
                );
//                }

            }.bind(this)
        )
    }

};

GameLib.System.Input.prototype.onKeyboardKeyUp = function(event) {
    GameLib.Event.Emit(
        GameLib.Event.KEY_DOWN,
        {
            code : event.code
        }
    );

};

GameLib.System.Input.prototype.onKeyboardKeyDown = function(event) {
    GameLib.Event.Emit(
        GameLib.Event.KEY_UP,
        {
            code : event.code
        }
    );

};

GameLib.System.Input.prototype.onTouchStart = function(event) {

    this.sensitivityCounter = 0;

    this.touches = {};

    for (var t = 0; t < event.touches.length; t++) {
        this.touches[event.touches[t].identifier] = {
            left : 0,
            right : 0,
            up : 0,
            down : 0,
            pageX : event.touches[t].pageX,
            pageY : event.touches[t].pageY,
            cancelled : false,
            ended : false
        };
    }

    this.touches.event = event;

    GameLib.Event.Emit(
        GameLib.Event.TOUCH_START,
        this.touches
    )
};

GameLib.System.Input.prototype.onTouchMove = function (event) {

    this.sensitivityCounter++;

    var id = null;

        for (var t = 0; t < event.changedTouches.length; t++) {

            id = event.changedTouches[t].identifier;

            var diffX = Math.abs(event.changedTouches[t].pageX - this.touches[id].pageX);
            var diffY = Math.abs(event.changedTouches[t].pageY - this.touches[id].pageY);

            var left = 0;
            var right = 0;
            var up = 0;
            var down = 0;

            if (event.changedTouches[t].pageX > this.touches[id].pageX) {
                right += diffX;
                left -= diffX;
            }

            if (event.changedTouches[t].pageX < this.touches[id].pageX) {
                left += diffX;
                right -= diffX;
            }

            if (event.changedTouches[t].pageY < this.touches[id].pageY) {
                up += diffY;
                down -= diffY;
            }

            if (event.changedTouches[t].pageY > this.touches[id].pageY) {
                down += diffY;
                up -= diffY;
            }

            this.touches[id].right += right;
            this.touches[id].left += left;
            this.touches[id].up += up;
            this.touches[id].down += down;
            this.touches[id].pageX = event.changedTouches[t].pageX;
            this.touches[id].pageY = event.changedTouches[t].pageY;

            //console.log(this.touches[id]);
        }

        this.touches.event = event;

    if (this.sensitivityCounter >= this.touchSensitivity) {

        this.sensitivityCounter = 0;

        GameLib.Event.Emit(
            GameLib.Event.TOUCH_MOVE,
            this.touches
        );

    }

};

GameLib.System.Input.prototype.onTouchCancel = function(event) {

    this.sensitivityCounter = 0;

    for (var t = 0; t < event.changedTouches.length; t++) {
        this.touches[event.changedTouches[t].identifier].cancelled = true;
        this.touches[event.changedTouches[t].identifier].event = event;
        GameLib.Event.Emit(
            GameLib.Event.TOUCH_CANCEL,
            this.touches[event.changedTouches[t].identifier]
        );
        delete this.touches[event.changedTouches[t].identifier];
    }
};

GameLib.System.Input.prototype.onTouchEnd = function(event) {

    this.sensitivityCounter = 0;

    for (var t = 0; t < event.changedTouches.length; t++) {
        this.touches[event.changedTouches[t].identifier].ended = true;
        this.touches[event.changedTouches[t].identifier].event = event;
        GameLib.Event.Emit(
            GameLib.Event.TOUCH_END,
            this.touches[event.changedTouches[t].identifier]
        );
        delete this.touches[event.changedTouches[t].identifier];
    }
};

GameLib.System.Input.prototype.onKeyDown = function(event) {

	console.log('input system emitted keypress ' + event.code);

	GameLib.Event.Emit(
		GameLib.Event.KEY_DOWN,
		{
			code : event.code
		}
	);

	var meshes = null;

	if (event.code === 'Delete') {

		meshes = GameLib.EntityManager.Instance.queryComponents([GameLib.D3.Mesh]);

		var deletedMeshes = [];

		meshes.map(
			function(mesh) {
				if (mesh.selected) {

					deletedMeshes.push(mesh);

					mesh.removeHelper();

					var scene = mesh.parentScene;
					scene.removeObject(mesh);
					scene.buildIdToObject();
				}
			}.bind(this)
		);

		GameLib.Event.Emit(
			GameLib.Event.REMOVE_MESH,
			{
				meshes : deletedMeshes
			}
		);

	}

	if (event.code === 'ControlLeft') {
		this.controlLeft = true;
	}

	if (event.code === 'KeyA') {

		this.selectAll = !this.selectAll;

		meshes = GameLib.EntityManager.Instance.queryComponents([GameLib.D3.Mesh]);

		meshes.map(function(mesh){
			if (this.selectAll) {
				this.selectMesh(mesh);
			} else {
				this.deSelectMesh(mesh);
			}
		}.bind(this));

		GameLib.Event.Emit(
			GameLib.Event.BUILD_GUI,
			null
		)

	}
};

GameLib.System.Input.prototype.onKeyUp = function(event) {

	GameLib.Event.Emit(
		GameLib.Event.KEY_UP,
		{
			code : event.code
		}
	);

	if (event.code === 'ControlLeft') {
		this.controlLeft = false;
	}
};

GameLib.System.Input.prototype.onMouseDown = function(event) {
//    console.log('mouse down');

    GameLib.Event.Emit(
        GameLib.Event.MOUSE_DOWN,
        {
            event : event
        }
    )
};

GameLib.System.Input.prototype.onMouseMove = function(event) {
//    console.log('mouse move');
    GameLib.Event.Emit(
        GameLib.Event.MOUSE_MOVE,
        {
            event : event
        }
    )
};

GameLib.System.Input.prototype.onMouseWheel = function(event) {
//    console.log('mouse wheel');
    GameLib.Event.Emit(
        GameLib.Event.MOUSE_WHEEL,
        {
            event : event
        }
    )
};

GameLib.System.Input.prototype.onMouseUp = function(event) {
//    console.log('mouse up');
    GameLib.Event.Emit(
        GameLib.Event.MOUSE_UP,
        {
            event : event
        }
    )
};

GameLib.System.Input.prototype.onMouseDownEdit = function(event) {

    if (event.button === 2) {

        this.editorControls.map(

            function(editorControl) {

                if (this.controlLeft) {
                    return;
                }

                this.mouse.x =  (event.offsetX / event.target.width ) * 2 - 1;
                this.mouse.y = -(event.offsetY / event.target.height) * 2 + 1;

                var scenes = GameLib.EntityManager.Instance.queryComponents(GameLib.D3.Scene);

                var intersects = scenes.reduce(

                    function (result, scene) {

                        editorControl.raycaster.instance.setFromCamera(
                            this.mouse,
                            editorControl.camera.instance
                        );

                        intersects = editorControl.raycaster.getIntersectedObjects(scene.meshes);

                        intersects.map(function (intersect) {
                            result.push(intersect);
                        });

                        return result;
                    }.bind(this),
                    []
                );

                intersects.sort(
                    function (a, b) {
                        if (a.distance < b.distance) {
                            return -1;
                        }

                        if (a.distance > b.distance) {
                            return 1;
                        }

                        return 0;
                    }
                );

                var meshes = intersects.map(function (intersect) {
                    return intersect.mesh;
                });

                var mesh = meshes[0];

                if (mesh) {

                    /**
                     * Prevent default action (like context menu or whatever)
                     */
                    event.preventDefault();

                    /**
                     * Prevent other event listeners for 'mousedown' from executing their actions
                     */
                    event.stopImmediatePropagation();

                    if (mesh.selected) {
                        this.deSelectMesh(mesh);
                    } else {
                        this.selectMesh(mesh);
                    }

                    /**
                     * Notify our GUI system to build a GUI
                     */
                    GameLib.Event.Emit(
                        GameLib.Event.BUILD_GUI,
                        null
                    )
                }
            }.bind(this)
        );
    }
};

/**
 *
 * @param event
 */
GameLib.System.Input.prototype.onMouseMoveEdit = function(event) {

};

/**
 * Update the camera position etc. after mouse up
 * @returns {Function}
 * @param event
 */
GameLib.System.Input.prototype.onMouseUpEdit = function(event) {
    this.editorControls.map(
        function(editorControl) {
            editorControl.camera.position.x = editorControl.camera.instance.position.x;
            editorControl.camera.position.y = editorControl.camera.instance.position.y;
            editorControl.camera.position.z = editorControl.camera.instance.position.z;

            editorControl.camera.quaternion.x = editorControl.camera.instance.quaternion.x;
            editorControl.camera.quaternion.y = editorControl.camera.instance.quaternion.y;
            editorControl.camera.quaternion.z = editorControl.camera.instance.quaternion.z;
            editorControl.camera.quaternion.w = editorControl.camera.instance.quaternion.w;

            editorControl.camera.lookAt.x = editorControl.instance.center.x;
            editorControl.camera.lookAt.y = editorControl.instance.center.y;
            editorControl.camera.lookAt.z = editorControl.instance.center.z;
            editorControl.camera.lookAt.instance.copy(editorControl.instance.center);
        }
    );
};

/**
 * Update our camera position after moving the mouse wheel
 * @returns {Function}
 * @param event
 */
GameLib.System.Input.prototype.onMouseWheelEdit = function(event) {
    this.editorControls.map(
        function(editorControl) {
            editorControl.camera.position.x = editorControl.camera.instance.position.x;
            editorControl.camera.position.y = editorControl.camera.instance.position.y;
            editorControl.camera.position.z = editorControl.camera.instance.position.z;
        }
    );
};

GameLib.System.Input.prototype.selectMesh = function(mesh) {

	/**
	 * If mesh is already selected, do nothing
	 */
	if (mesh.selected === true) {
		return;
	}

	/**
	 * Notify our component as being 'selected'
	 * @type {boolean}
	 */
	mesh.selected = true;

	mesh.createHelper();

	GameLib.Event.Emit(
		GameLib.Event.MESH_SELECTED,
		{
			mesh : mesh
		}
	);
};

GameLib.System.Input.prototype.deSelectMesh = function(mesh) {

	mesh.selected = false;

	mesh.removeHelper();

	GameLib.Event.Emit(
		GameLib.Event.MESH_DESELECTED,
		{
			mesh : mesh
		}
	);
};

/**
 *
 */
GameLib.System.Input.prototype.stop = function() {

    GameLib.System.prototype.stop.call(this);

    this.delayedInstanceEncounteredSubscription.remove();

    if (this.editorControls.length > 0) {
        /**
         * Now remove all input capabilities
         */
        this.editorControls.map(
            function(editorControl) {

//                if (this.mouseControls.length < 1) {

                    editorControl.domElement.instance.removeEventListener(
                        'mousedown',
                        this.mouseDownEdit,
                        false
                    );

                    editorControl.domElement.instance.removeEventListener(
                        'mousemove',
                        this.mouseMoveEdit,
                        false
                    );

//                }

                if (this.keyboardControls.length < 1) {
                    editorControl.domElement.instance.removeEventListener(
                        'keydown',
                        this.keyDown,
                        false
                    );

                    editorControl.domElement.instance.removeEventListener(
                        'keyup',
                        this.keyUp,
                        false
                    );
                }

                editorControl.instance.dispose();

//                if (this.mouseControls.length < 1) {
                    editorControl.domElement.instance.removeEventListener(
                        'wheel',
                        this.mouseWheelEdit,
                        false
                    );

                    editorControl.domElement.instance.removeEventListener(
                        'mouseup',
                        this.mouseUpEdit,
                        false
                    );
//                }
            }.bind(this)
        )
    }

    if (this.touchControls.length > 0) {

        this.touchControls.map(
            function(touchControl) {
                touchControl.domElement.instance.removeEventListener(
                    'touchstart',
                    this.touchStart,
                    false
                );

                touchControl.domElement.instance.removeEventListener(
                    'touchmove',
                    this.touchMove,
                    false
                );

                touchControl.domElement.instance.removeEventListener(
                    'touchend',
                    this.touchEnd,
                    false
                );

                touchControl.domElement.instance.removeEventListener(
                    'touchcancel',
                    this.touchCancel,
                    false
                );
            }.bind(this)
        )
    }

    if (this.keyboardControls.length > 0) {

        this.keyboardControls.map(
            function(keyboardControl) {
                keyboardControl.domElement.instance.removeEventListener(
                    'keydown',
                    this.keyboardKeyDown,
                    false
                );

                keyboardControl.domElement.instance.removeEventListener(
                    'keyup',
                    this.keyboardKeyUp,
                    false
                );
            }.bind(this)
        )
    }

    if (this.mouseControls.length > 0) {

        this.mouseControls.map(
            function(mouseControl) {
                mouseControl.domElement.instance.removeEventListener(
                    'mousedown',
                    this.mouseDown,
                    false
                );

                mouseControl.domElement.instance.removeEventListener(
                    'mousemove',
                    this.mouseMove,
                    false
                );
                mouseControl.domElement.instance.removeEventListener(
                    'wheel',
                    this.mouseWheel,
                    false
                );

                mouseControl.domElement.instance.removeEventListener(
                    'mouseup',
                    this.mouseUp,
                    false
                );
            }.bind(this)
        )
    }

};




//
//     console.log('keypressed ' + event.code);
//
//     if (event.code === 'KeyV') {
//         //todo - change view
//     }
//
//
//     if (event.code == 'KeyG') {
//         if (!this.meshMoveMode) {
//             console.log('move mode');
//             this.meshMoveMode = true;
//         }
//     }
//
//     if (event.code == 'KeyX') {
//         if (this.meshMoveMode) {
//             console.log('move along x');
//             this.meshMoveXMode = true;
//             this.meshMoveYMode = false;
//             this.meshMoveZMode = false;
//         }
//     }
//
//     if (event.code == 'KeyY') {
//         if (this.meshMoveMode) {
//             console.log('move along y');
//             this.meshMoveXMode = false;
//             this.meshMoveYMode = true;
//             this.meshMoveZMode = false;
//         }
//     }
//
//     if (event.code == 'KeyZ') {
//         if (this.meshMoveMode) {
//             console.log('move along z');
//             this.meshMoveXMode = false;
//             this.meshMoveYMode = false;
//             this.meshMoveZMode = true;
//         }
//     }
//
//     if (event.code == 'Escape') {
//         if (this.meshMoveMode) {
//             this.meshMoveMode = false;
//             console.log('TODO: implement restore positions');
//         }
//     }
//
//     if (event.code == 'Enter') {
//         if (this.meshMoveMode) {
//             this.meshMoveMode = false;
//             console.log('TODO: implement apply positions');
//         }
//     }
// };

// GameLib.D3.Input.Editor.prototype.onMouseDown = function(entity) {
//
// 	return function(event) {
//
// 		if (event.button === 2) {
// 			event.cancelBubble = true;
//
// 			event.preventDefault();
//
// 			if (event.stopPropagation) {
// 				event.stopPropagation();
// 			}
//
// 			var meshes = entity.queryComponents(GameLib.D3.Mesh);
//
// 			var intersects = this.raycaster.getIntersectedObjects(meshes);
//
// 			if (intersects.length > 0) {
//
// 				console.log('object(s) instersected');
//
// 				// var index = -1;
// 				//
// 				// for (var s = 0; s < this.editor.selectedObjects.length; s++) {
// 				// 	if (this.editor.selectedObjects[s].object == intersects[0]) {
// 				// 		index = s;
// 				// 		break;
// 				// 	}
// 				// }
// 				//
// 				// if (index == -1) {
// 				// 	/**
// 				// 	 * The object is not selected, select it
// 				// 	 */
// 				// 	this.selectObject(intersects[0]);
// 				//
// 				// } else {
// 				// 	/**
// 				// 	 * De-select the objec
// 				// 	 */
// 				// 	var delta = Date.now() - this.editor.selectedObjects[index].lastUpdate;
// 				// 	if (delta > this.selectDelayMs) {
// 				// 		this.unselectObject(intersects[0]);
// 				// 	}
// 				// }
// 				//
// 				// if (this.editor.onSelectionChanged) {
// 				// 	this.editor.onSelectionChanged(this.editor);
// 				// }
// 			}
//
// 			return false;
// 		}
// 	}
// };

// /**
//  * Mouse click events
//  * @param event
//  * @returns {boolean}
//  */
// GameLib.D3.Input.Editor.prototype.onMouseDown = function(event) {
//
//     if (event.button === 2) {
//
//
//
//
//
//     }
//
//     if (event.button == 0) {
//         if (this.meshMoveMode) {
//             this.meshMoveMode   = false;
//             this.meshMoveXMode  = false;
//             this.meshMoveYMode  = false;
//             this.meshMoveZMode  = false;
//         }
//     }
// };

// /**
//  * Mouse move events
//  * @param event
//  */
// GameLib.D3.Input.Editor.prototype.onMouseMove = function(event) {
//
//     // var clientX = event.clientX - this.widthOffset;
//     // this.mouse.x = ((clientX / (window.innerWidth - this.widthOffset))) * 2 - 1;
//     // this.mouse.y = -(event.clientY / window.innerHeight) * 2 + 1;
//
// 	this.mouse.x = event.clientX;
// 	this.mouse.y = event.clientY;
//
// 	console.log("mouse (" + this.mouse.x + ", " + this.mouse.y + ")");
//
//     this.raycaster.instance.setFromCamera(
//         this.mouse,
//         this.camera.instance
//     );
//
//     if (this.meshMoveMode) {
//
//         var units = event.movementY;
//
//         if (this.meshMoveXMode) {
//             this.moveSelectedObjects('x', units);
//         }
//
//         if (this.meshMoveYMode) {
//             this.moveSelectedObjects('y', units);
//         }
//
//         if (this.meshMoveZMode) {
//             this.moveSelectedObjects('z', units);
//         }
//     }
// };

// /**
//  * Moves selected objects along an axis
//  * @param alongAxis
//  * @param units
//  */
// GameLib.D3.Input.Editor.prototype.moveSelectedObjects = function(alongAxis, units) {
//
//     for (var s = 0; s < this.editor.selectedObjects.length; s++) {
//
//         var object = this.editor.selectedObjects[s].object;
//
//         if (object.position) {
//             if (alongAxis == 'x') {
//                 object.position.x += units;
//             }
//             if (alongAxis == 'y') {
//                 object.position.y += units;
//             }
//             if (alongAxis == 'z') {
//                 object.position.z += units;
//             }
//
//             if (object.updateInstance) {
//                 object.updateInstance();
//             }
//         }
//     }
// };