@polygonjs/polygonjs
Version:
node-based WebGL 3D engine https://polygonjs.com
125 lines (124 loc) • 4.1 kB
JavaScript
;
import { ACCEPTED_KEYBOARD_EVENT_TYPES } from "../../../core/event/KeyboardEventType";
import { allowCanvasKeyEventsListener } from "../../../core/event/CanvasKeyFocus";
import { getEventEmitter } from "../../../core/event/EventEmitter";
import { setToArray } from "../../../core/SetUtils";
const DEBUG = false;
const _eventTypesSet = /* @__PURE__ */ new Set();
export class ViewerEventsController {
constructor(viewer) {
this.viewer = viewer;
this._eventTypes = /* @__PURE__ */ new Map();
}
removeEvents(eventsController, _canvas) {
const canvas = _canvas || this.canvas();
if (!canvas) {
console.warn("no canvas found");
return;
}
const mapForController = this._eventTypes.get(eventsController.type());
if (!mapForController) {
return;
}
mapForController.forEach((listenerByEventType, emitter) => {
listenerByEventType.forEach((listenerWithData, eventType) => {
const eventEmitter = getEventEmitter({ emitter: listenerWithData.data.emitter, type: eventType }, canvas);
eventEmitter.removeEventListener(eventType, listenerWithData.listener);
});
listenerByEventType.clear();
});
}
updateEvents(eventsController) {
if (DEBUG) {
console.warn("------------ updateEvents START:", eventsController);
}
const canvas = this.canvas();
if (!canvas) {
console.warn("no canvas found");
return;
}
this.removeEvents(eventsController, canvas);
const activeEventDatas = eventsController.activeEventDatas();
for (const eventData of activeEventDatas) {
const eventEmitter = getEventEmitter(eventData, canvas);
const map = this._mapForEmitter(eventsController, eventEmitter);
const eventType = eventData.type;
const _processEvent = (event, controller) => {
const eventContext = {
viewer: this.viewer,
event,
emitter: eventData.emitter
// camera: this.camera(),
};
controller.processEvent(eventContext);
};
const listener = (event) => {
_processEvent(
event,
eventsController
/*, canvas*/
);
};
if (DEBUG) {
console.log("+ add event:", eventType, eventEmitter);
}
eventEmitter.addEventListener(eventType, listener, { passive: true });
if (eventEmitter != document) {
if (ACCEPTED_KEYBOARD_EVENT_TYPES.includes(eventData.type)) {
allowCanvasKeyEventsListener(eventEmitter);
}
}
map.set(eventData.type, { listener, data: eventData });
}
if (DEBUG) {
console.log("------------ updateEvents DONE:");
}
}
_mapForEmitter(eventsController, emitter) {
const controllerType = eventsController.type();
let mapForController = this._eventTypes.get(controllerType);
if (!mapForController) {
mapForController = /* @__PURE__ */ new Map();
this._eventTypes.set(controllerType, mapForController);
}
let mapForEmitter = mapForController.get(emitter);
if (!mapForEmitter) {
mapForEmitter = /* @__PURE__ */ new Map();
mapForController.set(emitter, mapForEmitter);
}
return mapForEmitter;
}
camera() {
return this.viewer.camera();
}
canvas() {
return this.viewer.canvas();
}
init() {
if (!this.canvas()) {
console.warn("no canvas found for eventsController");
return;
}
this.viewer.scene().eventsDispatcher.traverseControllers((controller) => {
this.updateEvents(controller);
});
}
unmount() {
this.viewer.scene().eventsDispatcher.traverseControllers((controller) => {
this.removeEvents(controller);
});
}
registeredEventTypes() {
_eventTypesSet.clear();
this._eventTypes.forEach((mapForEmitter) => {
mapForEmitter.forEach((listenerByEventType, emitter) => {
listenerByEventType.forEach((listener, eventType) => {
_eventTypesSet.add(eventType);
});
});
});
const target = [];
setToArray(_eventTypesSet, target);
return target;
}
}