1419 lines
36 KiB
JavaScript
1419 lines
36 KiB
JavaScript
/**
|
|
* System takes care of updating all the entities (based on their component data)
|
|
* @param apiSystem GameLib.API.System
|
|
* @constructor
|
|
*/
|
|
GameLib.System.Input = function(
|
|
apiSystem
|
|
) {
|
|
GameLib.System.call(
|
|
this,
|
|
apiSystem
|
|
);
|
|
|
|
this.selectAll = false;
|
|
|
|
this.controlLeft = false;
|
|
|
|
this.sensitivityCounter = 0;
|
|
|
|
this.editorControls = [];
|
|
this.touchControls = [];
|
|
this.keyboardControls = [];
|
|
this.mouseControls = [];
|
|
|
|
/**
|
|
* Touch Controls
|
|
* @type {null}
|
|
*/
|
|
this.touchStart = this.onTouchStart.bind(this);
|
|
this.touchMove = this.onTouchMove.bind(this);
|
|
this.touchEnd = this.onTouchEnd.bind(this);
|
|
this.touchCancel = this.onTouchCancel.bind(this);
|
|
|
|
/**
|
|
* Keyboard Controls
|
|
* @type {null}
|
|
*/
|
|
this.keyboardKeyUp = this.onKeyboardKeyUp.bind(this);
|
|
this.keyboardKeyDown = this.onKeyboardKeyDown.bind(this);
|
|
|
|
/**
|
|
* Mouse Controls
|
|
* @type {null}
|
|
*/
|
|
this.mouseDown = this.onMouseDown.bind(this);
|
|
this.mouseMove = this.onMouseMove.bind(this);
|
|
this.mouseWheel = this.onMouseWheel.bind(this);
|
|
this.mouseUp = this.onMouseUp.bind(this);
|
|
|
|
|
|
/**
|
|
* Editor Controls
|
|
* @type {null}
|
|
*/
|
|
this.keyDown = this.onKeyDown.bind(this);
|
|
this.keyUp = this.onKeyUp.bind(this);
|
|
this.mouseDownEdit = this.onMouseDownEdit.bind(this);
|
|
this.mouseMoveEdit = this.onMouseMoveEdit.bind(this);
|
|
this.mouseWheelEdit = this.onMouseWheelEdit.bind(this);
|
|
this.mouseUpEdit = this.onMouseUpEdit.bind(this);
|
|
|
|
this.delayedInstanceEncounteredSubscription = null;
|
|
this.instanceCreatedSubscription = null;
|
|
this.removeComponentSubscription = null;
|
|
this.canvasChangeSubscription = null;
|
|
this.selectionModeChangeSubscription = null;
|
|
|
|
this.selectionMode = GameLib.System.Input.SELECTION_MODE_DEFAULT;
|
|
|
|
this.mouse = new GameLib.Mouse();
|
|
};
|
|
|
|
GameLib.System.Input.prototype = Object.create(GameLib.System.prototype);
|
|
GameLib.System.Input.prototype.constructor = GameLib.System.Input;
|
|
|
|
GameLib.System.Input.SELECTION_MODE_MESH = 0x1;
|
|
GameLib.System.Input.SELECTION_MODE_FACE = 0x2;
|
|
GameLib.System.Input.SELECTION_MODE_DEFAULT = 0x1;
|
|
|
|
/**
|
|
*
|
|
*/
|
|
GameLib.System.Input.prototype.start = function() {
|
|
|
|
GameLib.System.prototype.start.call(this);
|
|
|
|
this.instanceCreatedSubscription = GameLib.Event.Subscribe(
|
|
GameLib.Event.INSTANCE_CREATED,
|
|
this.instanceCreated.bind(this)
|
|
);
|
|
|
|
this.removeComponentSubscription = GameLib.Event.Subscribe(
|
|
GameLib.Event.REMOVE_COMPONENT,
|
|
this.removeComponent.bind(this)
|
|
);
|
|
|
|
this.delayedInstanceEncounteredSubscription = GameLib.Event.Subscribe(
|
|
GameLib.Event.DELAYED_INSTANCE_ENCOUNTERED,
|
|
this.delayedInstanceEncountered.bind(this)
|
|
);
|
|
|
|
this.canvasChangeSubscription = GameLib.Event.Subscribe(
|
|
GameLib.Event.CANVAS_CHANGE,
|
|
this.canvasChange.bind(this)
|
|
);
|
|
|
|
this.selectionModeChangeSubscription = GameLib.Event.Subscribe(
|
|
GameLib.Event.SELECTION_MODE_CHANGE,
|
|
this.selectionModeChange.bind(this)
|
|
);
|
|
|
|
this.editorControls = GameLib.EntityManager.Instance.queryComponents(GameLib.Component.CONTROLS_EDITOR);
|
|
|
|
this.touchControls = GameLib.EntityManager.Instance.queryComponents(GameLib.Component.CONTROLS_TOUCH);
|
|
|
|
this.keyboardControls = GameLib.EntityManager.Instance.queryComponents(GameLib.Component.CONTROLS_KEYBOARD);
|
|
|
|
this.mouseControls = GameLib.EntityManager.Instance.queryComponents(GameLib.Component.CONTROLS_MOUSE);
|
|
|
|
/**
|
|
* If we have touch controls - inject them first so we can override editor controls if necessary
|
|
*/
|
|
this.touchControls.map(
|
|
function(touchControl){
|
|
this.registerTouchControls(touchControl);
|
|
}.bind(this)
|
|
);
|
|
|
|
this.keyboardControls.map(
|
|
function(keyboardControl){
|
|
this.registerKeyboardControls(keyboardControl);
|
|
}.bind(this)
|
|
);
|
|
|
|
this.mouseControls.map(
|
|
function(mouseControl){
|
|
this.registerMouseControls(mouseControl);
|
|
}.bind(this)
|
|
);
|
|
|
|
this.editorControls.map(
|
|
function(editorControl){
|
|
this.registerEditorControls(editorControl);
|
|
}.bind(this)
|
|
);
|
|
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
GameLib.System.Input.prototype.stop = function() {
|
|
|
|
GameLib.System.prototype.stop.call(this);
|
|
|
|
this.instanceCreatedSubscription.remove();
|
|
|
|
this.removeComponentSubscription.remove();
|
|
|
|
this.delayedInstanceEncounteredSubscription.remove();
|
|
|
|
this.canvasChangeSubscription.remove();
|
|
|
|
this.selectionModeChangeSubscription.remove();
|
|
|
|
this.touchControls.map(
|
|
function(touchControl){
|
|
this.deRegisterTouchControls(touchControl);
|
|
}.bind(this)
|
|
);
|
|
|
|
this.keyboardControls.map(
|
|
function(keyboardControl){
|
|
this.deRegisterKeyboardControls(keyboardControl);
|
|
}.bind(this)
|
|
);
|
|
|
|
this.mouseControls.map(
|
|
function(mouseControl){
|
|
this.deRegisterMouseControls(mouseControl);
|
|
}.bind(this)
|
|
);
|
|
|
|
this.editorControls.map(
|
|
function(editorControl){
|
|
this.deRegisterEditorControls(editorControl);
|
|
}.bind(this)
|
|
);
|
|
|
|
this.editorControls = [];
|
|
|
|
this.touchControls = [];
|
|
|
|
this.keyboardControls = [];
|
|
|
|
this.mouseControls = [];
|
|
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @param data
|
|
*/
|
|
GameLib.System.Input.prototype.canvasChange = function(data) {
|
|
if (data.component instanceof GameLib.Controls) {
|
|
console.log('todo: implement dom element change');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Changes the selection mode from face to mesh etc.
|
|
* @param data
|
|
*/
|
|
GameLib.System.Input.prototype.selectionModeChange = function(data) {
|
|
this.selectionMode = data.selectionMode;
|
|
};
|
|
|
|
/**
|
|
* From now on we want to track everything about a component, only from the systems that are active
|
|
* @param data
|
|
*/
|
|
GameLib.System.Input.prototype.instanceCreated = function(data) {
|
|
|
|
if (data.component instanceof GameLib.Controls.Touch) {
|
|
|
|
if (this.touchControls.indexOf(data.component) !== -1) {
|
|
console.warn('Touch controls already registered');
|
|
return;
|
|
}
|
|
|
|
this.touchControls.push(data.component);
|
|
this.registerTouchControls(data.component);
|
|
}
|
|
|
|
if (data.component instanceof GameLib.Controls.Keyboard) {
|
|
|
|
if (this.keyboardControls.indexOf(data.component) !== -1) {
|
|
console.warn('Keyboard controls already registered');
|
|
return;
|
|
}
|
|
|
|
this.keyboardControls.push(data.component);
|
|
this.registerKeyboardControls(data.component);
|
|
}
|
|
|
|
if (data.component instanceof GameLib.Controls.Mouse) {
|
|
|
|
if (this.mouseControls.indexOf(data.component) !== -1) {
|
|
console.warn('Mouse controls already registered');
|
|
return;
|
|
}
|
|
|
|
this.mouseControls.push(data.component);
|
|
this.registerMouseControls(data.component);
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Removes controls from this system
|
|
* @param data
|
|
*/
|
|
GameLib.System.Input.prototype.removeComponent = function(data) {
|
|
|
|
var index;
|
|
|
|
if (data.component instanceof GameLib.Controls.D3.Editor) {
|
|
|
|
index = this.editorControls.indexOf(data.component);
|
|
|
|
if (index === -1) {
|
|
console.warn('Failed to find the editor controls in the system - probably it was ignored - ' + data.component.name);
|
|
return;
|
|
}
|
|
|
|
console.log('removing editor controls from system');
|
|
|
|
this.deRegisterEditorControls(data.component);
|
|
|
|
this.editorControls.splice(index, 1);
|
|
}
|
|
|
|
if (data.component instanceof GameLib.Controls.Touch) {
|
|
|
|
index = this.touchControls.indexOf(data.component);
|
|
|
|
if (index === -1) {
|
|
console.warn('Failed to find the touch controls in the system - probably it was ignored - ' + data.component.name);
|
|
return;
|
|
}
|
|
|
|
console.log('removing touch controls from system');
|
|
|
|
this.deRegisterTouchControls(data.component);
|
|
|
|
this.touchControls.splice(index, 1);
|
|
}
|
|
|
|
if (data.component instanceof GameLib.Controls.Keyboard) {
|
|
|
|
index = this.keyboardControls.indexOf(data.component);
|
|
|
|
if (index === -1) {
|
|
console.warn('Failed to find the keyboard controls in the system - probably it was ignored - ' + data.component.name);
|
|
return;
|
|
}
|
|
|
|
console.log('removing keyboard controls from system');
|
|
|
|
this.deRegisterKeyboardControls(data.component);
|
|
|
|
this.keyboardControls.splice(index, 1);
|
|
}
|
|
|
|
if (data.component instanceof GameLib.Controls.Mouse) {
|
|
|
|
index = this.mouseControls.indexOf(data.component);
|
|
|
|
if (index === -1) {
|
|
console.warn('Failed to find the mouse controls in the system - probably it was ignored - ' + data.component.name);
|
|
return;
|
|
}
|
|
|
|
console.log('removing mouse controls from system');
|
|
|
|
this.deRegisterMouseControls(data.component);
|
|
|
|
this.mouseControls.splice(index, 1);
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Delayed Instance - we need to check if editControls will block the loading process (since only one will be created)
|
|
* @param data
|
|
*/
|
|
GameLib.System.Input.prototype.delayedInstanceEncountered = function(data) {
|
|
|
|
if (data.component instanceof GameLib.Controls.D3.Editor) {
|
|
|
|
if (this.editorControls.indexOf(data.component) !== -1) {
|
|
console.warn('Editor controls already registered');
|
|
return;
|
|
}
|
|
|
|
this.editorControls.push(data.component);
|
|
|
|
this.registerEditorControls(data.component);
|
|
}
|
|
|
|
};
|
|
|
|
GameLib.System.Input.prototype.registerTouchControls = function(touchControl) {
|
|
|
|
if (!touchControl.canvas || !touchControl.canvas.instance) {
|
|
console.warn('no canvas at time of registration of touch controls - this part will be skipped');
|
|
return;
|
|
}
|
|
|
|
touchControl.canvas.instance.addEventListener(
|
|
'touchstart',
|
|
this.touchStart,
|
|
true
|
|
);
|
|
|
|
touchControl.canvas.instance.addEventListener(
|
|
'touchmove',
|
|
this.touchMove,
|
|
true
|
|
);
|
|
touchControl.canvas.instance.addEventListener(
|
|
'touchend',
|
|
this.touchEnd,
|
|
true
|
|
);
|
|
touchControl.canvas.instance.addEventListener(
|
|
'touchcancel',
|
|
this.touchCancel,
|
|
true
|
|
);
|
|
};
|
|
|
|
GameLib.System.Input.prototype.registerKeyboardControls = function(keyboardControl) {
|
|
|
|
if (!keyboardControl.canvas || !keyboardControl.canvas.instance) {
|
|
console.warn('no canvas at time of registration of keyboard controls - this part will be skipped');
|
|
return;
|
|
}
|
|
|
|
keyboardControl.canvas.instance.addEventListener(
|
|
'keyup',
|
|
this.keyboardKeyUp,
|
|
true
|
|
);
|
|
|
|
keyboardControl.canvas.instance.addEventListener(
|
|
'keydown',
|
|
this.keyboardKeyDown,
|
|
true
|
|
);
|
|
};
|
|
|
|
GameLib.System.Input.prototype.registerMouseControls = function(mouseControl) {
|
|
|
|
if (!mouseControl.canvas || !mouseControl.canvas.instance) {
|
|
console.warn('no canvas at time of registration of mouse controls - this part will be skipped');
|
|
return;
|
|
}
|
|
|
|
mouseControl.canvas.instance.addEventListener(
|
|
'mousedown',
|
|
this.mouseDown,
|
|
false
|
|
);
|
|
|
|
mouseControl.canvas.instance.addEventListener(
|
|
'mousemove',
|
|
this.mouseMove,
|
|
false
|
|
);
|
|
|
|
mouseControl.canvas.instance.addEventListener(
|
|
'wheel',
|
|
this.mouseWheel,
|
|
false
|
|
);
|
|
|
|
mouseControl.canvas.instance.addEventListener(
|
|
'mouseup',
|
|
this.mouseUp,
|
|
false
|
|
);
|
|
};
|
|
|
|
/**
|
|
* TODO: change the input mode so that when in 'edit' mode - editor controls take effect only, otherwise the normal
|
|
* TODO: keyboard / mouse /touch controls are in effect
|
|
* @param editorControl
|
|
*/
|
|
GameLib.System.Input.prototype.registerEditorControls = function(editorControl) {
|
|
|
|
/**
|
|
* In the 'Flammentraum' example, we need the mouse controls
|
|
*/
|
|
// this.mouseControls.map(
|
|
// function(mouseControl) {
|
|
// if (mouseControl.canvas.instance === editorControl.canvas.instance) {
|
|
// this.deRegisterMouseControls(mouseControl);
|
|
// }
|
|
// }.bind(this)
|
|
// );
|
|
|
|
/**
|
|
* If we already have keyboard controls, we don't want to add another event listener onto the DOM
|
|
*/
|
|
this.keyboardControls.map(
|
|
function(keyboardControl) {
|
|
if (keyboardControl.canvas.instance === editorControl.canvas.instance) {
|
|
this.deRegisterKeyboardControls(keyboardControl);
|
|
}
|
|
}.bind(this)
|
|
);
|
|
|
|
if (!editorControl.canvas || !editorControl.canvas.instance) {
|
|
console.warn('no canvas at time of registration of editor controls - are you sure you know what you are doing?');
|
|
return;
|
|
}
|
|
|
|
editorControl.canvas.instance.addEventListener(
|
|
'mousedown',
|
|
this.mouseDownEdit,
|
|
true
|
|
);
|
|
|
|
editorControl.canvas.instance.addEventListener(
|
|
'mousemove',
|
|
this.mouseMoveEdit,
|
|
true
|
|
);
|
|
|
|
editorControl.canvas.instance.addEventListener(
|
|
'keydown',
|
|
this.keyDown,
|
|
true
|
|
);
|
|
|
|
editorControl.canvas.instance.addEventListener(
|
|
'keyup',
|
|
this.keyUp,
|
|
true
|
|
);
|
|
|
|
/**
|
|
* The order of creation is important here - it changes the way the DOM reacts to events
|
|
*/
|
|
editorControl.createInstance();
|
|
|
|
editorControl.canvas.instance.addEventListener(
|
|
'wheel',
|
|
this.mouseWheelEdit,
|
|
true
|
|
);
|
|
|
|
editorControl.canvas.instance.addEventListener(
|
|
'mouseup',
|
|
this.mouseUpEdit,
|
|
true
|
|
);
|
|
};
|
|
|
|
GameLib.System.Input.prototype.deRegisterEditorControls = function(editorControl) {
|
|
|
|
editorControl.canvas.instance.removeEventListener(
|
|
'mousedown',
|
|
this.mouseDownEdit,
|
|
true
|
|
);
|
|
|
|
editorControl.canvas.instance.removeEventListener(
|
|
'mousemove',
|
|
this.mouseMoveEdit,
|
|
true
|
|
);
|
|
|
|
editorControl.canvas.instance.removeEventListener(
|
|
'keydown',
|
|
this.keyDown,
|
|
true
|
|
);
|
|
|
|
editorControl.canvas.instance.removeEventListener(
|
|
'keyup',
|
|
this.keyUp,
|
|
true
|
|
);
|
|
|
|
editorControl.instance.dispose();
|
|
|
|
editorControl.canvas.instance.removeEventListener(
|
|
'wheel',
|
|
this.mouseWheelEdit,
|
|
true
|
|
);
|
|
|
|
editorControl.canvas.instance.removeEventListener(
|
|
'mouseup',
|
|
this.mouseUpEdit,
|
|
true
|
|
);
|
|
|
|
};
|
|
|
|
GameLib.System.Input.prototype.deRegisterTouchControls = function(touchControl) {
|
|
|
|
touchControl.canvas.instance.removeEventListener(
|
|
'touchstart',
|
|
this.touchStart,
|
|
true
|
|
);
|
|
|
|
touchControl.canvas.instance.removeEventListener(
|
|
'touchmove',
|
|
this.touchMove,
|
|
true
|
|
);
|
|
|
|
touchControl.canvas.instance.removeEventListener(
|
|
'touchend',
|
|
this.touchEnd,
|
|
true
|
|
);
|
|
|
|
touchControl.canvas.instance.removeEventListener(
|
|
'touchcancel',
|
|
this.touchCancel,
|
|
true
|
|
);
|
|
|
|
};
|
|
|
|
GameLib.System.Input.prototype.deRegisterKeyboardControls = function(keyboardControl) {
|
|
|
|
keyboardControl.canvas.instance.removeEventListener(
|
|
'keydown',
|
|
this.keyboardKeyDown,
|
|
true
|
|
);
|
|
|
|
keyboardControl.canvas.instance.removeEventListener(
|
|
'keyup',
|
|
this.keyboardKeyUp,
|
|
true
|
|
);
|
|
|
|
};
|
|
|
|
|
|
GameLib.System.Input.prototype.deRegisterMouseControls = function(mouseControl) {
|
|
|
|
mouseControl.canvas.instance.removeEventListener(
|
|
'mousedown',
|
|
this.mouseDown,
|
|
false
|
|
);
|
|
|
|
mouseControl.canvas.instance.removeEventListener(
|
|
'mousemove',
|
|
this.mouseMove,
|
|
false
|
|
);
|
|
|
|
mouseControl.canvas.instance.removeEventListener(
|
|
'wheel',
|
|
this.mouseWheel,
|
|
false
|
|
);
|
|
|
|
mouseControl.canvas.instance.removeEventListener(
|
|
'mouseup',
|
|
this.mouseUp,
|
|
false
|
|
);
|
|
|
|
};
|
|
|
|
GameLib.System.Input.prototype.onKeyboardKeyUp = function(event) {
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.KEY_DOWN,
|
|
{
|
|
code : event.code || event.key
|
|
}
|
|
);
|
|
|
|
};
|
|
|
|
GameLib.System.Input.prototype.onKeyboardKeyDown = function(event) {
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.KEY_UP,
|
|
{
|
|
code : event.code || event.key
|
|
}
|
|
);
|
|
|
|
};
|
|
|
|
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,
|
|
lastTouchX : event.touches[t].pageX,
|
|
lastTouchY : event.touches[t].pageY,
|
|
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;
|
|
|
|
var leftTouch = null;
|
|
var rightTouch = null;
|
|
var bottomTouch = null;
|
|
var topTouch = null;
|
|
|
|
var inward = false;
|
|
var outward = false;
|
|
var pinch = false;
|
|
var zoom = false;
|
|
|
|
var totalUp = 0;
|
|
var totalDown = 0;
|
|
var totalLeft = 0;
|
|
var totalRight = 0;
|
|
|
|
for (var t = 0; t < event.changedTouches.length; t++) {
|
|
|
|
id = event.changedTouches[t].identifier;
|
|
|
|
if (this.touches[id]) {
|
|
|
|
var diffX = Math.abs(this.touches[id].lastTouchX - event.changedTouches[t].pageX);
|
|
var diffY = Math.abs(this.touches[id].lastTouchY - event.changedTouches[t].pageY);
|
|
|
|
var left = 0;
|
|
var right = 0;
|
|
var up = 0;
|
|
var down = 0;
|
|
|
|
if (this.touches[id].lastTouchX < event.changedTouches[t].pageX) {
|
|
right += diffX;
|
|
}
|
|
|
|
if (this.touches[id].lastTouchX > event.changedTouches[t].pageX) {
|
|
left += diffX;
|
|
}
|
|
|
|
if (this.touches[id].lastTouchY > event.changedTouches[t].pageY) {
|
|
up += diffY;
|
|
}
|
|
|
|
if (this.touches[id].lastTouchY < event.changedTouches[t].pageY) {
|
|
down += diffY;
|
|
}
|
|
|
|
this.touches[id].right = right;
|
|
this.touches[id].left = left;
|
|
this.touches[id].up = up;
|
|
this.touches[id].down = down;
|
|
this.touches[id].lastTouchX = event.changedTouches[t].pageX;
|
|
this.touches[id].lastTouchY = event.changedTouches[t].pageY;
|
|
this.touches[id].pageX = event.changedTouches[t].pageX;
|
|
this.touches[id].pageY = event.changedTouches[t].pageY;
|
|
|
|
totalLeft += left;
|
|
totalRight += right;
|
|
totalUp += up;
|
|
totalDown += down;
|
|
}
|
|
}
|
|
|
|
if (event.changedTouches.length === 2) {
|
|
if (event.changedTouches[0].pageX < event.changedTouches[1].pageX) {
|
|
leftTouch = this.touches[event.changedTouches[0].identifier];
|
|
rightTouch = this.touches[event.changedTouches[1].identifier];
|
|
} else {
|
|
leftTouch = this.touches[event.changedTouches[1].identifier];
|
|
rightTouch = this.touches[event.changedTouches[0].identifier];
|
|
}
|
|
|
|
if (event.changedTouches[0].pageY < event.changedTouches[1].pageY) {
|
|
bottomTouch = this.touches[event.changedTouches[1].identifier];
|
|
topTouch = this.touches[event.changedTouches[0].identifier];
|
|
} else {
|
|
bottomTouch = this.touches[event.changedTouches[0].identifier];
|
|
topTouch = this.touches[event.changedTouches[1].identifier];
|
|
}
|
|
}
|
|
|
|
if (leftTouch && leftTouch.left && rightTouch && rightTouch.right) {
|
|
outward = true;
|
|
}
|
|
|
|
if (leftTouch && leftTouch.right && rightTouch && rightTouch.left) {
|
|
inward = true;
|
|
}
|
|
|
|
if (bottomTouch && bottomTouch.up && topTouch && topTouch.down) {
|
|
pinch = true;
|
|
}
|
|
|
|
if (bottomTouch && bottomTouch.down && topTouch && topTouch.up) {
|
|
zoom = true;
|
|
}
|
|
|
|
this.touches.event = event;
|
|
|
|
this.touches.meta = {
|
|
inward : inward,
|
|
outward : outward,
|
|
pinch : pinch,
|
|
zoom : zoom,
|
|
totalLeft : totalLeft,
|
|
totalRight : totalRight,
|
|
totalUp : totalUp,
|
|
totalDown : totalDown
|
|
};
|
|
|
|
// 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 || event.key
|
|
}
|
|
);
|
|
|
|
var meshes = null;
|
|
|
|
if (event.code === 'Delete') {
|
|
|
|
meshes = GameLib.EntityManager.Instance.queryComponentsByConstructor(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;
|
|
|
|
if (this.selectionMode === GameLib.System.Input.SELECTION_MODE_MESH) {
|
|
|
|
meshes = GameLib.EntityManager.Instance.queryComponentsByConstructor(GameLib.D3.Mesh);
|
|
|
|
meshes.map(function (mesh) {
|
|
if (this.selectAll) {
|
|
this.selectMesh(mesh);
|
|
} else {
|
|
this.deselectMesh(mesh);
|
|
}
|
|
}.bind(this));
|
|
} else {
|
|
console.warn('todo: implement face select all');
|
|
}
|
|
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.BUILD_GUI,
|
|
null
|
|
)
|
|
|
|
}
|
|
|
|
if (event.code === 'KeyP') {
|
|
GameLib.Event.Emit(GameLib.Event.GAME_PAUSE);
|
|
}
|
|
};
|
|
|
|
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) {
|
|
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.MOUSE_DOWN,
|
|
{
|
|
event : event
|
|
}
|
|
)
|
|
};
|
|
|
|
GameLib.System.Input.prototype.onMouseMove = function(event) {
|
|
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.MOUSE_MOVE,
|
|
{
|
|
event : event
|
|
}
|
|
)
|
|
};
|
|
|
|
GameLib.System.Input.prototype.onMouseWheel = function(event) {
|
|
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.MOUSE_WHEEL,
|
|
{
|
|
event : event
|
|
}
|
|
)
|
|
};
|
|
|
|
GameLib.System.Input.prototype.onMouseUp = function(event) {
|
|
|
|
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;
|
|
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.GET_RENDER_CONFIGURATION,
|
|
null,
|
|
function(configuration) {
|
|
|
|
var scenes = configuration.activeScenes;
|
|
|
|
var camera = configuration.activeCamera;
|
|
|
|
var intersects = scenes.reduce(
|
|
|
|
function (result, scene) {
|
|
|
|
editorControl.raycaster.setFromCamera(
|
|
this.mouse,
|
|
camera
|
|
);
|
|
|
|
intersects = editorControl.raycaster.getIntersectedObjects(scene.meshes);
|
|
|
|
intersects.map(function (intersect) {
|
|
result.push(intersect);
|
|
});
|
|
|
|
return result;
|
|
}.bind(this),
|
|
[]
|
|
);
|
|
|
|
if (intersects.length < 1) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Find the closest intersected mesh
|
|
*/
|
|
intersects.sort(
|
|
function (a, b) {
|
|
if (a.distance < b.distance) {
|
|
return -1;
|
|
}
|
|
|
|
if (a.distance > b.distance) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
);
|
|
|
|
var mesh = intersects[0].mesh;
|
|
var face = intersects[0].face;
|
|
|
|
/**
|
|
* Prevent default action (like context menu or whatever)
|
|
*/
|
|
event.preventDefault();
|
|
|
|
/**
|
|
* Prevent other event listeners for 'mousedown' from executing their actions
|
|
*/
|
|
event.stopImmediatePropagation();
|
|
|
|
if (this.selectionMode === GameLib.System.Input.SELECTION_MODE_MESH) {
|
|
|
|
if (mesh.selected) {
|
|
this.deselectMesh(mesh);
|
|
} else {
|
|
this.selectMesh(mesh);
|
|
}
|
|
|
|
} else {
|
|
if (face.selected) {
|
|
this.deselectFace(mesh, face);
|
|
} else {
|
|
this.selectFace(mesh, face);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notify our GUI system to build a GUI
|
|
*/
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.BUILD_GUI,
|
|
null
|
|
)
|
|
}.bind(this)
|
|
);
|
|
|
|
}.bind(this)
|
|
);
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @param event
|
|
*/
|
|
GameLib.System.Input.prototype.onMouseMoveEdit = function(event) {
|
|
GameLib.EntityManager.Instance.queryComponents(GameLib.Component.MOUSE).map(
|
|
function(mouse) {
|
|
mouse.x = event.clientX;
|
|
mouse.y = event.clientY;
|
|
}
|
|
)
|
|
|
|
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 the camera position etc. after mouse up
|
|
* @returns {Function}
|
|
* @param event
|
|
*/
|
|
GameLib.System.Input.prototype.onMouseUpEdit = function(event) {
|
|
|
|
};
|
|
|
|
/**
|
|
* 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.selectFace = function(mesh, face) {
|
|
|
|
/**
|
|
* If mesh is already selected, do nothing
|
|
*/
|
|
if (face.selected === true) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Notify our component as being 'selected'
|
|
* @type {boolean}
|
|
*/
|
|
face.selected = true;
|
|
|
|
face.createHelper(mesh);
|
|
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.MESH_FACE_SELECTED,
|
|
{
|
|
mesh : mesh,
|
|
face : face
|
|
}
|
|
);
|
|
};
|
|
|
|
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.deselectFace = function(mesh, face) {
|
|
|
|
face.selected = false;
|
|
|
|
face.removeHelper(mesh);
|
|
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.MESH_FACE_DESELECTED,
|
|
{
|
|
mesh : mesh,
|
|
face : face
|
|
}
|
|
);
|
|
};
|
|
|
|
GameLib.System.Input.prototype.deselectMesh = function(mesh) {
|
|
|
|
mesh.selected = false;
|
|
|
|
mesh.removeHelper();
|
|
|
|
GameLib.Event.Emit(
|
|
GameLib.Event.MESH_DESELECTED,
|
|
{
|
|
mesh : mesh
|
|
}
|
|
);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// 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.Component.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();
|
|
// }
|
|
// }
|
|
// }
|
|
// };
|
|
|