This is taking way too long. These plugins are hung:
- WebVR is not supported by your browser, so you can't use a headset.
Learn more
`;
- const _enterHeadsetVR = () => {
- _enterVR({
- stereoscopic: true,
- onExit: () => {
- overlay.style.display = 'flex';
-
- bootstrap.setVrMode(null);
- },
- });
-
- bootstrap.setVrMode('hmd');
-
- overlay.style.display = 'none';
- };
- const _enterKeyboardVR = () => {
- _enterVR({
- stereoscopic: false,
- onExit: () => {
- overlay.style.display = 'flex';
-
- bootstrap.setVrMode(null);
- },
- });
-
- bootstrap.setVrMode('keyboard');
-
- overlay.style.display = 'none';
- };
-
- const _styleButton = button => {
- button.addEventListener('mouseover', e => {
- button.style.backgroundColor = '#FFF';
- button.style.borderColor = 'transparent';
- button.style.color = '#000';
- });
- button.addEventListener('mouseout', e => {
- button.style.backgroundColor = 'transparent';
- button.style.borderColor = 'currentColor';
- button.style.color = '#FFF';
- });
- };
-
- const headsetButton = $$(enterHelperContent, '.headset-button')[0];
- if (supportsWebVR) {
- _styleButton(headsetButton);
-
- headsetButton.addEventListener('click', e => {
- if (!webvr.isPresenting()) {
- _enterHeadsetVR();
- }
- });
-
- errorMessage.style.display = 'none';
-
- window.onvrdisplayactivate = null;
- window.addEventListener('vrdisplayactivate', e => {
- _enterHeadsetVR();
- });
-
- const urlRequestPresent = _getQueryVariable('e');
- if (webvr.displayIsPresenting() || urlRequestPresent === 'hmd') {
- _enterHeadsetVR();
- } else if (urlRequestPresent === 'keyboard') {
- _enterKeyboardVR();
- }
- } else {
- headsetButton.style.display = 'none';
- }
+ const _enterHeadsetVR = () => {
+ _enterVR({
+ stereoscopic: true,
+ onExit: () => {
+ overlay.style.display = 'flex';
- const keyboardButton = $$(enterHelperContent, '.keyboard-button')[0];
- _styleButton(keyboardButton);
+ bootstrap.setVrMode(null);
+ },
+ });
- keyboardButton.addEventListener('click', e => {
- if (!webvr.isPresenting()) {
- _enterKeyboardVR();
- }
- });
+ bootstrap.setVrMode('hmd');
- overlayContent.appendChild(helper);
- helper.appendChild(enterHelperContent);
- helper.appendChild(errorMessage);
+ overlay.style.display = 'none';
+ };
+ const _enterKeyboardVR = () => {
+ _enterVR({
+ stereoscopic: false,
+ onExit: () => {
+ overlay.style.display = 'flex';
- // end helper content
+ bootstrap.setVrMode(null);
+ },
+ });
- class Listener {
- constructor(handler, priority) {
- this.handler = handler;
- this.priority = priority;
- }
+ bootstrap.setVrMode('keyboard');
+
+ overlay.style.display = 'none';
+ };
+
+ const _styleButton = button => {
+ button.addEventListener('mouseover', e => {
+ button.style.backgroundColor = '#FFF';
+ button.style.borderColor = 'transparent';
+ button.style.color = '#000';
+ });
+ button.addEventListener('mouseout', e => {
+ button.style.backgroundColor = 'transparent';
+ button.style.borderColor = 'currentColor';
+ button.style.color = '#FFF';
+ });
+ };
+
+ const headsetButton = $$(
+ enterHelperContent,
+ '.headset-button'
+ )[0];
+ if (supportsWebVR) {
+ _styleButton(headsetButton);
+
+ headsetButton.addEventListener('click', e => {
+ if (!webvr.isPresenting()) {
+ _enterHeadsetVR();
}
+ });
+
+ errorMessage.style.display = 'none';
+
+ window.onvrdisplayactivate = null;
+ window.addEventListener('vrdisplayactivate', e => {
+ _enterHeadsetVR();
+ });
+
+ const urlRequestPresent = _getQueryVariable('e');
+ if (
+ webvr.displayIsPresenting() ||
+ urlRequestPresent === 'hmd'
+ ) {
+ _enterHeadsetVR();
+ } else if (urlRequestPresent === 'keyboard') {
+ _enterKeyboardVR();
+ }
+ } else {
+ headsetButton.style.display = 'none';
+ }
- const _makeEventListener = () => {
- const listeners = [];
+ const keyboardButton = $$(
+ enterHelperContent,
+ '.keyboard-button'
+ )[0];
+ _styleButton(keyboardButton);
- const result = e => {
- let live = true;
- e.stopImmediatePropagation = (stopImmediatePropagation => () => {
- live = false;
+ keyboardButton.addEventListener('click', e => {
+ if (!webvr.isPresenting()) {
+ _enterKeyboardVR();
+ }
+ });
- stopImmediatePropagation.call(e);
- })(e.stopImmediatePropagation);
+ overlayContent.appendChild(helper);
+ helper.appendChild(enterHelperContent);
+ helper.appendChild(errorMessage);
- const oldListeners = listeners.slice();
- for (let i = 0; i < oldListeners.length; i++) {
- const listener = oldListeners[i];
- const {handler} = listener;
+ // end helper content
- handler(e);
+ class Listener {
+ constructor(handler, priority) {
+ this.handler = handler;
+ this.priority = priority;
+ }
+ }
- if (!live) {
- break;
- }
- }
- };
- result.add = (handler, {priority}) => {
- const listener = new Listener(handler, priority);
- listeners.push(listener);
- listeners.sort((a, b) => b.priority - a.priority);
- };
- result.remove = handler => {
- const index = listeners.indexOf(handler);
- if (index !== -1) {
- listeners.splice(index, 1);
- }
- };
+ const _makeEventListener = () => {
+ const listeners = [];
+
+ const result = e => {
+ let live = true;
+ e.stopImmediatePropagation = (stopImmediatePropagation => () => {
+ live = false;
- return result;
- };
+ stopImmediatePropagation.call(e);
+ })(e.stopImmediatePropagation);
- this._cleanup = () => {
- _stopRenderLoop();
- };
+ const oldListeners = listeners.slice();
+ for (let i = 0; i < oldListeners.length; i++) {
+ const listener = oldListeners[i];
+ const { handler } = listener;
- class ZeoThreeApi {
- constructor() {
- this.THREE = THREE;
- this.scene = scene;
- this.camera = camera;
- this.renderer = renderer;
+ handler(e);
+
+ if (!live) {
+ break;
}
}
+ };
+ result.add = (handler, { priority }) => {
+ const listener = new Listener(handler, priority);
+ listeners.push(listener);
+ listeners.sort((a, b) => b.priority - a.priority);
+ };
+ result.remove = handler => {
+ const index = listeners.indexOf(handler);
+ if (index !== -1) {
+ listeners.splice(index, 1);
+ }
+ };
- class ZeoPoseApi {
- getStatus() {
- return webvr.getStatus();
- }
+ return result;
+ };
- getStageMatrix() {
- return webvr.getStageMatrix();
- }
+ this._cleanup = () => {
+ _stopRenderLoop();
+ };
- setStageMatrix(stageMatrix) {
- webvr.setStageMatrix(stageMatrix);
- }
+ class ZeoThreeApi {
+ constructor() {
+ this.THREE = THREE;
+ this.scene = scene;
+ this.camera = camera;
+ this.renderer = renderer;
+ }
+ }
- updateStatus() {
- webvr.updateStatus();
- }
+ class ZeoPoseApi {
+ getStatus() {
+ return webvr.getStatus();
+ }
- resetPose() {
- webvr.resetPose();
- }
+ getStageMatrix() {
+ return webvr.getStageMatrix();
+ }
- getControllerLinearVelocity(side) {
- const player = cyborg.getPlayer();
- return player.getControllerLinearVelocity(side);
- }
+ setStageMatrix(stageMatrix) {
+ webvr.setStageMatrix(stageMatrix);
+ }
- getControllerAngularVelocity(side) {
- const player = cyborg.getPlayer();
- return player.getControllerAngularVelocity(side);
- }
+ updateStatus() {
+ webvr.updateStatus();
+ }
- getVrMode() {
- return bootstrap.getVrMode();
- }
- }
+ resetPose() {
+ webvr.resetPose();
+ }
- class ZeoInputApi {
- on(event, handler, options) {
- return input.on(event, handler, options);
- }
+ getControllerLinearVelocity(side) {
+ const player = cyborg.getPlayer();
+ return player.getControllerLinearVelocity(side);
+ }
- removeListener(event, handler) {
- return input.removeListener(event, handler);
- }
+ getControllerAngularVelocity(side) {
+ const player = cyborg.getPlayer();
+ return player.getControllerAngularVelocity(side);
+ }
- removeAllListeners(event) {
- return input.removeAllListeners(event);
- }
+ getVrMode() {
+ return bootstrap.getVrMode();
+ }
+ }
- vibrate(side, value, time) {
- webvr.vibrate(side, value, time);
- }
- }
+ class ZeoInputApi {
+ on(event, handler, options) {
+ return input.on(event, handler, options);
+ }
- class ZeoRenderApi {
- constructor() {
- /* rend.on('update', () => {
+ removeListener(event, handler) {
+ return input.removeListener(event, handler);
+ }
+
+ removeAllListeners(event) {
+ return input.removeAllListeners(event);
+ }
+
+ vibrate(side, value, time) {
+ webvr.vibrate(side, value, time);
+ }
+ }
+
+ class ZeoRenderApi {
+ constructor() {
+ /* rend.on('update', () => {
this.emit('update');
});
rend.on('updateStart', () => {
@@ -586,51 +605,51 @@ class Zeo {
tags.on('mutate', () => {
this.emit('mutate');
}); */
- }
+ }
- on(event, handler) {
- return rend.on(event, handler);
- }
+ on(event, handler) {
+ return rend.on(event, handler);
+ }
- removeListener(event, handler) {
- return rend.removeListener(event, handler);
- }
+ removeListener(event, handler) {
+ return rend.removeListener(event, handler);
+ }
- removeAllListeners(event) {
- return rend.removeAllListeners(event);
- }
- }
+ removeAllListeners(event) {
+ return rend.removeAllListeners(event);
+ }
+ }
- class ZeoElementsApi {
- registerEntity(pluginInstance, componentApi) {
- tags.registerEntity(pluginInstance, componentApi);
- }
+ class ZeoElementsApi {
+ registerEntity(pluginInstance, componentApi) {
+ tags.registerEntity(pluginInstance, componentApi);
+ }
- unregisterEntity(pluginInstance, componentApi) {
- tags.unregisterEntity(pluginInstance, componentApi);
- }
+ unregisterEntity(pluginInstance, componentApi) {
+ tags.unregisterEntity(pluginInstance, componentApi);
+ }
- getWorldElement() {
- return tags.getWorldElement();
- }
+ getWorldElement() {
+ return tags.getWorldElement();
+ }
- getEntitiesElement() {
- return tags.getEntitiesElement();
- }
+ getEntitiesElement() {
+ return tags.getEntitiesElement();
+ }
- makeListener(selector) {
- return tags.makeListener(selector);
- }
+ makeListener(selector) {
+ return tags.makeListener(selector);
+ }
- destroyListener(listener) {
- tags.destroyListener(listener);
- }
+ destroyListener(listener) {
+ tags.destroyListener(listener);
+ }
- requestElement(selector) {
- return tags.requestElement(selector);
- }
+ requestElement(selector) {
+ return tags.requestElement(selector);
+ }
- /* on(event, handler) {
+ /* on(event, handler) {
return tags.on(event, handler);
}
@@ -641,372 +660,388 @@ class Zeo {
removeAllListeners(event) {
return tags.removeAllListeners(event);
} */
- }
+ }
- class ZeoWorldApi {
- getWorldTime() {
- return bootstrap.getWorldTime();
- }
+ class ZeoWorldApi {
+ getWorldTime() {
+ return bootstrap.getWorldTime();
+ }
- getTags() {
- return bootstrap.getWorldTime();
- }
+ getTags() {
+ return bootstrap.getWorldTime();
+ }
- getSpawnMatrix() {
- return webvr.getSpawnMatrix();
- }
+ getSpawnMatrix() {
+ return webvr.getSpawnMatrix();
+ }
- setSpawnMatrix(spawnMatrix) {
- webvr.setSpawnMatrix(spawnMatrix);
- }
- }
+ setSpawnMatrix(spawnMatrix) {
+ webvr.setSpawnMatrix(spawnMatrix);
+ }
+ }
- /* const controllerMeshes = (() => {
+ /* const controllerMeshes = (() => {
const controllers = cyborg.getControllers();
return {
left: controllers['left'].mesh,
right: controllers['right'].mesh,
};
})(); */
- class ZeoPlayerApi {
- getId() {
- return multiplayer.getId();
- }
+ class ZeoPlayerApi {
+ getId() {
+ return multiplayer.getId();
+ }
- /* getControllerMeshes() {
+ /* getControllerMeshes() {
return controllerMeshes;
} */
- getRemoteStatuses() {
- return multiplayer.getPlayerStatuses();
- }
+ getRemoteStatuses() {
+ return multiplayer.getPlayerStatuses();
+ }
- getRemoteStatus(userId) {
- return multiplayer.getPlayerStatus(userId);
- }
+ getRemoteStatus(userId) {
+ return multiplayer.getPlayerStatus(userId);
+ }
- getRemoteHmdMesh(userId) {
- const remotePlayerMesh = multiplayer.getRemotePlayerMesh(userId);
+ getRemoteHmdMesh(userId) {
+ const remotePlayerMesh = multiplayer.getRemotePlayerMesh(
+ userId
+ );
- if (remotePlayerMesh) {
- const {hmd: hmdMesh} = remotePlayerMesh;
- return hmdMesh;
- } else {
- return null;
- }
- }
+ if (remotePlayerMesh) {
+ const { hmd: hmdMesh } = remotePlayerMesh;
+ return hmdMesh;
+ } else {
+ return null;
+ }
+ }
- getRemoteControllerMeshes(userId) {
- return multiplayer.getRemoteControllerMeshes(userId);
- }
+ getRemoteControllerMeshes(userId) {
+ return multiplayer.getRemoteControllerMeshes(userId);
+ }
- setSkin(skinImg) {
- return cyborg.setSkin(skinImg);
- }
+ setSkin(skinImg) {
+ return cyborg.setSkin(skinImg);
+ }
- on(event, handler) {
- return multiplayer.on(event, handler);
- }
+ on(event, handler) {
+ return multiplayer.on(event, handler);
+ }
- removeListener(event, handler) {
- return multiplayer.removeListener(event, handler);
- }
+ removeListener(event, handler) {
+ return multiplayer.removeListener(event, handler);
+ }
- removeAllListeners(event) {
- return multiplayer.removeAllListeners(event);
- }
- }
+ removeAllListeners(event) {
+ return multiplayer.removeAllListeners(event);
+ }
+ }
- class ZeoUiApi {
- makeUi(options) {
- return biolumi.makeUi(options);
- }
+ class ZeoUiApi {
+ makeUi(options) {
+ return biolumi.makeUi(options);
+ }
- addPage(page) {
- rend.addPage(page);
- }
+ addPage(page) {
+ rend.addPage(page);
+ }
- removePage(page) {
- rend.removePage(page);
- }
+ removePage(page) {
+ rend.removePage(page);
+ }
- getHoverState(side) {
- return rend.getHoverState(side);
- }
+ getHoverState(side) {
+ return rend.getHoverState(side);
+ }
- getTransparentImg() {
- return biolumi.getTransparentImg();
- }
- }
+ getTransparentImg() {
+ return biolumi.getTransparentImg();
+ }
+ }
- class ZeoSoundApi {
- requestSfx(url) {
- return somnifer.requestSfx(url);
- }
+ class ZeoSoundApi {
+ requestSfx(url) {
+ return somnifer.requestSfx(url);
+ }
- makeBody() {
- return somnifer.makeBody();
- }
- }
+ makeBody() {
+ return somnifer.makeBody();
+ }
+ }
- class ZeoStageApi {
- getStage() {
- return stage.getStage();
- }
+ class ZeoStageApi {
+ getStage() {
+ return stage.getStage();
+ }
- setStage(st) {
- stage.setStage(st);
- }
+ setStage(st) {
+ stage.setStage(st);
+ }
- add(st, object) {
- stage.add(st, object);
- }
+ add(st, object) {
+ stage.add(st, object);
+ }
- remove(st, object) {
- stage.remove(st, object);
- }
+ remove(st, object) {
+ stage.remove(st, object);
+ }
- on() {
- return stage.on.apply(stage, arguments);
- }
+ on() {
+ return stage.on.apply(stage, arguments);
+ }
- removeListener() {
- return stage.removeListener.apply(stage, arguments);
- }
+ removeListener() {
+ return stage.removeListener.apply(stage, arguments);
+ }
- removeAllListeners() {
- return stage.removeAllListeners.apply(stage, arguments);
- }
- }
+ removeAllListeners() {
+ return stage.removeAllListeners.apply(stage, arguments);
+ }
+ }
- class ZeoStckApi {
- requestCheck() {
- return stck.requestCheck.apply(stck, arguments);
- }
+ class ZeoStckApi {
+ requestCheck() {
+ return stck.requestCheck.apply(stck, arguments);
+ }
- makeDynamicBoxBody() {
- return stck.makeDynamicBoxBody.apply(stck, arguments);
- }
+ makeDynamicBoxBody() {
+ return stck.makeDynamicBoxBody.apply(stck, arguments);
+ }
- makeStaticHeightfieldBody() {
- return stck.makeStaticHeightfieldBody.apply(stck, arguments);
- }
+ makeStaticHeightfieldBody() {
+ return stck.makeStaticHeightfieldBody.apply(
+ stck,
+ arguments
+ );
+ }
- makeStaticEtherfieldBody() {
- return stck.makeStaticEtherfieldBody.apply(stck, arguments);
- }
+ makeStaticEtherfieldBody() {
+ return stck.makeStaticEtherfieldBody.apply(
+ stck,
+ arguments
+ );
+ }
- makeStaticBlockfieldBody() {
- return stck.makeStaticBlockfieldBody.apply(stck, arguments);
- }
+ makeStaticBlockfieldBody() {
+ return stck.makeStaticBlockfieldBody.apply(
+ stck,
+ arguments
+ );
+ }
- destroyBody(body) {
- stck.destroyBody(body);
- }
- }
+ destroyBody(body) {
+ stck.destroyBody(body);
+ }
+ }
- class ZeoIntersectApi {
- makeIntersecter() {
- return intersect.makeIntersecter();
- }
+ class ZeoIntersectApi {
+ makeIntersecter() {
+ return intersect.makeIntersecter();
+ }
- destroyIntersecter(object) {
- intersect.destroyIntersecter(object);
- }
- }
+ destroyIntersecter(object) {
+ intersect.destroyIntersecter(object);
+ }
+ }
- class ZeoTeleportApi {
- addTarget(object, options) {
- teleport.addTarget(object, options);
- }
+ class ZeoTeleportApi {
+ addTarget(object, options) {
+ teleport.addTarget(object, options);
+ }
- removeTarget(object) {
- teleport.removeTarget(object);
- }
+ removeTarget(object) {
+ teleport.removeTarget(object);
+ }
- getHoverState(side) {
- return teleport.getHoverState(side);
- }
+ getHoverState(side) {
+ return teleport.getHoverState(side);
+ }
- on(event, handler, options) {
- return teleport.on(event, handler, options);
- }
+ on(event, handler, options) {
+ return teleport.on(event, handler, options);
+ }
- removeListener(event, handler) {
- return teleport.removeListener(event, handler);
- }
+ removeListener(event, handler) {
+ return teleport.removeListener(event, handler);
+ }
- removeAllListeners(event) {
- return teleport.removeAllListeners(event);
- }
- }
+ removeAllListeners(event) {
+ return teleport.removeAllListeners(event);
+ }
+ }
- class ZeoHandsApi {
- makeGrabbable(id, options) {
- return hand.makeGrabbable(id, options);
- }
+ class ZeoHandsApi {
+ makeGrabbable(id, options) {
+ return hand.makeGrabbable(id, options);
+ }
- destroyGrabbable(grabbable) {
- hand.destroyGrabbable(grabbable);
- }
+ destroyGrabbable(grabbable) {
+ hand.destroyGrabbable(grabbable);
+ }
- getGrabbedGrabbable(side) {
- return hand.getGrabbedGrabbable(side);
- }
+ getGrabbedGrabbable(side) {
+ return hand.getGrabbedGrabbable(side);
+ }
- on() {
- return hand.on.apply(hand, arguments);
- }
+ on() {
+ return hand.on.apply(hand, arguments);
+ }
- removeListener() {
- return hand.removeListener.apply(hand, arguments);
- }
+ removeListener() {
+ return hand.removeListener.apply(hand, arguments);
+ }
- removeAllListeners() {
- return hand.removeAllListeners.apply(hand, arguments);
- }
- }
+ removeAllListeners() {
+ return hand.removeAllListeners.apply(hand, arguments);
+ }
+ }
- class ZeoTransformApi {
- makeTransformGizmo(spec) {
- return transform.makeTransformGizmo(spec);
- }
+ class ZeoTransformApi {
+ makeTransformGizmo(spec) {
+ return transform.makeTransformGizmo(spec);
+ }
- destroyTransformGizmo(transformGizmo) {
- return transform.destroyTransformGizmo(transformGizmo);
- }
- }
+ destroyTransformGizmo(transformGizmo) {
+ return transform.destroyTransformGizmo(transformGizmo);
+ }
+ }
- class ZeoAnimationApi {
- makeAnimation(startValue, endValue, duration) {
- return anima.makeAnimation(startValue, endValue, duration);
- }
- }
+ class ZeoAnimationApi {
+ makeAnimation(startValue, endValue, duration) {
+ return anima.makeAnimation(
+ startValue,
+ endValue,
+ duration
+ );
+ }
+ }
- class ZeoItemsApi {
- getItem(id) {
- return wallet.getAsset(id);
- }
+ class ZeoItemsApi {
+ getItem(id) {
+ return wallet.getAsset(id);
+ }
- makeItem(itemSpec) {
- return wallet.makeItem(itemSpec);
- }
+ makeItem(itemSpec) {
+ return wallet.makeItem(itemSpec);
+ }
- destroyItem(item) {
- wallet.destroyItem(item);
- }
+ destroyItem(item) {
+ wallet.destroyItem(item);
+ }
- makeFile(options) {
- return wallet.makeFile(options);
- }
+ makeFile(options) {
+ return wallet.makeFile(options);
+ }
- reifyFile(options) {
- return wallet.reifyFile(options);
- }
+ reifyFile(options) {
+ return wallet.reifyFile(options);
+ }
- getFile(id) {
- return fs.makeRemoteFile(id);
- }
+ getFile(id) {
+ return fs.makeRemoteFile(id);
+ }
- registerItem(pluginInstance, itemApi) {
- wallet.registerItem(pluginInstance, itemApi);
- }
+ registerItem(pluginInstance, itemApi) {
+ wallet.registerItem(pluginInstance, itemApi);
+ }
- unregisterItem(pluginInstance, itemApi) {
- wallet.unregisterItem(pluginInstance, itemApi);
- }
+ unregisterItem(pluginInstance, itemApi) {
+ wallet.unregisterItem(pluginInstance, itemApi);
+ }
- registerEquipment(pluginInstance, equipmentApi) {
- wallet.registerEquipment(pluginInstance, equipmentApi);
- }
+ registerEquipment(pluginInstance, equipmentApi) {
+ wallet.registerEquipment(pluginInstance, equipmentApi);
+ }
- unregisterEquipment(pluginInstance, equipmentApi) {
- wallet.unregisterEquipment(pluginInstance, equipmentApi);
- }
+ unregisterEquipment(pluginInstance, equipmentApi) {
+ wallet.unregisterEquipment(pluginInstance, equipmentApi);
+ }
- registerRecipe(pluginInstance, recipe) {
- craft.registerRecipe(pluginInstance, recipe);
- }
+ registerRecipe(pluginInstance, recipe) {
+ craft.registerRecipe(pluginInstance, recipe);
+ }
- unregisterRecipe(pluginInstance, recipe) {
- craft.unregisterRecipe(pluginInstance, recipe);
- }
+ unregisterRecipe(pluginInstance, recipe) {
+ craft.unregisterRecipe(pluginInstance, recipe);
+ }
- getAssetsMaterial() {
- return wallet.getAssetsMaterial();
- }
+ getAssetsMaterial() {
+ return wallet.getAssetsMaterial();
+ }
- on() {
- return wallet.on.apply(wallet, arguments);
- }
+ on() {
+ return wallet.on.apply(wallet, arguments);
+ }
- removeListener() {
- return wallet.removeListener.apply(wallet, arguments);
- }
+ removeListener() {
+ return wallet.removeListener.apply(wallet, arguments);
+ }
- removeAllListeners() {
- return wallet.removeAllListeners.apply(wallet, arguments);
- }
- }
+ removeAllListeners() {
+ return wallet.removeAllListeners.apply(wallet, arguments);
+ }
+ }
- class ZeoJsApi {
- constructor() {
- this.events = events;
- }
- }
+ class ZeoJsApi {
+ constructor() {
+ this.events = events;
+ }
+ }
- class ZeoUtilsApi {
- constructor() {
- this.js = jsUtils;
- this.network = networkUtils;
- this.geometry = geometryUtils;
- this.hash = hashUtils;
- this.random = randomUtils;
- this.text = textUtils;
- this.menu = menuUtils;
- this.skin = skinUtils;
- this.creature = creatureUtils;
- this.sprite = spriteUtils;
- }
- }
+ class ZeoUtilsApi {
+ constructor() {
+ this.js = jsUtils;
+ this.network = networkUtils;
+ this.geometry = geometryUtils;
+ this.hash = hashUtils;
+ this.random = randomUtils;
+ this.text = textUtils;
+ this.menu = menuUtils;
+ this.skin = skinUtils;
+ this.creature = creatureUtils;
+ this.sprite = spriteUtils;
+ }
+ }
- class ZeoApi extends EventEmitter {
- constructor() {
- super();
-
- this.three = new ZeoThreeApi();
- this.pose = new ZeoPoseApi();
- this.input = new ZeoInputApi();
- this.render = new ZeoRenderApi();
- this.elements = new ZeoElementsApi();
- this.world = new ZeoWorldApi();
- this.player = new ZeoPlayerApi();
- this.ui = new ZeoUiApi();
- this.sound = new ZeoSoundApi();
- this.stage = new ZeoStageApi();
- this.stck = new ZeoStckApi();
- this.teleport = new ZeoTeleportApi();
- this.hands = new ZeoHandsApi();
- this.transform = new ZeoTransformApi();
- this.animation = new ZeoAnimationApi();
- this.items = new ZeoItemsApi();
- this.utils = new ZeoUtilsApi();
- }
- }
- const zeoApi = new ZeoApi();
- window.zeo = zeoApi;
+ class ZeoApi extends EventEmitter {
+ constructor() {
+ super();
+
+ this.three = new ZeoThreeApi();
+ this.pose = new ZeoPoseApi();
+ this.input = new ZeoInputApi();
+ this.render = new ZeoRenderApi();
+ this.elements = new ZeoElementsApi();
+ this.world = new ZeoWorldApi();
+ this.player = new ZeoPlayerApi();
+ this.ui = new ZeoUiApi();
+ this.sound = new ZeoSoundApi();
+ this.stage = new ZeoStageApi();
+ this.stck = new ZeoStckApi();
+ this.teleport = new ZeoTeleportApi();
+ this.hands = new ZeoHandsApi();
+ this.transform = new ZeoTransformApi();
+ this.animation = new ZeoAnimationApi();
+ this.items = new ZeoItemsApi();
+ this.utils = new ZeoUtilsApi();
+ }
+ }
+ const zeoApi = new ZeoApi();
+ window.zeo = zeoApi;
- renderer.compile(scene, camera);
+ renderer.compile(scene, camera);
- world.init();
+ world.init();
- return zeoApi;
- }
- })
- }
- });
- }
- });
+ return zeoApi;
+ }
+ });
+ }
+ }
+ );
+ }
+ });
}
unmount() {
diff --git a/core/engines/zeo/server.js b/core/engines/zeo/server.js
index e92b6fa75..9bf677b3f 100644
--- a/core/engines/zeo/server.js
+++ b/core/engines/zeo/server.js
@@ -7,111 +7,115 @@ class Zeo {
}
mount() {
- const {_archae: archae} = this;
- const {app, dirname, dataDirectory} = archae.getCore();
+ const { _archae: archae } = this;
+ const { app, dirname, dataDirectory } = archae.getCore();
let live = true;
this._cleanup = () => {
live = false;
};
- return archae.requestPlugins([
- '/core/engines/three',
- '/core/engines/tags',
- '/core/engines/world',
- '/core/engines/multiplayer',
- '/core/engines/fs',
- '/core/utils/js-utils',
- '/core/utils/hash-utils',
- '/core/utils/random-utils',
- '/core/utils/image-utils',
- ])
- .then(([
- three,
- tags,
- world,
- multiplayer,
- fs,
- jsUtils,
- hashUtils,
- randomUtils,
- imageUtils,
- ]) => {
- if (live) {
- class ZeoThreeApi {
- constructor() {
- this.THREE = three.THREE;
+ return archae
+ .requestPlugins([
+ '/core/engines/three',
+ '/core/engines/tags',
+ '/core/engines/world',
+ '/core/engines/multiplayer',
+ '/core/engines/fs',
+ '/core/utils/js-utils',
+ '/core/utils/hash-utils',
+ '/core/utils/random-utils',
+ '/core/utils/image-utils',
+ ])
+ .then(
+ (
+ [
+ three,
+ tags,
+ world,
+ multiplayer,
+ fs,
+ jsUtils,
+ hashUtils,
+ randomUtils,
+ imageUtils,
+ ]
+ ) => {
+ if (live) {
+ class ZeoThreeApi {
+ constructor() {
+ this.THREE = three.THREE;
+ }
}
- }
- class ZeoElementsApi {
- getWorldElement() {
- return tags.getWorldElement();
- }
+ class ZeoElementsApi {
+ getWorldElement() {
+ return tags.getWorldElement();
+ }
- requestElement(selector) {
- return tags.requestElement(selector);
- }
+ requestElement(selector) {
+ return tags.requestElement(selector);
+ }
- registerEntity(pluginInstance, entityApi) {
- tags.registerEntity(pluginInstance, entityApi);
- }
+ registerEntity(pluginInstance, entityApi) {
+ tags.registerEntity(pluginInstance, entityApi);
+ }
- unregisterEntity(pluginInstance, entityApi) {
- tags.unregisterEntity(pluginInstance, entityApi);
+ unregisterEntity(pluginInstance, entityApi) {
+ tags.unregisterEntity(pluginInstance, entityApi);
+ }
}
- }
- class ZeoWorldApi {
- getTags() {
- return world.getTags();
+ class ZeoWorldApi {
+ getTags() {
+ return world.getTags();
+ }
}
- }
- class ZeoMultiplayerApi {
- getPlayerStatuses() {
- return multiplayer.getPlayerStatuses();
+ class ZeoMultiplayerApi {
+ getPlayerStatuses() {
+ return multiplayer.getPlayerStatuses();
+ }
}
- }
- class ZeoFsApi {
- makeFile(id, pathname) {
- return fs.makeFile(id, pathname);
+ class ZeoFsApi {
+ makeFile(id, pathname) {
+ return fs.makeFile(id, pathname);
+ }
}
- }
- class ZeoUtilsApi {
- constructor() {
- this.js = jsUtils;
- this.hash = hashUtils;
- this.random = randomUtils;
- this.image = imageUtils;
+ class ZeoUtilsApi {
+ constructor() {
+ this.js = jsUtils;
+ this.hash = hashUtils;
+ this.random = randomUtils;
+ this.image = imageUtils;
+ }
}
- }
- class ZeoApi {
- constructor() {
- this.three = new ZeoThreeApi();
- this.elements = new ZeoElementsApi();
- this.world = new ZeoWorldApi();
- this.fs = new ZeoFsApi();
- this.multiplayer = new ZeoMultiplayerApi();
- this.utils = new ZeoUtilsApi();
+ class ZeoApi {
+ constructor() {
+ this.three = new ZeoThreeApi();
+ this.elements = new ZeoElementsApi();
+ this.world = new ZeoWorldApi();
+ this.fs = new ZeoFsApi();
+ this.multiplayer = new ZeoMultiplayerApi();
+ this.utils = new ZeoUtilsApi();
+ }
}
- }
- const zeoApi = new ZeoApi();
- global.zeo = zeoApi;
+ const zeoApi = new ZeoApi();
+ global.zeo = zeoApi;
- world.initTags()
- .catch(err => {
+ world.initTags().catch(err => {
console.warn(err);
});
- this._cleanup = () => {};
+ this._cleanup = () => {};
- return zeoApi;
+ return zeoApi;
+ }
}
- });
+ );
}
unmount() {
diff --git a/plugins/generator/client.js b/plugins/generator/client.js
index 0d0c83bba..c97caee5f 100644
--- a/plugins/generator/client.js
+++ b/plugins/generator/client.js
@@ -21,9 +21,18 @@ class Generator {
}
mount() {
- const {_archae: archae} = this;
- const {three, render, pose, input, world, elements, stck, utils: {js: {mod, sbffr}, random: {chnkr}, hash: {murmur}}} = zeo;
- const {THREE, scene, camera, renderer} = three;
+ const { _archae: archae } = this;
+ const {
+ three,
+ render,
+ pose,
+ input,
+ world,
+ elements,
+ stck,
+ utils: { js: { mod, sbffr }, random: { chnkr }, hash: { murmur } },
+ } = zeo;
+ const { THREE, scene, camera, renderer } = three;
const textureAtlas = new THREE.Texture(
null,
@@ -59,7 +68,10 @@ class Generator {
};
function _updateModelViewMatrix(camera) {
if (!modelViewMatricesValid[camera.name]) {
- modelViewMatrices[camera.name].multiplyMatrices(camera.matrixWorldInverse, this.matrixWorld);
+ modelViewMatrices[camera.name].multiplyMatrices(
+ camera.matrixWorldInverse,
+ this.matrixWorld
+ );
modelViewMatricesValid[camera.name] = true;
}
this.modelViewMatrix = modelViewMatrices[camera.name];
@@ -80,8 +92,9 @@ class Generator {
}
}
- const _getChunkIndex = (x, z) => (mod(x, 0xFFFF) << 16) | mod(z, 0xFFFF);
- const _getObjectId = (x, z, i) => (mod(x, 0xFF) << 24) | (mod(z, 0xFF) << 16) | (i & 0xFFFF);
+ const _getChunkIndex = (x, z) => (mod(x, 0xffff) << 16) | mod(z, 0xffff);
+ const _getObjectId = (x, z, i) =>
+ (mod(x, 0xff) << 24) | (mod(z, 0xff) << 16) | (i & 0xffff);
const forwardVector = new THREE.Vector3(0, 0, -1);
const localVector = new THREE.Vector3();
@@ -92,18 +105,21 @@ class Generator {
const localArray16 = Array(16);
const localArray162 = Array(16);
- const _requestImage = src => new Promise((accept, reject) => {
- const img = new Image();
- img.onload = () => {
- accept(img);
- };
- img.onerror = err => {
- reject(img);
- };
- img.src = src;
- });
- const _requestImageBitmap = src => _requestImage(src)
- .then(img => createImageBitmap(img, 0, 0, img.width, img.height));
+ const _requestImage = src =>
+ new Promise((accept, reject) => {
+ const img = new Image();
+ img.onload = () => {
+ accept(img);
+ };
+ img.onerror = err => {
+ reject(img);
+ };
+ img.src = src;
+ });
+ const _requestImageBitmap = src =>
+ _requestImage(src).then(img =>
+ createImageBitmap(img, 0, 0, img.width, img.height)
+ );
let terrainGenerateBuffer = new ArrayBuffer(4 * NUM_POSITIONS_CHUNK);
let objectsGenerateBuffer = new ArrayBuffer(NUM_POSITIONS_CHUNK);
@@ -116,7 +132,9 @@ class Generator {
};
let bodyObjectBuffer = new ArrayBuffer(4 * 4);
- const worker = new Worker('archae/plugins/_plugins_generator/build/worker.js');
+ const worker = new Worker(
+ 'archae/plugins/_plugins_generator/build/worker.js'
+ );
let queues = {};
let numRemovedQueues = 0;
const _cleanupQueues = () => {
@@ -152,20 +170,30 @@ class Generator {
});
queues[id] = cb;
};
- worker.requestTerrainGenerate = (x, y, index, numPositions, numIndices, cb) => {
+ worker.requestTerrainGenerate = (
+ x,
+ y,
+ index,
+ numPositions,
+ numIndices,
+ cb
+ ) => {
const id = _makeId();
- worker.postMessage({
- type: 'terrainGenerate',
- id,
- args: {
- x,
- y,
- index,
- numPositions,
- numIndices,
- buffer: terrainGenerateBuffer,
+ worker.postMessage(
+ {
+ type: 'terrainGenerate',
+ id,
+ args: {
+ x,
+ y,
+ index,
+ numPositions,
+ numIndices,
+ buffer: terrainGenerateBuffer,
+ },
},
- }, [terrainGenerateBuffer]);
+ [terrainGenerateBuffer]
+ );
queues[id] = newGenerateBuffer => {
terrainGenerateBuffer = newGenerateBuffer;
@@ -174,35 +202,49 @@ class Generator {
};
worker.requestTerrainsGenerate = (specs, cb) => {
const id = _makeId();
- worker.postMessage({
- type: 'terrainsGenerate',
- id,
- args: {
- specs,
- buffer: terrainGenerateBuffer,
+ worker.postMessage(
+ {
+ type: 'terrainsGenerate',
+ id,
+ args: {
+ specs,
+ buffer: terrainGenerateBuffer,
+ },
},
- }, [terrainGenerateBuffer]);
+ [terrainGenerateBuffer]
+ );
queues[id] = newGenerateBuffer => {
terrainGenerateBuffer = newGenerateBuffer;
cb(newGenerateBuffer);
};
};
- worker.requestObjectsGenerate = (x, z, index, numPositions, numObjectIndices, numIndices, cb) => {
+ worker.requestObjectsGenerate = (
+ x,
+ z,
+ index,
+ numPositions,
+ numObjectIndices,
+ numIndices,
+ cb
+ ) => {
const id = _makeId();
- worker.postMessage({
- type: 'objectsGenerate',
- id,
- args: {
- x,
- z,
- index,
- numPositions,
- numObjectIndices,
- numIndices,
- buffer: objectsGenerateBuffer,
+ worker.postMessage(
+ {
+ type: 'objectsGenerate',
+ id,
+ args: {
+ x,
+ z,
+ index,
+ numPositions,
+ numObjectIndices,
+ numIndices,
+ buffer: objectsGenerateBuffer,
+ },
},
- }, [objectsGenerateBuffer]);
+ [objectsGenerateBuffer]
+ );
queues[id] = newGenerateBuffer => {
objectsGenerateBuffer = newGenerateBuffer;
@@ -229,7 +271,14 @@ class Generator {
clear,
});
};
- worker.requestUnregisterObject = (n, added, removed, updated, set, clear) => {
+ worker.requestUnregisterObject = (
+ n,
+ added,
+ removed,
+ updated,
+ set,
+ clear
+ ) => {
worker.postMessage({
type: 'unregisterObject',
n,
@@ -284,18 +333,26 @@ class Generator {
z,
});
};
- worker.requestTerrainCull = (hmdPosition, projectionMatrix, matrixWorldInverse, cb) => {
+ worker.requestTerrainCull = (
+ hmdPosition,
+ projectionMatrix,
+ matrixWorldInverse,
+ cb
+ ) => {
const id = _makeId();
- worker.postMessage({
- type: 'terrainCull',
- id,
- args: {
- hmdPosition: hmdPosition.toArray(localArray3),
- projectionMatrix: projectionMatrix.toArray(localArray16),
- matrixWorldInverse: matrixWorldInverse.toArray(localArray162),
- buffer: terrainCullBuffer,
+ worker.postMessage(
+ {
+ type: 'terrainCull',
+ id,
+ args: {
+ hmdPosition: hmdPosition.toArray(localArray3),
+ projectionMatrix: projectionMatrix.toArray(localArray16),
+ matrixWorldInverse: matrixWorldInverse.toArray(localArray162),
+ buffer: terrainCullBuffer,
+ },
},
- }, [terrainCullBuffer]);
+ [terrainCullBuffer]
+ );
terrainCullBuffer = null;
queues[id] = buffer => {
@@ -303,18 +360,26 @@ class Generator {
cb(buffer);
};
};
- worker.requestObjectsCull = (hmdPosition, projectionMatrix, matrixWorldInverse, cb) => {
+ worker.requestObjectsCull = (
+ hmdPosition,
+ projectionMatrix,
+ matrixWorldInverse,
+ cb
+ ) => {
const id = _makeId();
- worker.postMessage({
- type: 'objectsCull',
- id,
- args: {
- hmdPosition: hmdPosition.toArray(localArray3),
- projectionMatrix: projectionMatrix.toArray(localArray16),
- matrixWorldInverse: matrixWorldInverse.toArray(localArray162),
- buffer: objectsCullBuffer,
+ worker.postMessage(
+ {
+ type: 'objectsCull',
+ id,
+ args: {
+ hmdPosition: hmdPosition.toArray(localArray3),
+ projectionMatrix: projectionMatrix.toArray(localArray16),
+ matrixWorldInverse: matrixWorldInverse.toArray(localArray162),
+ buffer: objectsCullBuffer,
+ },
},
- }, [objectsCullBuffer]);
+ [objectsCullBuffer]
+ );
objectsCullBuffer = null;
queues[id] = buffer => {
@@ -324,7 +389,7 @@ class Generator {
};
worker.requestHoveredObjects = cb => {
const id = _makeId();
- const {gamepads} = pose.getStatus();
+ const { gamepads } = pose.getStatus();
const float32Array = new Float32Array(hoveredObjectsBuffer, 0, 6);
float32Array[0] = gamepads.left.worldPosition.x;
@@ -334,13 +399,16 @@ class Generator {
float32Array[4] = gamepads.right.worldPosition.y;
float32Array[5] = gamepads.right.worldPosition.z;
- worker.postMessage({
- type: 'getHoveredObjects',
- id,
- args: {
- buffer: hoveredObjectsBuffer,
+ worker.postMessage(
+ {
+ type: 'getHoveredObjects',
+ id,
+ args: {
+ buffer: hoveredObjectsBuffer,
+ },
},
- }, [hoveredObjectsBuffer]);
+ [hoveredObjectsBuffer]
+ );
queues[id] = newHoveredObjectsBuffer => {
hoveredObjectsBuffer = newHoveredObjectsBuffer;
@@ -356,13 +424,16 @@ class Generator {
float32Array[1] = position.y;
float32Array[2] = position.z;
- worker.postMessage({
- type: 'getTeleportObject',
- id,
- args: {
- buffer: teleportObjectBuffer,
+ worker.postMessage(
+ {
+ type: 'getTeleportObject',
+ id,
+ args: {
+ buffer: teleportObjectBuffer,
+ },
},
- }, [teleportObjectBuffer]);
+ [teleportObjectBuffer]
+ );
queues[id] = newTeleportObjectsBuffer => {
teleportObjectBuffers[side] = newTeleportObjectsBuffer;
@@ -377,13 +448,16 @@ class Generator {
float32Array[1] = position.y;
float32Array[2] = position.z;
- worker.postMessage({
- type: 'getBodyObject',
- id,
- args: {
- buffer: bodyObjectBuffer,
+ worker.postMessage(
+ {
+ type: 'getBodyObject',
+ id,
+ args: {
+ buffer: bodyObjectBuffer,
+ },
},
- }, [bodyObjectBuffer]);
+ [bodyObjectBuffer]
+ );
queues[id] = newBodyObjectBuffer => {
bodyObjectBuffer = newBodyObjectBuffer;
@@ -408,12 +482,12 @@ class Generator {
}, transfers);
}; */
worker.onmessage = e => {
- const {data} = e;
- const {type, args} = data;
+ const { data } = e;
+ const { type, args } = data;
if (type === 'response') {
const [id] = args;
- const {result} = data;
+ const { result } = data;
queues[id](result);
queues[id] = null;
@@ -457,14 +531,24 @@ class Generator {
const objectApi = objectApis[n];
if (objectApi) {
- objectApi.removedCallback(_getObjectId(x, z, objectIndex), x, z, objectIndex);
+ objectApi.removedCallback(
+ _getObjectId(x, z, objectIndex),
+ x,
+ z,
+ objectIndex
+ );
}
} else if (type === 'objectUpdated') {
const [n, x, z, objectIndex, position, rotation, value] = args;
const objectApi = objectApis[n];
if (objectApi) {
- objectApi.updateCallback(_getObjectId(x, z, objectIndex), localVector.fromArray(position), localQuaternion.fromArray(rotation), value);
+ objectApi.updateCallback(
+ _getObjectId(x, z, objectIndex),
+ localVector.fromArray(position),
+ localQuaternion.fromArray(rotation),
+ value
+ );
}
} else if (type === 'blockSet') {
const [n, x, y, z] = args;
@@ -481,7 +565,10 @@ class Generator {
objectApi.clearCallback(_getObjectId(x, y, z), x, y, z);
}
} else {
- console.warn('generator got unknown worker message type:', JSON.stringify(type));
+ console.warn(
+ 'generator got unknown worker message type:',
+ JSON.stringify(type)
+ );
}
};
@@ -526,20 +613,50 @@ class Generator {
generatorElement.requestOriginHeight = cb => {
worker.requestOriginHeight(cb);
};
- generatorElement.requestTerrainGenerate = (x, z, index, numPositions, numIndices, cb) => {
- worker.requestTerrainGenerate(x, z, index, numPositions, numIndices, buffer => {
- cb(protocolUtils.parseTerrainRenderChunk(buffer));
- });
+ generatorElement.requestTerrainGenerate = (
+ x,
+ z,
+ index,
+ numPositions,
+ numIndices,
+ cb
+ ) => {
+ worker.requestTerrainGenerate(
+ x,
+ z,
+ index,
+ numPositions,
+ numIndices,
+ buffer => {
+ cb(protocolUtils.parseTerrainRenderChunk(buffer));
+ }
+ );
};
generatorElement.requestTerrainsGenerate = (specs, cb) => {
worker.requestTerrainsGenerate(specs, buffer => {
cb(protocolUtils.parseTerrainsRenderChunk(buffer));
});
};
- generatorElement.requestObjectsGenerate = (x, z, index, numPositions, numObjectIndices, numIndices, cb) => {
- worker.requestObjectsGenerate(x, z, index, numPositions, numObjectIndices, numIndices, buffer => {
- cb(protocolUtils.parseWorker(buffer));
- });
+ generatorElement.requestObjectsGenerate = (
+ x,
+ z,
+ index,
+ numPositions,
+ numObjectIndices,
+ numIndices,
+ cb
+ ) => {
+ worker.requestObjectsGenerate(
+ x,
+ z,
+ index,
+ numPositions,
+ numObjectIndices,
+ numIndices,
+ buffer => {
+ cb(protocolUtils.parseWorker(buffer));
+ }
+ );
};
generatorElement.addVoxel = (x, y, z) => {
worker.requestAddVoxel(x, y, z);
@@ -547,7 +664,12 @@ class Generator {
generatorElement.mutateVoxel = (x, y, z, v) => {
worker.requestMutateVoxel(x, y, z, v);
};
- generatorElement.requestAddObject = (name, position, rotation, value) => {
+ generatorElement.requestAddObject = (
+ name,
+ position,
+ rotation,
+ value
+ ) => {
worker.requestAddObject(name, position, rotation, value);
};
generatorElement.requestRemoveObject = (x, z, objectIndex) => {
@@ -555,7 +677,7 @@ class Generator {
};
generatorElement.setData = (x, z, objectIndex, value) => {
worker.requestSetObjectData(x, z, objectIndex, value);
- }
+ };
generatorElement.getObjectApi = n => objectApis[n];
generatorElement.registerObject = objectApi => {
const n = murmur(objectApi.object);
@@ -589,15 +711,35 @@ class Generator {
generatorElement.clearBlock = (x, y, z) => {
worker.requestClearBlock(x, y, z);
};
- generatorElement.requestTerrainCull = (hmdPosition, projectionMatrix, matrixWorldInverse, cb) => {
- worker.requestTerrainCull(hmdPosition, projectionMatrix, matrixWorldInverse, buffer => {
- cb(protocolUtils.parseTerrainCull(buffer));
- });
+ generatorElement.requestTerrainCull = (
+ hmdPosition,
+ projectionMatrix,
+ matrixWorldInverse,
+ cb
+ ) => {
+ worker.requestTerrainCull(
+ hmdPosition,
+ projectionMatrix,
+ matrixWorldInverse,
+ buffer => {
+ cb(protocolUtils.parseTerrainCull(buffer));
+ }
+ );
};
- generatorElement.requestObjectsCull = (hmdPosition, projectionMatrix, matrixWorldInverse, cb) => {
- worker.requestObjectsCull(hmdPosition, projectionMatrix, matrixWorldInverse, buffer => {
- cb(protocolUtils.parseObjectsCull(buffer));
- });
+ generatorElement.requestObjectsCull = (
+ hmdPosition,
+ projectionMatrix,
+ matrixWorldInverse,
+ cb
+ ) => {
+ worker.requestObjectsCull(
+ hmdPosition,
+ projectionMatrix,
+ matrixWorldInverse,
+ buffer => {
+ cb(protocolUtils.parseObjectsCull(buffer));
+ }
+ );
};
generatorElement.requestHoveredObjects = cb => {
worker.requestHoveredObjects(cb);
@@ -641,9 +783,12 @@ class Generator {
};
})();
const _debouncedRequestRefreshMapChunks = _debounce(nextDebounce => {
- const {hmd} = pose.getStatus();
- const {worldPosition: hmdPosition} = hmd;
- const {added, removed, done} = chunker.update(hmdPosition.x, hmdPosition.z);
+ const { hmd } = pose.getStatus();
+ const { worldPosition: hmdPosition } = hmd;
+ const { added, removed, done } = chunker.update(
+ hmdPosition.x,
+ hmdPosition.z
+ );
let running = false;
const queue = [];
@@ -667,7 +812,7 @@ class Generator {
if (!running) {
running = true;
- const {x, z, lod} = chunk;
+ const { x, z, lod } = chunk;
const index = _getChunkIndex(x, z);
const oldMapChunkMesh = mapChunkMeshes[index];
if (oldMapChunkMesh) {
@@ -692,7 +837,7 @@ class Generator {
if (removed.length > 0) {
for (let i = 0; i < removed.length; i++) {
const chunk = removed[i];
- const {x, z} = chunk;
+ const { x, z } = chunk;
worker.requestUngenerate(x, z);
@@ -714,7 +859,7 @@ class Generator {
let refreshChunksTimeout = null;
const _recurseRefreshChunks = () => {
- const {hmd: {worldPosition: hmdPosition}} = pose.getStatus();
+ const { hmd: { worldPosition: hmdPosition } } = pose.getStatus();
_debouncedRequestRefreshMapChunks();
refreshChunksTimeout = setTimeout(_recurseRefreshChunks, 1000);
};
diff --git a/plugins/generator/objects-tesselator.js b/plugins/generator/objects-tesselator.js
index f758a24cb..4c9c096ac 100644
--- a/plugins/generator/objects-tesselator.js
+++ b/plugins/generator/objects-tesselator.js
@@ -1,8 +1,5 @@
const zeode = require('zeode');
-const {
- GEOMETRY_BUFFER_SIZE,
- BLOCK_BUFFER_SIZE,
-} = zeode;
+const { GEOMETRY_BUFFER_SIZE, BLOCK_BUFFER_SIZE } = zeode;
const {
NUM_CELLS,
@@ -10,7 +7,9 @@ const {
} = require('./lib/constants/constants');
const NUM_CELLS_HALF = NUM_CELLS / 2;
-const NUM_CELLS_CUBE = Math.sqrt((NUM_CELLS_HALF + 16) * (NUM_CELLS_HALF + 16) * 3); // larger than the actual bounding box to account for geometry overflow
+const NUM_CELLS_CUBE = Math.sqrt(
+ (NUM_CELLS_HALF + 16) * (NUM_CELLS_HALF + 16) * 3
+); // larger than the actual bounding box to account for geometry overflow
// const NUM_VOXELS_CHUNK_HEIGHT = BLOCK_BUFFER_SIZE / 4 / NUM_CHUNKS_HEIGHT;
module.exports = ({
@@ -22,106 +21,142 @@ module.exports = ({
translucentVoxels,
faceUvs,
}) => {
-
-const _makeGeometeriesBuffer = (() => {
- const slab = new ArrayBuffer(GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT * 7);
- let index = 0;
- const result = constructor => {
- const result = new constructor(slab, index, (GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT) / constructor.BYTES_PER_ELEMENT);
- index += GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT;
+ const _makeGeometeriesBuffer = (() => {
+ const slab = new ArrayBuffer(GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT * 7);
+ let index = 0;
+ const result = constructor => {
+ const result = new constructor(
+ slab,
+ index,
+ GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT / constructor.BYTES_PER_ELEMENT
+ );
+ index += GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT;
+ return result;
+ };
+ result.reset = () => {
+ index = 0;
+ };
return result;
- };
- result.reset = () => {
- index = 0;
- };
- return result;
-})();
-const boundingSpheres = (() => {
- const slab = new ArrayBuffer(NUM_CHUNKS_HEIGHT * 4 * Float32Array.BYTES_PER_ELEMENT);
- const result = Array(NUM_CHUNKS_HEIGHT);
- for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
- result[i] = new Float32Array(slab, i * 4 * Float32Array.BYTES_PER_ELEMENT, 4);
- }
- return result;
-})();
-const tesselate = chunk => {
- _makeGeometeriesBuffer.reset();
- const geometriesPositions = _makeGeometeriesBuffer(Float32Array);
- const geometriesUvs = _makeGeometeriesBuffer(Float32Array);
- const geometriesSsaos = _makeGeometeriesBuffer(Uint8Array);
- const geometriesFrames = _makeGeometeriesBuffer(Float32Array);
- const geometriesObjectIndices = _makeGeometeriesBuffer(Float32Array);
- const geometriesIndices = _makeGeometeriesBuffer(Uint32Array);
- const geometriesObjects = _makeGeometeriesBuffer(Uint32Array);
+ })();
+ const boundingSpheres = (() => {
+ const slab = new ArrayBuffer(
+ NUM_CHUNKS_HEIGHT * 4 * Float32Array.BYTES_PER_ELEMENT
+ );
+ const result = Array(NUM_CHUNKS_HEIGHT);
+ for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
+ result[i] = new Float32Array(
+ slab,
+ i * 4 * Float32Array.BYTES_PER_ELEMENT,
+ 4
+ );
+ }
+ return result;
+ })();
+ const tesselate = chunk => {
+ _makeGeometeriesBuffer.reset();
+ const geometriesPositions = _makeGeometeriesBuffer(Float32Array);
+ const geometriesUvs = _makeGeometeriesBuffer(Float32Array);
+ const geometriesSsaos = _makeGeometeriesBuffer(Uint8Array);
+ const geometriesFrames = _makeGeometeriesBuffer(Float32Array);
+ const geometriesObjectIndices = _makeGeometeriesBuffer(Float32Array);
+ const geometriesIndices = _makeGeometeriesBuffer(Uint32Array);
+ const geometriesObjects = _makeGeometeriesBuffer(Uint32Array);
+
+ const {
+ positions: numNewPositions,
+ uvs: numNewUvs,
+ ssaos: numNewSsaos,
+ frames: numNewFrames,
+ objectIndices: numNewObjectIndices,
+ indices: numNewIndices,
+ objects: numNewObjects,
+ } = vxl.objectize({
+ src: chunk.getObjectBuffer(),
+ geometries: geometriesBuffer,
+ geometryIndex: geometryTypes,
+ blocks: chunk.getBlockBuffer(),
+ blockTypes,
+ dims: Int32Array.from([NUM_CELLS, NUM_CELLS, NUM_CELLS]),
+ transparentVoxels,
+ translucentVoxels,
+ faceUvs,
+ shift: Float32Array.from([chunk.x * NUM_CELLS, 0, chunk.z * NUM_CELLS]),
+ positions: geometriesPositions,
+ uvs: geometriesUvs,
+ ssaos: geometriesSsaos,
+ frames: geometriesFrames,
+ objectIndices: geometriesObjectIndices,
+ indices: geometriesIndices,
+ objects: geometriesObjects,
+ });
- const {
- positions: numNewPositions,
- uvs: numNewUvs,
- ssaos: numNewSsaos,
- frames: numNewFrames,
- objectIndices: numNewObjectIndices,
- indices: numNewIndices,
- objects: numNewObjects,
- } = vxl.objectize({
- src: chunk.getObjectBuffer(),
- geometries: geometriesBuffer,
- geometryIndex: geometryTypes,
- blocks: chunk.getBlockBuffer(),
- blockTypes,
- dims: Int32Array.from([NUM_CELLS, NUM_CELLS, NUM_CELLS]),
- transparentVoxels,
- translucentVoxels,
- faceUvs,
- shift: Float32Array.from([chunk.x * NUM_CELLS, 0, chunk.z * NUM_CELLS]),
- positions: geometriesPositions,
- uvs: geometriesUvs,
- ssaos: geometriesSsaos,
- frames: geometriesFrames,
- objectIndices: geometriesObjectIndices,
- indices: geometriesIndices,
- objects: geometriesObjects,
- });
+ const localGeometries = Array(NUM_CHUNKS_HEIGHT);
+ for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
+ const attributeRangeStart = i === 0 ? 0 : numNewPositions[i - 1];
+ const attributeRangeCount = numNewPositions[i] - attributeRangeStart;
+ const indexRangeStart = i === 0 ? 0 : numNewIndices[i - 1];
+ const indexRangeCount = numNewIndices[i] - indexRangeStart;
- const localGeometries = Array(NUM_CHUNKS_HEIGHT);
- for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
- const attributeRangeStart = i === 0 ? 0 : numNewPositions[i - 1];
- const attributeRangeCount = numNewPositions[i] - attributeRangeStart;
- const indexRangeStart = i === 0 ? 0 : numNewIndices[i - 1];
- const indexRangeCount = numNewIndices[i] - indexRangeStart;
+ const boundingSphere = boundingSpheres[i];
+ boundingSphere[0] = chunk.x * NUM_CELLS + NUM_CELLS_HALF;
+ boundingSphere[1] = i * NUM_CELLS + NUM_CELLS_HALF;
+ boundingSphere[2] = chunk.z * NUM_CELLS + NUM_CELLS_HALF;
+ boundingSphere[3] = NUM_CELLS_CUBE;
- const boundingSphere = boundingSpheres[i];
- boundingSphere[0] = chunk.x * NUM_CELLS + NUM_CELLS_HALF;
- boundingSphere[1] = i * NUM_CELLS + NUM_CELLS_HALF;
- boundingSphere[2] = chunk.z * NUM_CELLS + NUM_CELLS_HALF;
- boundingSphere[3] = NUM_CELLS_CUBE;
+ localGeometries[i] = {
+ attributeRange: {
+ start: attributeRangeStart,
+ count: attributeRangeCount,
+ },
+ indexRange: {
+ start: indexRangeStart,
+ count: indexRangeCount,
+ },
+ boundingSphere,
+ };
+ }
- localGeometries[i] = {
- attributeRange: {
- start: attributeRangeStart,
- count: attributeRangeCount,
- },
- indexRange: {
- start: indexRangeStart,
- count: indexRangeCount,
- },
- boundingSphere,
+ return {
+ positions: new Float32Array(
+ geometriesPositions.buffer,
+ geometriesPositions.byteOffset,
+ numNewPositions[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ uvs: new Float32Array(
+ geometriesUvs.buffer,
+ geometriesUvs.byteOffset,
+ numNewUvs[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ ssaos: new Uint8Array(
+ geometriesSsaos.buffer,
+ geometriesSsaos.byteOffset,
+ numNewSsaos[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ frames: new Float32Array(
+ geometriesFrames.buffer,
+ geometriesFrames.byteOffset,
+ numNewFrames[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ objectIndices: new Float32Array(
+ geometriesObjectIndices.buffer,
+ geometriesObjectIndices.byteOffset,
+ numNewObjectIndices[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ indices: new Uint32Array(
+ geometriesIndices.buffer,
+ geometriesIndices.byteOffset,
+ numNewIndices[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ objects: new Uint32Array(
+ geometriesObjects.buffer,
+ geometriesObjects.byteOffset,
+ numNewObjects[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ geometries: localGeometries,
};
};
return {
- positions: new Float32Array(geometriesPositions.buffer, geometriesPositions.byteOffset, numNewPositions[NUM_CHUNKS_HEIGHT - 1]),
- uvs: new Float32Array(geometriesUvs.buffer, geometriesUvs.byteOffset, numNewUvs[NUM_CHUNKS_HEIGHT - 1]),
- ssaos: new Uint8Array(geometriesSsaos.buffer, geometriesSsaos.byteOffset, numNewSsaos[NUM_CHUNKS_HEIGHT - 1]),
- frames: new Float32Array(geometriesFrames.buffer, geometriesFrames.byteOffset, numNewFrames[NUM_CHUNKS_HEIGHT - 1]),
- objectIndices: new Float32Array(geometriesObjectIndices.buffer, geometriesObjectIndices.byteOffset, numNewObjectIndices[NUM_CHUNKS_HEIGHT - 1]),
- indices: new Uint32Array(geometriesIndices.buffer, geometriesIndices.byteOffset, numNewIndices[NUM_CHUNKS_HEIGHT - 1]),
- objects: new Uint32Array(geometriesObjects.buffer, geometriesObjects.byteOffset, numNewObjects[NUM_CHUNKS_HEIGHT - 1]),
- geometries: localGeometries,
+ tesselate,
};
};
-
-return {
- tesselate,
-};
-
-};
diff --git a/plugins/generator/server.js b/plugins/generator/server.js
index d8662e55b..0413ce12c 100644
--- a/plugins/generator/server.js
+++ b/plugins/generator/server.js
@@ -3,10 +3,7 @@ const fs = require('fs');
const touch = require('touch');
const zeode = require('zeode');
-const {
- BLOCK_BUFFER_SIZE,
- GEOMETRY_BUFFER_SIZE,
-} = zeode;
+const { BLOCK_BUFFER_SIZE, GEOMETRY_BUFFER_SIZE } = zeode;
const txtr = require('txtr');
const {
NUM_CELLS,
@@ -25,12 +22,7 @@ const protocolUtils = require('./lib/utils/protocol-utils');
const terrainTesselatorLib = require('./terrain-tesselator');
const objectsTesselatorLib = require('./objects-tesselator');
-const DIRECTIONS = [
- [-1, -1],
- [-1, 1],
- [1, -1],
- [1, 1],
-];
+const DIRECTIONS = [[-1, -1], [-1, 1], [1, -1], [1, 1]];
const lightsSymbol = Symbol();
const lightsRenderedSymbol = Symbol();
@@ -44,15 +36,24 @@ class Generator {
}
mount() {
- const {_archae: archae} = this;
- const {dirname, dataDirectory} = archae;
- const {express, ws, app, wss} = archae.getCore();
- const {three, elements, utils: {js: jsUtils, hash: hashUtils, random: randomUtils, image: imageUtils}} = zeo;
- const {THREE} = three;
- const {mod} = jsUtils;
- const {murmur} = hashUtils;
- const {alea, vxlPath, vxl} = randomUtils;
- const {jimp} = imageUtils;
+ const { _archae: archae } = this;
+ const { dirname, dataDirectory } = archae;
+ const { express, ws, app, wss } = archae.getCore();
+ const {
+ three,
+ elements,
+ utils: {
+ js: jsUtils,
+ hash: hashUtils,
+ random: randomUtils,
+ image: imageUtils,
+ },
+ } = zeo;
+ const { THREE } = three;
+ const { mod } = jsUtils;
+ const { murmur } = hashUtils;
+ const { alea, vxlPath, vxl } = randomUtils;
+ const { jimp } = imageUtils;
const zeroVector = new THREE.Vector3();
const zeroVectorArray = zeroVector.toArray();
@@ -69,7 +70,7 @@ class Generator {
const transparentVoxels = new Uint8Array(256);
const translucentVoxels = new Uint8Array(256);
const faceUvs = new Float32Array(256 * 6 * 4);
- const lights = new Uint32Array(256);;
+ const lights = new Uint32Array(256);
let lightsIndex = 0;
const noiser = vxl.noiser({
seed: murmur(DEFAULT_SEED),
@@ -92,10 +93,18 @@ class Generator {
faceUvs,
});
const zeodeDataPath = path.join(dirname, dataDirectory, 'zeode.dat');
- const texturesPngDataPath = path.join(dirname, dataDirectory, 'textures.png');
- const texturesJsonDataPath = path.join(dirname, dataDirectory, 'textures.json');
-
- const _getChunkIndex = (x, z) => (mod(x, 0xFFFF) << 16) | mod(z, 0xFFFF);
+ const texturesPngDataPath = path.join(
+ dirname,
+ dataDirectory,
+ 'textures.png'
+ );
+ const texturesJsonDataPath = path.join(
+ dirname,
+ dataDirectory,
+ 'textures.json'
+ );
+
+ const _getChunkIndex = (x, z) => (mod(x, 0xffff) << 16) | mod(z, 0xffff);
// const _getLightsIndex = (x, y, z) => x + y * NUM_CELLS_OVERSCAN + z * NUM_CELLS_OVERSCAN * (NUM_CELLS_HEIGHT + 1);
const _getLightsArrayIndex = (x, z) => x + z * 3;
const _findLight = n => {
@@ -113,7 +122,11 @@ class Generator {
};
const _generateChunkTerrain = (chunk, opts) => {
const uint32Buffer = chunk.getTerrainBuffer();
- protocolUtils.stringifyTerrainData(terrainTesselator.generate(chunk.x, chunk.z, opts), uint32Buffer.buffer, uint32Buffer.byteOffset);
+ protocolUtils.stringifyTerrainData(
+ terrainTesselator.generate(chunk.x, chunk.z, opts),
+ uint32Buffer.buffer,
+ uint32Buffer.byteOffset
+ );
};
const _generateChunkObjects = chunk => {
for (let i = 0; i < generators.length; i++) {
@@ -133,38 +146,47 @@ class Generator {
};
const _decorateChunkObjectsGeometry = chunk => {
const geometryBuffer = chunk.getGeometryBuffer();
- protocolUtils.stringifyGeometry(objectsTesselator.tesselate(chunk), geometryBuffer.buffer, geometryBuffer.byteOffset);
+ protocolUtils.stringifyGeometry(
+ objectsTesselator.tesselate(chunk),
+ geometryBuffer.buffer,
+ geometryBuffer.byteOffset
+ );
return Promise.resolve(chunk);
};
const _symbolizeChunk = chunk => {
if (chunk) {
- chunk[lightsSymbol] = new Uint8Array(NUM_CELLS_OVERSCAN * (NUM_CELLS_HEIGHT + 1) * NUM_CELLS_OVERSCAN);
+ chunk[lightsSymbol] = new Uint8Array(
+ NUM_CELLS_OVERSCAN * (NUM_CELLS_HEIGHT + 1) * NUM_CELLS_OVERSCAN
+ );
chunk[lightsRenderedSymbol] = false;
chunk[lightmapsSymbol] = null;
- chunk[blockfieldSymbol] = new Uint8Array(NUM_CELLS * NUM_CELLS_HEIGHT * NUM_CELLS);
+ chunk[blockfieldSymbol] = new Uint8Array(
+ NUM_CELLS * NUM_CELLS_HEIGHT * NUM_CELLS
+ );
chunk[blockfieldRenderedSymbol] = false;
}
};
- const _readEnsureFile = (p, opts) => new Promise((accept, reject) => {
- fs.readFile(p, opts, (err, d) => {
- if (!err) {
- accept(d);
- } else if (err.code === 'ENOENT') {
- touch(p, err => {
- if (!err) {
- accept(null);
- } else {
- reject(err);
- }
- });
- } else {
- reject(err);
- }
+ const _readEnsureFile = (p, opts) =>
+ new Promise((accept, reject) => {
+ fs.readFile(p, opts, (err, d) => {
+ if (!err) {
+ accept(d);
+ } else if (err.code === 'ENOENT') {
+ touch(p, err => {
+ if (!err) {
+ accept(null);
+ } else {
+ reject(err);
+ }
+ });
+ } else {
+ reject(err);
+ }
+ });
});
- });
- const _getZeode = () => _readEnsureFile(zeodeDataPath)
- .then(b => {
+ const _getZeode = () =>
+ _readEnsureFile(zeodeDataPath).then(b => {
const zde = zeode();
if (b) {
zde.load(b);
@@ -175,42 +197,29 @@ class Generator {
}
return zde;
});
- const _getTextures = () => Promise.all([
- _readEnsureFile(texturesPngDataPath)
- .then(b => {
- if (b !== null && b.length > 0) {
- return jimp.read(b);
- } else {
- return Promise.resolve(new jimp(TEXTURE_SIZE, TEXTURE_SIZE));
- }
- })
- .then(textureImg => {
- textureImg.version = 0;
- return textureImg;
- }),
- _readEnsureFile(texturesJsonDataPath, 'utf8')
- .then(s => {
+ const _getTextures = () =>
+ Promise.all([
+ _readEnsureFile(texturesPngDataPath)
+ .then(b => {
+ if (b !== null && b.length > 0) {
+ return jimp.read(b);
+ } else {
+ return Promise.resolve(new jimp(TEXTURE_SIZE, TEXTURE_SIZE));
+ }
+ })
+ .then(textureImg => {
+ textureImg.version = 0;
+ return textureImg;
+ }),
+ _readEnsureFile(texturesJsonDataPath, 'utf8').then(s => {
if (s !== null && s.length > 0) {
- const {atlas, uvs} = JSON.parse(s);
- return [
- txtr.fromJson(atlas),
- uvs,
- ];
+ const { atlas, uvs } = JSON.parse(s);
+ return [txtr.fromJson(atlas), uvs];
} else {
- return [
- txtr(TEXTURE_SIZE, TEXTURE_SIZE),
- {},
- ];
+ return [txtr(TEXTURE_SIZE, TEXTURE_SIZE), {}];
}
}),
- ])
- .then(([
- textureImg,
- [
- textureAtlas,
- textureUvs,
- ],
- ]) => ({
+ ]).then(([textureImg, [textureAtlas, textureUvs]]) => ({
textureImg,
textureAtlas,
textureUvs,
@@ -219,31 +228,24 @@ class Generator {
return Promise.all([
_getZeode(),
_getTextures(),
- ])
- .then(([
- zde,
- {
- textureImg,
- textureAtlas,
- textureUvs,
- },
- ]) => {
- const _requestChunkHard = (x, z) => {
- const chunk = zde.getChunk(x, z);
-
- if (chunk) {
- return Promise.resolve(chunk);
- } else {
- const chunk = zde.makeChunk(x, z);
- _symbolizeChunk(chunk);
- _generateChunk(chunk);
+ ]).then(([zde, { textureImg, textureAtlas, textureUvs }]) => {
+ const _requestChunkHard = (x, z) => {
+ const chunk = zde.getChunk(x, z);
+
+ if (chunk) {
+ return Promise.resolve(chunk);
+ } else {
+ const chunk = zde.makeChunk(x, z);
+ _symbolizeChunk(chunk);
+ _generateChunk(chunk);
- _saveChunks();
+ _saveChunks();
- return Promise.resolve(chunk);
- }
- };
- const _decorateChunkLights = chunk => _decorateChunkLightsRange(
+ return Promise.resolve(chunk);
+ }
+ };
+ const _decorateChunkLights = chunk =>
+ _decorateChunkLightsRange(
chunk,
(chunk.x - 1) * NUM_CELLS,
(chunk.x + 2) * NUM_CELLS,
@@ -253,7 +255,8 @@ class Generator {
(chunk.z + 2) * NUM_CELLS,
false
);
- const _decorateChunkLightsSub = (chunk, x, y, z) => _decorateChunkLightsRange(
+ const _decorateChunkLightsSub = (chunk, x, y, z) =>
+ _decorateChunkLightsRange(
chunk,
Math.max(x - 15, (chunk.x - 1) * NUM_CELLS),
Math.min(x + 15, (chunk.x + 2) * NUM_CELLS),
@@ -263,140 +266,209 @@ class Generator {
Math.min(z + 15, (chunk.z + 2) * NUM_CELLS),
true
);
- /* const _ensureChunksHardRange = (minX, maxX, minZ, maxZ) => {
+ /* const _ensureChunksHardRange = (minX, maxX, minZ, maxZ) => {
const minOX = Math.floor(minX / NUM_CELLS);
const maxOX = Math.floor((maxX - 1) / NUM_CELLS);
const minOZ = Math.floor(minZ / NUM_CELLS);
const maxOZ = Math.floor((maxZ - 1) / NUM_CELLS); */
- const _ensureChunksHardRange = (ox, oz) => {
- const promises = [];
+ const _ensureChunksHardRange = (ox, oz) => {
+ const promises = [];
+ for (let doz = -1; doz <= 1; doz++) {
+ for (let dox = -1; dox <= 1; dox++) {
+ /* for (let doz = minOZ; doz < maxOZ; doz++) {
+ for (let dox = minOX; dox < maxOX; dox++) { */
+ promises.push(_requestChunkHard(ox + dox, oz + doz));
+ }
+ }
+ return Promise.all(promises).then(() => {});
+ };
+ // const _decorateChunkLightsRange = (chunk, minX, maxX, minY, maxY, minZ, maxZ, relight) => _ensureChunksHardRange(minX, maxZ, minZ, maxZ)
+ const _decorateChunkLightsRange = (
+ chunk,
+ minX,
+ maxX,
+ minY,
+ maxY,
+ minZ,
+ maxZ,
+ relight
+ ) =>
+ _ensureChunksHardRange(chunk.x, chunk.z).then(() => {
+ const { x: ox, z: oz } = chunk;
+ const updatingLights = chunk[lightsRenderedSymbol];
+
+ const lavaArray = Array(9);
+ const objectLightsArray = Array(9);
+ const etherArray = Array(9);
+ const blocksArray = Array(9);
+ const lightsArray = Array(9);
for (let doz = -1; doz <= 1; doz++) {
for (let dox = -1; dox <= 1; dox++) {
- /* for (let doz = minOZ; doz < maxOZ; doz++) {
- for (let dox = minOX; dox < maxOX; dox++) { */
- promises.push(_requestChunkHard(ox + dox, oz + doz));
+ const arrayIndex = _getLightsArrayIndex(dox + 1, doz + 1);
+
+ const aox = ox + dox;
+ const aoz = oz + doz;
+ const chunk = zde.getChunk(aox, aoz);
+ const uint32Buffer = chunk.getTerrainBuffer();
+ const { ether, lava } = protocolUtils.parseTerrainData(
+ uint32Buffer.buffer,
+ uint32Buffer.byteOffset
+ ); // XXX can be reduced to only parse the needed fields
+ lavaArray[arrayIndex] = lava;
+
+ const objectLights = chunk.getLightBuffer();
+ objectLightsArray[arrayIndex] = objectLights;
+
+ etherArray[arrayIndex] = ether;
+
+ const blocks = chunk.getBlockBuffer();
+ blocksArray[arrayIndex] = blocks;
+
+ const { [lightsSymbol]: lights } = chunk;
+ lightsArray[arrayIndex] = lights;
}
}
- return Promise.all(promises).then(() => {});
- };
- // const _decorateChunkLightsRange = (chunk, minX, maxX, minY, maxY, minZ, maxZ, relight) => _ensureChunksHardRange(minX, maxZ, minZ, maxZ)
- const _decorateChunkLightsRange = (chunk, minX, maxX, minY, maxY, minZ, maxZ, relight) => _ensureChunksHardRange(chunk.x, chunk.z)
- .then(() => {
- const {x: ox, z: oz} = chunk;
- const updatingLights = chunk[lightsRenderedSymbol];
-
- const lavaArray = Array(9);
- const objectLightsArray = Array(9);
- const etherArray = Array(9);
- const blocksArray = Array(9);
- const lightsArray = Array(9);
- for (let doz = -1; doz <= 1; doz++) {
- for (let dox = -1; dox <= 1; dox++) {
- const arrayIndex = _getLightsArrayIndex(dox + 1, doz + 1);
-
- const aox = ox + dox;
- const aoz = oz + doz;
- const chunk = zde.getChunk(aox, aoz);
- const uint32Buffer = chunk.getTerrainBuffer();
- const {ether, lava} = protocolUtils.parseTerrainData(uint32Buffer.buffer, uint32Buffer.byteOffset); // XXX can be reduced to only parse the needed fields
- lavaArray[arrayIndex] = lava;
-
- const objectLights = chunk.getLightBuffer();
- objectLightsArray[arrayIndex] = objectLights;
-
- etherArray[arrayIndex] = ether;
-
- const blocks = chunk.getBlockBuffer();
- blocksArray[arrayIndex] = blocks;
-
- const {[lightsSymbol]: lights} = chunk;
- lightsArray[arrayIndex] = lights;
- }
- }
- vxl.light(
- ox, oz,
- minX, maxX, minY, maxY, minZ, maxZ,
- relight,
- lavaArray,
- objectLightsArray,
- etherArray,
- blocksArray,
- lightsArray,
+ vxl.light(
+ ox,
+ oz,
+ minX,
+ maxX,
+ minY,
+ maxY,
+ minZ,
+ maxZ,
+ relight,
+ lavaArray,
+ objectLightsArray,
+ etherArray,
+ blocksArray,
+ lightsArray
+ );
+ chunk[lightsRenderedSymbol] = true;
+ chunk[lightmapsSymbol] = null;
+
+ return chunk;
+ });
+ const _requestChunkWithLights = chunk =>
+ chunk[lightsRenderedSymbol]
+ ? Promise.resolve(chunk)
+ : _decorateChunkLights(chunk);
+ const _requestChunkWithLightmaps = chunk => {
+ if (chunk[lightmapsSymbol]) {
+ return Promise.resolve(chunk);
+ } else {
+ const _getTerrainLightmaps = () => {
+ const terrainBuffer = chunk.getTerrainBuffer();
+ const {
+ positions,
+ staticHeightfield,
+ } = protocolUtils.parseTerrainData(
+ terrainBuffer.buffer,
+ terrainBuffer.byteOffset
+ );
+ const { [lightsSymbol]: lights } = chunk;
+
+ const numPositions = positions.length;
+ const numLightmaps = numPositions / 3;
+ const lightmapsBuffer = new ArrayBuffer(numLightmaps * 2);
+ const skyLightmaps = new Uint8Array(
+ lightmapsBuffer,
+ 0,
+ numLightmaps
+ );
+ const torchLightmaps = new Uint8Array(
+ lightmapsBuffer,
+ numLightmaps,
+ numLightmaps
);
- chunk[lightsRenderedSymbol] = true;
- chunk[lightmapsSymbol] = null;
-
- return chunk;
- });
- const _requestChunkWithLights = chunk => chunk[lightsRenderedSymbol] ? Promise.resolve(chunk) : _decorateChunkLights(chunk);
- const _requestChunkWithLightmaps = chunk => {
- if (chunk[lightmapsSymbol]) {
- return Promise.resolve(chunk);
- } else {
- const _getTerrainLightmaps = () => {
- const terrainBuffer = chunk.getTerrainBuffer();
- const {positions, staticHeightfield} = protocolUtils.parseTerrainData(terrainBuffer.buffer, terrainBuffer.byteOffset);
- const {[lightsSymbol]: lights} = chunk;
-
- const numPositions = positions.length;
- const numLightmaps = numPositions / 3;
- const lightmapsBuffer = new ArrayBuffer(numLightmaps * 2);
- const skyLightmaps = new Uint8Array(lightmapsBuffer, 0, numLightmaps);
- const torchLightmaps = new Uint8Array(lightmapsBuffer, numLightmaps, numLightmaps);
- vxl.lightmap(chunk.x, chunk.z, positions, numPositions, staticHeightfield, lights, skyLightmaps, torchLightmaps);
+ vxl.lightmap(
+ chunk.x,
+ chunk.z,
+ positions,
+ numPositions,
+ staticHeightfield,
+ lights,
+ skyLightmaps,
+ torchLightmaps
+ );
- return {
- skyLightmaps,
- torchLightmaps,
- };
+ return {
+ skyLightmaps,
+ torchLightmaps,
};
- const _getObjectLightmaps = () => {
- const geometryBuffer = chunk.getGeometryBuffer();
- const {positions} = protocolUtils.parseGeometry(geometryBuffer.buffer, geometryBuffer.byteOffset);
-
- const terrainBuffer = chunk.getTerrainBuffer();
- const {staticHeightfield} = protocolUtils.parseTerrainData(terrainBuffer.buffer, terrainBuffer.byteOffset);
- const {[lightsSymbol]: lights} = chunk;
+ };
+ const _getObjectLightmaps = () => {
+ const geometryBuffer = chunk.getGeometryBuffer();
+ const { positions } = protocolUtils.parseGeometry(
+ geometryBuffer.buffer,
+ geometryBuffer.byteOffset
+ );
- const numPositions = positions.length;
- const numLightmaps = numPositions / 3;
- const lightmapsBuffer = new ArrayBuffer(numLightmaps * 2);
- const skyLightmaps = new Uint8Array(lightmapsBuffer, 0, numLightmaps);
- const torchLightmaps = new Uint8Array(lightmapsBuffer, numLightmaps, numLightmaps);
+ const terrainBuffer = chunk.getTerrainBuffer();
+ const { staticHeightfield } = protocolUtils.parseTerrainData(
+ terrainBuffer.buffer,
+ terrainBuffer.byteOffset
+ );
+ const { [lightsSymbol]: lights } = chunk;
+
+ const numPositions = positions.length;
+ const numLightmaps = numPositions / 3;
+ const lightmapsBuffer = new ArrayBuffer(numLightmaps * 2);
+ const skyLightmaps = new Uint8Array(
+ lightmapsBuffer,
+ 0,
+ numLightmaps
+ );
+ const torchLightmaps = new Uint8Array(
+ lightmapsBuffer,
+ numLightmaps,
+ numLightmaps
+ );
- vxl.lightmap(chunk.x, chunk.z, positions, numPositions, staticHeightfield, lights, skyLightmaps, torchLightmaps);
+ vxl.lightmap(
+ chunk.x,
+ chunk.z,
+ positions,
+ numPositions,
+ staticHeightfield,
+ lights,
+ skyLightmaps,
+ torchLightmaps
+ );
- return {
- skyLightmaps,
- torchLightmaps,
- };
+ return {
+ skyLightmaps,
+ torchLightmaps,
};
+ };
- chunk[lightmapsSymbol] = {
- terrain: _getTerrainLightmaps(),
- objects: _getObjectLightmaps(),
- };
+ chunk[lightmapsSymbol] = {
+ terrain: _getTerrainLightmaps(),
+ objects: _getObjectLightmaps(),
+ };
- return Promise.resolve(chunk);
- }
- };
- const _requestChunkWithBlockfield = chunk => {
- if (chunk[blockfieldRenderedSymbol]) {
- return Promise.resolve(chunk);
- } else {
- vxl.blockfield(chunk.getBlockBuffer(), chunk[blockfieldSymbol]);
- chunk[blockfieldRenderedSymbol] = true;
- return Promise.resolve(chunk);
- }
- };
- const _requestChunk = (x, z) => _requestChunkHard(x, z)
+ return Promise.resolve(chunk);
+ }
+ };
+ const _requestChunkWithBlockfield = chunk => {
+ if (chunk[blockfieldRenderedSymbol]) {
+ return Promise.resolve(chunk);
+ } else {
+ vxl.blockfield(chunk.getBlockBuffer(), chunk[blockfieldSymbol]);
+ chunk[blockfieldRenderedSymbol] = true;
+ return Promise.resolve(chunk);
+ }
+ };
+ const _requestChunk = (x, z) =>
+ _requestChunkHard(x, z)
.then(chunk => _requestChunkWithLights(chunk))
.then(chunk => _requestChunkWithLightmaps(chunk))
.then(chunk => _requestChunkWithBlockfield(chunk));
- const _writeFileData = (p, data, byteOffset) => new Promise((accept, reject) => {
+ const _writeFileData = (p, data, byteOffset) =>
+ new Promise((accept, reject) => {
const ws = fs.createWriteStream(p, {
flags: 'r+',
start: byteOffset,
@@ -409,61 +481,82 @@ class Generator {
reject(err);
});
});
- const _saveChunks = _debounce(next => {
- const promises = [];
- zde.save((byteOffset, data) => {
- promises.push(_writeFileData(zeodeDataPath, new Buffer(data.buffer, data.byteOffset, data.byteLength), byteOffset));
- });
- Promise.all(promises)
- .then(() => {
- next();
- })
- .catch(err => {
- console.warn(err);
-
- next();
- });
+ const _saveChunks = _debounce(next => {
+ const promises = [];
+ zde.save((byteOffset, data) => {
+ promises.push(
+ _writeFileData(
+ zeodeDataPath,
+ new Buffer(data.buffer, data.byteOffset, data.byteLength),
+ byteOffset
+ )
+ );
});
- const _saveTextures = _debounce(next => {
- Promise.all([
- textureImg.write(texturesPngDataPath),
- _writeFileData(texturesJsonDataPath, JSON.stringify({
- atlas: textureAtlas.toJson(),
- uvs: textureUvs,
- }, null, 2)),
- ])
- .then(() => {
- next();
- })
- .catch(err => {
- console.warn(err);
+ Promise.all(promises)
+ .then(() => {
+ next();
+ })
+ .catch(err => {
+ console.warn(err);
- next();
- });
- });
+ next();
+ });
+ });
+ const _saveTextures = _debounce(next => {
+ Promise.all([
+ textureImg.write(texturesPngDataPath),
+ _writeFileData(
+ texturesJsonDataPath,
+ JSON.stringify(
+ {
+ atlas: textureAtlas.toJson(),
+ uvs: textureUvs,
+ },
+ null,
+ 2
+ )
+ ),
+ ])
+ .then(() => {
+ next();
+ })
+ .catch(err => {
+ console.warn(err);
+
+ next();
+ });
+ });
- class Generator {
- getElevation(x, z) {
- return noiser.getElevation(x, z);
+ class Generator {
+ getElevation(x, z) {
+ return noiser.getElevation(x, z);
+ }
+ getBiome(x, z) {
+ return noiser.getBiome(x, z);
+ }
+ registerGeometry(name, geometry) {
+ if (!geometry.getAttribute('ssao')) {
+ const ssaos = new Uint8Array(
+ geometry.getAttribute('position').array.length / 3
+ );
+ geometry.addAttribute('ssao', new THREE.BufferAttribute(ssaos, 1));
+ }
+ if (!geometry.getAttribute('frame')) {
+ const frames = new Float32Array(
+ geometry.getAttribute('position').array.length
+ );
+ geometry.addAttribute(
+ 'frame',
+ new THREE.BufferAttribute(frames, 3)
+ );
}
- getBiome(x, z) {
- return noiser.getBiome(x, z);
+ if (!geometry.boundingBox) {
+ geometry.computeBoundingBox();
}
- registerGeometry(name, geometry) {
- if (!geometry.getAttribute('ssao')) {
- const ssaos = new Uint8Array(geometry.getAttribute('position').array.length / 3);
- geometry.addAttribute('ssao', new THREE.BufferAttribute(ssaos, 1));
- }
- if (!geometry.getAttribute('frame')) {
- const frames = new Float32Array(geometry.getAttribute('position').array.length);
- geometry.addAttribute('frame', new THREE.BufferAttribute(frames, 3));
- }
- if (!geometry.boundingBox) {
- geometry.computeBoundingBox();
- }
- const offset = geometriesOffset;
- geometriesOffset = protocolUtils.stringifyTemplate({
+ const offset = geometriesOffset;
+ geometriesOffset = protocolUtils.stringifyTemplate(
+ {
positions: geometry.getAttribute('position').array,
uvs: geometry.getAttribute('uv').array,
ssaos: geometry.getAttribute('ssao').array,
@@ -477,216 +570,300 @@ class Generator {
geometry.boundingBox.max.y,
geometry.boundingBox.max.z,
]),
- }, geometriesBuffer.buffer, geometriesBuffer.byteOffset + geometriesOffset)[1];
-
- const index = geometriesIndex++;
- geometryTypes[index * 2 + 0] = murmur(name);
- geometryTypes[index * 2 + 1] = offset;
- }
- registerBlock(name, blockSpec) {
- const index = ++blockTypesIndex;
- // blockSpec.index = index;
-
- blockTypes[index] = murmur(name);
-
- transparentVoxels[index] = +blockSpec.transparent;
- translucentVoxels[index] = +blockSpec.translucent;
- for (let d = 0; d < 6; d++) {
- faceUvs.set(Float32Array.from(blockSpec.uvs[d]), index * 6 * 4 + d * 4);
- }
+ },
+ geometriesBuffer.buffer,
+ geometriesBuffer.byteOffset + geometriesOffset
+ )[1];
+
+ const index = geometriesIndex++;
+ geometryTypes[index * 2 + 0] = murmur(name);
+ geometryTypes[index * 2 + 1] = offset;
+ }
+ registerBlock(name, blockSpec) {
+ const index = ++blockTypesIndex;
+ // blockSpec.index = index;
+
+ blockTypes[index] = murmur(name);
+
+ transparentVoxels[index] = +blockSpec.transparent;
+ translucentVoxels[index] = +blockSpec.translucent;
+ for (let d = 0; d < 6; d++) {
+ faceUvs.set(
+ Float32Array.from(blockSpec.uvs[d]),
+ index * 6 * 4 + d * 4
+ );
}
- registerLight(name, v) {
- const index = ++lightsIndex;
+ }
+ registerLight(name, v) {
+ const index = ++lightsIndex;
- lights[index * 2 + 0] = murmur(name);
- lights[index * 2 + 1] = v;
- }
- setBlock(chunk, x, y, z, name) {
- const ox = Math.floor(x / NUM_CELLS);
- const oz = Math.floor(z / NUM_CELLS);
- if (ox === chunk.x && oz === chunk.z && y > 0 && y < NUM_CELLS_HEIGHT) {
- chunk.setBlock(x - ox * NUM_CELLS, y, z - oz * NUM_CELLS, murmur(name));
- }
- }
- clearBlock(chunk, x, y, z) {
- const ox = Math.floor(x / NUM_CELLS);
- const oz = Math.floor(z / NUM_CELLS);
- if (ox === chunk.x && oz === chunk.z && y > 0 && y < NUM_CELLS_HEIGHT) {
- chunk.clearBlock(x - ox * NUM_CELLS, y, z - oz * NUM_CELLS);
- }
+ lights[index * 2 + 0] = murmur(name);
+ lights[index * 2 + 1] = v;
+ }
+ setBlock(chunk, x, y, z, name) {
+ const ox = Math.floor(x / NUM_CELLS);
+ const oz = Math.floor(z / NUM_CELLS);
+ if (
+ ox === chunk.x &&
+ oz === chunk.z &&
+ y > 0 &&
+ y < NUM_CELLS_HEIGHT
+ ) {
+ chunk.setBlock(
+ x - ox * NUM_CELLS,
+ y,
+ z - oz * NUM_CELLS,
+ murmur(name)
+ );
}
- getUv(name) {
- return textureUvs[murmur(name)];
+ }
+ clearBlock(chunk, x, y, z) {
+ const ox = Math.floor(x / NUM_CELLS);
+ const oz = Math.floor(z / NUM_CELLS);
+ if (
+ ox === chunk.x &&
+ oz === chunk.z &&
+ y > 0 &&
+ y < NUM_CELLS_HEIGHT
+ ) {
+ chunk.clearBlock(x - ox * NUM_CELLS, y, z - oz * NUM_CELLS);
}
- getTileUv(name) {
- const uv = textureUvs[murmur(name)];
+ }
+ getUv(name) {
+ return textureUvs[murmur(name)];
+ }
+ getTileUv(name) {
+ const uv = textureUvs[murmur(name)];
- const tileSizeU = uv[2] - uv[0];
- const tileSizeV = uv[3] - uv[1];
+ const tileSizeU = uv[2] - uv[0];
+ const tileSizeV = uv[3] - uv[1];
- const tileSizeIntU = Math.floor(tileSizeU * TEXTURE_SIZE) / 2;
- const tileSizeIntV = Math.floor(tileSizeV * TEXTURE_SIZE) / 2;
+ const tileSizeIntU = Math.floor(tileSizeU * TEXTURE_SIZE) / 2;
+ const tileSizeIntV = Math.floor(tileSizeV * TEXTURE_SIZE) / 2;
- const u = tileSizeIntU + uv[0];
- const v = tileSizeIntV + uv[1];
+ const u = tileSizeIntU + uv[0];
+ const v = tileSizeIntV + uv[1];
- return [-u, 1 - v, -u, 1 - v];
- }
- registerTexture(name, img, {fourTap = false} = {}) {
- const n = murmur(name);
-
- if (!textureUvs[n]) {
- if (fourTap) {
- const srcImg = img;
- img = new jimp(srcImg.bitmap.width * 2, srcImg.bitmap.height * 2);
- img.composite(srcImg, 0, 0);
- img.composite(srcImg, srcImg.bitmap.width, 0);
- img.composite(srcImg, 0, srcImg.bitmap.height);
- img.composite(srcImg, srcImg.bitmap.width, srcImg.bitmap.height);
- }
- const rect = textureAtlas.pack(img.bitmap.width, img.bitmap.height);
- const uv = textureAtlas.uv(rect);
+ return [-u, 1 - v, -u, 1 - v];
+ }
+ registerTexture(name, img, { fourTap = false } = {}) {
+ const n = murmur(name);
+
+ if (!textureUvs[n]) {
+ if (fourTap) {
+ const srcImg = img;
+ img = new jimp(srcImg.bitmap.width * 2, srcImg.bitmap.height * 2);
+ img.composite(srcImg, 0, 0);
+ img.composite(srcImg, srcImg.bitmap.width, 0);
+ img.composite(srcImg, 0, srcImg.bitmap.height);
+ img.composite(srcImg, srcImg.bitmap.width, srcImg.bitmap.height);
+ }
+ const rect = textureAtlas.pack(img.bitmap.width, img.bitmap.height);
+ const uv = textureAtlas.uv(rect);
- textureImg.composite(img, rect.x, rect.y);
- textureImg.version++;
+ textureImg.composite(img, rect.x, rect.y);
+ textureImg.version++;
- textureUvs[n] = uv;
+ textureUvs[n] = uv;
- _saveTextures();
- }
+ _saveTextures();
}
- registerGenerator(name, fn) {
- const n = murmur(name);
- const generator = [n, fn];
- generators.push(generator);
-
- if (zde.chunks.length > 0) {
- const promises = [];
- for (let i = 0; i < zde.chunks.length; i++) {
- const chunk = zde.chunks[i];
- if (_generateChunkObjectsWithGenerator(chunk, generator)) {
- promises.push(
- _decorateChunkObjectsGeometry(chunk)
- .then(() => {
- chunk.dirty = true;
- })
- );
- }
- }
- if (promises.length > 0) {
- Promise.all(promises)
- .then(() => {
- _saveChunks();
+ }
+ registerGenerator(name, fn) {
+ const n = murmur(name);
+ const generator = [n, fn];
+ generators.push(generator);
+
+ if (zde.chunks.length > 0) {
+ const promises = [];
+ for (let i = 0; i < zde.chunks.length; i++) {
+ const chunk = zde.chunks[i];
+ if (_generateChunkObjectsWithGenerator(chunk, generator)) {
+ promises.push(
+ _decorateChunkObjectsGeometry(chunk).then(() => {
+ chunk.dirty = true;
})
- .catch(err => {
- console.warn(err);
- });
+ );
}
}
- }
- addObject(chunk, name, position, rotation, value) {
- const n = murmur(name);
- const matrix = position.toArray().concat(rotation.toArray());
- const objectIndex = chunk.addObject(n, matrix, value);
-
- const light = _findLight(n);
- if (light) {
- chunk.addLightAt(objectIndex, position.x, position.y, position.z, light);
+ if (promises.length > 0) {
+ Promise.all(promises)
+ .then(() => {
+ _saveChunks();
+ })
+ .catch(err => {
+ console.warn(err);
+ });
}
}
- requestLightmaps(x, z, positions) {
- return _requestChunkHard(x, z)
- .then(chunk => _requestChunkWithLights(chunk))
- .then(chunk => {
- const terrainBuffer = chunk.getTerrainBuffer();
- const {staticHeightfield} = protocolUtils.parseTerrainData(terrainBuffer.buffer, terrainBuffer.byteOffset);
- const {[lightsSymbol]: lights} = chunk;
-
- const numPositions = positions.length;
- const numLightmaps = numPositions / 3;
- const lightmapsBuffer = new ArrayBuffer(numLightmaps * 2);
- const skyLightmaps = new Uint8Array(lightmapsBuffer, 0, numLightmaps);
- const torchLightmaps = new Uint8Array(lightmapsBuffer, numLightmaps, numLightmaps);
-
- vxl.lightmap(chunk.x, chunk.z, positions, numPositions, staticHeightfield, lights, skyLightmaps, torchLightmaps);
-
- return {
- skyLightmaps,
- torchLightmaps,
- };
- });
+ }
+ addObject(chunk, name, position, rotation, value) {
+ const n = murmur(name);
+ const matrix = position.toArray().concat(rotation.toArray());
+ const objectIndex = chunk.addObject(n, matrix, value);
+
+ const light = _findLight(n);
+ if (light) {
+ chunk.addLightAt(
+ objectIndex,
+ position.x,
+ position.y,
+ position.z,
+ light
+ );
}
- requestRelight(x, y, z) {
- const promises = [];
+ }
+ requestLightmaps(x, z, positions) {
+ return _requestChunkHard(x, z)
+ .then(chunk => _requestChunkWithLights(chunk))
+ .then(chunk => {
+ const terrainBuffer = chunk.getTerrainBuffer();
+ const { staticHeightfield } = protocolUtils.parseTerrainData(
+ terrainBuffer.buffer,
+ terrainBuffer.byteOffset
+ );
+ const { [lightsSymbol]: lights } = chunk;
- const seenIndex = {};
- for (let i = 0; i < DIRECTIONS.length; i++) {
- const [dx, dz] = DIRECTIONS[i];
- const ax = x + dx * (NUM_CELLS / 2);
- const az = z + dz * (NUM_CELLS / 2);
- const ox = Math.floor(ax / NUM_CELLS);
- const oz = Math.floor(az / NUM_CELLS);
-
- const index = _getChunkIndex(ox, oz);
- if (!seenIndex[index]) {
- const chunk = zde.getChunk(ox, oz);
- if (chunk && chunk[lightsRenderedSymbol]) {
- promises.push(_decorateChunkLightsSub(chunk, x, y, z));
- }
- seenIndex[index] = true;
+ const numPositions = positions.length;
+ const numLightmaps = numPositions / 3;
+ const lightmapsBuffer = new ArrayBuffer(numLightmaps * 2);
+ const skyLightmaps = new Uint8Array(
+ lightmapsBuffer,
+ 0,
+ numLightmaps
+ );
+ const torchLightmaps = new Uint8Array(
+ lightmapsBuffer,
+ numLightmaps,
+ numLightmaps
+ );
+
+ vxl.lightmap(
+ chunk.x,
+ chunk.z,
+ positions,
+ numPositions,
+ staticHeightfield,
+ lights,
+ skyLightmaps,
+ torchLightmaps
+ );
+
+ return {
+ skyLightmaps,
+ torchLightmaps,
+ };
+ });
+ }
+ requestRelight(x, y, z) {
+ const promises = [];
+
+ const seenIndex = {};
+ for (let i = 0; i < DIRECTIONS.length; i++) {
+ const [dx, dz] = DIRECTIONS[i];
+ const ax = x + dx * (NUM_CELLS / 2);
+ const az = z + dz * (NUM_CELLS / 2);
+ const ox = Math.floor(ax / NUM_CELLS);
+ const oz = Math.floor(az / NUM_CELLS);
+
+ const index = _getChunkIndex(ox, oz);
+ if (!seenIndex[index]) {
+ const chunk = zde.getChunk(ox, oz);
+ if (chunk && chunk[lightsRenderedSymbol]) {
+ promises.push(_decorateChunkLightsSub(chunk, x, y, z));
}
+ seenIndex[index] = true;
}
-
- return Promise.all(promises).then(() => {});
}
- };
- const generatorElement = new Generator();
- elements.registerEntity(this, generatorElement);
-
- function serveObjectsTextureAtlas(req, res, next) {
- textureImg.getBuffer('image/png', (err, buffer) => {
- if (!err) {
- res.type('image/png');
- res.send(buffer);
- } else {
- res.status(500);
- res.json({
- error: err.stack,
- });
- }
- });
- }
- app.get('/archae/objects/texture-atlas.png', serveObjectsTextureAtlas);
- function serveObjectsObjectizeJs(req, res, next) {
- res.type('application/javascript');
- fs.createReadStream(path.join(vxlPath, 'bin', 'objectize.js')).pipe(res);
- }
- app.get('/archae/objects/objectize.js', serveObjectsObjectizeJs);
- function serveObjectsObjectizeWasm(req, res, next) {
- res.type('application/octret-stream');
- fs.createReadStream(path.join(vxlPath, 'bin', 'objectize.wasm')).pipe(res);
- }
- app.get('/archae/objects/objectize.wasm', serveObjectsObjectizeWasm);
- function serveObjectsTemplates(req, res, next) {
- res.write(new Buffer(geometriesBuffer.buffer, geometriesBuffer.byteOffset, geometriesBuffer.byteLength));
- res.write(new Buffer(geometryTypes.buffer, geometryTypes.byteOffset, geometryTypes.byteLength));
- res.write(new Buffer(blockTypes.buffer, blockTypes.byteOffset, blockTypes.byteLength));
- res.write(new Buffer(transparentVoxels.buffer, transparentVoxels.byteOffset, transparentVoxels.byteLength));
- res.write(new Buffer(translucentVoxels.buffer, translucentVoxels.byteOffset, translucentVoxels.byteLength));
- res.write(new Buffer(faceUvs.buffer, faceUvs.byteOffset, faceUvs.byteLength));
- res.write(new Buffer(lights.buffer, lights.byteOffset, lights.byteLength));
- res.end();
+ return Promise.all(promises).then(() => {});
}
- app.get('/archae/objects/geometry.bin', serveObjectsTemplates);
+ }
+ const generatorElement = new Generator();
+ elements.registerEntity(this, generatorElement);
+
+ function serveObjectsTextureAtlas(req, res, next) {
+ textureImg.getBuffer('image/png', (err, buffer) => {
+ if (!err) {
+ res.type('image/png');
+ res.send(buffer);
+ } else {
+ res.status(500);
+ res.json({
+ error: err.stack,
+ });
+ }
+ });
+ }
+ app.get('/archae/objects/texture-atlas.png', serveObjectsTextureAtlas);
+
+ function serveObjectsObjectizeJs(req, res, next) {
+ res.type('application/javascript');
+ fs
+ .createReadStream(path.join(vxlPath, 'bin', 'objectize.js'))
+ .pipe(res);
+ }
+ app.get('/archae/objects/objectize.js', serveObjectsObjectizeJs);
+ function serveObjectsObjectizeWasm(req, res, next) {
+ res.type('application/octret-stream');
+ fs
+ .createReadStream(path.join(vxlPath, 'bin', 'objectize.wasm'))
+ .pipe(res);
+ }
+ app.get('/archae/objects/objectize.wasm', serveObjectsObjectizeWasm);
+ function serveObjectsTemplates(req, res, next) {
+ res.write(
+ new Buffer(
+ geometriesBuffer.buffer,
+ geometriesBuffer.byteOffset,
+ geometriesBuffer.byteLength
+ )
+ );
+ res.write(
+ new Buffer(
+ geometryTypes.buffer,
+ geometryTypes.byteOffset,
+ geometryTypes.byteLength
+ )
+ );
+ res.write(
+ new Buffer(
+ blockTypes.buffer,
+ blockTypes.byteOffset,
+ blockTypes.byteLength
+ )
+ );
+ res.write(
+ new Buffer(
+ transparentVoxels.buffer,
+ transparentVoxels.byteOffset,
+ transparentVoxels.byteLength
+ )
+ );
+ res.write(
+ new Buffer(
+ translucentVoxels.buffer,
+ translucentVoxels.byteOffset,
+ translucentVoxels.byteLength
+ )
+ );
+ res.write(
+ new Buffer(faceUvs.buffer, faceUvs.byteOffset, faceUvs.byteLength)
+ );
+ res.write(
+ new Buffer(lights.buffer, lights.byteOffset, lights.byteLength)
+ );
+ res.end();
+ }
+ app.get('/archae/objects/geometry.bin', serveObjectsTemplates);
- function serveGeneratorChunks(req, res, next) {
- const {query: {x: xs, z: zs}} = req;
- const x = parseInt(xs, 10);
- const z = parseInt(zs, 10);
+ function serveGeneratorChunks(req, res, next) {
+ const { query: { x: xs, z: zs } } = req;
+ const x = parseInt(xs, 10);
+ const z = parseInt(zs, 10);
- if (!isNaN(x) && !isNaN(z)) {
- /* new Promise((accept, reject) => {
+ if (!isNaN(x) && !isNaN(z)) {
+ /* new Promise((accept, reject) => {
let chunk = zde.getChunk(x, z);
if (!chunk) {
chunk = _generateChunk(zde.makeChunk(x, z));
@@ -696,321 +873,386 @@ class Generator {
})
.then(chunk => !chunk[lightsRenderedSymbol] ? _decorateChunkLights(chunk) : Promise.resolve(chunk))
.then(chunk => !chunk[lightmapsSymbol] ? _decorateChunkLightmaps(chunk) : Promise.resolve(chunk)) */
- _requestChunk(x, z)
- .then(chunk => {
- res.type('application/octet-stream');
- res.set('Texture-Atlas-Version', textureImg.version);
- res.set('Geometry-Version', geometriesBuffer.version);
-
- const terrainBuffer = chunk.getTerrainBuffer();
- res.write(new Buffer(terrainBuffer.buffer, terrainBuffer.byteOffset, terrainBuffer.byteLength));
+ _requestChunk(x, z)
+ .then(chunk => {
+ res.type('application/octet-stream');
+ res.set('Texture-Atlas-Version', textureImg.version);
+ res.set('Geometry-Version', geometriesBuffer.version);
- const objectBuffer = chunk.getObjectBuffer();
- res.write(new Buffer(objectBuffer.buffer, objectBuffer.byteOffset, objectBuffer.byteLength));
-
- const blockBuffer = chunk.getBlockBuffer();
- res.write(new Buffer(blockBuffer.buffer, blockBuffer.byteOffset, blockBuffer.byteLength));
-
- const lightBuffer = chunk.getLightBuffer();
- res.write(new Buffer(lightBuffer.buffer, lightBuffer.byteOffset, lightBuffer.byteLength));
-
- const geometryBuffer = chunk.getGeometryBuffer();
- res.write(new Buffer(geometryBuffer.buffer, geometryBuffer.byteOffset, geometryBuffer.byteLength));
+ const terrainBuffer = chunk.getTerrainBuffer();
+ res.write(
+ new Buffer(
+ terrainBuffer.buffer,
+ terrainBuffer.byteOffset,
+ terrainBuffer.byteLength
+ )
+ );
+
+ const objectBuffer = chunk.getObjectBuffer();
+ res.write(
+ new Buffer(
+ objectBuffer.buffer,
+ objectBuffer.byteOffset,
+ objectBuffer.byteLength
+ )
+ );
+
+ const blockBuffer = chunk.getBlockBuffer();
+ res.write(
+ new Buffer(
+ blockBuffer.buffer,
+ blockBuffer.byteOffset,
+ blockBuffer.byteLength
+ )
+ );
+
+ const lightBuffer = chunk.getLightBuffer();
+ res.write(
+ new Buffer(
+ lightBuffer.buffer,
+ lightBuffer.byteOffset,
+ lightBuffer.byteLength
+ )
+ );
- const [arrayBuffer, byteOffset] = protocolUtils.stringifyDecorations(chunk[lightmapsSymbol], chunk[blockfieldSymbol]);
- res.end(new Buffer(arrayBuffer, 0, byteOffset));
- })
- .catch(err => {
- console.warn(err);
+ const geometryBuffer = chunk.getGeometryBuffer();
+ res.write(
+ new Buffer(
+ geometryBuffer.buffer,
+ geometryBuffer.byteOffset,
+ geometryBuffer.byteLength
+ )
+ );
+
+ const [
+ arrayBuffer,
+ byteOffset,
+ ] = protocolUtils.stringifyDecorations(
+ chunk[lightmapsSymbol],
+ chunk[blockfieldSymbol]
+ );
+ res.end(new Buffer(arrayBuffer, 0, byteOffset));
+ })
+ .catch(err => {
+ console.warn(err);
- res.status(500);
- res.json({
- error: err.stack,
- });
+ res.status(500);
+ res.json({
+ error: err.stack,
});
- } else {
- res.status(400);
- res.send();
- }
+ });
+ } else {
+ res.status(400);
+ res.send();
}
- app.get('/archae/generator/chunks', serveGeneratorChunks);
+ }
+ app.get('/archae/generator/chunks', serveGeneratorChunks);
- const connections = [];
- const _connection = c => {
- const {url} = c.upgradeReq;
+ const connections = [];
+ const _connection = c => {
+ const { url } = c.upgradeReq;
- if (url === '/archae/generatorWs') {
- const _broadcast = e => {
- const es = JSON.stringify(e);
+ if (url === '/archae/generatorWs') {
+ const _broadcast = e => {
+ const es = JSON.stringify(e);
- for (let i = 0; i < connections.length; i++) {
- const connection = connections[i];
- if (connection.readyState === ws.OPEN && connection !== c) {
- connection.send(es);
- }
+ for (let i = 0; i < connections.length; i++) {
+ const connection = connections[i];
+ if (connection.readyState === ws.OPEN && connection !== c) {
+ connection.send(es);
}
- };
+ }
+ };
+
+ c.on('message', msg => {
+ const m = JSON.parse(msg);
+ const { method } = m;
+
+ if (method === 'mutateVoxel') {
+ const { id, args } = m;
+ const { x, y, z, v } = args;
+
+ const regeneratePromises = [];
+ const seenIndex = {};
+ for (let i = 0; i < DIRECTIONS.length; i++) {
+ const [dx, dz] = DIRECTIONS[i];
+ const ax = x + dx * 2;
+ const az = z + dz * 2;
+ const ox = Math.floor(ax / NUM_CELLS);
+ const oz = Math.floor(az / NUM_CELLS);
+ const lx = x - ox * NUM_CELLS;
+ const lz = z - oz * NUM_CELLS;
+ const newEther = Float32Array.from([lx, y, lz, v]);
+
+ const index = _getChunkIndex(ox, oz);
+ if (!seenIndex[index]) {
+ let chunk = zde.getChunk(ox, oz);
+ if (chunk) {
+ const oldTerrainBuffer = chunk.getTerrainBuffer();
+ const oldChunkData = protocolUtils.parseTerrainData(
+ oldTerrainBuffer.buffer,
+ oldTerrainBuffer.byteOffset
+ );
+ const oldBiomes = oldChunkData.biomes.slice();
+ const oldElevations = oldChunkData.elevations.slice();
+ const oldEther = oldChunkData.ether.slice();
+ const oldWater = oldChunkData.water.slice();
+ const oldLava = oldChunkData.lava.slice();
+
+ _generateChunkTerrain(chunk, {
+ oldBiomes,
+ oldElevations,
+ oldEther,
+ oldWater,
+ oldLava,
+ newEther,
+ });
- c.on('message', msg => {
- const m = JSON.parse(msg);
- const {method} = m;
-
- if (method === 'mutateVoxel') {
- const {id, args} = m;
- const {x, y, z, v} = args;
-
- const regeneratePromises = [];
- const seenIndex = {};
- for (let i = 0; i < DIRECTIONS.length; i++) {
- const [dx, dz] = DIRECTIONS[i];
- const ax = x + dx * 2;
- const az = z + dz * 2;
- const ox = Math.floor(ax / NUM_CELLS);
- const oz = Math.floor(az / NUM_CELLS);
- const lx = x - (ox * NUM_CELLS);
- const lz = z - (oz * NUM_CELLS);
- const newEther = Float32Array.from([lx, y, lz, v]);
-
- const index = _getChunkIndex(ox, oz);
- if (!seenIndex[index]) {
- let chunk = zde.getChunk(ox, oz);
- if (chunk) {
- const oldTerrainBuffer = chunk.getTerrainBuffer();
- const oldChunkData = protocolUtils.parseTerrainData(oldTerrainBuffer.buffer, oldTerrainBuffer.byteOffset);
- const oldBiomes = oldChunkData.biomes.slice();
- const oldElevations = oldChunkData.elevations.slice();
- const oldEther = oldChunkData.ether.slice();
- const oldWater = oldChunkData.water.slice();
- const oldLava = oldChunkData.lava.slice();
-
- _generateChunkTerrain(chunk, {
- oldBiomes,
- oldElevations,
- oldEther,
- oldWater,
- oldLava,
- newEther,
- });
-
- regeneratePromises.push(generatorElement.requestRelight(x, y, z));
- }
-
- seenIndex[index] = true;
+ regeneratePromises.push(
+ generatorElement.requestRelight(x, y, z)
+ );
}
+
+ seenIndex[index] = true;
}
- _saveChunks();
+ }
+ _saveChunks();
- Promise.all(regeneratePromises)
- .then(regeneratedChunks => {
- c.send(JSON.stringify({
- type: 'response',
- id,
- result: null,
- }));
+ Promise.all(regeneratePromises).then(regeneratedChunks => {
+ c.send(
+ JSON.stringify({
+ type: 'response',
+ id,
+ result: null,
+ })
+ );
- _broadcast({
- type: 'mutateVoxel',
- args,
- result: {x, y, z, v},
- });
- });
- } else if (method === 'addObject') {
- const {id, args} = m;
- const {n, positions, rotations, value} = args;
-
- const ox = Math.floor(positions[0] / NUM_CELLS);
- const oz = Math.floor(positions[2] / NUM_CELLS);
-
- const chunk = zde.getChunk(ox, oz);
- if (chunk) {
- const matrix = positions.concat(rotations).concat(zeroVectorArray);
- const objectIndex = chunk.addObject(n, matrix, value);
-
- _decorateChunkObjectsGeometry(chunk)
- .then(() => {
- _saveChunks();
-
- return generatorElement.requestRelight(Math.floor(positions[0]), Math.floor(positions[1]), Math.floor(positions[2]));
- })
- .then(() => {
- c.send(JSON.stringify({
+ _broadcast({
+ type: 'mutateVoxel',
+ args,
+ result: { x, y, z, v },
+ });
+ });
+ } else if (method === 'addObject') {
+ const { id, args } = m;
+ const { n, positions, rotations, value } = args;
+
+ const ox = Math.floor(positions[0] / NUM_CELLS);
+ const oz = Math.floor(positions[2] / NUM_CELLS);
+
+ const chunk = zde.getChunk(ox, oz);
+ if (chunk) {
+ const matrix = positions
+ .concat(rotations)
+ .concat(zeroVectorArray);
+ const objectIndex = chunk.addObject(n, matrix, value);
+
+ _decorateChunkObjectsGeometry(chunk)
+ .then(() => {
+ _saveChunks();
+
+ return generatorElement.requestRelight(
+ Math.floor(positions[0]),
+ Math.floor(positions[1]),
+ Math.floor(positions[2])
+ );
+ })
+ .then(() => {
+ c.send(
+ JSON.stringify({
type: 'response',
id,
result: objectIndex,
- }));
+ })
+ );
- _broadcast({
- type: 'addObject',
- args,
- result: objectIndex,
- });
- })
- .catch(err => {
- console.warn(err);
+ _broadcast({
+ type: 'addObject',
+ args,
+ result: objectIndex,
});
- }
- } else if (method === 'removeObject') {
- const {id, args} = m;
- const {x, z, index} = args;
-
- const chunk = zde.getChunk(x, z);
- if (chunk) {
- const matrix = chunk.getObjectMatrix(index);
- const n = chunk.removeObject(index);
- chunk.removeLight(index);
-
- _decorateChunkObjectsGeometry(chunk)
- .then(() => {
- _saveChunks();
-
- return generatorElement.requestRelight(Math.floor(matrix[0]), Math.floor(matrix[1]), Math.floor(matrix[2]));
- })
- .then(() => {
- c.send(JSON.stringify({
+ })
+ .catch(err => {
+ console.warn(err);
+ });
+ }
+ } else if (method === 'removeObject') {
+ const { id, args } = m;
+ const { x, z, index } = args;
+
+ const chunk = zde.getChunk(x, z);
+ if (chunk) {
+ const matrix = chunk.getObjectMatrix(index);
+ const n = chunk.removeObject(index);
+ chunk.removeLight(index);
+
+ _decorateChunkObjectsGeometry(chunk)
+ .then(() => {
+ _saveChunks();
+
+ return generatorElement.requestRelight(
+ Math.floor(matrix[0]),
+ Math.floor(matrix[1]),
+ Math.floor(matrix[2])
+ );
+ })
+ .then(() => {
+ c.send(
+ JSON.stringify({
type: 'response',
id,
result: n,
- }));
+ })
+ );
- _broadcast({
- type: 'removeObject',
- args,
- result: n,
- });
- })
- .catch(err => {
- console.warn(err);
+ _broadcast({
+ type: 'removeObject',
+ args,
+ result: n,
});
- }
- } else if (method === 'setObjectData') {
- const {id, args} = m;
- const {x, z, index, value} = args;
+ })
+ .catch(err => {
+ console.warn(err);
+ });
+ }
+ } else if (method === 'setObjectData') {
+ const { id, args } = m;
+ const { x, z, index, value } = args;
- const chunk = zde.getChunk(x, z);
- if (chunk) {
- chunk.setObjectData(index, value);
+ const chunk = zde.getChunk(x, z);
+ if (chunk) {
+ chunk.setObjectData(index, value);
- _saveChunks();
+ _saveChunks();
- c.send(JSON.stringify({
+ c.send(
+ JSON.stringify({
type: 'response',
id,
result: null,
- }));
+ })
+ );
- _broadcast({
- type: 'setObjectData',
- args,
- result: null,
- });
- }
- } else if (method === 'setBlock') {
- const {id, args} = m;
- const {x, y, z, v} = args;
-
- const ox = Math.floor(x / NUM_CELLS);
- const oz = Math.floor(z / NUM_CELLS);
- const chunk = zde.getChunk(ox, oz);
- if (chunk) {
- chunk.setBlock(x - ox * NUM_CELLS, y, z - oz * NUM_CELLS, v);
- chunk[blockfieldRenderedSymbol] = false;
-
- _decorateChunkObjectsGeometry(chunk)
- .then(() => {
- _saveChunks();
-
- return generatorElement.requestRelight(x, y, z);
- })
- .then(() => {
- c.send(JSON.stringify({
+ _broadcast({
+ type: 'setObjectData',
+ args,
+ result: null,
+ });
+ }
+ } else if (method === 'setBlock') {
+ const { id, args } = m;
+ const { x, y, z, v } = args;
+
+ const ox = Math.floor(x / NUM_CELLS);
+ const oz = Math.floor(z / NUM_CELLS);
+ const chunk = zde.getChunk(ox, oz);
+ if (chunk) {
+ chunk.setBlock(x - ox * NUM_CELLS, y, z - oz * NUM_CELLS, v);
+ chunk[blockfieldRenderedSymbol] = false;
+
+ _decorateChunkObjectsGeometry(chunk)
+ .then(() => {
+ _saveChunks();
+
+ return generatorElement.requestRelight(x, y, z);
+ })
+ .then(() => {
+ c.send(
+ JSON.stringify({
type: 'response',
id,
result: null,
- }));
+ })
+ );
- _broadcast({
- type: 'setBlock',
- args,
- result: null,
- });
- })
- .catch(err => {
- console.warn(err);
+ _broadcast({
+ type: 'setBlock',
+ args,
+ result: null,
});
- }
- } else if (method === 'clearBlock') {
- const {id, args} = m;
- const {x, y, z} = args;
-
- const ox = Math.floor(x / NUM_CELLS);
- const oz = Math.floor(z / NUM_CELLS);
- const chunk = zde.getChunk(ox, oz);
- if (chunk) {
- chunk.clearBlock(x - ox * NUM_CELLS, y, z - oz * NUM_CELLS);
- chunk[blockfieldRenderedSymbol] = false;
-
- _decorateChunkObjectsGeometry(chunk)
- .then(() => {
- _saveChunks();
-
- return generatorElement.requestRelight(x, y, z);
- })
- .then(() => {
- c.send(JSON.stringify({
+ })
+ .catch(err => {
+ console.warn(err);
+ });
+ }
+ } else if (method === 'clearBlock') {
+ const { id, args } = m;
+ const { x, y, z } = args;
+
+ const ox = Math.floor(x / NUM_CELLS);
+ const oz = Math.floor(z / NUM_CELLS);
+ const chunk = zde.getChunk(ox, oz);
+ if (chunk) {
+ chunk.clearBlock(x - ox * NUM_CELLS, y, z - oz * NUM_CELLS);
+ chunk[blockfieldRenderedSymbol] = false;
+
+ _decorateChunkObjectsGeometry(chunk)
+ .then(() => {
+ _saveChunks();
+
+ return generatorElement.requestRelight(x, y, z);
+ })
+ .then(() => {
+ c.send(
+ JSON.stringify({
type: 'response',
id,
result: null,
- }));
+ })
+ );
- _broadcast({
- type: 'clearBlock',
- args,
- result: null,
- });
- })
- .catch(err => {
- console.warn(err);
+ _broadcast({
+ type: 'clearBlock',
+ args,
+ result: null,
});
- }
- } else {
- console.warn('objects server got unknown method:', JSON.stringify(method));
+ })
+ .catch(err => {
+ console.warn(err);
+ });
}
- });
- c.on('close', () => {
- connections.splice(connections.indexOf(c), 1);
- });
+ } else {
+ console.warn(
+ 'objects server got unknown method:',
+ JSON.stringify(method)
+ );
+ }
+ });
+ c.on('close', () => {
+ connections.splice(connections.indexOf(c), 1);
+ });
- connections.push(c);
+ connections.push(c);
+ }
+ };
+ wss.on('connection', _connection);
+
+ this._cleanup = () => {
+ function removeMiddlewares(route, i, routes) {
+ if (
+ route.handle.name === 'serveObjectsTextureAtlas' ||
+ route.handle.name === 'serveObjectsObjectizeJs' ||
+ route.handle.name === 'serveObjectsObjectizeWasm' ||
+ route.handle.name === 'serveObjectsTemplates' ||
+ route.handle.name === 'serveGeneratorChunks' ||
+ route.handle.name === 'serveGeneratorVoxels'
+ ) {
+ routes.splice(i, 1);
}
- };
- wss.on('connection', _connection);
-
- this._cleanup = () => {
- function removeMiddlewares(route, i, routes) {
- if (
- route.handle.name === 'serveObjectsTextureAtlas' ||
- route.handle.name === 'serveObjectsObjectizeJs' ||
- route.handle.name === 'serveObjectsObjectizeWasm' ||
- route.handle.name === 'serveObjectsTemplates' ||
- route.handle.name === 'serveGeneratorChunks' ||
- route.handle.name === 'serveGeneratorVoxels'
- ) {
- routes.splice(i, 1);
- }
- if (route.route) {
- route.route.stack.forEach(removeMiddlewares);
- }
+ if (route.route) {
+ route.route.stack.forEach(removeMiddlewares);
}
- app._router.stack.forEach(removeMiddlewares);
+ }
+ app._router.stack.forEach(removeMiddlewares);
- for (let i = 0; i < connections.length; i++) {
- connections[i].close();
- }
- wss.removeListener('connection', _connection);
+ for (let i = 0; i < connections.length; i++) {
+ connections[i].close();
+ }
+ wss.removeListener('connection', _connection);
- elements.unregisterEntity(this, generatorElement);
- };
- });
+ elements.unregisterEntity(this, generatorElement);
+ };
+ });
}
unmount() {
diff --git a/plugins/generator/terrain-tesselator.js b/plugins/generator/terrain-tesselator.js
index 5b4eb5a24..e3c98f1de 100644
--- a/plugins/generator/terrain-tesselator.js
+++ b/plugins/generator/terrain-tesselator.js
@@ -18,129 +18,192 @@ const NUM_CELLS_HALF = NUM_CELLS / 2;
const NUM_CELLS_CUBE = Math.sqrt(NUM_CELLS_HALF * NUM_CELLS_HALF * 3);
const NUM_CELLS_OVERSCAN_Y = NUM_CELLS_HEIGHT + OVERSCAN;
-module.exports = ({
- THREE,
- mod,
- murmur,
- alea,
- vxl,
- noiser,
-}) => {
-
-const _align = (n, alignment) => {
- let alignDiff = n % alignment;
- if (alignDiff > 0) {
- n += alignment - alignDiff;
- }
- return n;
-};
-
-const slab = (() => {
- const BIOMES_SIZE = _align(NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * Uint8Array.BYTES_PER_ELEMENT, Float32Array.BYTES_PER_ELEMENT);
- const ELEVATIONS_SIZE = NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * Float32Array.BYTES_PER_ELEMENT;
- const ETHER_SIZE = ((NUM_CELLS + 1) * (NUM_CELLS_HEIGHT + 1) * (NUM_CELLS + 1)) * Float32Array.BYTES_PER_ELEMENT;
- const WATER_SIZE = ((NUM_CELLS + 1) * (NUM_CELLS_HEIGHT + 1) * (NUM_CELLS + 1)) * Float32Array.BYTES_PER_ELEMENT;
- const LAVA_SIZE = ((NUM_CELLS + 1) * (NUM_CELLS_HEIGHT + 1) * (NUM_CELLS + 1)) * Float32Array.BYTES_PER_ELEMENT;
- const POSITIONS_SIZE = NUM_POSITIONS_CHUNK * Float32Array.BYTES_PER_ELEMENT;
- const INDICES_SIZE = NUM_POSITIONS_CHUNK * Uint32Array.BYTES_PER_ELEMENT;
- const COLORS_SIZE = NUM_POSITIONS_CHUNK * Float32Array.BYTES_PER_ELEMENT;
- const HEIGHTFIELD_SIZE = NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * HEIGHTFIELD_DEPTH * Float32Array.BYTES_PER_ELEMENT;
- const STATIC_HEIGHTFIELD_SIZE = NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * Float32Array.BYTES_PER_ELEMENT;
- const ATTRIBUTE_RANGES_SIZE = NUM_CHUNKS_HEIGHT * 6 * Uint32Array.BYTES_PER_ELEMENT;
- const INDEX_RANGES_SIZE = NUM_CHUNKS_HEIGHT * 6 * Uint32Array.BYTES_PER_ELEMENT;
- const PEEK_SIZE = 16 * Uint8Array.BYTES_PER_ELEMENT;
- const PEEKS_ARRAY_SIZE = PEEK_SIZE * NUM_CHUNKS_HEIGHT;
-
- const buffer = new ArrayBuffer(
- BIOMES_SIZE +
- ELEVATIONS_SIZE +
- ETHER_SIZE +
- WATER_SIZE +
- LAVA_SIZE +
- POSITIONS_SIZE +
- INDICES_SIZE +
- COLORS_SIZE +
- HEIGHTFIELD_SIZE +
- STATIC_HEIGHTFIELD_SIZE +
- ATTRIBUTE_RANGES_SIZE +
- INDEX_RANGES_SIZE +
- PEEKS_ARRAY_SIZE
- );
-
- let index = 0;
- const biomes = new Uint8Array(buffer, index, BIOMES_SIZE / Uint8Array.BYTES_PER_ELEMENT);
- index += BIOMES_SIZE;
- const elevations = new Float32Array(buffer, index, ELEVATIONS_SIZE / Float32Array.BYTES_PER_ELEMENT);
- index += ELEVATIONS_SIZE;
- const ether = new Float32Array(buffer, index, ETHER_SIZE / Float32Array.BYTES_PER_ELEMENT);
- index += ETHER_SIZE;
- const water = new Float32Array(buffer, index, WATER_SIZE / Float32Array.BYTES_PER_ELEMENT);
- index += WATER_SIZE;
- const lava = new Float32Array(buffer, index, LAVA_SIZE / Float32Array.BYTES_PER_ELEMENT);
- index += LAVA_SIZE;
- const positions = new Float32Array(buffer, index, POSITIONS_SIZE / Float32Array.BYTES_PER_ELEMENT);
- index += POSITIONS_SIZE;
- const indices = new Uint32Array(buffer, index, INDICES_SIZE / Uint32Array.BYTES_PER_ELEMENT);
- index += INDICES_SIZE;
- const colors = new Float32Array(buffer, index, COLORS_SIZE / Float32Array.BYTES_PER_ELEMENT);
- index += COLORS_SIZE;
- const heightfield = new Float32Array(buffer, index, HEIGHTFIELD_SIZE / Float32Array.BYTES_PER_ELEMENT);
- index += HEIGHTFIELD_SIZE;
- const staticHeightfield = new Float32Array(buffer, index, STATIC_HEIGHTFIELD_SIZE / Float32Array.BYTES_PER_ELEMENT);
- index += STATIC_HEIGHTFIELD_SIZE;
- const attributeRanges = new Uint32Array(ATTRIBUTE_RANGES_SIZE / Uint32Array.BYTES_PER_ELEMENT);
- index += ATTRIBUTE_RANGES_SIZE;
- const indexRanges = new Uint32Array(INDEX_RANGES_SIZE / Uint32Array.BYTES_PER_ELEMENT);
- index += INDEX_RANGES_SIZE;
- const peeks = new Uint8Array(buffer, index, PEEK_SIZE * NUM_CHUNKS_HEIGHT);
- const peeksArray = Array(NUM_CHUNKS_HEIGHT);
- for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
- peeksArray[i] = new Uint8Array(buffer, index, PEEK_SIZE / Uint8Array.BYTES_PER_ELEMENT);
- index += PEEK_SIZE;
- }
-
- return {
- biomes,
- elevations,
- ether,
- water,
- lava,
- positions,
- indices,
- colors,
- heightfield,
- staticHeightfield,
- attributeRanges,
- indexRanges,
- peeks,
- peeksArray,
+module.exports = ({ THREE, mod, murmur, alea, vxl, noiser }) => {
+ const _align = (n, alignment) => {
+ let alignDiff = n % alignment;
+ if (alignDiff > 0) {
+ n += alignment - alignDiff;
+ }
+ return n;
};
-})();
-
-const _generateMapChunk = (ox, oy, opts) => {
- // generate
-
- let biomes = opts.oldBiomes;
- let fillBiomes = false;
- if (!biomes) {
- biomes = slab.biomes;
- fillBiomes = true;
- }
-
- let elevations = opts.oldElevations;
- let fillElevations = false;
- if (!elevations) {
- elevations = slab.elevations;
- fillElevations = true;
- }
-
- let ether = opts.oldEther;
- let fillEther = false;
- if (!ether) {
- ether = slab.ether;
- fillEther = true;
-
- /* let index = 0;
+
+ const slab = (() => {
+ const BIOMES_SIZE = _align(
+ NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * Uint8Array.BYTES_PER_ELEMENT,
+ Float32Array.BYTES_PER_ELEMENT
+ );
+ const ELEVATIONS_SIZE =
+ NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * Float32Array.BYTES_PER_ELEMENT;
+ const ETHER_SIZE =
+ (NUM_CELLS + 1) *
+ (NUM_CELLS_HEIGHT + 1) *
+ (NUM_CELLS + 1) *
+ Float32Array.BYTES_PER_ELEMENT;
+ const WATER_SIZE =
+ (NUM_CELLS + 1) *
+ (NUM_CELLS_HEIGHT + 1) *
+ (NUM_CELLS + 1) *
+ Float32Array.BYTES_PER_ELEMENT;
+ const LAVA_SIZE =
+ (NUM_CELLS + 1) *
+ (NUM_CELLS_HEIGHT + 1) *
+ (NUM_CELLS + 1) *
+ Float32Array.BYTES_PER_ELEMENT;
+ const POSITIONS_SIZE = NUM_POSITIONS_CHUNK * Float32Array.BYTES_PER_ELEMENT;
+ const INDICES_SIZE = NUM_POSITIONS_CHUNK * Uint32Array.BYTES_PER_ELEMENT;
+ const COLORS_SIZE = NUM_POSITIONS_CHUNK * Float32Array.BYTES_PER_ELEMENT;
+ const HEIGHTFIELD_SIZE =
+ NUM_CELLS_OVERSCAN *
+ NUM_CELLS_OVERSCAN *
+ HEIGHTFIELD_DEPTH *
+ Float32Array.BYTES_PER_ELEMENT;
+ const STATIC_HEIGHTFIELD_SIZE =
+ NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * Float32Array.BYTES_PER_ELEMENT;
+ const ATTRIBUTE_RANGES_SIZE =
+ NUM_CHUNKS_HEIGHT * 6 * Uint32Array.BYTES_PER_ELEMENT;
+ const INDEX_RANGES_SIZE =
+ NUM_CHUNKS_HEIGHT * 6 * Uint32Array.BYTES_PER_ELEMENT;
+ const PEEK_SIZE = 16 * Uint8Array.BYTES_PER_ELEMENT;
+ const PEEKS_ARRAY_SIZE = PEEK_SIZE * NUM_CHUNKS_HEIGHT;
+
+ const buffer = new ArrayBuffer(
+ BIOMES_SIZE +
+ ELEVATIONS_SIZE +
+ ETHER_SIZE +
+ WATER_SIZE +
+ LAVA_SIZE +
+ POSITIONS_SIZE +
+ INDICES_SIZE +
+ COLORS_SIZE +
+ HEIGHTFIELD_SIZE +
+ STATIC_HEIGHTFIELD_SIZE +
+ ATTRIBUTE_RANGES_SIZE +
+ INDEX_RANGES_SIZE +
+ PEEKS_ARRAY_SIZE
+ );
+
+ let index = 0;
+ const biomes = new Uint8Array(
+ buffer,
+ index,
+ BIOMES_SIZE / Uint8Array.BYTES_PER_ELEMENT
+ );
+ index += BIOMES_SIZE;
+ const elevations = new Float32Array(
+ buffer,
+ index,
+ ELEVATIONS_SIZE / Float32Array.BYTES_PER_ELEMENT
+ );
+ index += ELEVATIONS_SIZE;
+ const ether = new Float32Array(
+ buffer,
+ index,
+ ETHER_SIZE / Float32Array.BYTES_PER_ELEMENT
+ );
+ index += ETHER_SIZE;
+ const water = new Float32Array(
+ buffer,
+ index,
+ WATER_SIZE / Float32Array.BYTES_PER_ELEMENT
+ );
+ index += WATER_SIZE;
+ const lava = new Float32Array(
+ buffer,
+ index,
+ LAVA_SIZE / Float32Array.BYTES_PER_ELEMENT
+ );
+ index += LAVA_SIZE;
+ const positions = new Float32Array(
+ buffer,
+ index,
+ POSITIONS_SIZE / Float32Array.BYTES_PER_ELEMENT
+ );
+ index += POSITIONS_SIZE;
+ const indices = new Uint32Array(
+ buffer,
+ index,
+ INDICES_SIZE / Uint32Array.BYTES_PER_ELEMENT
+ );
+ index += INDICES_SIZE;
+ const colors = new Float32Array(
+ buffer,
+ index,
+ COLORS_SIZE / Float32Array.BYTES_PER_ELEMENT
+ );
+ index += COLORS_SIZE;
+ const heightfield = new Float32Array(
+ buffer,
+ index,
+ HEIGHTFIELD_SIZE / Float32Array.BYTES_PER_ELEMENT
+ );
+ index += HEIGHTFIELD_SIZE;
+ const staticHeightfield = new Float32Array(
+ buffer,
+ index,
+ STATIC_HEIGHTFIELD_SIZE / Float32Array.BYTES_PER_ELEMENT
+ );
+ index += STATIC_HEIGHTFIELD_SIZE;
+ const attributeRanges = new Uint32Array(
+ ATTRIBUTE_RANGES_SIZE / Uint32Array.BYTES_PER_ELEMENT
+ );
+ index += ATTRIBUTE_RANGES_SIZE;
+ const indexRanges = new Uint32Array(
+ INDEX_RANGES_SIZE / Uint32Array.BYTES_PER_ELEMENT
+ );
+ index += INDEX_RANGES_SIZE;
+ const peeks = new Uint8Array(buffer, index, PEEK_SIZE * NUM_CHUNKS_HEIGHT);
+ const peeksArray = Array(NUM_CHUNKS_HEIGHT);
+ for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
+ peeksArray[i] = new Uint8Array(
+ buffer,
+ index,
+ PEEK_SIZE / Uint8Array.BYTES_PER_ELEMENT
+ );
+ index += PEEK_SIZE;
+ }
+
+ return {
+ biomes,
+ elevations,
+ ether,
+ water,
+ lava,
+ positions,
+ indices,
+ colors,
+ heightfield,
+ staticHeightfield,
+ attributeRanges,
+ indexRanges,
+ peeks,
+ peeksArray,
+ };
+ })();
+
+ const _generateMapChunk = (ox, oy, opts) => {
+ // generate
+
+ let biomes = opts.oldBiomes;
+ let fillBiomes = false;
+ if (!biomes) {
+ biomes = slab.biomes;
+ fillBiomes = true;
+ }
+
+ let elevations = opts.oldElevations;
+ let fillElevations = false;
+ if (!elevations) {
+ elevations = slab.elevations;
+ fillElevations = true;
+ }
+
+ let ether = opts.oldEther;
+ let fillEther = false;
+ if (!ether) {
+ ether = slab.ether;
+ fillEther = true;
+
+ /* let index = 0;
for (let z = 0; z < NUM_CELLS_OVERSCAN; z++) {
for (let x = 0; x < NUM_CELLS_OVERSCAN; x++) {
const elevation = elevations[index++];
@@ -150,7 +213,7 @@ const _generateMapChunk = (ox, oy, opts) => {
}
} */
- /* const _fillOblateSpheroid = (centerX, centerY, centerZ, minX, minZ, maxX, maxZ, radius) => {
+ /* const _fillOblateSpheroid = (centerX, centerY, centerZ, minX, minZ, maxX, maxZ, radius) => {
for (let z = -radius; z <= radius; z++) {
const lz = centerZ + z;
if (lz >= minZ && lz < (maxZ + 1)) {
@@ -234,60 +297,70 @@ const _generateMapChunk = (ox, oy, opts) => {
}
}
} */
- }
-
- let water = opts.oldWater;
- let lava = opts.oldLava;
- let fillLiquid = false;
- if (!water || !lava) {
- water = slab.water;
- lava = slab.lava;
- fillLiquid = true;
- }
-
- let newEther;
- let numNewEthers = 0;
- if (opts.newEther && opts.newEther.length > 0) {
- newEther = opts.newEther;
- numNewEthers = opts.newEther.length;
- } else {
- newEther = new Float32Array(0);
- }
-
- const {heightfield, staticHeightfield, colors, attributeRanges, indexRanges, peeks} = slab;
- noiser.fill(
- ox,
- oy,
- biomes,
- fillBiomes,
- elevations,
- fillElevations,
- ether,
- fillEther,
- water,
- lava,
- fillLiquid,
- newEther,
- numNewEthers,
- slab.positions,
- slab.indices,
- attributeRanges,
- indexRanges,
- heightfield,
- staticHeightfield,
- colors,
- peeks
- );
-
- const attributeIndex = attributeRanges[attributeRanges.length - 2] + attributeRanges[attributeRanges.length - 1];
- const indexIndex = indexRanges[indexRanges.length - 2] + indexRanges[indexRanges.length - 1];
- const positions = slab.positions.subarray(0, attributeIndex);
- const indices = slab.indices.subarray(0, indexIndex);
-
- const geometries = Array(NUM_CHUNKS_HEIGHT);
- for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
- geometries[i] = {
- /* attributeRange: {
+ }
+
+ let water = opts.oldWater;
+ let lava = opts.oldLava;
+ let fillLiquid = false;
+ if (!water || !lava) {
+ water = slab.water;
+ lava = slab.lava;
+ fillLiquid = true;
+ }
+
+ let newEther;
+ let numNewEthers = 0;
+ if (opts.newEther && opts.newEther.length > 0) {
+ newEther = opts.newEther;
+ numNewEthers = opts.newEther.length;
+ } else {
+ newEther = new Float32Array(0);
+ }
+
+ const {
+ heightfield,
+ staticHeightfield,
+ colors,
+ attributeRanges,
+ indexRanges,
+ peeks,
+ } = slab;
+ noiser.fill(
+ ox,
+ oy,
+ biomes,
+ fillBiomes,
+ elevations,
+ fillElevations,
+ ether,
+ fillEther,
+ water,
+ lava,
+ fillLiquid,
+ newEther,
+ numNewEthers,
+ slab.positions,
+ slab.indices,
+ attributeRanges,
+ indexRanges,
+ heightfield,
+ staticHeightfield,
+ colors,
+ peeks
+ );
+
+ const attributeIndex =
+ attributeRanges[attributeRanges.length - 2] +
+ attributeRanges[attributeRanges.length - 1];
+ const indexIndex =
+ indexRanges[indexRanges.length - 2] + indexRanges[indexRanges.length - 1];
+ const positions = slab.positions.subarray(0, attributeIndex);
+ const indices = slab.indices.subarray(0, indexIndex);
+
+ const geometries = Array(NUM_CHUNKS_HEIGHT);
+ for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
+ geometries[i] = {
+ /* attributeRange: {
landStart: attributeRanges[i * 6 + 0],
landCount: attributeRanges[i * 6 + 1],
waterStart: attributeRanges[i * 6 + 2],
@@ -295,43 +368,46 @@ const _generateMapChunk = (ox, oy, opts) => {
lavaStart: attributeRanges[i * 6 + 4],
lavaCount: attributeRanges[i * 6 + 5],
}, */
- indexRange: {
- landStart: indexRanges[i * 6 + 0],
- landCount: indexRanges[i * 6 + 1],
- waterStart: indexRanges[i * 6 + 2],
- waterCount: indexRanges[i * 6 + 3],
- lavaStart: indexRanges[i * 6 + 4],
- lavaCount: indexRanges[i * 6 + 5],
- },
- boundingSphere: Float32Array.from([
- ox * NUM_CELLS + NUM_CELLS_HALF,
- i * NUM_CELLS + NUM_CELLS_HALF,
- oy * NUM_CELLS + NUM_CELLS_HALF,
- NUM_CELLS_CUBE,
- ]),
- peeks: slab.peeksArray[i],
+ indexRange: {
+ landStart: indexRanges[i * 6 + 0],
+ landCount: indexRanges[i * 6 + 1],
+ waterStart: indexRanges[i * 6 + 2],
+ waterCount: indexRanges[i * 6 + 3],
+ lavaStart: indexRanges[i * 6 + 4],
+ lavaCount: indexRanges[i * 6 + 5],
+ },
+ boundingSphere: Float32Array.from([
+ ox * NUM_CELLS + NUM_CELLS_HALF,
+ i * NUM_CELLS + NUM_CELLS_HALF,
+ oy * NUM_CELLS + NUM_CELLS_HALF,
+ NUM_CELLS_CUBE,
+ ]),
+ peeks: slab.peeksArray[i],
+ };
+ }
+
+ return {
+ positions,
+ colors: new Float32Array(
+ colors.buffer,
+ colors.byteOffset,
+ attributeIndex
+ ),
+ indices,
+ geometries,
+ heightfield,
+ staticHeightfield,
+ biomes,
+ elevations,
+ ether,
+ water,
+ lava,
};
- }
-
- return {
- positions,
- colors: new Float32Array(colors.buffer, colors.byteOffset, attributeIndex),
- indices,
- geometries,
- heightfield,
- staticHeightfield,
- biomes,
- elevations,
- ether,
- water,
- lava,
};
-};
-
-const generate = (x, y, opts = {}) => _generateMapChunk(x, y, opts);
-return {
- generate,
-};
+ const generate = (x, y, opts = {}) => _generateMapChunk(x, y, opts);
+ return {
+ generate,
+ };
};
diff --git a/plugins/generator/worker.js b/plugins/generator/worker.js
index 87bd8cd78..ce6e00c28 100644
--- a/plugins/generator/worker.js
+++ b/plugins/generator/worker.js
@@ -1,38 +1,74 @@
importScripts('/archae/assets/three.js');
-const {exports: THREE} = self.module;
+const { exports: THREE } = self.module;
importScripts('/archae/assets/murmurhash.js');
-const {exports: murmur} = self.module;
+const { exports: murmur } = self.module;
importScripts('/archae/assets/autows.js');
-const {exports: Autows} = self.module;
+const { exports: Autows } = self.module;
importScripts('/archae/assets/alea.js');
-const {exports: alea} = self.module;
+const { exports: alea } = self.module;
self.module = {};
let slab = null;
Module = {
- print(text) { console.log(text); },
- printErr(text) { console.warn(text); },
+ print(text) {
+ console.log(text);
+ },
+ printErr(text) {
+ console.warn(text);
+ },
wasmBinaryFile: '/archae/objects/objectize.wasm',
onRuntimeInitialized: () => {
slab = (() => {
- const BIOMES_SIZE = _align(NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * Uint8Array.BYTES_PER_ELEMENT, Float32Array.BYTES_PER_ELEMENT);
- const ELEVATIONS_SIZE = NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * Float32Array.BYTES_PER_ELEMENT;
- const ETHER_SIZE = ((NUM_CELLS + 1) * (NUM_CELLS_HEIGHT + 1) * (NUM_CELLS + 1)) * Float32Array.BYTES_PER_ELEMENT;
- const WATER_SIZE = ((NUM_CELLS + 1) * (NUM_CELLS_HEIGHT + 1) * (NUM_CELLS + 1)) * Float32Array.BYTES_PER_ELEMENT;
- const LAVA_SIZE = ((NUM_CELLS + 1) * (NUM_CELLS_HEIGHT + 1) * (NUM_CELLS + 1)) * Float32Array.BYTES_PER_ELEMENT;
- const POSITIONS_SIZE = NUM_POSITIONS_CHUNK * Float32Array.BYTES_PER_ELEMENT;
+ const BIOMES_SIZE = _align(
+ NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * Uint8Array.BYTES_PER_ELEMENT,
+ Float32Array.BYTES_PER_ELEMENT
+ );
+ const ELEVATIONS_SIZE =
+ NUM_CELLS_OVERSCAN *
+ NUM_CELLS_OVERSCAN *
+ Float32Array.BYTES_PER_ELEMENT;
+ const ETHER_SIZE =
+ (NUM_CELLS + 1) *
+ (NUM_CELLS_HEIGHT + 1) *
+ (NUM_CELLS + 1) *
+ Float32Array.BYTES_PER_ELEMENT;
+ const WATER_SIZE =
+ (NUM_CELLS + 1) *
+ (NUM_CELLS_HEIGHT + 1) *
+ (NUM_CELLS + 1) *
+ Float32Array.BYTES_PER_ELEMENT;
+ const LAVA_SIZE =
+ (NUM_CELLS + 1) *
+ (NUM_CELLS_HEIGHT + 1) *
+ (NUM_CELLS + 1) *
+ Float32Array.BYTES_PER_ELEMENT;
+ const POSITIONS_SIZE =
+ NUM_POSITIONS_CHUNK * Float32Array.BYTES_PER_ELEMENT;
const INDICES_SIZE = NUM_POSITIONS_CHUNK * Uint32Array.BYTES_PER_ELEMENT;
const COLORS_SIZE = NUM_POSITIONS_CHUNK * Float32Array.BYTES_PER_ELEMENT;
- const HEIGHTFIELD_SIZE = NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * HEIGHTFIELD_DEPTH * Float32Array.BYTES_PER_ELEMENT;
- const STATIC_HEIGHTFIELD_SIZE = NUM_CELLS_OVERSCAN * NUM_CELLS_OVERSCAN * Float32Array.BYTES_PER_ELEMENT;
- const ATTRIBUTE_RANGES_SIZE = NUM_CHUNKS_HEIGHT * 6 * Uint32Array.BYTES_PER_ELEMENT;
- const INDEX_RANGES_SIZE = NUM_CHUNKS_HEIGHT * 6 * Uint32Array.BYTES_PER_ELEMENT;
+ const HEIGHTFIELD_SIZE =
+ NUM_CELLS_OVERSCAN *
+ NUM_CELLS_OVERSCAN *
+ HEIGHTFIELD_DEPTH *
+ Float32Array.BYTES_PER_ELEMENT;
+ const STATIC_HEIGHTFIELD_SIZE =
+ NUM_CELLS_OVERSCAN *
+ NUM_CELLS_OVERSCAN *
+ Float32Array.BYTES_PER_ELEMENT;
+ const ATTRIBUTE_RANGES_SIZE =
+ NUM_CHUNKS_HEIGHT * 6 * Uint32Array.BYTES_PER_ELEMENT;
+ const INDEX_RANGES_SIZE =
+ NUM_CHUNKS_HEIGHT * 6 * Uint32Array.BYTES_PER_ELEMENT;
const PEEK_SIZE = 16 * Uint8Array.BYTES_PER_ELEMENT;
const PEEKS_ARRAY_SIZE = PEEK_SIZE * NUM_CHUNKS_HEIGHT;
const _alloc = (constructor, size) => {
const offset = Module._malloc(size);
- const b = new constructor(Module.HEAP8.buffer, Module.HEAP8.byteOffset + offset, size / constructor.BYTES_PER_ELEMENT);
+ const b = new constructor(
+ Module.HEAP8.buffer,
+ Module.HEAP8.byteOffset + offset,
+ size / constructor.BYTES_PER_ELEMENT
+ );
b.offset = offset;
return b;
};
@@ -52,15 +88,40 @@ Module = {
const peeks = _alloc(Uint8Array, PEEK_SIZE * NUM_CHUNKS_HEIGHT);
const peeksArray = Array(NUM_CHUNKS_HEIGHT);
for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
- peeksArray[i] = new Uint8Array(peeks.buffer, peeks.byteOffset + i * PEEK_SIZE, PEEK_SIZE / Uint8Array.BYTES_PER_ELEMENT);
+ peeksArray[i] = new Uint8Array(
+ peeks.buffer,
+ peeks.byteOffset + i * PEEK_SIZE,
+ PEEK_SIZE / Uint8Array.BYTES_PER_ELEMENT
+ );
}
- const geometriesPositions = _alloc(Float32Array, GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT);
- const geometriesUvs = _alloc(Float32Array, GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT);
- const geometriesSsaos = _alloc(Uint8Array, GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT);
- const geometriesFrames = _alloc(Float32Array, GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT);
- const geometriesObjectIndices = _alloc(Float32Array, GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT);
- const geometriesIndices = _alloc(Uint32Array, GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT);
- const geometriesObjects = _alloc(Uint32Array, GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT);
+ const geometriesPositions = _alloc(
+ Float32Array,
+ GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT
+ );
+ const geometriesUvs = _alloc(
+ Float32Array,
+ GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT
+ );
+ const geometriesSsaos = _alloc(
+ Uint8Array,
+ GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT
+ );
+ const geometriesFrames = _alloc(
+ Float32Array,
+ GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT
+ );
+ const geometriesObjectIndices = _alloc(
+ Float32Array,
+ GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT
+ );
+ const geometriesIndices = _alloc(
+ Uint32Array,
+ GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT
+ );
+ const geometriesObjects = _alloc(
+ Uint32Array,
+ GEOMETRY_BUFFER_SIZE * NUM_CHUNKS_HEIGHT
+ );
const tesselateObjectsResult = _alloc(Uint32Array, 7 * 8 * 4);
return {
@@ -123,15 +184,12 @@ const {
const protocolUtils = require('./lib/utils/protocol-utils');
const NUM_CELLS_HALF = NUM_CELLS / 2;
-const NUM_CELLS_CUBE = Math.sqrt((NUM_CELLS_HALF + 16) * (NUM_CELLS_HALF + 16) * 3); // larger than the actual bounding box to account for geometry overflow
+const NUM_CELLS_CUBE = Math.sqrt(
+ (NUM_CELLS_HALF + 16) * (NUM_CELLS_HALF + 16) * 3
+); // larger than the actual bounding box to account for geometry overflow
const NUM_VOXELS_CHUNK_HEIGHT = BLOCK_BUFFER_SIZE / 4 / NUM_CHUNKS_HEIGHT;
-const DIRECTIONS = [
- [-1, -1],
- [-1, 1],
- [1, -1],
- [1, 1],
-];
+const DIRECTIONS = [[-1, -1], [-1, 1], [1, -1], [1, 1]];
const CROSS_DIRECTIONS = [
[-1, -1],
[0, -1],
@@ -182,10 +240,16 @@ let geometryVersion = '';
const objectApis = {};
const boundingSpheres = (() => {
- const slab = new ArrayBuffer(NUM_CHUNKS_HEIGHT * 4 * Float32Array.BYTES_PER_ELEMENT);
+ const slab = new ArrayBuffer(
+ NUM_CHUNKS_HEIGHT * 4 * Float32Array.BYTES_PER_ELEMENT
+ );
const result = Array(NUM_CHUNKS_HEIGHT);
for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
- result[i] = new Float32Array(slab, i * 4 * Float32Array.BYTES_PER_ELEMENT, 4);
+ result[i] = new Float32Array(
+ slab,
+ i * 4 * Float32Array.BYTES_PER_ELEMENT,
+ 4
+ );
}
return result;
})();
@@ -199,19 +263,31 @@ class Allocator {
allocBuffer(b) {
const offset = Module._malloc(b.byteLength);
this.offsets.push(offset);
- new b.constructor(Module.HEAP8.buffer, Module.HEAP8.byteOffset + offset, b.length).set(b);
+ new b.constructor(
+ Module.HEAP8.buffer,
+ Module.HEAP8.byteOffset + offset,
+ b.length
+ ).set(b);
return offset;
}
allocBufferArray(bs) {
const offset = Module._malloc(bs.length * Uint32Array.BYTES_PER_ELEMENT);
this.offsets.push(offset);
- const array = new Uint32Array(Module.HEAP8.buffer, Module.HEAP8.byteOffset + offset, bs.length);
+ const array = new Uint32Array(
+ Module.HEAP8.buffer,
+ Module.HEAP8.byteOffset + offset,
+ bs.length
+ );
for (let i = 0; i < bs.length; i++) {
const b = bs[i];
const offset = Module._malloc(b.byteLength);
this.offsets.push(offset);
- const shadowBuffer = new b.constructor(Module.HEAP8.buffer, Module.HEAP8.byteOffset + offset, b.length);
+ const shadowBuffer = new b.constructor(
+ Module.HEAP8.buffer,
+ Module.HEAP8.byteOffset + offset,
+ b.length
+ );
shadowBuffer.set(b);
array[i] = offset;
}
@@ -221,29 +297,35 @@ class Allocator {
allocShadowBuffer(b) {
const offset = Module._malloc(b.byteLength);
this.offsets.push(offset);
- const shadowBuffer = new b.constructor(Module.HEAP8.buffer, Module.HEAP8.byteOffset + offset, b.length);
+ const shadowBuffer = new b.constructor(
+ Module.HEAP8.buffer,
+ Module.HEAP8.byteOffset + offset,
+ b.length
+ );
shadowBuffer.set(b);
- this.backbuffers.push([
- b,
- shadowBuffer
- ]);
+ this.backbuffers.push([b, shadowBuffer]);
return offset;
}
allocShadowBufferArray(bs) {
const offset = Module._malloc(bs.length * Uint32Array.BYTES_PER_ELEMENT);
this.offsets.push(offset);
- const array = new Uint32Array(Module.HEAP8.buffer, Module.HEAP8.byteOffset + offset, bs.length);
+ const array = new Uint32Array(
+ Module.HEAP8.buffer,
+ Module.HEAP8.byteOffset + offset,
+ bs.length
+ );
for (let i = 0; i < bs.length; i++) {
const b = bs[i];
const offset = Module._malloc(b.byteLength);
this.offsets.push(offset);
- const shadowBuffer = new b.constructor(Module.HEAP8.buffer, Module.HEAP8.byteOffset + offset, b.length);
+ const shadowBuffer = new b.constructor(
+ Module.HEAP8.buffer,
+ Module.HEAP8.byteOffset + offset,
+ b.length
+ );
shadowBuffer.set(b);
- this.backbuffers.push([
- b,
- shadowBuffer
- ]);
+ this.backbuffers.push([b, shadowBuffer]);
array[i] = offset;
}
return offset;
@@ -263,10 +345,12 @@ class Allocator {
}
}
-
const _retesselateTerrain = (chunk, newEther) => {
const oldTerrainBuffer = chunk.getTerrainBuffer();
- const oldChunkData = protocolUtils.parseTerrainData(oldTerrainBuffer.buffer, oldTerrainBuffer.byteOffset);
+ const oldChunkData = protocolUtils.parseTerrainData(
+ oldTerrainBuffer.buffer,
+ oldTerrainBuffer.byteOffset
+ );
const oldBiomes = oldChunkData.biomes.slice();
const oldElevations = oldChunkData.elevations.slice();
const oldEther = oldChunkData.ether.slice();
@@ -275,7 +359,13 @@ const _retesselateTerrain = (chunk, newEther) => {
const allocator = new Allocator();
- const {attributeRanges, indexRanges, heightfield, staticHeightfield, peeks} = slab;
+ const {
+ attributeRanges,
+ indexRanges,
+ heightfield,
+ staticHeightfield,
+ peeks,
+ } = slab;
const noiser = Module._make_noiser(murmur(DEFAULT_SEED));
Module._noiser_fill(
noiser,
@@ -304,11 +394,18 @@ const _retesselateTerrain = (chunk, newEther) => {
allocator.unshadow();
- const attributeIndex = attributeRanges[attributeRanges.length - 2] + attributeRanges[attributeRanges.length - 1];
- const indexIndex = indexRanges[indexRanges.length - 2] + indexRanges[indexRanges.length - 1];
+ const attributeIndex =
+ attributeRanges[attributeRanges.length - 2] +
+ attributeRanges[attributeRanges.length - 1];
+ const indexIndex =
+ indexRanges[indexRanges.length - 2] + indexRanges[indexRanges.length - 1];
const positions = slab.positions.subarray(0, attributeIndex);
const indices = slab.indices.subarray(0, indexIndex);
- const colors = new Float32Array(slab.colors.buffer, slab.colors.byteOffset, attributeIndex);
+ const colors = new Float32Array(
+ slab.colors.buffer,
+ slab.colors.byteOffset,
+ attributeIndex
+ );
const geometries = Array(NUM_CHUNKS_HEIGHT);
for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
@@ -354,9 +451,16 @@ const _retesselateTerrain = (chunk, newEther) => {
};
const terrainBuffer = chunk.getTerrainBuffer();
- protocolUtils.stringifyTerrainData(chunkDataSpec, terrainBuffer.buffer, terrainBuffer.byteOffset);
+ protocolUtils.stringifyTerrainData(
+ chunkDataSpec,
+ terrainBuffer.buffer,
+ terrainBuffer.byteOffset
+ );
- const chunkData = protocolUtils.parseTerrainData(terrainBuffer.buffer, terrainBuffer.byteOffset);
+ const chunkData = protocolUtils.parseTerrainData(
+ terrainBuffer.buffer,
+ terrainBuffer.byteOffset
+ );
chunk.chunkData.terrain = chunkData;
chunk.chunkData.decorations.terrain = {
skyLightmaps: new Uint8Array(chunkData.positions.length / 3),
@@ -370,7 +474,16 @@ const _retesselateTerrain = (chunk, newEther) => {
const _retesselateObjects = chunk => {
const allocator = new Allocator();
- const {geometriesPositions, geometriesUvs, geometriesSsaos, geometriesFrames, geometriesObjectIndices, geometriesIndices, geometriesObjects, tesselateObjectsResult} = slab;
+ const {
+ geometriesPositions,
+ geometriesUvs,
+ geometriesSsaos,
+ geometriesFrames,
+ geometriesObjectIndices,
+ geometriesIndices,
+ geometriesObjects,
+ tesselateObjectsResult,
+ } = slab;
Module._objectize(
allocator.allocBuffer(chunk.getObjectBuffer()),
@@ -382,7 +495,9 @@ const _retesselateObjects = chunk => {
allocator.allocBuffer(transparentVoxels),
allocator.allocBuffer(translucentVoxels),
allocator.allocBuffer(faceUvs),
- allocator.allocBuffer(Float32Array.from([chunk.x * NUM_CELLS, 0, chunk.z * NUM_CELLS])),
+ allocator.allocBuffer(
+ Float32Array.from([chunk.x * NUM_CELLS, 0, chunk.z * NUM_CELLS])
+ ),
geometriesPositions.offset,
geometriesUvs.offset,
geometriesSsaos.offset,
@@ -395,13 +510,34 @@ const _retesselateObjects = chunk => {
allocator.unshadow();
- const numNewPositions = tesselateObjectsResult.subarray(NUM_CHUNKS_HEIGHT * 0, NUM_CHUNKS_HEIGHT * 1);
- const numNewUvs = tesselateObjectsResult.subarray(NUM_CHUNKS_HEIGHT * 1, NUM_CHUNKS_HEIGHT * 2);
- const numNewSsaos = tesselateObjectsResult.subarray(NUM_CHUNKS_HEIGHT * 2, NUM_CHUNKS_HEIGHT * 3);
- const numNewFrames = tesselateObjectsResult.subarray(NUM_CHUNKS_HEIGHT * 3, NUM_CHUNKS_HEIGHT * 4);
- const numNewObjectIndices = tesselateObjectsResult.subarray(NUM_CHUNKS_HEIGHT * 4, NUM_CHUNKS_HEIGHT * 5);
- const numNewIndices = tesselateObjectsResult.subarray(NUM_CHUNKS_HEIGHT * 5, NUM_CHUNKS_HEIGHT * 6);
- const numNewObjects = tesselateObjectsResult.subarray(NUM_CHUNKS_HEIGHT * 6, NUM_CHUNKS_HEIGHT * 7);
+ const numNewPositions = tesselateObjectsResult.subarray(
+ NUM_CHUNKS_HEIGHT * 0,
+ NUM_CHUNKS_HEIGHT * 1
+ );
+ const numNewUvs = tesselateObjectsResult.subarray(
+ NUM_CHUNKS_HEIGHT * 1,
+ NUM_CHUNKS_HEIGHT * 2
+ );
+ const numNewSsaos = tesselateObjectsResult.subarray(
+ NUM_CHUNKS_HEIGHT * 2,
+ NUM_CHUNKS_HEIGHT * 3
+ );
+ const numNewFrames = tesselateObjectsResult.subarray(
+ NUM_CHUNKS_HEIGHT * 3,
+ NUM_CHUNKS_HEIGHT * 4
+ );
+ const numNewObjectIndices = tesselateObjectsResult.subarray(
+ NUM_CHUNKS_HEIGHT * 4,
+ NUM_CHUNKS_HEIGHT * 5
+ );
+ const numNewIndices = tesselateObjectsResult.subarray(
+ NUM_CHUNKS_HEIGHT * 5,
+ NUM_CHUNKS_HEIGHT * 6
+ );
+ const numNewObjects = tesselateObjectsResult.subarray(
+ NUM_CHUNKS_HEIGHT * 6,
+ NUM_CHUNKS_HEIGHT * 7
+ );
const localGeometries = Array(NUM_CHUNKS_HEIGHT);
for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
@@ -427,22 +563,57 @@ const _retesselateObjects = chunk => {
},
boundingSphere,
};
- };
+ }
const chunkDataSpec = {
- positions: new Float32Array(geometriesPositions.buffer, geometriesPositions.byteOffset, numNewPositions[NUM_CHUNKS_HEIGHT - 1]),
- uvs: new Float32Array(geometriesUvs.buffer, geometriesUvs.byteOffset, numNewUvs[NUM_CHUNKS_HEIGHT - 1]),
- ssaos: new Uint8Array(geometriesSsaos.buffer, geometriesSsaos.byteOffset, numNewSsaos[NUM_CHUNKS_HEIGHT - 1]),
- frames: new Float32Array(geometriesFrames.buffer, geometriesFrames.byteOffset, numNewFrames[NUM_CHUNKS_HEIGHT - 1]),
- objectIndices: new Float32Array(geometriesObjectIndices.buffer, geometriesObjectIndices.byteOffset, numNewObjectIndices[NUM_CHUNKS_HEIGHT - 1]),
- indices: new Uint32Array(geometriesIndices.buffer, geometriesIndices.byteOffset, numNewIndices[NUM_CHUNKS_HEIGHT - 1]),
- objects: new Uint32Array(geometriesObjects.buffer, geometriesObjects.byteOffset, numNewObjects[NUM_CHUNKS_HEIGHT - 1]),
+ positions: new Float32Array(
+ geometriesPositions.buffer,
+ geometriesPositions.byteOffset,
+ numNewPositions[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ uvs: new Float32Array(
+ geometriesUvs.buffer,
+ geometriesUvs.byteOffset,
+ numNewUvs[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ ssaos: new Uint8Array(
+ geometriesSsaos.buffer,
+ geometriesSsaos.byteOffset,
+ numNewSsaos[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ frames: new Float32Array(
+ geometriesFrames.buffer,
+ geometriesFrames.byteOffset,
+ numNewFrames[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ objectIndices: new Float32Array(
+ geometriesObjectIndices.buffer,
+ geometriesObjectIndices.byteOffset,
+ numNewObjectIndices[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ indices: new Uint32Array(
+ geometriesIndices.buffer,
+ geometriesIndices.byteOffset,
+ numNewIndices[NUM_CHUNKS_HEIGHT - 1]
+ ),
+ objects: new Uint32Array(
+ geometriesObjects.buffer,
+ geometriesObjects.byteOffset,
+ numNewObjects[NUM_CHUNKS_HEIGHT - 1]
+ ),
geometries: localGeometries,
};
const geometryBuffer = chunk.getGeometryBuffer();
- protocolUtils.stringifyGeometry(chunkDataSpec, geometryBuffer.buffer, geometryBuffer.byteOffset);
+ protocolUtils.stringifyGeometry(
+ chunkDataSpec,
+ geometryBuffer.buffer,
+ geometryBuffer.byteOffset
+ );
- const chunkData = protocolUtils.parseGeometry(geometryBuffer.buffer, geometryBuffer.byteOffset);
+ const chunkData = protocolUtils.parseGeometry(
+ geometryBuffer.buffer,
+ geometryBuffer.byteOffset
+ );
chunk.chunkData.objects = chunkData;
chunk.chunkData.decorations.objects = {
skyLightmaps: new Uint8Array(chunkData.positions.length / 3),
@@ -454,18 +625,28 @@ const _retesselateObjects = chunk => {
allocator.destroy();
};
const _relight = (chunk, x, y, z) => {
- const _decorateChunkLightsSub = (chunk, x, y, z) => _decorateChunkLightsRange(
+ const _decorateChunkLightsSub = (chunk, x, y, z) =>
+ _decorateChunkLightsRange(
+ chunk,
+ Math.max(x - 15, (chunk.x - 1) * NUM_CELLS),
+ Math.min(x + 15, (chunk.x + 2) * NUM_CELLS),
+ Math.max(y - 15, 0),
+ Math.min(y + 15, NUM_CELLS_HEIGHT),
+ Math.max(z - 15, (chunk.z - 1) * NUM_CELLS),
+ Math.min(z + 15, (chunk.z + 2) * NUM_CELLS),
+ true
+ );
+ const _decorateChunkLightsRange = (
chunk,
- Math.max(x - 15, (chunk.x - 1) * NUM_CELLS),
- Math.min(x + 15, (chunk.x + 2) * NUM_CELLS),
- Math.max(y - 15, 0),
- Math.min(y + 15, NUM_CELLS_HEIGHT),
- Math.max(z - 15, (chunk.z - 1) * NUM_CELLS),
- Math.min(z + 15, (chunk.z + 2) * NUM_CELLS),
- true
- );
- const _decorateChunkLightsRange = (chunk, minX, maxX, minY, maxY, minZ, maxZ, relight) => {
- const {x: ox, z: oz} = chunk;
+ minX,
+ maxX,
+ minY,
+ maxY,
+ minZ,
+ maxZ,
+ relight
+ ) => {
+ const { x: ox, z: oz } = chunk;
const updatingLights = chunk[lightsRenderedSymbol];
const lavaArray = Array(9);
@@ -473,7 +654,8 @@ const _relight = (chunk, x, y, z) => {
const etherArray = Array(9);
const blocksArray = Array(9);
const lightsArray = Array(9);
- for (let doz = -1; doz <= 1; doz++) { // XXX can be reduced to use only the relight range
+ for (let doz = -1; doz <= 1; doz++) {
+ // XXX can be reduced to use only the relight range
for (let dox = -1; dox <= 1; dox++) {
const arrayIndex = _getLightsArrayIndex(dox + 1, doz + 1);
@@ -481,7 +663,10 @@ const _relight = (chunk, x, y, z) => {
const aoz = oz + doz;
const chunk = zde.getChunk(aox, aoz);
const uint32Buffer = chunk.getTerrainBuffer();
- const {ether, lava} = protocolUtils.parseTerrainData(uint32Buffer.buffer, uint32Buffer.byteOffset); // XXX can be reduced to only parse the needed fields
+ const { ether, lava } = protocolUtils.parseTerrainData(
+ uint32Buffer.buffer,
+ uint32Buffer.byteOffset
+ ); // XXX can be reduced to only parse the needed fields
lavaArray[arrayIndex] = lava;
const objectLights = chunk.getLightBuffer();
@@ -494,7 +679,9 @@ const _relight = (chunk, x, y, z) => {
let lights = chunk[lightsSymbol];
if (!lights) {
- lights = new Uint8Array(NUM_CELLS_OVERSCAN * (NUM_CELLS_HEIGHT + 1) * NUM_CELLS_OVERSCAN);
+ lights = new Uint8Array(
+ NUM_CELLS_OVERSCAN * (NUM_CELLS_HEIGHT + 1) * NUM_CELLS_OVERSCAN
+ );
chunk[lightsSymbol] = lights;
}
lightsArray[arrayIndex] = lights;
@@ -504,14 +691,20 @@ const _relight = (chunk, x, y, z) => {
const allocator = new Allocator();
Module._lght(
- ox, oz,
- minX, maxX, minY, maxY, minZ, maxZ,
+ ox,
+ oz,
+ minX,
+ maxX,
+ minY,
+ maxY,
+ minZ,
+ maxZ,
+relight,
allocator.allocBufferArray(lavaArray),
allocator.allocBufferArray(objectLightsArray),
allocator.allocBufferArray(etherArray),
allocator.allocBufferArray(blocksArray),
- allocator.allocShadowBufferArray(lightsArray),
+ allocator.allocShadowBufferArray(lightsArray)
);
allocator.unshadow();
@@ -524,19 +717,31 @@ const _relight = (chunk, x, y, z) => {
const _relightmap = chunk => {
const _relightmapTerrain = () => {
const terrainBuffer = chunk.getTerrainBuffer();
- const {positions} = protocolUtils.parseTerrainData(terrainBuffer.buffer, terrainBuffer.byteOffset);
- const {skyLightmaps, torchLightmaps} = chunk.chunkData.decorations.terrain;
- _relightmapSpec({positions, skyLightmaps, torchLightmaps});
+ const { positions } = protocolUtils.parseTerrainData(
+ terrainBuffer.buffer,
+ terrainBuffer.byteOffset
+ );
+ const {
+ skyLightmaps,
+ torchLightmaps,
+ } = chunk.chunkData.decorations.terrain;
+ _relightmapSpec({ positions, skyLightmaps, torchLightmaps });
};
const _relightmapObjects = () => {
- const {positions} = chunk.chunkData.objects;
- const {skyLightmaps, torchLightmaps} = chunk.chunkData.decorations.objects;
- _relightmapSpec({positions, skyLightmaps, torchLightmaps});
+ const { positions } = chunk.chunkData.objects;
+ const {
+ skyLightmaps,
+ torchLightmaps,
+ } = chunk.chunkData.decorations.objects;
+ _relightmapSpec({ positions, skyLightmaps, torchLightmaps });
};
- const _relightmapSpec = ({positions, skyLightmaps, torchLightmaps}) => {
+ const _relightmapSpec = ({ positions, skyLightmaps, torchLightmaps }) => {
const terrainBuffer = chunk.getTerrainBuffer();
- const {staticHeightfield} = protocolUtils.parseTerrainData(terrainBuffer.buffer, terrainBuffer.byteOffset);
- const {[lightsSymbol]: lights} = chunk;
+ const { staticHeightfield } = protocolUtils.parseTerrainData(
+ terrainBuffer.buffer,
+ terrainBuffer.byteOffset
+ );
+ const { [lightsSymbol]: lights } = chunk;
const numPositions = positions.length;
@@ -587,35 +792,42 @@ const _getHoveredTrackedObject = (x, y, z, buffer, byteOffset) => {
for (const index in zde.chunks) {
const chunk = zde.chunks[index];
- if (chunk && chunk[objectsDecorationsSymbol] && localCoord.set(chunk.x - ox, chunk.z - oz).lengthSq() <= 2) {
- const chunkResult = chunk.forEachObject((n, matrix, value, objectIndex) => {
- const position = localVector2.fromArray(matrix, 0);
- const rotation = localQuaternion.fromArray(matrix, 3);
- const rotationInverse = localQuaternion2.copy(rotation).inverse();
- const objectArray = chunk.objectsMap[objectIndex];
- localBox.min.fromArray(objectArray, 0);
- localBox.max.fromArray(objectArray, 3);
-
- localVector3.copy(controllerPosition)
- .sub(position)
- .applyQuaternion(rotationInverse);
+ if (
+ chunk &&
+ chunk[objectsDecorationsSymbol] &&
+ localCoord.set(chunk.x - ox, chunk.z - oz).lengthSq() <= 2
+ ) {
+ const chunkResult = chunk.forEachObject(
+ (n, matrix, value, objectIndex) => {
+ const position = localVector2.fromArray(matrix, 0);
+ const rotation = localQuaternion.fromArray(matrix, 3);
+ const rotationInverse = localQuaternion2.copy(rotation).inverse();
+ const objectArray = chunk.objectsMap[objectIndex];
+ localBox.min.fromArray(objectArray, 0);
+ localBox.max.fromArray(objectArray, 3);
+
+ localVector3
+ .copy(controllerPosition)
+ .sub(position)
+ .applyQuaternion(rotationInverse);
// .add(position);
- if (localBox.containsPoint(localVector3)) {
- uint32Array[0] = n;
- int32Array[1] = chunk.x;
- int32Array[2] = chunk.z;
- uint32Array[3] = objectIndex;
- // uint32Array[3] = objectIndex + chunk.offsets.index * chunk.offsets.numObjectIndices;
- float32Array[4] = position.x;
- float32Array[5] = position.y;
- float32Array[6] = position.z;
-
- return false;
- } else {
- return true;
+ if (localBox.containsPoint(localVector3)) {
+ uint32Array[0] = n;
+ int32Array[1] = chunk.x;
+ int32Array[2] = chunk.z;
+ uint32Array[3] = objectIndex;
+ // uint32Array[3] = objectIndex + chunk.offsets.index * chunk.offsets.numObjectIndices;
+ float32Array[4] = position.x;
+ float32Array[5] = position.y;
+ float32Array[6] = position.z;
+
+ return false;
+ } else {
+ return true;
+ }
}
- });
+ );
if (chunkResult === false) {
break;
@@ -657,41 +869,55 @@ const _getTeleportObject = (x, y, z, buffer) => {
for (const index in zde.chunks) {
const chunk = zde.chunks[index];
- if (chunk && chunk[objectsDecorationsSymbol] && localCoord.set(chunk.x - ox, chunk.z - oz).lengthSq() <= 2) {
- const chunkResult = chunk.forEachObject((n, matrix, value, objectIndex) => {
- const position = localVector.fromArray(matrix, 0);
- const rotation = localQuaternion.fromArray(matrix, 3);
- const rotationInverse = localQuaternion2.copy(rotation).inverse();
- const objectArray = chunk.objectsMap[objectIndex];
- localBox.min.fromArray(objectArray, 0);
- localBox.max.fromArray(objectArray, 3);
-
- localRay2.origin.copy(localRay.origin)
- .sub(position)
- .applyQuaternion(rotationInverse);
+ if (
+ chunk &&
+ chunk[objectsDecorationsSymbol] &&
+ localCoord.set(chunk.x - ox, chunk.z - oz).lengthSq() <= 2
+ ) {
+ const chunkResult = chunk.forEachObject(
+ (n, matrix, value, objectIndex) => {
+ const position = localVector.fromArray(matrix, 0);
+ const rotation = localQuaternion.fromArray(matrix, 3);
+ const rotationInverse = localQuaternion2.copy(rotation).inverse();
+ const objectArray = chunk.objectsMap[objectIndex];
+ localBox.min.fromArray(objectArray, 0);
+ localBox.max.fromArray(objectArray, 3);
+
+ localRay2.origin
+ .copy(localRay.origin)
+ .sub(position)
+ .applyQuaternion(rotationInverse);
// .add(position);
- localRay2.direction.copy(localRay.direction);
-
- const intersectionPoint = localRay2.intersectBox(localBox, localVector2);
- if (intersectionPoint && intersectionPoint.y > topY) {
- topY = intersectionPoint.y;
- topPosition = position;
- topRotation = rotation;
- topRotationInverse = rotationInverse;
- topBox = localBox2.copy(localBox);
-
- return false;
- } else {
- return true;
+ localRay2.direction.copy(localRay.direction);
+
+ const intersectionPoint = localRay2.intersectBox(
+ localBox,
+ localVector2
+ );
+ if (intersectionPoint && intersectionPoint.y > topY) {
+ topY = intersectionPoint.y;
+ topPosition = position;
+ topRotation = rotation;
+ topRotationInverse = rotationInverse;
+ topBox = localBox2.copy(localBox);
+
+ return false;
+ } else {
+ return true;
+ }
}
- });
+ );
if (chunkResult === false) {
let byteOffset = 0;
new Uint32Array(buffer, byteOffset, 1)[0] = 1;
byteOffset += 4;
- const float32Array = new Float32Array(buffer, byteOffset, 3 + 3 + 3 + 4 + 4);
+ const float32Array = new Float32Array(
+ buffer,
+ byteOffset,
+ 3 + 3 + 3 + 4 + 4
+ );
topBox.min.toArray(float32Array, 0);
topBox.max.toArray(float32Array, 3);
topPosition.toArray(float32Array, 6);
@@ -718,32 +944,39 @@ const _getBodyObject = (x, y, z, buffer) => {
for (const index in zde.chunks) {
const chunk = zde.chunks[index];
- if (chunk && chunk[objectsDecorationsSymbol] && localCoord.set(chunk.x - ox, chunk.z - oz).lengthSq() <= 2) {
- const chunkResult = chunk.forEachObject((n, matrix, value, objectIndex) => {
- const position = localVector2.fromArray(matrix, 0);
- const rotation = localQuaternion.fromArray(matrix, 3);
- const rotationInverse = localQuaternion2.copy(rotation).inverse();
- const objectArray = chunk.objectsMap[objectIndex];
- localBox.min.fromArray(objectArray, 0);
- localBox.max.fromArray(objectArray, 3);
-
- localVector3.copy(bodyCenterPoint)
- .sub(position)
- .applyQuaternion(rotationInverse);
+ if (
+ chunk &&
+ chunk[objectsDecorationsSymbol] &&
+ localCoord.set(chunk.x - ox, chunk.z - oz).lengthSq() <= 2
+ ) {
+ const chunkResult = chunk.forEachObject(
+ (n, matrix, value, objectIndex) => {
+ const position = localVector2.fromArray(matrix, 0);
+ const rotation = localQuaternion.fromArray(matrix, 3);
+ const rotationInverse = localQuaternion2.copy(rotation).inverse();
+ const objectArray = chunk.objectsMap[objectIndex];
+ localBox.min.fromArray(objectArray, 0);
+ localBox.max.fromArray(objectArray, 3);
+
+ localVector3
+ .copy(bodyCenterPoint)
+ .sub(position)
+ .applyQuaternion(rotationInverse);
// .add(position);
- const distance = localBox.distanceToPoint(localVector3);
- if (distance < 0.3 && (distance < topDistance)) {
- topDistance = distance;
- topN = n;
- topChunkX = chunk.x;
- topChunkZ = chunk.z;
- topObjectIndex = objectIndex;
- return false;
- } else {
- return true;
+ const distance = localBox.distanceToPoint(localVector3);
+ if (distance < 0.3 && distance < topDistance) {
+ topDistance = distance;
+ topN = n;
+ topChunkX = chunk.x;
+ topChunkZ = chunk.z;
+ topObjectIndex = objectIndex;
+ return false;
+ } else {
+ return true;
+ }
}
- });
+ );
if (chunkResult === false) {
const uint32Array = new Uint32Array(buffer, 0, 4);
@@ -765,12 +998,12 @@ const queue = [];
let pendingMessage = null;
const connection = new AutoWs(_wsUrl('/archae/generatorWs'));
connection.on('message', e => {
- const {data} = e;
+ const { data } = e;
const m = JSON.parse(data);
- const {type} = m;
+ const { type } = m;
if (type === 'addObject') {
- const {args: {n, positions, rotations, value, result: objectIndex}} = m;
+ const { args: { n, positions, rotations, value, result: objectIndex } } = m;
const ox = Math.floor(positions[0] / NUM_CELLS);
const oz = Math.floor(positions[2] / NUM_CELLS);
@@ -788,13 +1021,21 @@ connection.on('message', e => {
const light = _findLight(n);
if (light) {
- oldChunk.addLightAt(objectIndex, positions[0], positions[1], positions[2], light);
+ oldChunk.addLightAt(
+ objectIndex,
+ positions[0],
+ positions[1],
+ positions[2],
+ light
+ );
for (let i = 0; i < CROSS_DIRECTIONS.length; i++) {
const [dx, dz] = CROSS_DIRECTIONS[i];
const ox = Math.floor((x + dx * light) / NUM_CELLS);
const oz = Math.floor((z + dz * light) / NUM_CELLS);
- if (!updateSpecs.some(update => update[0] === ox && update[1] === oz)) {
+ if (
+ !updateSpecs.some(update => update[0] === ox && update[1] === oz)
+ ) {
updateSpecs.push([ox, oz]);
}
}
@@ -820,12 +1061,20 @@ connection.on('message', e => {
if (objectApi && objectApi.added) {
postMessage({
type: 'objectAdded',
- args: [n, ox, oz, objectIndex, matrix.slice(0, 3), matrix.slice(3, 7), value],
+ args: [
+ n,
+ ox,
+ oz,
+ objectIndex,
+ matrix.slice(0, 3),
+ matrix.slice(3, 7),
+ value,
+ ],
});
}
}
} else if (type === 'removeObject') {
- const {args: {x: ox, z: oz, index: objectIndex}} = m;
+ const { args: { x: ox, z: oz, index: objectIndex } } = m;
const oldChunk = zde.getChunk(ox, oz);
if (oldChunk) {
@@ -845,7 +1094,9 @@ connection.on('message', e => {
const [dx, dz] = CROSS_DIRECTIONS[i];
const ox = Math.floor((x + dx * light) / NUM_CELLS);
const oz = Math.floor((z + dz * light) / NUM_CELLS);
- if (!updateSpecs.some(update => update[0] === ox && update[1] === oz)) {
+ if (
+ !updateSpecs.some(update => update[0] === ox && update[1] === oz)
+ ) {
updateSpecs.push([ox, oz]);
}
}
@@ -878,7 +1129,7 @@ connection.on('message', e => {
}
}
} else if (type === 'setObjectData') {
- const {args: {x, z, index: objectIndex, value}} = m;
+ const { args: { x, z, index: objectIndex, value } } = m;
const chunk = zde.getChunk(x, z);
if (chunk) {
@@ -891,12 +1142,20 @@ connection.on('message', e => {
postMessage({
type: 'objectUpdated',
- args: [n, x, z, objectIndex, matrix.slice(0, 3), matrix.slice(3, 7), value],
+ args: [
+ n,
+ x,
+ z,
+ objectIndex,
+ matrix.slice(0, 3),
+ matrix.slice(3, 7),
+ value,
+ ],
});
}
}
} else if (type === 'setBlock') {
- const {args: {x, y, z, v}} = m;
+ const { args: { x, y, z, v } } = m;
const ox = Math.floor(x / NUM_CELLS);
const oz = Math.floor(z / NUM_CELLS);
@@ -922,7 +1181,7 @@ connection.on('message', e => {
}
}
} else if (type === 'clearBlock') {
- const {args: {x, y, z}} = m;
+ const { args: { x, y, z } } = m;
const ox = Math.floor(x / NUM_CELLS);
const oz = Math.floor(z / NUM_CELLS);
@@ -948,7 +1207,7 @@ connection.on('message', e => {
}
}
} else if (type === 'mutateVoxel') {
- const {args: {x, y, z, v}} = m;
+ const { args: { x, y, z, v } } = m;
const seenChunks = [];
for (let i = 0; i < DIRECTIONS.length; i++) {
@@ -961,8 +1220,8 @@ connection.on('message', e => {
if (!seenChunks.some(([x, z]) => x === ox && z === oz)) {
const oldChunk = zde.getChunk(ox, oz);
- const lx = x - (ox * NUM_CELLS);
- const lz = z - (oz * NUM_CELLS);
+ const lx = x - ox * NUM_CELLS;
+ const lz = z - oz * NUM_CELLS;
const newEther = Float32Array.from([lx, y, lz, v]);
_retesselateTerrain(oldChunk, newEther);
@@ -978,7 +1237,7 @@ connection.on('message', e => {
args: seenChunks,
});
} else if (type === 'response') {
- const {id, result} = m;
+ const { id, result } = m;
queues[id](result);
queues[id] = null;
@@ -990,84 +1249,96 @@ connection.on('message', e => {
});
connection.mutateVoxel = (x, y, z, v, cb) => {
const id = _makeId();
- connection.send(JSON.stringify({
- method: 'mutateVoxel',
- id,
- args: {
- x,
- y,
- z,
- v,
- },
- }));
+ connection.send(
+ JSON.stringify({
+ method: 'mutateVoxel',
+ id,
+ args: {
+ x,
+ y,
+ z,
+ v,
+ },
+ })
+ );
queues[id] = cb;
};
connection.addObject = (n, positions, rotations, value, cb) => {
const id = _makeId();
- connection.send(JSON.stringify({
- method: 'addObject',
- id,
- args: {
- n,
- positions,
- rotations,
- value,
- },
- }));
+ connection.send(
+ JSON.stringify({
+ method: 'addObject',
+ id,
+ args: {
+ n,
+ positions,
+ rotations,
+ value,
+ },
+ })
+ );
queues[id] = cb;
};
connection.removeObject = (x, z, index, cb) => {
const id = _makeId();
- connection.send(JSON.stringify({
- method: 'removeObject',
- id,
- args: {
- x,
- z,
- index,
- },
- }));
+ connection.send(
+ JSON.stringify({
+ method: 'removeObject',
+ id,
+ args: {
+ x,
+ z,
+ index,
+ },
+ })
+ );
queues[id] = cb;
};
connection.setObjectData = (x, z, index, value, cb) => {
const id = _makeId();
- connection.send(JSON.stringify({
- method: 'setObjectData',
- id,
- args: {
- x,
- z,
- index,
- value,
- },
- }));
+ connection.send(
+ JSON.stringify({
+ method: 'setObjectData',
+ id,
+ args: {
+ x,
+ z,
+ index,
+ value,
+ },
+ })
+ );
queues[id] = cb;
};
connection.setBlock = (x, y, z, v, cb) => {
const id = _makeId();
- connection.send(JSON.stringify({
- method: 'setBlock',
- id,
- args: {
- x,
- y,
- z,
- v,
- },
- }));
+ connection.send(
+ JSON.stringify({
+ method: 'setBlock',
+ id,
+ args: {
+ x,
+ y,
+ z,
+ v,
+ },
+ })
+ );
queues[id] = cb;
};
connection.clearBlock = (x, y, z, cb) => {
const id = _makeId();
- connection.send(JSON.stringify({
- method: 'clearBlock',
- id,
- args: {
- x,
- y,
- z,
- },
- }));
+ connection.send(
+ JSON.stringify({
+ method: 'clearBlock',
+ id,
+ args: {
+ x,
+ y,
+ z,
+ },
+ })
+ );
queues[id] = cb;
};
const _getOriginHeight = () => 64;
@@ -1083,11 +1354,10 @@ const _resArrayBuffer = res => {
};
const _resArrayBufferHeaders = res => {
if (res.status >= 200 && res.status < 300) {
- return res.arrayBuffer()
- .then(buffer => ({
- buffer,
- headers: res.headers,
- }));
+ return res.arrayBuffer().then(buffer => ({
+ buffer,
+ headers: res.headers,
+ }));
} else {
return Promise.reject({
status: res.status,
@@ -1107,12 +1377,14 @@ const _resBlob = res => {
};
function mod(value, divisor) {
var n = value % divisor;
- return n < 0 ? (divisor + n) : n;
+ return n < 0 ? divisor + n : n;
}
-const _getChunkIndex = (x, z) => (mod(x, 0xFFFF) << 16) | mod(z, 0xFFFF);
+const _getChunkIndex = (x, z) => (mod(x, 0xffff) << 16) | mod(z, 0xffff);
const NUM_MAP_CHUNK_MESHES = 512;
-const terrainMapChunkMeshes = new Int32Array(NUM_MAP_CHUNK_MESHES * NUM_CELLS_HEIGHT * 14);
+const terrainMapChunkMeshes = new Int32Array(
+ NUM_MAP_CHUNK_MESHES * NUM_CELLS_HEIGHT * 14
+);
let terrainMapChunkMeshesIndex = 0;
const _findFreeTerrainMapChunkMeshIndex = () => {
let baseIndex = 0;
@@ -1126,7 +1398,9 @@ const _findFreeTerrainMapChunkMeshIndex = () => {
throw new Error('ran out of map chunk mesh buffer');
return -1;
};
-const objectsMapChunkMeshes = new Int32Array(NUM_MAP_CHUNK_MESHES * (1 + 2 + NUM_CHUNKS_HEIGHT * 2));
+const objectsMapChunkMeshes = new Int32Array(
+ NUM_MAP_CHUNK_MESHES * (1 + 2 + NUM_CHUNKS_HEIGHT * 2)
+);
let objectsMapChunkMeshesIndex = 0;
const _findFreeObjectsMapChunkMeshIndex = () => {
let baseIndex = 0;
@@ -1150,7 +1424,7 @@ const _requestChunk = (x, z) => {
credentials: 'include',
})
.then(_resArrayBufferHeaders)
- .then(({buffer, headers}) => {
+ .then(({ buffer, headers }) => {
const newTextureAtlasVersion = headers.get('Texture-Atlas-Version');
if (newTextureAtlasVersion !== textureAtlasVersion) {
textureAtlasVersion = newTextureAtlasVersion;
@@ -1165,31 +1439,59 @@ const _requestChunk = (x, z) => {
}
let index = 0;
- const terrainBuffer = new Uint32Array(buffer, index, TERRAIN_BUFFER_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+ const terrainBuffer = new Uint32Array(
+ buffer,
+ index,
+ TERRAIN_BUFFER_SIZE / Uint32Array.BYTES_PER_ELEMENT
+ );
index += TERRAIN_BUFFER_SIZE;
- const objectBuffer = new Uint32Array(buffer, index, OBJECT_BUFFER_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+ const objectBuffer = new Uint32Array(
+ buffer,
+ index,
+ OBJECT_BUFFER_SIZE / Uint32Array.BYTES_PER_ELEMENT
+ );
index += OBJECT_BUFFER_SIZE;
- const blockBuffer = new Uint32Array(buffer, index, BLOCK_BUFFER_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+ const blockBuffer = new Uint32Array(
+ buffer,
+ index,
+ BLOCK_BUFFER_SIZE / Uint32Array.BYTES_PER_ELEMENT
+ );
index += BLOCK_BUFFER_SIZE;
- const lightBuffer = new Float32Array(buffer, index, LIGHT_BUFFER_SIZE / Float32Array.BYTES_PER_ELEMENT);
+ const lightBuffer = new Float32Array(
+ buffer,
+ index,
+ LIGHT_BUFFER_SIZE / Float32Array.BYTES_PER_ELEMENT
+ );
index += LIGHT_BUFFER_SIZE;
- const geometryBuffer = new Uint8Array(buffer, index, GEOMETRY_BUFFER_SIZE / Uint8Array.BYTES_PER_ELEMENT);
+ const geometryBuffer = new Uint8Array(
+ buffer,
+ index,
+ GEOMETRY_BUFFER_SIZE / Uint8Array.BYTES_PER_ELEMENT
+ );
index += GEOMETRY_BUFFER_SIZE;
const decorationsBuffer = new Uint8Array(buffer, index);
- const chunk = new zeode.Chunk(x, z, 0, terrainBuffer, objectBuffer, blockBuffer, lightBuffer, geometryBuffer);
chunk.chunkData = {
- terrain: protocolUtils.parseTerrainData(terrainBuffer.buffer, terrainBuffer.byteOffset),
- objects: protocolUtils.parseGeometry(geometryBuffer.buffer, geometryBuffer.byteOffset),
- decorations: protocolUtils.parseDecorations(decorationsBuffer.buffer, decorationsBuffer.byteOffset),
+ terrain: protocolUtils.parseTerrainData(
+ terrainBuffer.buffer,
+ terrainBuffer.byteOffset
+ ),
+ objects: protocolUtils.parseGeometry(
+ geometryBuffer.buffer,
+ geometryBuffer.byteOffset
+ ),
+ decorations: protocolUtils.parseDecorations(
+ decorationsBuffer.buffer,
+ decorationsBuffer.byteOffset
+ ),
};
zde.pushChunk(chunk);
return chunk;
});
}
};
-const _requestTerrainChunk = (x, y, index, numPositions, numIndices) => _requestChunk(x, y)
- .then(chunk => {
+const _requestTerrainChunk = (x, y, index, numPositions, numIndices) =>
+ _requestChunk(x, y).then(chunk => {
_decorateTerrainChunk(chunk, index, numPositions, numIndices);
return chunk;
});
@@ -1198,13 +1500,26 @@ const _getTerrainChunk = (x, y, index, numPositions, numIndices) => {
_decorateTerrainChunk(chunk, index, numPositions, numIndices);
return chunk;
};
-const _requestObjectsChunk = (x, z, index, numPositions, numObjectIndices, numIndices) => _requestChunk(x, z)
- .then(chunk => {
- _decorateObjectsChunk(chunk, index, numPositions, numObjectIndices, numIndices);
+const _requestObjectsChunk = (
+ x,
+ z,
+ index,
+ numPositions,
+ numObjectIndices,
+ numIndices
+) =>
+ _requestChunk(x, z).then(chunk => {
+ _decorateObjectsChunk(
+ chunk,
+ index,
+ numPositions,
+ numObjectIndices,
+ numIndices
+ );
return chunk;
});
const _offsetChunkData = (chunkData, index, numPositions) => {
- const {indices} = chunkData;
+ const { indices } = chunkData;
const positionOffset = index * (numPositions / 3);
for (let i = 0; i < indices.length; i++) {
indices[i] += positionOffset;
@@ -1212,11 +1527,11 @@ const _offsetChunkData = (chunkData, index, numPositions) => {
};
const _decorateTerrainChunk = (chunk, index, numPositions, numIndices) => {
if (!chunk[terrainDecorationsSymbol]) {
- const {x, z} = chunk;
+ const { x, z } = chunk;
const terrainMapChunkMeshIndices = Array(NUM_CHUNKS_HEIGHT);
for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
- const {indexRange, peeks} = chunk.chunkData.terrain.geometries[i];
+ const { indexRange, peeks } = chunk.chunkData.terrain.geometries[i];
const indexOffset = index * numIndices;
const terrainMapChunkMeshIndex = _findFreeTerrainMapChunkMeshIndex();
@@ -1225,12 +1540,18 @@ const _decorateTerrainChunk = (chunk, index, numPositions, numIndices) => {
terrainMapChunkMeshes[baseIndex + 1] = x;
terrainMapChunkMeshes[baseIndex + 2] = i;
terrainMapChunkMeshes[baseIndex + 3] = z;
- new Uint8Array(terrainMapChunkMeshes.buffer, terrainMapChunkMeshes.byteOffset + (baseIndex + 4) * 4, 16).set(peeks);
+ new Uint8Array(
+ terrainMapChunkMeshes.buffer,
+ terrainMapChunkMeshes.byteOffset + (baseIndex + 4) * 4,
+ 16
+ ).set(peeks);
terrainMapChunkMeshes[baseIndex + 8] = indexRange.landStart + indexOffset;
terrainMapChunkMeshes[baseIndex + 9] = indexRange.landCount;
- terrainMapChunkMeshes[baseIndex + 10] = indexRange.waterStart + indexOffset;
+ terrainMapChunkMeshes[baseIndex + 10] =
+ indexRange.waterStart + indexOffset;
terrainMapChunkMeshes[baseIndex + 11] = indexRange.waterCount;
- terrainMapChunkMeshes[baseIndex + 12] = indexRange.lavaStart + indexOffset;
+ terrainMapChunkMeshes[baseIndex + 12] =
+ indexRange.lavaStart + indexOffset;
terrainMapChunkMeshes[baseIndex + 13] = indexRange.lavaCount;
terrainMapChunkMeshIndices[i] = terrainMapChunkMeshIndex;
@@ -1254,7 +1575,13 @@ const _undecorateTerrainChunk = chunk => {
}
};
let ids = 0;
-const _decorateObjectsChunk = (chunk, index, numPositions, numObjectIndices, numIndices) => {
+const _decorateObjectsChunk = (
+ chunk,
+ index,
+ numPositions,
+ numObjectIndices,
+ numIndices
+) => {
if (!chunk[objectsDecorationsSymbol]) {
chunk.id = ids++;
@@ -1266,31 +1593,37 @@ const _decorateObjectsChunk = (chunk, index, numPositions, numObjectIndices, num
};
const objectsMap = {};
- const {objects} = chunk.chunkData.objects;
+ const { objects } = chunk.chunkData.objects;
const numObjects = objects.length / 7;
for (let i = 0; i < numObjects; i++) {
const baseIndex = i * 7;
const index = objects[baseIndex];
- objectsMap[index] = new Float32Array(objects.buffer, objects.byteOffset + ((baseIndex + 1) * 4), 6);
+ objectsMap[index] = new Float32Array(
+ objects.buffer,
+ objects.byteOffset + (baseIndex + 1) * 4,
+ 6
+ );
}
chunk.objectsMap = objectsMap;
- const {objectIndices} = chunk.chunkData.objects;
+ const { objectIndices } = chunk.chunkData.objects;
const objectIndexOffset = index * numObjectIndices;
for (let i = 0; i < objectIndices.length; i++) {
objectIndices[i] += objectIndexOffset;
}
const objectsMapChunkMeshIndex = _findFreeObjectsMapChunkMeshIndex();
- const baseIndex = objectsMapChunkMeshIndex * (1 + 2 + NUM_CHUNKS_HEIGHT * 2);
+ const baseIndex =
+ objectsMapChunkMeshIndex * (1 + 2 + NUM_CHUNKS_HEIGHT * 2);
objectsMapChunkMeshes[baseIndex + 0] = 1;
objectsMapChunkMeshes[baseIndex + 1] = chunk.x;
objectsMapChunkMeshes[baseIndex + 2] = chunk.z;
- const {geometries} = chunk.chunkData.objects;
+ const { geometries } = chunk.chunkData.objects;
const indexOffset = index * numIndices;
for (let i = 0; i < NUM_CHUNKS_HEIGHT; i++) {
- const {indexRange} = geometries[i];
- objectsMapChunkMeshes[baseIndex + 3 + i * 2 + 0] = indexRange.start + indexOffset;
+ const { indexRange } = geometries[i];
+ objectsMapChunkMeshes[baseIndex + 3 + i * 2 + 0] =
+ indexRange.start + indexOffset;
objectsMapChunkMeshes[baseIndex + 3 + i * 2 + 1] = indexRange.count;
}
@@ -1299,10 +1632,10 @@ const _decorateObjectsChunk = (chunk, index, numPositions, numObjectIndices, num
const allocator = new Allocator();
const blocks = chunk.getBlockBuffer();
- const {blockfield} = chunk.chunkData.decorations.objects;
+ const { blockfield } = chunk.chunkData.decorations.objects;
Module._blockfield(
allocator.allocBuffer(blocks),
- allocator.allocShadowBuffer(blockfield),
+ allocator.allocShadowBuffer(blockfield)
);
allocator.unshadow();
@@ -1314,12 +1647,21 @@ const _decorateObjectsChunk = (chunk, index, numPositions, numObjectIndices, num
};
}
if (!chunk[objectsCallbacksSymbol]) {
- chunk.forEachObject((n, matrix, value, objectIndex) => { // XXX can optimize this with some kind of index
+ chunk.forEachObject((n, matrix, value, objectIndex) => {
+ // XXX can optimize this with some kind of index
const entry = objectApis[n];
if (entry && entry.added) {
postMessage({
type: 'objectAdded',
- args: [n, chunk.x, chunk.z, objectIndex, matrix.slice(0, 3), matrix.slice(3, 7), value],
+ args: [
+ n,
+ chunk.x,
+ chunk.z,
+ objectIndex,
+ matrix.slice(0, 3),
+ matrix.slice(3, 7),
+ value,
+ ],
});
}
});
@@ -1339,7 +1681,15 @@ const _decorateObjectsChunk = (chunk, index, numPositions, numObjectIndices, num
if (entry && entry.removed) {
postMessage({
type: 'objectRemoved',
- args: [n, chunk.x, chunk.z, objectIndex, matrix.slice(0, 3), matrix.slice(3, 7), value],
+ args: [
+ n,
+ chunk.x,
+ chunk.z,
+ objectIndex,
+ matrix.slice(0, 3),
+ matrix.slice(3, 7),
+ value,
+ ],
});
}
});
@@ -1376,14 +1726,19 @@ const _updateTextureAtlas = _debounce(next => {
credentials: 'include',
})
.then(_resBlob)
- .then(blob => createImageBitmap(blob, 0, 0, TEXTURE_SIZE, TEXTURE_SIZE, {
- imageOrientation: 'flipY',
- }))
+ .then(blob =>
+ createImageBitmap(blob, 0, 0, TEXTURE_SIZE, TEXTURE_SIZE, {
+ imageOrientation: 'flipY',
+ })
+ )
.then(imageBitmap => {
- postMessage({
- type: 'textureAtlas',
- args: [imageBitmap],
- }, [imageBitmap]);
+ postMessage(
+ {
+ type: 'textureAtlas',
+ args: [imageBitmap],
+ },
+ [imageBitmap]
+ );
next();
})
@@ -1455,16 +1810,16 @@ const _cleanupQueues = () => {
};
function _wsUrl(s) {
const l = self.location;
- return ((l.protocol === 'https:') ? 'wss://' : 'ws://') + l.host + s;
+ return (l.protocol === 'https:' ? 'wss://' : 'ws://') + l.host + s;
}
self.onmessage = e => {
- const {data} = e;
- const {type} = data;
+ const { data } = e;
+ const { type } = data;
switch (type) {
case 'getOriginHeight': {
- const {id} = data;
+ const { id } = data;
postMessage({
type: 'response',
@@ -1474,7 +1829,7 @@ self.onmessage = e => {
break;
}
case 'registerObject': {
- const {n, added, removed, updated, set, clear} = data;
+ const { n, added, removed, updated, set, clear } = data;
let entry = objectApis[n];
if (!entry) {
@@ -1491,11 +1846,20 @@ self.onmessage = e => {
entry.added++;
if (entry.added === 1) {
- zde.forEachObject((localN, matrix, value, objectIndex) => { // XXX also need to do this efficiently when the chunk loads
+ zde.forEachObject((localN, matrix, value, objectIndex) => {
+ // XXX also need to do this efficiently when the chunk loads
if (localN === n) {
postMessage({
type: 'objectAdded',
- args: [localN, chunk.x, chunk.z, objectIndex, matrix.slice(0, 3), matrix.slice(3, 7), value],
+ args: [
+ localN,
+ chunk.x,
+ chunk.z,
+ objectIndex,
+ matrix.slice(0, 3),
+ matrix.slice(3, 7),
+ value,
+ ],
});
}
});
@@ -1517,7 +1881,12 @@ self.onmessage = e => {
if (localN === n) {
postMessage({
type: 'blockSet',
- args: [n, chunk.x * NUM_CELLS + x, y, chunk.z * NUM_CELLS + z],
+ args: [
+ n,
+ chunk.x * NUM_CELLS + x,
+ y,
+ chunk.z * NUM_CELLS + z,
+ ],
});
}
});
@@ -1530,7 +1899,7 @@ self.onmessage = e => {
break;
}
case 'unregisterObject': {
- const {n, added, removed, updated, set, clear} = data;
+ const { n, added, removed, updated, set, clear } = data;
const entry = objectApis[n];
if (added) {
entry.added--;
@@ -1581,13 +1950,19 @@ self.onmessage = e => {
}
} */
}
- if (entry.added === 0 && entry.removed === 0 && entry.updated === 0 && entry.set === 0 && entry.clear === 0) {
+ if (
+ entry.added === 0 &&
+ entry.removed === 0 &&
+ entry.updated === 0 &&
+ entry.set === 0 &&
+ entry.clear === 0
+ ) {
objectApis[n] = null;
}
break;
}
case 'addObject': {
- const {name, position: positions, rotation: rotations, value} = data;
+ const { name, position: positions, rotation: rotations, value } = data;
const ox = Math.floor(positions[0] / NUM_CELLS);
const oz = Math.floor(positions[2] / NUM_CELLS);
@@ -1608,13 +1983,21 @@ self.onmessage = e => {
const light = _findLight(n);
if (light) {
- oldChunk.addLightAt(objectIndex, positions[0], positions[1], positions[2], light);
+ oldChunk.addLightAt(
+ objectIndex,
+ positions[0],
+ positions[1],
+ positions[2],
+ light
+ );
for (let i = 0; i < CROSS_DIRECTIONS.length; i++) {
const [dx, dz] = CROSS_DIRECTIONS[i];
const ox = Math.floor((x + dx * light) / NUM_CELLS);
const oz = Math.floor((z + dz * light) / NUM_CELLS);
- if (!updateSpecs.some(update => update[0] === ox && update[1] === oz)) {
+ if (
+ !updateSpecs.some(update => update[0] === ox && update[1] === oz)
+ ) {
updateSpecs.push([ox, oz]);
}
}
@@ -1640,14 +2023,22 @@ self.onmessage = e => {
if (objectApi && objectApi.added) {
postMessage({
type: 'objectAdded',
- args: [n, ox, oz, objectIndex, matrix.slice(0, 3), matrix.slice(3, 7), value],
+ args: [
+ n,
+ ox,
+ oz,
+ objectIndex,
+ matrix.slice(0, 3),
+ matrix.slice(3, 7),
+ value,
+ ],
});
}
}
break;
}
case 'removeObject': {
- const {x: ox, z: oz, index: objectIndex} = data;
+ const { x: ox, z: oz, index: objectIndex } = data;
const oldChunk = zde.getChunk(ox, oz);
if (oldChunk) {
@@ -1669,7 +2060,11 @@ self.onmessage = e => {
const [dx, dz] = CROSS_DIRECTIONS[i];
const ox = Math.floor((x + dx * light) / NUM_CELLS);
const oz = Math.floor((z + dz * light) / NUM_CELLS);
- if (!updateSpecs.some(update => update[0] === ox && update[1] === oz)) {
+ if (
+ !updateSpecs.some(
+ update => update[0] === ox && update[1] === oz
+ )
+ ) {
updateSpecs.push([ox, oz]);
}
}
@@ -1708,7 +2103,7 @@ self.onmessage = e => {
break;
}
case 'setObjectData': {
- const {x, z, index, value} = data;
+ const { x, z, index, value } = data;
const chunk = zde.getChunk(x, z);
if (chunk) {
@@ -1722,7 +2117,15 @@ self.onmessage = e => {
postMessage({
type: 'objectUpdated',
- args: [n, x, z, index, matrix.slice(0, 3), matrix.slice(3, 7), value],
+ args: [
+ n,
+ x,
+ z,
+ index,
+ matrix.slice(0, 3),
+ matrix.slice(3, 7),
+ value,
+ ],
});
}
});
@@ -1730,7 +2133,7 @@ self.onmessage = e => {
break;
}
case 'setBlock': {
- const {x, y, z, v} = data;
+ const { x, y, z, v } = data;
const ox = Math.floor(x / NUM_CELLS);
const oz = Math.floor(z / NUM_CELLS);
@@ -1760,7 +2163,7 @@ self.onmessage = e => {
break;
}
case 'clearBlock': {
- const {x, y, z} = data;
+ const { x, y, z } = data;
const ox = Math.floor(x / NUM_CELLS);
const oz = Math.floor(z / NUM_CELLS);
@@ -1768,7 +2171,11 @@ self.onmessage = e => {
if (oldChunk) {
connection.clearBlock(x, y, z, () => {});
- const n = oldChunk.clearBlock(x - ox * NUM_CELLS, y, z - oz * NUM_CELLS);
+ const n = oldChunk.clearBlock(
+ x - ox * NUM_CELLS,
+ y,
+ z - oz * NUM_CELLS
+ );
_retesselateObjects(oldChunk);
_relight(oldChunk, x, y, z);
@@ -1790,8 +2197,8 @@ self.onmessage = e => {
break;
}
case 'generate': {
- const {id, args} = data;
- const {x, y} = args;
+ const { id, args } = data;
+ const { x, y } = args;
_requestChunk(x, y)
.then(() => {
@@ -1807,19 +2214,27 @@ self.onmessage = e => {
break;
}
case 'terrainGenerate': {
- const {id, args} = data;
- const {x, y, index, numPositions, numIndices} = args;
- let {buffer} = args;
+ const { id, args } = data;
+ const { x, y, index, numPositions, numIndices } = args;
+ let { buffer } = args;
_requestTerrainChunk(x, y, index, numPositions, numIndices)
.then(chunk => {
- protocolUtils.stringifyTerrainRenderChunk(chunk.chunkData.terrain, chunk.chunkData.decorations.terrain, buffer, 0);
-
- postMessage({
- type: 'response',
- args: [id],
- result: buffer,
- }, [buffer]);
+ protocolUtils.stringifyTerrainRenderChunk(
+ chunk.chunkData.terrain,
+ chunk.chunkData.decorations.terrain,
+ buffer,
+ 0
+ );
+
+ postMessage(
+ {
+ type: 'response',
+ args: [id],
+ result: buffer,
+ },
+ [buffer]
+ );
})
.catch(err => {
console.warn(err);
@@ -1827,36 +2242,56 @@ self.onmessage = e => {
break;
}
case 'terrainsGenerate': {
- const {id, args} = data;
- const {specs} = args;
- let {buffer} = args;
+ const { id, args } = data;
+ const { specs } = args;
+ let { buffer } = args;
- const chunks = specs.map(({x, y, index, numPositions, numIndices}) => _getTerrainChunk(x, y, index, numPositions, numIndices));
+ const chunks = specs.map(({ x, y, index, numPositions, numIndices }) =>
+ _getTerrainChunk(x, y, index, numPositions, numIndices)
+ );
protocolUtils.stringifyTerrainsRenderChunk(chunks, buffer, 0);
- postMessage({
- type: 'response',
- args: [id],
- result: buffer,
- }, [buffer]);
+ postMessage(
+ {
+ type: 'response',
+ args: [id],
+ result: buffer,
+ },
+ [buffer]
+ );
break;
}
case 'objectsGenerate': {
- const {id, args} = data;
- const {x, z, index, numPositions, numObjectIndices, numIndices} = args;
- let {buffer} = args;
-
- _requestObjectsChunk(x, z, index, numPositions, numObjectIndices, numIndices)
+ const { id, args } = data;
+ const { x, z, index, numPositions, numObjectIndices, numIndices } = args;
+ let { buffer } = args;
+
+ _requestObjectsChunk(
+ x,
+ z,
+ index,
+ numPositions,
+ numObjectIndices,
+ numIndices
+ )
.then(chunk => {
zde.pushChunk(chunk);
- protocolUtils.stringifyWorker(chunk.chunkData.objects, chunk.chunkData.decorations.objects, buffer, 0);
-
- postMessage({
- type: 'response',
- args: [id],
- result: buffer,
- }, [buffer]);
+ protocolUtils.stringifyWorker(
+ chunk.chunkData.objects,
+ chunk.chunkData.decorations.objects,
+ buffer,
+ 0
+ );
+
+ postMessage(
+ {
+ type: 'response',
+ args: [id],
+ result: buffer,
+ },
+ [buffer]
+ );
chunk.forEachObject((n, matrix, value, objectIndex) => {
const objectApi = objectApis[n];
@@ -1864,7 +2299,15 @@ self.onmessage = e => {
if (objectApi && objectApi.added) {
postMessage({
type: 'objectAdded',
- args: [n, x, z, objectIndex, matrix.slice(0, 3), matrix.slice(3, 7), value],
+ args: [
+ n,
+ x,
+ z,
+ objectIndex,
+ matrix.slice(0, 3),
+ matrix.slice(3, 7),
+ value,
+ ],
});
}
});
@@ -1875,8 +2318,8 @@ self.onmessage = e => {
break;
}
case 'ungenerate': {
- const {args} = data;
- const {x, z} = args;
+ const { args } = data;
+ const { x, z } = args;
const chunk = _unrequestChunk(x, z);
chunk.forEachObject((n, matrix, value, objectIndex) => {
@@ -1926,8 +2369,8 @@ self.onmessage = e => {
break;
} */
case 'mutateVoxel': {
- const {id, args} = data;
- const {position: [x, y, z, v]} = args;
+ const { id, args } = data;
+ const { position: [x, y, z, v] } = args;
connection.mutateVoxel(x, y, z, v, () => {});
@@ -1942,8 +2385,8 @@ self.onmessage = e => {
if (!seenChunks.some(([x, z]) => x === ox && z === oz)) {
const oldChunk = zde.getChunk(ox, oz);
- const lx = x - (ox * NUM_CELLS);
- const lz = z - (oz * NUM_CELLS);
+ const lx = x - ox * NUM_CELLS;
+ const lz = z - oz * NUM_CELLS;
const newEther = Float32Array.from([lx, y, lz, v]);
_retesselateTerrain(oldChunk, newEther);
@@ -1961,33 +2404,57 @@ self.onmessage = e => {
break;
}
case 'terrainCull': {
- const {id, args} = data;
- const {hmdPosition, projectionMatrix, matrixWorldInverse, buffer} = args;
-
- const groups = _getTerrainCull(hmdPosition, projectionMatrix, matrixWorldInverse);
+ const { id, args } = data;
+ const {
+ hmdPosition,
+ projectionMatrix,
+ matrixWorldInverse,
+ buffer,
+ } = args;
+
+ const groups = _getTerrainCull(
+ hmdPosition,
+ projectionMatrix,
+ matrixWorldInverse
+ );
protocolUtils.stringifyTerrainCull(groups, buffer, 0);
- postMessage({
- type: 'response',
- args: [id],
- result: buffer,
- }, [buffer]);
+ postMessage(
+ {
+ type: 'response',
+ args: [id],
+ result: buffer,
+ },
+ [buffer]
+ );
break;
}
case 'objectsCull': {
- const {id, args} = data;
- const {hmdPosition, projectionMatrix, matrixWorldInverse, buffer} = args;
-
- const chunks = _getObjectsCull(hmdPosition, projectionMatrix, matrixWorldInverse);
+ const { id, args } = data;
+ const {
+ hmdPosition,
+ projectionMatrix,
+ matrixWorldInverse,
+ buffer,
+ } = args;
+
+ const chunks = _getObjectsCull(
+ hmdPosition,
+ projectionMatrix,
+ matrixWorldInverse
+ );
protocolUtils.stringifyObjectsCull(chunks, buffer, 0);
- postMessage({
- type: 'response',
- args: [id],
- result: buffer,
- }, [buffer]);
+ postMessage(
+ {
+ type: 'response',
+ args: [id],
+ result: buffer,
+ },
+ [buffer]
+ );
break;
}
case 'getHoveredObjects': {
- const {id, args: {buffer}} = data;
+ const { id, args: { buffer } } = data;
const float32Array = new Float32Array(buffer);
const lx = float32Array[0];
@@ -1996,44 +2463,58 @@ self.onmessage = e => {
const rx = float32Array[3];
const ry = float32Array[4];
const rz = float32Array[5];
- _getHoveredTrackedObject(lx, ly, lz, buffer, 0)
+ _getHoveredTrackedObject(lx, ly, lz, buffer, 0);
_getHoveredTrackedObject(rx, ry, rz, buffer, 12 * 4);
- postMessage({
- type: 'response',
- args: [id],
- result: buffer,
- }, [buffer]);
+ postMessage(
+ {
+ type: 'response',
+ args: [id],
+ result: buffer,
+ },
+ [buffer]
+ );
break;
}
case 'getTeleportObject': {
- const {id, args: {buffer}} = data;
+ const { id, args: { buffer } } = data;
const float32Array = new Float32Array(buffer, 0, 3);
- _getTeleportObject(float32Array[0], float32Array[1], float32Array[2], buffer);
-
- postMessage({
- type: 'response',
- args: [id],
- result: buffer,
- }, [buffer]);
+ _getTeleportObject(
+ float32Array[0],
+ float32Array[1],
+ float32Array[2],
+ buffer
+ );
+
+ postMessage(
+ {
+ type: 'response',
+ args: [id],
+ result: buffer,
+ },
+ [buffer]
+ );
break;
}
case 'getBodyObject': {
- const {id, args: {buffer}} = data;
+ const { id, args: { buffer } } = data;
const float32Array = new Float32Array(buffer, 0, 3);
_getBodyObject(float32Array[0], float32Array[1], float32Array[2], buffer);
- postMessage({
- type: 'response',
- args: [id],
- result: buffer,
- }, [buffer]);
+ postMessage(
+ {
+ type: 'response',
+ args: [id],
+ result: buffer,
+ },
+ [buffer]
+ );
break;
}
case 'response': {
- const {id, result} = data;
+ const { id, result } = data;
queues[id](result);
queues[id] = null;
@@ -2054,7 +2535,11 @@ const _getTerrainCull = (hmdPosition, projectionMatrix, matrixWorldInverse) => {
const resultSize = NUM_MAP_CHUNK_MESHES * (1 + NUM_RENDER_GROUPS * 6);
const resultOffset = Module._malloc(resultSize * 4);
allocator.offsets.push(resultOffset);
- const groups = new Uint32Array(Module.HEAP8.buffer, Module.HEAP8.byteOffset + resultOffset, resultSize);
+ const groups = new Uint32Array(
+ Module.HEAP8.buffer,
+ Module.HEAP8.byteOffset + resultOffset,
+ resultSize
+ );
const groupsIndex = Module._cllTerrain(
allocator.allocBuffer(Float32Array.from(hmdPosition)),
@@ -2077,7 +2562,11 @@ const _getObjectsCull = (hmdPosition, projectionMatrix, matrixWorldInverse) => {
const resultSize = NUM_MAP_CHUNK_MESHES * (1 + NUM_RENDER_GROUPS * 2);
const resultOffset = Module._malloc(resultSize * 4);
allocator.offsets.push(resultOffset);
- const groups = new Uint32Array(Module.HEAP8.buffer, Module.HEAP8.byteOffset + resultOffset, resultSize);
+ const groups = new Uint32Array(
+ Module.HEAP8.buffer,
+ Module.HEAP8.byteOffset + resultOffset,
+ resultSize
+ );
const groupsIndex = Module._cllObjects(
allocator.allocBuffer(Float32Array.from(hmdPosition)),