mirror of
https://github.com/misskey-dev/misskey.git
synced 2026-08-03 22:05:55 +00:00
syuilo
408 lines
15 KiB
TypeScript
408 lines
15 KiB
TypeScript
/*
|
|
* SPDX-FileCopyrightText: syuilo and misskey-project
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
*/
|
|
|
|
import * as BABYLON from '@babylonjs/core';
|
|
import { registerBuiltInLoaders } from '@babylonjs/loaders/dynamic.js';
|
|
import { GridMaterial } from '@babylonjs/materials';
|
|
import { camelToKebab, WORLD_SCALE, cm, getMeshesBoundingBox, Timer, sleep } from '../utility.js';
|
|
import { getObjectDef } from './object-defs.js';
|
|
import { SYSTEM_MESH_NAMES, ModelManager, GRAPHICS_QUALITY } from './utility.js';
|
|
import type { RoomObjectInstance } from './object.js';
|
|
import { genId } from '@/utility/id.js';
|
|
import { deepClone } from '@/utility/clone.js';
|
|
import { store } from '@/store.js';
|
|
|
|
export async function createRoomObjectPreviewEngine(canvas: HTMLCanvasElement) {
|
|
const babylonEngine = new BABYLON.WebGPUEngine(canvas, { doNotHandleContextLost: true, powerPreference: 'low-power' });
|
|
babylonEngine.compatibilityMode = false;
|
|
babylonEngine.enableOfflineSupport = false;
|
|
await babylonEngine.initAsync();
|
|
return new RoomObjectPreviewEngine({ canvas, engine: babylonEngine });
|
|
}
|
|
|
|
export class RoomObjectPreviewEngine {
|
|
private canvas: HTMLCanvasElement;
|
|
private engine: BABYLON.WebGPUEngine;
|
|
private scene: BABYLON.Scene;
|
|
private sr: BABYLON.SnapshotRenderingHelper;
|
|
private shadowGenerator: BABYLON.ShadowGenerator;
|
|
private camera: BABYLON.ArcRotateCamera;
|
|
private objectMesh: BABYLON.Mesh | null = null;
|
|
private objectInstance: RoomObjectInstance | null = null;
|
|
private objectOptions: any = null;
|
|
private objectType: string | null = null;
|
|
private envMapIndoor: BABYLON.CubeTexture;
|
|
private roomLight: BABYLON.SpotLight;
|
|
private zGridPreviewPlane: BABYLON.Mesh;
|
|
private timerForEachObject: Timer | null = null;
|
|
private pipeline: BABYLON.DefaultRenderingPipeline;
|
|
private fps: number | null = null;
|
|
private disposed = false;
|
|
|
|
constructor(options: {
|
|
canvas: HTMLCanvasElement;
|
|
engine: BABYLON.WebGPUEngine;
|
|
}) {
|
|
this.canvas = options.canvas;
|
|
|
|
registerBuiltInLoaders();
|
|
|
|
this.engine = options.engine;
|
|
this.scene = new BABYLON.Scene(this.engine);
|
|
this.scene.autoClear = false;
|
|
this.scene.skipPointerMovePicking = true;
|
|
|
|
this.sr = new BABYLON.SnapshotRenderingHelper(this.scene);
|
|
|
|
this.camera = new BABYLON.ArcRotateCamera('camera', -Math.PI / 2, Math.PI / 2.5, cm(300), new BABYLON.Vector3(0, cm(90), 0), this.scene);
|
|
|
|
this.envMapIndoor = BABYLON.CubeTexture.CreateFromPrefilteredData('/client-assets/room/indoor.env', this.scene);
|
|
this.envMapIndoor.boundingBoxSize = new BABYLON.Vector3(cm(500), cm(500), cm(500));
|
|
this.envMapIndoor.level = 0.6;
|
|
|
|
const ambientLight = new BABYLON.HemisphericLight('ambientLight', new BABYLON.Vector3(0, 1, -0.5), this.scene);
|
|
ambientLight.diffuse = new BABYLON.Color3(1.0, 1.0, 1.0);
|
|
ambientLight.intensity = 0.3;
|
|
//ambientLight.intensity = 0;
|
|
|
|
this.roomLight = new BABYLON.SpotLight('roomLight', new BABYLON.Vector3(cm(50), cm(249), cm(50)), new BABYLON.Vector3(0, -1, 0), 16, 8, this.scene);
|
|
this.roomLight.diffuse = new BABYLON.Color3(1.0, 0.9, 0.8);
|
|
this.roomLight.shadowMinZ = cm(10);
|
|
this.roomLight.shadowMaxZ = cm(500);
|
|
this.roomLight.radius = cm(30);
|
|
this.roomLight.intensity = 10 * WORLD_SCALE * WORLD_SCALE;
|
|
|
|
this.shadowGenerator = new BABYLON.ShadowGenerator(1024, this.roomLight);
|
|
this.shadowGenerator.forceBackFacesOnly = true;
|
|
this.shadowGenerator.bias = 0.0001;
|
|
this.shadowGenerator.usePercentageCloserFiltering = true;
|
|
this.shadowGenerator.filteringQuality = BABYLON.ShadowGenerator.QUALITY_HIGH;
|
|
this.shadowGenerator.getShadowMap().refreshRate = 60;
|
|
|
|
const gridMaterial = new GridMaterial('grid', this.scene);
|
|
gridMaterial.lineColor = store.s.darkMode ? new BABYLON.Color3(1, 1, 1) : new BABYLON.Color3(0, 0, 0);
|
|
gridMaterial.mainColor = new BABYLON.Color3(0, 0, 0);
|
|
gridMaterial.minorUnitVisibility = 1;
|
|
gridMaterial.opacity = 0.05;
|
|
gridMaterial.gridRatio = cm(10);
|
|
|
|
this.zGridPreviewPlane = BABYLON.MeshBuilder.CreatePlane('zGridPreviewPlane', { width: cm(300), height: cm(300) }, this.scene);
|
|
this.zGridPreviewPlane.material = gridMaterial;
|
|
this.zGridPreviewPlane.rotation = new BABYLON.Vector3(Math.PI / 2, 0, 0);
|
|
|
|
const gl = new BABYLON.GlowLayer('glow', this.scene, {
|
|
blurKernelSize: 64,
|
|
});
|
|
gl.intensity = 0.5;
|
|
this.scene.setRenderingAutoClearDepthStencil(gl.renderingGroupId, false);
|
|
this.sr.updateMeshesForEffectLayer(gl);
|
|
|
|
this.pipeline = new BABYLON.DefaultRenderingPipeline('default', true, this.scene);
|
|
this.pipeline.samples = 4;
|
|
this.pipeline.bloomEnabled = true;
|
|
this.pipeline.bloomThreshold = 0.95;
|
|
this.pipeline.bloomWeight = 0.1;
|
|
this.pipeline.bloomKernel = 256;
|
|
this.pipeline.bloomScale = 2;
|
|
this.pipeline.sharpenEnabled = true;
|
|
this.pipeline.sharpen.edgeAmount = 0.5;
|
|
|
|
if (_DEV_) {
|
|
window.takeScreenshot = () => {
|
|
const def = getObjectDef(this.objectType);
|
|
|
|
const boundingInfo = getMeshesBoundingBox(this.objectMesh!.getChildMeshes().filter(m => m.isEnabled() && m.isVisible));
|
|
|
|
const camera = new BABYLON.ArcRotateCamera('camera', Math.PI / 4, Math.PI / 2.5, cm(300), new BABYLON.Vector3(0, cm(90), 0), this.scene);
|
|
camera.inputs.clear();
|
|
camera.minZ = cm(1);
|
|
camera.maxZ = cm(100000);
|
|
camera.mode = BABYLON.Camera.ORTHOGRAPHIC_CAMERA;
|
|
camera.setTarget(boundingInfo.center);
|
|
if (def.placement === 'wall' || def.placement === 'side') {
|
|
} else if (def.placement === 'ceiling' || def.placement === 'bottom') {
|
|
camera.beta = Math.PI / 1.75;
|
|
} else {
|
|
}
|
|
|
|
// zoom to fit
|
|
const size = boundingInfo.extendSize;
|
|
const distance = Math.max(size.x, size.y, size.z) * 3;
|
|
camera.orthoTop = (distance / 2);
|
|
camera.orthoBottom = -(distance / 2);
|
|
camera.orthoLeft = -(distance / 2);
|
|
camera.orthoRight = (distance / 2);
|
|
|
|
this.scene.activeCamera = camera;
|
|
|
|
this.zGridPreviewPlane.isVisible = false;
|
|
|
|
window.setTimeout(() => {
|
|
BABYLON.Tools.CreateScreenshotUsingRenderTarget(this.engine, camera, { width: 256, height: 256 }, undefined, undefined, undefined, true, `${camelToKebab(this.objectType!)}.png`);
|
|
}, 100);
|
|
};
|
|
}
|
|
}
|
|
|
|
private currentRafId: number | null = null;
|
|
|
|
private startRenderLoop() {
|
|
if (this.fps == null) {
|
|
this.engine.runRenderLoop(() => {
|
|
this.scene.render();
|
|
});
|
|
} else {
|
|
let then = 0;
|
|
const interval = 1000 / this.fps;
|
|
|
|
const renderLoop = (timeStamp: number) => {
|
|
if (this.disposed) return;
|
|
|
|
// workerで実行される可能性がある
|
|
this.currentRafId = requestAnimationFrame(renderLoop);
|
|
|
|
const delta = timeStamp - then;
|
|
if (delta <= interval) return;
|
|
then = timeStamp - (delta % interval);
|
|
|
|
this.engine.beginFrame();
|
|
this.scene.render();
|
|
this.engine.endFrame();
|
|
};
|
|
|
|
// workerで実行される可能性がある
|
|
this.currentRafId = requestAnimationFrame(renderLoop);
|
|
}
|
|
}
|
|
|
|
public pauseRender() { // TODO: srと同じく参照カウント方式にした方が便利そう
|
|
this.engine.stopRenderLoop();
|
|
if (this.currentRafId != null) {
|
|
// workerで実行される可能性がある
|
|
cancelAnimationFrame(this.currentRafId);
|
|
this.currentRafId = null;
|
|
}
|
|
}
|
|
|
|
public resumeRender() {
|
|
this.startRenderLoop();
|
|
}
|
|
|
|
public async init() {
|
|
await this.scene.whenReadyAsync();
|
|
this.sr.enableSnapshotRendering();
|
|
}
|
|
|
|
public async load(type: string) {
|
|
this.sr.disableSnapshotRendering();
|
|
this.clear();
|
|
|
|
const id = genId();
|
|
const def = getObjectDef(type);
|
|
this.objectOptions = deepClone(def.options.default);
|
|
for (const [key, value] of Object.entries(def.options.schema)) {
|
|
if (value.type === 'seed') {
|
|
this.objectOptions[key] = Math.floor(Math.random() * 1000);
|
|
}
|
|
}
|
|
|
|
await this.loadObject({
|
|
type,
|
|
options: this.objectOptions,
|
|
id,
|
|
});
|
|
|
|
const boundingInfo = getMeshesBoundingBox(this.objectMesh!.getChildMeshes().filter(m => m.isEnabled() && m.isVisible), true);
|
|
|
|
this.pipeline.removeCamera(this.camera);
|
|
this.camera.dispose();
|
|
|
|
this.camera = new BABYLON.ArcRotateCamera('camera', Math.PI / 2, Math.PI / 2.5, cm(300), new BABYLON.Vector3(0, cm(90), 0), this.scene);
|
|
this.camera.attachControl(this.canvas);
|
|
this.camera.minZ = cm(1);
|
|
this.camera.maxZ = cm(100000);
|
|
this.camera.fov = 0.5;
|
|
this.camera.lowerRadiusLimit = cm(50);
|
|
this.camera.upperRadiusLimit = cm(1000);
|
|
this.camera.useAutoRotationBehavior = true;
|
|
this.camera.autoRotationBehavior!.idleRotationSpeed = 0.3;
|
|
this.camera.panningSensibility = 0;
|
|
this.camera.wheelDeltaPercentage = 0.01;
|
|
//this.camera.mode = BABYLON.Camera.ORTHOGRAPHIC_CAMERA;
|
|
this.camera.setTarget(new BABYLON.Vector3(0, boundingInfo.centerWorld.y, 0));
|
|
|
|
if (def.placement === 'wall' || def.placement === 'side') {
|
|
this.camera.lowerBetaLimit = 0;
|
|
this.camera.upperBetaLimit = Math.PI;
|
|
this.zGridPreviewPlane.rotation = new BABYLON.Vector3(0, Math.PI, 0);
|
|
} else if (def.placement === 'ceiling' || def.placement === 'bottom') {
|
|
this.camera.lowerBetaLimit = (Math.PI / 2) - 0.1;
|
|
this.camera.upperBetaLimit = Math.PI;
|
|
this.camera.beta = Math.PI / 1.75;
|
|
this.zGridPreviewPlane.rotation = new BABYLON.Vector3(-Math.PI / 2, 0, 0);
|
|
} else {
|
|
this.camera.lowerBetaLimit = 0;
|
|
this.camera.upperBetaLimit = (Math.PI / 2) + 0.1;
|
|
this.zGridPreviewPlane.rotation = new BABYLON.Vector3(Math.PI / 2, 0, 0);
|
|
}
|
|
|
|
// zoom to fit
|
|
const size = boundingInfo.extendSize;
|
|
const distance = Math.max(size.x, size.y, size.z) * 2;
|
|
this.camera.radius = distance * 3;
|
|
//this.camera.orthoLeft = -distance;
|
|
//this.camera.orthoRight = distance;
|
|
//this.camera.orthoTop = distance;
|
|
//this.camera.orthoBottom = -distance;
|
|
|
|
this.pipeline.addCamera(this.camera);
|
|
|
|
this.sr.enableSnapshotRendering();
|
|
|
|
return {
|
|
id,
|
|
objectInstance: this.objectInstance,
|
|
options: this.objectOptions,
|
|
};
|
|
}
|
|
|
|
private async loadObject(args: {
|
|
type: string;
|
|
options: any;
|
|
id: string;
|
|
}) {
|
|
const def = getObjectDef(args.type);
|
|
|
|
const root = new BABYLON.Mesh(`object_${args.type}`, this.scene);
|
|
|
|
const filePath = def.path != null ? `/client-assets/room/objects/${def.path}.glb` : `/client-assets/room/objects/${camelToKebab(args.type)}/${camelToKebab(args.type)}.glb`;
|
|
const loaderResult = await BABYLON.LoadAssetContainerAsync(filePath, this.scene);
|
|
|
|
// babylonによって自動で追加される右手系変換用ノード
|
|
const subRoot = loaderResult.meshes[0];
|
|
subRoot.scaling = subRoot.scaling.scale(WORLD_SCALE);// cmをmに
|
|
|
|
def.treatLoaderResult?.(loaderResult);
|
|
|
|
root.addChild(subRoot);
|
|
|
|
const updateMeshes = (meshes: BABYLON.AbstractMesh[]) => {
|
|
for (const mesh of meshes) {
|
|
// シェイプキー(morph)を考慮してbounding boxを更新するために必要
|
|
mesh.refreshBoundingInfo({ applyMorph: true });
|
|
|
|
if (SYSTEM_MESH_NAMES.some(n => mesh.name.includes(n))) {
|
|
mesh.receiveShadows = false;
|
|
mesh.isVisible = false;
|
|
} else {
|
|
if (def.receiveShadows !== false) mesh.receiveShadows = true;
|
|
if (def.castShadows !== false) {
|
|
this.shadowGenerator.addShadowCaster(mesh);
|
|
}
|
|
|
|
if (mesh.material) {
|
|
if (mesh.material instanceof BABYLON.MultiMaterial) {
|
|
for (const subMat of mesh.material.subMaterials) {
|
|
(subMat as BABYLON.PBRMaterial).reflectionTexture = this.envMapIndoor;
|
|
(subMat as BABYLON.PBRMaterial).useGLTFLightFalloff = true; // Clustered Lightingではphysical falloffを持つマテリアルはアーチファクトが発生する https://doc.babylonjs.com/features/featuresDeepDive/lights/clusteredLighting/#materials-with-a-physical-falloff-may-cause-artefacts
|
|
(subMat as BABYLON.PBRMaterial).anisotropy.isEnabled = false; // なんかきれいにレンダリングされないため
|
|
}
|
|
} else {
|
|
(mesh.material as BABYLON.PBRMaterial).reflectionTexture = this.envMapIndoor;
|
|
(mesh.material as BABYLON.PBRMaterial).useGLTFLightFalloff = true; // Clustered Lightingではphysical falloffを持つマテリアルはアーチファクトが発生する https://doc.babylonjs.com/features/featuresDeepDive/lights/clusteredLighting/#materials-with-a-physical-falloff-may-cause-artefacts
|
|
(mesh.material as BABYLON.PBRMaterial).anisotropy.isEnabled = false; // なんかきれいにレンダリングされないため
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!this.scene.meshes.includes(mesh)) this.scene.addMesh(mesh);
|
|
}
|
|
};
|
|
|
|
const model = new ModelManager(subRoot, loaderResult.meshes.filter(m => !m.isDisposed() && m !== subRoot), def.hasTexture, (meshes) => {
|
|
updateMeshes(meshes);
|
|
});
|
|
//model.updatedCallback = () => {
|
|
// this.sr.disableSnapshotRendering();
|
|
// this.sr.enableSnapshotRendering();
|
|
//};
|
|
|
|
updateMeshes(subRoot.getChildMeshes());
|
|
|
|
this.timerForEachObject = new Timer();
|
|
|
|
const objectInstance = await def.createInstance({
|
|
room: null,
|
|
scene: this.scene,
|
|
sr: this.sr,
|
|
root,
|
|
options: args.options,
|
|
model,
|
|
id: args.id,
|
|
timer: this.timerForEachObject,
|
|
graphicsQuality: GRAPHICS_QUALITY.MEDIUM,
|
|
});
|
|
|
|
objectInstance.onInited?.();
|
|
|
|
this.objectType = args.type;
|
|
this.objectInstance = objectInstance;
|
|
this.objectMesh = root;
|
|
}
|
|
|
|
public updateObjectOption(key: string, value: any) {
|
|
this.sr.disableSnapshotRendering();
|
|
this.objectOptions[key] = value;
|
|
this.objectInstance?.onOptionsUpdated?.([key, value]);
|
|
this.sr.enableSnapshotRendering();
|
|
return this.objectOptions;
|
|
}
|
|
|
|
public clear() {
|
|
this.sr.disableSnapshotRendering();
|
|
if (this.timerForEachObject != null) {
|
|
this.timerForEachObject.dispose();
|
|
this.timerForEachObject = null;
|
|
}
|
|
if (this.objectInstance != null) {
|
|
this.objectInstance.dispose?.();
|
|
this.objectInstance = null;
|
|
this.objectOptions = null;
|
|
this.objectMesh!.dispose();
|
|
this.objectMesh = null;
|
|
this.objectType = null;
|
|
}
|
|
this.sr.enableSnapshotRendering();
|
|
}
|
|
|
|
public resize() {
|
|
// 一旦snapshot renderingを無効にしておかないとエラーが出る(babylonのバグ？)
|
|
// ~~...が、一旦無効にしたらしたで複数のマテリアルがそれぞれ入れ替わる(?)という謎の現象が発生するためコメントアウトしとく(エラー出てもレンダリングが止まったりするわけでもないし)~~
|
|
// ↑追記: engine.resizeした後に一瞬待つことで回避できることが判明
|
|
this.sr.disableSnapshotRendering();
|
|
this.engine.resize();
|
|
// workerで実行される可能性がある
|
|
// eslint-disable-next-line no-restricted-globals
|
|
setTimeout(() => {
|
|
this.sr.enableSnapshotRendering();
|
|
}, 1);
|
|
}
|
|
|
|
public destroy() {
|
|
this.engine.stopRenderLoop();
|
|
if (this.currentRafId != null) {
|
|
// workerで実行される可能性がある
|
|
cancelAnimationFrame(this.currentRafId);
|
|
this.currentRafId = null;
|
|
}
|
|
if (this.timerForEachObject != null) {
|
|
this.timerForEachObject.dispose();
|
|
}
|
|
this.engine.dispose();
|
|
this.scene.dispose();
|
|
this.disposed = true;
|
|
}
|
|
}
|