@realsee/five 6.8.0-alpha.26 → 6.8.0-alpha.27
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/ai_guides/features/event.md +12 -7
- package/docs/classes/five.Five.html +17 -17
- package/docs/documents/features_event.html +5 -2
- package/docs/interfaces/five.PanoramaControllerCustomInitArgs.html +9 -9
- package/docs/interfaces/five.VRPanoramaControllerCustomInitArgs.html +8 -8
- package/docs/interfaces/five.XRPanoramaControllerCustomInitArgs.html +8 -8
- package/five/index.js +54 -54
- package/five/index.mjs +403 -323
- package/gltf-loader/index.js +2 -2
- package/gltf-loader/index.mjs +2 -2
- package/line/index.js +2 -2
- package/line/index.mjs +2 -2
- package/package.json +1 -1
- package/plugins/index.js +1 -1
- package/plugins/index.mjs +1 -1
- package/react/index.js +1 -1
- package/react/index.mjs +1 -1
- package/shader-lib/index.js +1 -1
- package/shader-lib/index.mjs +1 -1
- package/sticker/index.js +2 -2
- package/sticker/index.mjs +2 -2
- package/umd/five-gltf-loader.js +2 -2
- package/umd/five-line.js +2 -2
- package/umd/five-plugins.js +1 -1
- package/umd/five-react.js +1 -1
- package/umd/five-shader-lib.js +1 -1
- package/umd/five-sticker.js +2 -2
- package/umd/five-vfx.js +1 -1
- package/umd/five-vue.js +1 -1
- package/umd/five.js +6 -6
- package/vfx/index.js +1 -1
- package/vfx/index.mjs +1 -1
- package/vue/index.js +1 -1
- package/vue/index.mjs +1 -1
- package/work-downloader/index.js +1 -1
- package/work-downloader/index.mjs +1 -1
package/five/index.mjs
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
* @license
|
|
3
3
|
* @realsee/five
|
|
4
4
|
* Generated: 4/1/2026
|
|
5
|
-
* Version: 6.8.0-alpha.
|
|
5
|
+
* Version: 6.8.0-alpha.27
|
|
6
6
|
* Terms:
|
|
7
7
|
* Realsee SDK License Agreement
|
|
8
8
|
* Update: July 28, 2021
|
|
@@ -19487,144 +19487,144 @@ var Kh = new e.Box3(), qh = new e.Vector3(), Jh = {
|
|
|
19487
19487
|
}, 0).catch(K);
|
|
19488
19488
|
}
|
|
19489
19489
|
onTapGesture(t) {
|
|
19490
|
-
var n;
|
|
19491
19490
|
this.userAction = t.userAction, this.stopMomentumMovement();
|
|
19492
|
-
let
|
|
19493
|
-
if (!
|
|
19491
|
+
let n = t.center.raycaster, r = this.getForwardObserverOrNot(n);
|
|
19492
|
+
if (!r) this.emit("gesture.tap", t);
|
|
19494
19493
|
else {
|
|
19495
|
-
let
|
|
19494
|
+
let n = {
|
|
19496
19495
|
longitude: this.camera.pose.longitude,
|
|
19497
19496
|
latitude: 0
|
|
19498
|
-
},
|
|
19497
|
+
}, i = Object.assign(Object.assign({}, t.state), {
|
|
19499
19498
|
mode: "Panorama",
|
|
19500
|
-
workCode:
|
|
19501
|
-
panoIndex:
|
|
19502
|
-
longitude:
|
|
19503
|
-
latitude:
|
|
19504
|
-
offset:
|
|
19499
|
+
workCode: r.work.workCode,
|
|
19500
|
+
panoIndex: r.panoIndex,
|
|
19501
|
+
longitude: n.longitude,
|
|
19502
|
+
latitude: n.latitude,
|
|
19503
|
+
offset: r ? r.position.clone() : new e.Vector3(),
|
|
19505
19504
|
distance: 0
|
|
19506
19505
|
});
|
|
19507
|
-
if (t.state =
|
|
19506
|
+
if (t.state = i, this.emit("gesture.tap", t), !t.defaultPrevented && (this.emit("pano.select", Q("pano.select", {
|
|
19508
19507
|
prevPano: this.currentPano,
|
|
19509
19508
|
pano: {
|
|
19510
|
-
panoIndex:
|
|
19511
|
-
workCode:
|
|
19509
|
+
panoIndex: i.panoIndex,
|
|
19510
|
+
workCode: i.workCode
|
|
19512
19511
|
},
|
|
19513
|
-
state:
|
|
19512
|
+
state: i,
|
|
19514
19513
|
userAction: t.userAction,
|
|
19515
|
-
options:
|
|
19514
|
+
options: n,
|
|
19516
19515
|
progress: 0,
|
|
19517
19516
|
error: null
|
|
19518
|
-
})),
|
|
19519
|
-
let t = this.pendingTextureId = $t(),
|
|
19520
|
-
panoIndex:
|
|
19521
|
-
workCode:
|
|
19522
|
-
},
|
|
19523
|
-
right:
|
|
19524
|
-
left:
|
|
19525
|
-
up:
|
|
19526
|
-
down:
|
|
19527
|
-
front:
|
|
19528
|
-
back:
|
|
19529
|
-
},
|
|
19517
|
+
})), r && r.active)) {
|
|
19518
|
+
let t = this.pendingTextureId = $t(), a = {
|
|
19519
|
+
panoIndex: r.panoIndex,
|
|
19520
|
+
workCode: r.work.workCode
|
|
19521
|
+
}, o = Z(a), s = {
|
|
19522
|
+
right: r.images.work.getURL(r.images.right),
|
|
19523
|
+
left: r.images.work.getURL(r.images.left),
|
|
19524
|
+
up: r.images.work.getURL(r.images.up),
|
|
19525
|
+
down: r.images.work.getURL(r.images.down),
|
|
19526
|
+
front: r.images.work.getURL(r.images.front),
|
|
19527
|
+
back: r.images.work.getURL(r.images.back)
|
|
19528
|
+
}, c = this.imageOptions.transform, l = Object.assign({ key: `pano.${o}` }, mr(this.imageOptions, [
|
|
19530
19529
|
"format",
|
|
19531
19530
|
"size",
|
|
19532
19531
|
"quality",
|
|
19533
19532
|
"sharpen",
|
|
19534
19533
|
"forceUseExifOrientation",
|
|
19535
19534
|
"mappings"
|
|
19536
|
-
])),
|
|
19537
|
-
|
|
19538
|
-
|
|
19539
|
-
|
|
19540
|
-
]),
|
|
19541
|
-
if (f.pano0 && f.pano0.map.name === d ? p = f.pano0 : f.pano1 && f.pano1.map.name === d && (p = f.pano1), p) f.pano0 && f.pano0.map !== p.map && f.pano0.map.dispose(), f.pano1 && f.pano1.map !== p.map && f.pano1.map !== ((n = f.pano0) == null ? void 0 : n.map) && f.pano1.map.dispose(), f.set({
|
|
19542
|
-
pano0: p,
|
|
19543
|
-
pano1: p
|
|
19544
|
-
}), this.emit("pano.request", Q("pano.request", {
|
|
19545
|
-
userAction: !0,
|
|
19535
|
+
])), u = "pano:" + up([
|
|
19536
|
+
s,
|
|
19537
|
+
l,
|
|
19538
|
+
c
|
|
19539
|
+
]), d = this.modelScene.parameter, f = Ch("pano.prepare", {
|
|
19546
19540
|
prevPano: this.currentPano,
|
|
19547
|
-
pano:
|
|
19548
|
-
|
|
19549
|
-
|
|
19550
|
-
|
|
19551
|
-
|
|
19552
|
-
|
|
19553
|
-
|
|
19554
|
-
|
|
19555
|
-
|
|
19556
|
-
|
|
19557
|
-
|
|
19541
|
+
pano: a
|
|
19542
|
+
});
|
|
19543
|
+
if (this.emit("pano.prepare", f), f.defaultPrevented) {
|
|
19544
|
+
this.pendingTextureId = null;
|
|
19545
|
+
return;
|
|
19546
|
+
}
|
|
19547
|
+
let p;
|
|
19548
|
+
d.pano0 && d.pano0.map.name === u ? p = d.pano0 : d.pano1 && d.pano1.map.name === u && (p = d.pano1), p ? Promise.resolve().then(() => wh(f)).catch((e) => Gh(e)).then((e) => {
|
|
19549
|
+
var t;
|
|
19550
|
+
e instanceof Error ? (this.pendingTextureId = null, e.message && this.emit("error", e)) : (d.pano0 && d.pano0.map !== p.map && d.pano0.map.dispose(), d.pano1 && d.pano1.map !== p.map && d.pano1.map !== ((t = d.pano0) == null ? void 0 : t.map) && d.pano1.map.dispose(), d.set({
|
|
19551
|
+
pano0: p,
|
|
19552
|
+
pano1: p
|
|
19553
|
+
}), this.emit("pano.request", Q("pano.request", {
|
|
19554
|
+
userAction: !0,
|
|
19558
19555
|
prevPano: this.currentPano,
|
|
19559
|
-
pano:
|
|
19560
|
-
|
|
19561
|
-
|
|
19562
|
-
this.emit("pano.texture.load", Q("pano.texture.load", {
|
|
19563
|
-
error: null,
|
|
19564
|
-
progress: 0,
|
|
19565
|
-
meta: null,
|
|
19566
|
-
pano: o
|
|
19567
|
-
}));
|
|
19568
|
-
}).then(() => this.textureLoader.loadCubeTexture(c, {
|
|
19569
|
-
imageURL: {
|
|
19570
|
-
transform: l,
|
|
19571
|
-
options: u
|
|
19556
|
+
pano: {
|
|
19557
|
+
panoIndex: i.panoIndex,
|
|
19558
|
+
workCode: i.workCode
|
|
19572
19559
|
},
|
|
19573
|
-
|
|
19574
|
-
|
|
19575
|
-
|
|
19576
|
-
|
|
19577
|
-
|
|
19578
|
-
|
|
19579
|
-
|
|
19580
|
-
|
|
19581
|
-
|
|
19582
|
-
|
|
19583
|
-
|
|
19584
|
-
})
|
|
19585
|
-
|
|
19586
|
-
|
|
19587
|
-
|
|
19588
|
-
|
|
19589
|
-
|
|
19590
|
-
|
|
19591
|
-
|
|
19592
|
-
|
|
19593
|
-
|
|
19594
|
-
|
|
19595
|
-
|
|
19596
|
-
|
|
19597
|
-
|
|
19598
|
-
|
|
19599
|
-
|
|
19600
|
-
|
|
19601
|
-
|
|
19602
|
-
|
|
19603
|
-
|
|
19604
|
-
|
|
19605
|
-
|
|
19606
|
-
|
|
19607
|
-
|
|
19608
|
-
pano1: h
|
|
19609
|
-
}), this.emit("pano.request", Q("pano.request", {
|
|
19610
|
-
userAction: !0,
|
|
19611
|
-
prevPano: this.currentPano,
|
|
19612
|
-
pano: {
|
|
19613
|
-
panoIndex: a.panoIndex,
|
|
19614
|
-
workCode: a.workCode
|
|
19615
|
-
},
|
|
19616
|
-
progress: 0,
|
|
19617
|
-
state: a,
|
|
19618
|
-
options: r,
|
|
19619
|
-
error: null
|
|
19620
|
-
}));
|
|
19621
|
-
} else {
|
|
19622
|
-
let e = null;
|
|
19623
|
-
if (n instanceof Error ? e || (e = n) : n.body.dispose(), o instanceof Error && (e || (e = o)), this.destroyed || this.pendingTextureId !== t) return;
|
|
19624
|
-
this.pendingTextureId = null, this.emit("error", e);
|
|
19560
|
+
progress: 0,
|
|
19561
|
+
state: i,
|
|
19562
|
+
options: n,
|
|
19563
|
+
error: null
|
|
19564
|
+
})));
|
|
19565
|
+
}) : Promise.all([Promise.resolve().then(() => {
|
|
19566
|
+
this.emit("pano.texture.load", Q("pano.texture.load", {
|
|
19567
|
+
error: null,
|
|
19568
|
+
progress: 0,
|
|
19569
|
+
meta: null,
|
|
19570
|
+
pano: a
|
|
19571
|
+
}));
|
|
19572
|
+
}).then(() => this.textureLoader.loadCubeTexture(s, {
|
|
19573
|
+
imageURL: {
|
|
19574
|
+
transform: c,
|
|
19575
|
+
options: l
|
|
19576
|
+
},
|
|
19577
|
+
format: e.RGBFormat,
|
|
19578
|
+
viaAjax: !0,
|
|
19579
|
+
fetcher: yf(this.fiveId, r.work)
|
|
19580
|
+
}, void 0, void 0, void 0, this.renderer)).catch((e) => {
|
|
19581
|
+
let t = Gh(e);
|
|
19582
|
+
return this.emit("pano.texture.error", Q("pano.texture.error", {
|
|
19583
|
+
error: t,
|
|
19584
|
+
progress: 0,
|
|
19585
|
+
meta: null,
|
|
19586
|
+
pano: a
|
|
19587
|
+
})), t;
|
|
19588
|
+
}), Promise.resolve().then(() => wh(f)).catch((e) => Gh(e))]).then(([a, s]) => {
|
|
19589
|
+
var c, l;
|
|
19590
|
+
if (!(a instanceof Error) && !(s instanceof Error)) {
|
|
19591
|
+
let { body: s } = a;
|
|
19592
|
+
if (this.destroyed || this.pendingTextureId !== t) {
|
|
19593
|
+
s.dispose();
|
|
19594
|
+
return;
|
|
19625
19595
|
}
|
|
19626
|
-
|
|
19627
|
-
|
|
19596
|
+
this.pendingTextureId = null, s.name = u;
|
|
19597
|
+
let f = Array.isArray(s.image) ? s.image[0] : s.image, p = (c = f == null ? void 0 : f.width) == null ? 2048 : c, m = r.images.histogram;
|
|
19598
|
+
m || (m = new pm().formPixels(zh(this.renderer, s, !0, lm).data), r.images.histogram = m);
|
|
19599
|
+
let h = {
|
|
19600
|
+
panoId: o,
|
|
19601
|
+
map: s,
|
|
19602
|
+
mapSize: p,
|
|
19603
|
+
mapHistogram: new e.Vector4().fromArray(m.toArray()),
|
|
19604
|
+
matrix: r.matrix.clone().premultiply(r.work.transform),
|
|
19605
|
+
zoom: 1
|
|
19606
|
+
};
|
|
19607
|
+
d.pano0 && d.pano0.map.dispose(), d.pano1 && d.pano1.map !== ((l = d.pano0) == null ? void 0 : l.map) && d.pano1.map.dispose(), d.set({
|
|
19608
|
+
pano0: h,
|
|
19609
|
+
pano1: h
|
|
19610
|
+
}), this.emit("pano.request", Q("pano.request", {
|
|
19611
|
+
userAction: !0,
|
|
19612
|
+
prevPano: this.currentPano,
|
|
19613
|
+
pano: {
|
|
19614
|
+
panoIndex: i.panoIndex,
|
|
19615
|
+
workCode: i.workCode
|
|
19616
|
+
},
|
|
19617
|
+
progress: 0,
|
|
19618
|
+
state: i,
|
|
19619
|
+
options: n,
|
|
19620
|
+
error: null
|
|
19621
|
+
}));
|
|
19622
|
+
} else {
|
|
19623
|
+
let e = null;
|
|
19624
|
+
if (a instanceof Error ? e || (e = a) : a.body.dispose(), s instanceof Error && (e || (e = s)), this.destroyed || this.pendingTextureId !== t) return;
|
|
19625
|
+
this.pendingTextureId = null, e instanceof Error && e.message && this.emit("error", e);
|
|
19626
|
+
}
|
|
19627
|
+
});
|
|
19628
19628
|
}
|
|
19629
19629
|
}
|
|
19630
19630
|
}
|
|
@@ -20875,30 +20875,67 @@ var Gg = Vu, Kg = new e.Raycaster(), qg = new e.Vector3(), Jg = [
|
|
|
20875
20875
|
}
|
|
20876
20876
|
let g = "move-to-pano-" + c;
|
|
20877
20877
|
this.pending.add(g);
|
|
20878
|
-
let _ =
|
|
20879
|
-
|
|
20878
|
+
let _ = Ch("pano.prepare", {
|
|
20879
|
+
prevPano: this.currentPano,
|
|
20880
|
+
pano: t
|
|
20881
|
+
});
|
|
20882
|
+
if (this.emit("pano.prepare", _), _.defaultPrevented) {
|
|
20883
|
+
this.pending.delete(g);
|
|
20884
|
+
return;
|
|
20885
|
+
}
|
|
20886
|
+
let v = this.modelScene.parameter, y;
|
|
20887
|
+
if (v.pano0 && v.pano0.map.name === h ? y = v.pano0 : v.pano1 && v.pano1.map.name === h && (y = v.pano1), y) {
|
|
20880
20888
|
let r = {
|
|
20881
20889
|
panoId: c,
|
|
20882
20890
|
effect: s,
|
|
20883
20891
|
effectEasing: (o = n.effectEasing) == null ? Gg : o,
|
|
20884
20892
|
panoPicture: {
|
|
20885
|
-
panoId:
|
|
20886
|
-
map:
|
|
20887
|
-
mapHistogram:
|
|
20888
|
-
mapSize:
|
|
20893
|
+
panoId: y.panoId,
|
|
20894
|
+
map: y.map,
|
|
20895
|
+
mapHistogram: y.mapHistogram,
|
|
20896
|
+
mapSize: y.mapSize,
|
|
20889
20897
|
matrix: l.matrix.clone().premultiply(l.work.transform),
|
|
20890
20898
|
zoom: 1
|
|
20891
20899
|
},
|
|
20892
20900
|
position: l.position.clone().applyMatrix4(l.work.transform),
|
|
20893
20901
|
fixCameraTransform: new e.Matrix4()
|
|
20894
20902
|
};
|
|
20895
|
-
r.panoPicture && this.panoPictureObserverMap.set(r.panoPicture, l), this.pendingPanoTask = void 0,
|
|
20896
|
-
|
|
20897
|
-
|
|
20903
|
+
r.panoPicture && this.panoPictureObserverMap.set(r.panoPicture, l), this.pendingPanoTask = void 0, Promise.resolve().then(() => wh(_)).catch((e) => Gh(e)).then((e) => {
|
|
20904
|
+
var i, a;
|
|
20905
|
+
if (!(e instanceof Error)) this.pending.delete(g), this.pendingPanoTask = void 0, (i = this.panoMeshes.get(c)) == null || i.setProgress(0), this.doMoveToPano(t, r, n);
|
|
20906
|
+
else {
|
|
20907
|
+
let t = null;
|
|
20908
|
+
e instanceof Error && (t || (t = e));
|
|
20909
|
+
let r = Object.assign(Object.assign(Object.assign({}, this.currentPano), { mode: this.mode }), $(this.camera.pose));
|
|
20910
|
+
this.emit("pano.cancel", Q("pano.cancel", {
|
|
20911
|
+
error: t,
|
|
20912
|
+
userAction: this.userAction,
|
|
20913
|
+
options: n,
|
|
20914
|
+
prevPano: this.currentPano,
|
|
20915
|
+
pano: {
|
|
20916
|
+
panoIndex: l.panoIndex,
|
|
20917
|
+
workCode: l.work.workCode
|
|
20918
|
+
},
|
|
20919
|
+
progress: 0,
|
|
20920
|
+
state: r
|
|
20921
|
+
})), n.moveCancelCallback && n.moveCancelCallback(), this.emit("pano.error", Q("pano.error", {
|
|
20922
|
+
error: t,
|
|
20923
|
+
userAction: this.userAction,
|
|
20924
|
+
options: n,
|
|
20925
|
+
prevPano: this.currentPano,
|
|
20926
|
+
pano: {
|
|
20927
|
+
panoIndex: l.panoIndex,
|
|
20928
|
+
workCode: l.work.workCode
|
|
20929
|
+
},
|
|
20930
|
+
progress: 0,
|
|
20931
|
+
state: r
|
|
20932
|
+
})), t instanceof Error && t.message && this.emit("error", t), this.pending.delete(g), this.pendingPanoTask = void 0, (a = this.panoMeshes.get(c)) == null || a.setProgress(0);
|
|
20933
|
+
}
|
|
20934
|
+
});
|
|
20898
20935
|
return;
|
|
20899
20936
|
}
|
|
20900
|
-
let
|
|
20901
|
-
|
|
20937
|
+
let b = this.panoMeshes.get(c);
|
|
20938
|
+
b && b.tap && b.tap(), this.pendingPanoTask = {
|
|
20902
20939
|
panoId: c,
|
|
20903
20940
|
hash: h,
|
|
20904
20941
|
onLoad: (r) => {
|
|
@@ -20928,37 +20965,32 @@ var Gg = Vu, Kg = new e.Raycaster(), qg = new e.Vector3(), Jg = [
|
|
|
20928
20965
|
}
|
|
20929
20966
|
},
|
|
20930
20967
|
onError: (e) => {
|
|
20931
|
-
let
|
|
20932
|
-
this.emit("pano.
|
|
20968
|
+
let t = Object.assign(Object.assign(Object.assign({}, this.currentPano), { mode: this.mode }), $(this.camera.pose));
|
|
20969
|
+
this.emit("pano.cancel", Q("pano.cancel", {
|
|
20933
20970
|
error: e,
|
|
20934
20971
|
userAction: this.userAction,
|
|
20935
20972
|
options: n,
|
|
20936
20973
|
prevPano: this.currentPano,
|
|
20937
20974
|
pano: {
|
|
20938
|
-
panoIndex:
|
|
20939
|
-
workCode:
|
|
20975
|
+
panoIndex: l.panoIndex,
|
|
20976
|
+
workCode: l.work.workCode
|
|
20940
20977
|
},
|
|
20941
20978
|
progress: 0,
|
|
20942
|
-
state:
|
|
20943
|
-
})), this.emit("pano.
|
|
20979
|
+
state: t
|
|
20980
|
+
})), n.moveCancelCallback && n.moveCancelCallback(), this.emit("pano.error", Q("pano.error", {
|
|
20944
20981
|
error: e,
|
|
20945
20982
|
userAction: this.userAction,
|
|
20946
20983
|
options: n,
|
|
20947
20984
|
prevPano: this.currentPano,
|
|
20948
20985
|
pano: {
|
|
20949
|
-
panoIndex:
|
|
20950
|
-
workCode:
|
|
20986
|
+
panoIndex: l.panoIndex,
|
|
20987
|
+
workCode: l.work.workCode
|
|
20951
20988
|
},
|
|
20952
20989
|
progress: 0,
|
|
20953
|
-
state:
|
|
20954
|
-
})), this.emit("error", e)
|
|
20990
|
+
state: t
|
|
20991
|
+
})), e instanceof Error && e.message && this.emit("error", e);
|
|
20955
20992
|
}
|
|
20956
|
-
}
|
|
20957
|
-
let b = Ch("pano.prepare", {
|
|
20958
|
-
prevPano: this.currentPano,
|
|
20959
|
-
pano: t
|
|
20960
|
-
});
|
|
20961
|
-
this.emit("pano.prepare", b), Promise.all([Promise.resolve().then(() => {
|
|
20993
|
+
}, Promise.all([Promise.resolve().then(() => {
|
|
20962
20994
|
this.emit("pano.texture.load", Q("pano.texture.load", {
|
|
20963
20995
|
error: null,
|
|
20964
20996
|
progress: 0,
|
|
@@ -20988,11 +21020,8 @@ var Gg = Vu, Kg = new e.Raycaster(), qg = new e.Vector3(), Jg = [
|
|
|
20988
21020
|
progress: 0,
|
|
20989
21021
|
meta: null,
|
|
20990
21022
|
pano: t
|
|
20991
|
-
})),
|
|
20992
|
-
}), Promise.resolve().then(() => wh(
|
|
20993
|
-
let t = Gh(e);
|
|
20994
|
-
return this.emit("error", t), t;
|
|
20995
|
-
})]).then(([e, n]) => {
|
|
21023
|
+
})), n;
|
|
21024
|
+
}), Promise.resolve().then(() => wh(_)).catch((e) => Gh(e))]).then(([e, n]) => {
|
|
20996
21025
|
var r, i, a, o;
|
|
20997
21026
|
if (!(e instanceof Error) && !(n instanceof Error)) this.pending.delete(g), ((r = this.pendingPanoTask) == null ? void 0 : r.hash) === h ? (this.pendingPanoTask.onLoad(e), this.pendingPanoTask = void 0, (i = this.panoMeshes.get(c)) == null || i.setProgress(0)) : e.body.dispose(), this.emit("pano.texture.success", Q("pano.texture.success", {
|
|
20998
21027
|
error: null,
|
|
@@ -21013,7 +21042,7 @@ var Gg = Vu, Kg = new e.Raycaster(), qg = new e.Vector3(), Jg = [
|
|
|
21013
21042
|
let a = t.initAnimationEndState(this), o = {
|
|
21014
21043
|
workCode: a.workCode,
|
|
21015
21044
|
panoIndex: a.panoIndex
|
|
21016
|
-
}, s =
|
|
21045
|
+
}, s = !1;
|
|
21017
21046
|
this.moveToPano(o, {
|
|
21018
21047
|
longitude: a.longitude,
|
|
21019
21048
|
latitude: a.latitude,
|
|
@@ -21021,20 +21050,7 @@ var Gg = Vu, Kg = new e.Raycaster(), qg = new e.Vector3(), Jg = [
|
|
|
21021
21050
|
effect: r,
|
|
21022
21051
|
duration: n,
|
|
21023
21052
|
moveStartCallback: (e) => {
|
|
21024
|
-
|
|
21025
|
-
{
|
|
21026
|
-
progress: 0,
|
|
21027
|
-
value: Object.assign({}, this.modelAlphaMotion.value)
|
|
21028
|
-
},
|
|
21029
|
-
{
|
|
21030
|
-
progress: .6,
|
|
21031
|
-
value: Object.assign({}, this.modelAlphaMotion.value)
|
|
21032
|
-
},
|
|
21033
|
-
{
|
|
21034
|
-
progress: 1,
|
|
21035
|
-
value: s
|
|
21036
|
-
}
|
|
21037
|
-
], n).catch(K), this.emit("initAnimation.start", Q("initAnimation.start", {
|
|
21053
|
+
s = !0, this.emit("initAnimation.start", Q("initAnimation.start", {
|
|
21038
21054
|
state: e,
|
|
21039
21055
|
userAction: this.userAction
|
|
21040
21056
|
}));
|
|
@@ -21047,7 +21063,7 @@ var Gg = Vu, Kg = new e.Raycaster(), qg = new e.Vector3(), Jg = [
|
|
|
21047
21063
|
},
|
|
21048
21064
|
moveCancelCallback: () => {
|
|
21049
21065
|
let t = Object.assign(Object.assign(Object.assign({}, o), { mode: this.mode }), $(this.camera.pose));
|
|
21050
|
-
|
|
21066
|
+
s === !1 && this.emit("initAnimation.start", Q("initAnimation.start", {
|
|
21051
21067
|
state: t,
|
|
21052
21068
|
userAction: this.userAction
|
|
21053
21069
|
})), this.emit("initAnimation.end", Q("initAnimation.end", {
|
|
@@ -21136,7 +21152,20 @@ var Gg = Vu, Kg = new e.Raycaster(), qg = new e.Vector3(), Jg = [
|
|
|
21136
21152
|
state: S,
|
|
21137
21153
|
userAction: this.userAction,
|
|
21138
21154
|
error: null
|
|
21139
|
-
})), r.moveStartCallback && r.moveStartCallback(S), this.
|
|
21155
|
+
})), r.moveStartCallback && r.moveStartCallback(S), this.perspToOrthoMotion.set({ perspToOrtho: 0 }, b).catch(K), this.modelAlphaMotion.setKeyframes([
|
|
21156
|
+
{
|
|
21157
|
+
progress: 0,
|
|
21158
|
+
value: Object.assign({}, this.modelAlphaMotion.value)
|
|
21159
|
+
},
|
|
21160
|
+
{
|
|
21161
|
+
progress: .6,
|
|
21162
|
+
value: Object.assign({}, this.modelAlphaMotion.value)
|
|
21163
|
+
},
|
|
21164
|
+
{
|
|
21165
|
+
progress: 1,
|
|
21166
|
+
value: { modelAlpha: 0 }
|
|
21167
|
+
}
|
|
21168
|
+
], b).catch(K), this.videoTexture && this.videoTexture.image instanceof HTMLVideoElement && this.videoTexture.image.getAttribute("src") && (this.videoTexture.image.pause(), this.videoTexture.image.removeAttribute("uuid"), this.videoTexture.image.removeAttribute("src"), this.videoTexture.image.oncanplay = K, this.videoTexture.needsUpdate = !0), this.panoVideo.setMaterial(null), n.effect === "fly" || n.effect === "model") this.cameraMotion.set(x, b).catch(K);
|
|
21140
21169
|
else {
|
|
21141
21170
|
let t = Rt({
|
|
21142
21171
|
longitude: this.cameraMotion.value.longitude,
|
|
@@ -21230,15 +21259,16 @@ var Gg = Vu, Kg = new e.Raycaster(), qg = new e.Vector3(), Jg = [
|
|
|
21230
21259
|
e.removeAttribute("uuid"), e.oncanplay = K, e.ontimeupdate = K;
|
|
21231
21260
|
}
|
|
21232
21261
|
}, () => {
|
|
21262
|
+
let e = Object.assign(Object.assign(Object.assign({}, this.currentPano), { mode: this.mode }), $(this.camera.pose));
|
|
21233
21263
|
this.emit("pano.cancel", Q("pano.cancel", {
|
|
21234
21264
|
options: r,
|
|
21235
21265
|
prevPano: C,
|
|
21236
21266
|
pano: {
|
|
21237
|
-
panoIndex:
|
|
21238
|
-
workCode:
|
|
21267
|
+
panoIndex: e.panoIndex,
|
|
21268
|
+
workCode: e.workCode
|
|
21239
21269
|
},
|
|
21240
21270
|
progress: 0,
|
|
21241
|
-
state:
|
|
21271
|
+
state: e,
|
|
21242
21272
|
userAction: this.userAction,
|
|
21243
21273
|
error: null
|
|
21244
21274
|
})), r.moveCancelCallback && r.moveCancelCallback();
|
|
@@ -23306,144 +23336,144 @@ var N_ = new e.CircleBufferGeometry(.12, 16), P_ = "\nvarying vec2 vUv;\n#includ
|
|
|
23306
23336
|
}
|
|
23307
23337
|
}
|
|
23308
23338
|
onTapGesture(t) {
|
|
23309
|
-
var n;
|
|
23310
23339
|
this.userAction = t.userAction, this.stopMomentumMovement();
|
|
23311
|
-
let
|
|
23312
|
-
if (!
|
|
23340
|
+
let n = t.center.raycaster, r = this.getForwardObserverOrNot(n);
|
|
23341
|
+
if (!r) this.emit("gesture.tap", t);
|
|
23313
23342
|
else {
|
|
23314
|
-
let
|
|
23343
|
+
let n = {
|
|
23315
23344
|
longitude: this.camera.pose.longitude,
|
|
23316
23345
|
latitude: 0
|
|
23317
|
-
},
|
|
23346
|
+
}, i = Object.assign(Object.assign({}, t.state), {
|
|
23318
23347
|
mode: "Panorama",
|
|
23319
|
-
workCode:
|
|
23320
|
-
panoIndex:
|
|
23321
|
-
longitude:
|
|
23322
|
-
latitude:
|
|
23323
|
-
offset:
|
|
23348
|
+
workCode: r.work.workCode,
|
|
23349
|
+
panoIndex: r.panoIndex,
|
|
23350
|
+
longitude: n.longitude,
|
|
23351
|
+
latitude: n.latitude,
|
|
23352
|
+
offset: r ? r.position.clone() : new e.Vector3(),
|
|
23324
23353
|
distance: 0
|
|
23325
23354
|
});
|
|
23326
|
-
if (t.state =
|
|
23355
|
+
if (t.state = i, this.emit("gesture.tap", t), !t.defaultPrevented && (this.emit("pano.select", Q("pano.select", {
|
|
23327
23356
|
prevPano: this.currentPano,
|
|
23328
23357
|
pano: {
|
|
23329
|
-
panoIndex:
|
|
23330
|
-
workCode:
|
|
23358
|
+
panoIndex: i.panoIndex,
|
|
23359
|
+
workCode: i.workCode
|
|
23331
23360
|
},
|
|
23332
|
-
state:
|
|
23361
|
+
state: i,
|
|
23333
23362
|
userAction: t.userAction,
|
|
23334
|
-
options:
|
|
23363
|
+
options: n,
|
|
23335
23364
|
progress: 0,
|
|
23336
23365
|
error: null
|
|
23337
|
-
})),
|
|
23338
|
-
let t = this.pendingTextureId = $t(),
|
|
23339
|
-
panoIndex:
|
|
23340
|
-
workCode:
|
|
23341
|
-
},
|
|
23342
|
-
right:
|
|
23343
|
-
left:
|
|
23344
|
-
up:
|
|
23345
|
-
down:
|
|
23346
|
-
front:
|
|
23347
|
-
back:
|
|
23348
|
-
},
|
|
23366
|
+
})), r && r.active)) {
|
|
23367
|
+
let t = this.pendingTextureId = $t(), a = {
|
|
23368
|
+
panoIndex: r.panoIndex,
|
|
23369
|
+
workCode: r.work.workCode
|
|
23370
|
+
}, o = Z(a), s = {
|
|
23371
|
+
right: r.images.work.getURL(r.images.right),
|
|
23372
|
+
left: r.images.work.getURL(r.images.left),
|
|
23373
|
+
up: r.images.work.getURL(r.images.up),
|
|
23374
|
+
down: r.images.work.getURL(r.images.down),
|
|
23375
|
+
front: r.images.work.getURL(r.images.front),
|
|
23376
|
+
back: r.images.work.getURL(r.images.back)
|
|
23377
|
+
}, c = this.imageOptions.transform, l = Object.assign({ key: `pano.${o}` }, mr(this.imageOptions, [
|
|
23349
23378
|
"format",
|
|
23350
23379
|
"size",
|
|
23351
23380
|
"quality",
|
|
23352
23381
|
"sharpen",
|
|
23353
23382
|
"forceUseExifOrientation",
|
|
23354
23383
|
"mappings"
|
|
23355
|
-
])),
|
|
23356
|
-
|
|
23357
|
-
|
|
23358
|
-
|
|
23359
|
-
]),
|
|
23360
|
-
if (f.pano0 && f.pano0.map.name === d ? p = f.pano0 : f.pano1 && f.pano1.map.name === d && (p = f.pano1), p) f.pano0 && f.pano0.map !== p.map && f.pano0.map.dispose(), f.pano1 && f.pano1.map !== p.map && f.pano1.map !== ((n = f.pano0) == null ? void 0 : n.map) && f.pano1.map.dispose(), f.set({
|
|
23361
|
-
pano0: p,
|
|
23362
|
-
pano1: p
|
|
23363
|
-
}), this.emit("pano.request", Q("pano.request", {
|
|
23364
|
-
userAction: !0,
|
|
23384
|
+
])), u = "pano:" + up([
|
|
23385
|
+
s,
|
|
23386
|
+
l,
|
|
23387
|
+
c
|
|
23388
|
+
]), d = this.modelScene.parameter, f = Ch("pano.prepare", {
|
|
23365
23389
|
prevPano: this.currentPano,
|
|
23366
|
-
pano:
|
|
23367
|
-
|
|
23368
|
-
|
|
23369
|
-
|
|
23370
|
-
|
|
23371
|
-
|
|
23372
|
-
|
|
23373
|
-
|
|
23374
|
-
|
|
23375
|
-
|
|
23376
|
-
|
|
23390
|
+
pano: a
|
|
23391
|
+
});
|
|
23392
|
+
if (this.emit("pano.prepare", f), f.defaultPrevented) {
|
|
23393
|
+
this.pendingTextureId = null;
|
|
23394
|
+
return;
|
|
23395
|
+
}
|
|
23396
|
+
let p;
|
|
23397
|
+
d.pano0 && d.pano0.map.name === u ? p = d.pano0 : d.pano1 && d.pano1.map.name === u && (p = d.pano1), p ? Promise.resolve().then(() => wh(f)).catch((e) => Gh(e)).then((e) => {
|
|
23398
|
+
var t;
|
|
23399
|
+
e instanceof Error ? (this.pendingTextureId = null, e.message && this.emit("error", e)) : (d.pano0 && d.pano0.map !== p.map && d.pano0.map.dispose(), d.pano1 && d.pano1.map !== p.map && d.pano1.map !== ((t = d.pano0) == null ? void 0 : t.map) && d.pano1.map.dispose(), d.set({
|
|
23400
|
+
pano0: p,
|
|
23401
|
+
pano1: p
|
|
23402
|
+
}), this.emit("pano.request", Q("pano.request", {
|
|
23403
|
+
userAction: !0,
|
|
23377
23404
|
prevPano: this.currentPano,
|
|
23378
|
-
pano:
|
|
23379
|
-
|
|
23380
|
-
|
|
23381
|
-
this.emit("pano.texture.load", Q("pano.texture.load", {
|
|
23382
|
-
error: null,
|
|
23383
|
-
progress: 0,
|
|
23384
|
-
meta: null,
|
|
23385
|
-
pano: o
|
|
23386
|
-
}));
|
|
23387
|
-
}).then(() => this.textureLoader.loadCubeTexture(c, {
|
|
23388
|
-
imageURL: {
|
|
23389
|
-
transform: l,
|
|
23390
|
-
options: u
|
|
23405
|
+
pano: {
|
|
23406
|
+
panoIndex: i.panoIndex,
|
|
23407
|
+
workCode: i.workCode
|
|
23391
23408
|
},
|
|
23392
|
-
|
|
23393
|
-
|
|
23394
|
-
|
|
23395
|
-
|
|
23396
|
-
|
|
23397
|
-
|
|
23398
|
-
|
|
23399
|
-
|
|
23400
|
-
|
|
23401
|
-
|
|
23402
|
-
|
|
23403
|
-
})
|
|
23404
|
-
|
|
23405
|
-
|
|
23406
|
-
|
|
23407
|
-
|
|
23408
|
-
|
|
23409
|
-
|
|
23410
|
-
|
|
23411
|
-
|
|
23412
|
-
|
|
23413
|
-
|
|
23414
|
-
|
|
23415
|
-
|
|
23416
|
-
|
|
23417
|
-
|
|
23418
|
-
|
|
23419
|
-
|
|
23420
|
-
|
|
23421
|
-
|
|
23422
|
-
|
|
23423
|
-
|
|
23424
|
-
|
|
23425
|
-
|
|
23426
|
-
|
|
23427
|
-
pano1: h
|
|
23428
|
-
}), this.emit("pano.request", Q("pano.request", {
|
|
23429
|
-
userAction: !0,
|
|
23430
|
-
prevPano: this.currentPano,
|
|
23431
|
-
pano: {
|
|
23432
|
-
panoIndex: a.panoIndex,
|
|
23433
|
-
workCode: a.workCode
|
|
23434
|
-
},
|
|
23435
|
-
progress: 0,
|
|
23436
|
-
state: a,
|
|
23437
|
-
options: r,
|
|
23438
|
-
error: null
|
|
23439
|
-
}));
|
|
23440
|
-
} else {
|
|
23441
|
-
let e = null;
|
|
23442
|
-
if (n instanceof Error ? e || (e = n) : n.body.dispose(), o instanceof Error && (e || (e = o)), this.destroyed || this.pendingTextureId !== t) return;
|
|
23443
|
-
this.pendingTextureId = null, this.emit("error", e);
|
|
23409
|
+
progress: 0,
|
|
23410
|
+
state: i,
|
|
23411
|
+
options: n,
|
|
23412
|
+
error: null
|
|
23413
|
+
})));
|
|
23414
|
+
}) : Promise.all([Promise.resolve().then(() => {
|
|
23415
|
+
this.emit("pano.texture.load", Q("pano.texture.load", {
|
|
23416
|
+
error: null,
|
|
23417
|
+
progress: 0,
|
|
23418
|
+
meta: null,
|
|
23419
|
+
pano: a
|
|
23420
|
+
}));
|
|
23421
|
+
}).then(() => this.textureLoader.loadCubeTexture(s, {
|
|
23422
|
+
imageURL: {
|
|
23423
|
+
transform: c,
|
|
23424
|
+
options: l
|
|
23425
|
+
},
|
|
23426
|
+
format: e.RGBFormat,
|
|
23427
|
+
viaAjax: !0,
|
|
23428
|
+
fetcher: yf(this.fiveId, r.work)
|
|
23429
|
+
}, void 0, void 0, void 0, this.renderer)).catch((e) => {
|
|
23430
|
+
let t = Gh(e);
|
|
23431
|
+
return this.emit("pano.texture.error", Q("pano.texture.error", {
|
|
23432
|
+
error: t,
|
|
23433
|
+
progress: 0,
|
|
23434
|
+
meta: null,
|
|
23435
|
+
pano: a
|
|
23436
|
+
})), t;
|
|
23437
|
+
}), Promise.resolve().then(() => wh(f)).catch((e) => Gh(e))]).then(([a, s]) => {
|
|
23438
|
+
var c, l;
|
|
23439
|
+
if (!(a instanceof Error) && !(s instanceof Error)) {
|
|
23440
|
+
let { body: s } = a;
|
|
23441
|
+
if (this.destroyed || this.pendingTextureId !== t) {
|
|
23442
|
+
s.dispose();
|
|
23443
|
+
return;
|
|
23444
23444
|
}
|
|
23445
|
-
|
|
23446
|
-
|
|
23445
|
+
this.pendingTextureId = null, s.name = u;
|
|
23446
|
+
let f = Array.isArray(s.image) ? s.image[0] : s.image, p = (c = f == null ? void 0 : f.width) == null ? 2048 : c, m = r.images.histogram;
|
|
23447
|
+
m || (m = new pm().formPixels(zh(this.renderer, s, !0, lm).data), r.images.histogram = m);
|
|
23448
|
+
let h = {
|
|
23449
|
+
panoId: o,
|
|
23450
|
+
map: s,
|
|
23451
|
+
mapSize: p,
|
|
23452
|
+
mapHistogram: new e.Vector4().fromArray(m.toArray()),
|
|
23453
|
+
matrix: r.matrix.clone().premultiply(r.work.transform),
|
|
23454
|
+
zoom: 1
|
|
23455
|
+
};
|
|
23456
|
+
d.pano0 && d.pano0.map.dispose(), d.pano1 && d.pano1.map !== ((l = d.pano0) == null ? void 0 : l.map) && d.pano1.map.dispose(), d.set({
|
|
23457
|
+
pano0: h,
|
|
23458
|
+
pano1: h
|
|
23459
|
+
}), this.emit("pano.request", Q("pano.request", {
|
|
23460
|
+
userAction: !0,
|
|
23461
|
+
prevPano: this.currentPano,
|
|
23462
|
+
pano: {
|
|
23463
|
+
panoIndex: i.panoIndex,
|
|
23464
|
+
workCode: i.workCode
|
|
23465
|
+
},
|
|
23466
|
+
progress: 0,
|
|
23467
|
+
state: i,
|
|
23468
|
+
options: n,
|
|
23469
|
+
error: null
|
|
23470
|
+
}));
|
|
23471
|
+
} else {
|
|
23472
|
+
let e = null;
|
|
23473
|
+
if (a instanceof Error ? e || (e = a) : a.body.dispose(), s instanceof Error && (e || (e = s)), this.destroyed || this.pendingTextureId !== t) return;
|
|
23474
|
+
this.pendingTextureId = null, e instanceof Error && e.message && this.emit("error", e);
|
|
23475
|
+
}
|
|
23476
|
+
});
|
|
23447
23477
|
}
|
|
23448
23478
|
}
|
|
23449
23479
|
}
|
|
@@ -23977,7 +24007,7 @@ Object.assign(dv.prototype, { isLineGeometry: !0 });
|
|
|
23977
24007
|
//#region build/line/index.js
|
|
23978
24008
|
var fv = 14467195, pv = 8, mv = 2, hv = 20, gv = null, _v = class extends e.Object3D {
|
|
23979
24009
|
static get version() {
|
|
23980
|
-
return "6.8.0-alpha.
|
|
24010
|
+
return "6.8.0-alpha.27";
|
|
23981
24011
|
}
|
|
23982
24012
|
constructor(t = new e.Vector3(), n = new e.Vector3()) {
|
|
23983
24013
|
super(), this.type = "FiveLine", this.needsRender = !0, this.line = new uv(new dv(), new cv({
|
|
@@ -24451,30 +24481,70 @@ var Fv = 300, Iv = new e.Raycaster(), Lv = new e.Vector3(), Rv = {
|
|
|
24451
24481
|
}
|
|
24452
24482
|
let _ = "move-to-pano-" + c;
|
|
24453
24483
|
this.pending.add(_);
|
|
24454
|
-
let v =
|
|
24455
|
-
|
|
24484
|
+
let v = Ch("pano.prepare", {
|
|
24485
|
+
prevPano: this.currentPano,
|
|
24486
|
+
pano: t
|
|
24487
|
+
});
|
|
24488
|
+
if (this.emit("pano.prepare", v), v.defaultPrevented) {
|
|
24489
|
+
this.pending.delete(_);
|
|
24490
|
+
return;
|
|
24491
|
+
}
|
|
24492
|
+
let y = this.modelScene.parameter, b;
|
|
24493
|
+
if (y.pano0 && y.pano0.map.name === g ? b = y.pano0 : y.pano1 && y.pano1.map.name === g && (b = y.pano1), b) {
|
|
24456
24494
|
let r = {
|
|
24457
24495
|
panoId: c,
|
|
24458
24496
|
effect: s,
|
|
24459
24497
|
effectEasing: (o = n.effectEasing) == null ? Gg : o,
|
|
24460
24498
|
leftPanoPicture: {
|
|
24461
|
-
panoId:
|
|
24462
|
-
map:
|
|
24463
|
-
mapHistogram:
|
|
24464
|
-
mapSize:
|
|
24499
|
+
panoId: b.panoId,
|
|
24500
|
+
map: b.map,
|
|
24501
|
+
mapHistogram: b.mapHistogram,
|
|
24502
|
+
mapSize: b.mapSize,
|
|
24465
24503
|
matrix: l.matrix.clone().premultiply(l.work.transform),
|
|
24466
24504
|
zoom: 1
|
|
24467
24505
|
},
|
|
24468
24506
|
position: l.position.clone().applyMatrix4(l.work.transform),
|
|
24469
24507
|
fixCameraTransform: new e.Matrix4()
|
|
24470
24508
|
};
|
|
24471
|
-
r.leftPanoPicture && this.panoPictureObserverMap.set(r.leftPanoPicture, l), this.pendingPanoTask = void 0,
|
|
24472
|
-
|
|
24473
|
-
|
|
24509
|
+
r.leftPanoPicture && this.panoPictureObserverMap.set(r.leftPanoPicture, l), this.pendingPanoTask = void 0, Promise.resolve().then(() => wh(v)).catch((e) => {
|
|
24510
|
+
let t = Gh(e);
|
|
24511
|
+
return this.emit("error", t), t;
|
|
24512
|
+
}).then((e) => {
|
|
24513
|
+
var i, a;
|
|
24514
|
+
if (!(e instanceof Error)) this.pending.delete(_), this.pendingPanoTask = void 0, (i = this.panoMeshes.get(c)) == null || i.setProgress(0), this.doMoveToPano(t, r, n);
|
|
24515
|
+
else {
|
|
24516
|
+
let t = null;
|
|
24517
|
+
e instanceof Error && (t || (t = e));
|
|
24518
|
+
let r = Object.assign(Object.assign(Object.assign({}, this.currentPano), { mode: this.mode }), $(this.camera.pose));
|
|
24519
|
+
this.emit("pano.cancel", Q("pano.cancel", {
|
|
24520
|
+
error: null,
|
|
24521
|
+
userAction: this.userAction,
|
|
24522
|
+
options: n,
|
|
24523
|
+
prevPano: this.currentPano,
|
|
24524
|
+
pano: {
|
|
24525
|
+
panoIndex: l.panoIndex,
|
|
24526
|
+
workCode: l.work.workCode
|
|
24527
|
+
},
|
|
24528
|
+
progress: 0,
|
|
24529
|
+
state: r
|
|
24530
|
+
})), n.moveCancelCallback && n.moveCancelCallback(), this.emit("pano.error", Q("pano.error", {
|
|
24531
|
+
error: t,
|
|
24532
|
+
userAction: this.userAction,
|
|
24533
|
+
options: n,
|
|
24534
|
+
prevPano: this.currentPano,
|
|
24535
|
+
pano: {
|
|
24536
|
+
panoIndex: l.panoIndex,
|
|
24537
|
+
workCode: l.work.workCode
|
|
24538
|
+
},
|
|
24539
|
+
progress: 0,
|
|
24540
|
+
state: r
|
|
24541
|
+
})), t instanceof Error && t.message && this.emit("error", t), this.pending.delete(_), this.pendingPanoTask = void 0, (a = this.panoMeshes.get(c)) == null || a.setProgress(0);
|
|
24542
|
+
}
|
|
24543
|
+
});
|
|
24474
24544
|
return;
|
|
24475
24545
|
}
|
|
24476
|
-
let
|
|
24477
|
-
|
|
24546
|
+
let x = this.panoMeshes.get(c);
|
|
24547
|
+
x && x.tap && x.tap(), this.pendingPanoTask = {
|
|
24478
24548
|
panoId: c,
|
|
24479
24549
|
hash: g,
|
|
24480
24550
|
onLoad: (r) => {
|
|
@@ -24502,37 +24572,32 @@ var Fv = 300, Iv = new e.Raycaster(), Lv = new e.Vector3(), Rv = {
|
|
|
24502
24572
|
}
|
|
24503
24573
|
},
|
|
24504
24574
|
onError: (e) => {
|
|
24505
|
-
let
|
|
24506
|
-
this.emit("pano.
|
|
24507
|
-
error:
|
|
24575
|
+
let t = Object.assign(Object.assign(Object.assign({}, this.currentPano), { mode: this.mode }), $(this.camera.pose));
|
|
24576
|
+
this.emit("pano.cancel", Q("pano.cancel", {
|
|
24577
|
+
error: null,
|
|
24508
24578
|
userAction: this.userAction,
|
|
24509
24579
|
options: n,
|
|
24510
24580
|
prevPano: this.currentPano,
|
|
24511
24581
|
pano: {
|
|
24512
|
-
panoIndex:
|
|
24513
|
-
workCode:
|
|
24582
|
+
panoIndex: l.panoIndex,
|
|
24583
|
+
workCode: l.work.workCode
|
|
24514
24584
|
},
|
|
24515
24585
|
progress: 0,
|
|
24516
|
-
state:
|
|
24517
|
-
})), this.emit("pano.
|
|
24518
|
-
error:
|
|
24586
|
+
state: t
|
|
24587
|
+
})), this.emit("pano.error", Q("pano.error", {
|
|
24588
|
+
error: e,
|
|
24519
24589
|
userAction: this.userAction,
|
|
24520
24590
|
options: n,
|
|
24521
24591
|
prevPano: this.currentPano,
|
|
24522
24592
|
pano: {
|
|
24523
|
-
panoIndex:
|
|
24524
|
-
workCode:
|
|
24593
|
+
panoIndex: l.panoIndex,
|
|
24594
|
+
workCode: l.work.workCode
|
|
24525
24595
|
},
|
|
24526
24596
|
progress: 0,
|
|
24527
|
-
state:
|
|
24528
|
-
})), this.emit("error", e), n.moveCancelCallback && n.moveCancelCallback();
|
|
24597
|
+
state: t
|
|
24598
|
+
})), e instanceof Error && e.message && this.emit("error", e), n.moveCancelCallback && n.moveCancelCallback();
|
|
24529
24599
|
}
|
|
24530
|
-
}
|
|
24531
|
-
let x = Ch("pano.prepare", {
|
|
24532
|
-
prevPano: this.currentPano,
|
|
24533
|
-
pano: t
|
|
24534
|
-
});
|
|
24535
|
-
this.emit("pano.prepare", x), Promise.all([Promise.resolve().then(() => {
|
|
24600
|
+
}, Promise.all([Promise.resolve().then(() => {
|
|
24536
24601
|
this.emit("pano.texture.load", Q("pano.texture.load", {
|
|
24537
24602
|
error: null,
|
|
24538
24603
|
progress: 0,
|
|
@@ -24562,11 +24627,8 @@ var Fv = 300, Iv = new e.Raycaster(), Lv = new e.Vector3(), Rv = {
|
|
|
24562
24627
|
progress: 0,
|
|
24563
24628
|
meta: null,
|
|
24564
24629
|
pano: t
|
|
24565
|
-
})),
|
|
24566
|
-
}), Promise.resolve().then(() => wh(
|
|
24567
|
-
let t = Gh(e);
|
|
24568
|
-
return this.emit("error", t), t;
|
|
24569
|
-
})]).then(([e, n]) => {
|
|
24630
|
+
})), n;
|
|
24631
|
+
}), Promise.resolve().then(() => wh(v)).catch((e) => Gh(e))]).then(([e, n]) => {
|
|
24570
24632
|
var r, i, a, o;
|
|
24571
24633
|
if (!(e instanceof Error) && !(n instanceof Error)) this.pending.delete(_), ((r = this.pendingPanoTask) == null ? void 0 : r.hash) === g ? (this.pendingPanoTask.onLoad(e), this.pendingPanoTask = void 0, (i = this.panoMeshes.get(c)) == null || i.setProgress(0)) : e.body.dispose(), this.emit("pano.texture.success", Q("pano.texture.success", {
|
|
24572
24634
|
error: null,
|
|
@@ -24647,7 +24709,20 @@ var Fv = 300, Iv = new e.Raycaster(), Lv = new e.Vector3(), Rv = {
|
|
|
24647
24709
|
state: x,
|
|
24648
24710
|
userAction: this.userAction,
|
|
24649
24711
|
error: null
|
|
24650
|
-
})), r.moveStartCallback && r.moveStartCallback(x), this.
|
|
24712
|
+
})), r.moveStartCallback && r.moveStartCallback(x), this.perspToOrthoMotion.set({ perspToOrtho: 0 }, y).catch(K), this.modelAlphaMotion.setKeyframes([
|
|
24713
|
+
{
|
|
24714
|
+
progress: 0,
|
|
24715
|
+
value: Object.assign({}, this.modelAlphaMotion.value)
|
|
24716
|
+
},
|
|
24717
|
+
{
|
|
24718
|
+
progress: .6,
|
|
24719
|
+
value: Object.assign({}, this.modelAlphaMotion.value)
|
|
24720
|
+
},
|
|
24721
|
+
{
|
|
24722
|
+
progress: 1,
|
|
24723
|
+
value: { modelAlpha: 0 }
|
|
24724
|
+
}
|
|
24725
|
+
], y).catch(K), this.videoTexture && this.videoTexture.image instanceof HTMLVideoElement && this.videoTexture.image.getAttribute("src") && (this.videoTexture.image.pause(), this.videoTexture.image.removeAttribute("uuid"), this.videoTexture.image.removeAttribute("src"), this.videoTexture.image.oncanplay = K, this.videoTexture.needsUpdate = !0), this.panoVideo.setMaterial(null), n.effect === "fly" || n.effect === "model") this.cameraMotion.set(b, y).catch(K);
|
|
24651
24726
|
else {
|
|
24652
24727
|
let t = Rt({
|
|
24653
24728
|
longitude: this.cameraMotion.value.longitude,
|
|
@@ -24738,15 +24813,16 @@ var Fv = 300, Iv = new e.Raycaster(), Lv = new e.Vector3(), Rv = {
|
|
|
24738
24813
|
}));
|
|
24739
24814
|
}
|
|
24740
24815
|
}, () => {
|
|
24816
|
+
let e = Object.assign(Object.assign(Object.assign({}, this.currentPano), { mode: this.mode }), $(this.camera.pose));
|
|
24741
24817
|
this.emit("pano.cancel", Q("pano.cancel", {
|
|
24742
24818
|
options: r,
|
|
24743
24819
|
prevPano: S,
|
|
24744
24820
|
pano: {
|
|
24745
|
-
panoIndex:
|
|
24746
|
-
workCode:
|
|
24821
|
+
panoIndex: e.panoIndex,
|
|
24822
|
+
workCode: e.workCode
|
|
24747
24823
|
},
|
|
24748
24824
|
progress: 0,
|
|
24749
|
-
state:
|
|
24825
|
+
state: e,
|
|
24750
24826
|
userAction: this.userAction,
|
|
24751
24827
|
error: null
|
|
24752
24828
|
})), r.moveCancelCallback && r.moveCancelCallback();
|
|
@@ -26148,7 +26224,7 @@ var yy = function(...e) {
|
|
|
26148
26224
|
}
|
|
26149
26225
|
}, Cy = 1e3, wy = 90, Ty = (e) => e.replace("//vrlab-public.ljcdn.com/", "//vr-public.realsee-cdn.cn/").replace("//vrlab-image4.ljcdn.com/", "//vr-image-4.realsee-cdn.cn/").replace("//vrlab-image3.ljcdn.com/", "//vr-image-3.realsee-cdn.cn/").replace("//vrlab-image2.ljcdn.com/", "//vr-image-2.realsee-cdn.cn/").replace("//vrlab-image1.ljcdn.com/", "//vr-image-1.realsee-cdn.cn/"), Ey = new e.Sphere(), Dy = new e.Box3(), Oy = new e.Vector4(), ky = new e.Vector4(), Ay = new e.Color(), jy = new e.Vector2(), My = /* @__PURE__ */ new WeakMap(), Ny = Qp([Yp(null)]), Py = {}, Fy = class t extends an {
|
|
26150
26226
|
static get version() {
|
|
26151
|
-
return "6.8.0-alpha.
|
|
26227
|
+
return "6.8.0-alpha.27";
|
|
26152
26228
|
}
|
|
26153
26229
|
static get dracoPath() {
|
|
26154
26230
|
return eo.decoderPath;
|
|
@@ -27094,6 +27170,10 @@ var yy = function(...e) {
|
|
|
27094
27170
|
userAction: r,
|
|
27095
27171
|
state: this.state
|
|
27096
27172
|
})), (t = this.analysis) == null || t.state(this.works, this.state));
|
|
27173
|
+
}), i.on("pano.error", (e) => {
|
|
27174
|
+
var t;
|
|
27175
|
+
let { state: n } = e;
|
|
27176
|
+
this.state.mode === n.mode && !Oh(this.state, n) && (Dh(this.state, n), (t = this.analysis) == null || t.state(this.works, this.state));
|
|
27097
27177
|
}), i.on("pano.moveTo", (e) => {
|
|
27098
27178
|
let { userAction: t } = e;
|
|
27099
27179
|
this.emit("currentState.change", Q("currentState.change", {
|