@metagl/smartearth-base 0.0.0-stage → 0.3.0
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/CHANGELOG.md +78 -0
- package/README.md +320 -3
- package/dist/chunk-24R3PPPA.js +2116 -0
- package/dist/chunk-POH7K3F4.js +705 -0
- package/dist/chunk-UENQT22J.js +885 -0
- package/dist/createEarth-BY0dtgQQ.d.ts +647 -0
- package/dist/errors-cB7IQlHy.d.ts +15 -0
- package/dist/index.d.ts +345 -0
- package/dist/index.js +2 -0
- package/dist/presets.d.ts +312 -0
- package/dist/presets.js +2 -0
- package/dist/vite.d.ts +20 -0
- package/dist/vite.js +89 -0
- package/dist/vue.d.ts +108 -0
- package/dist/vue.js +291 -0
- package/package.json +75 -6
|
@@ -0,0 +1,885 @@
|
|
|
1
|
+
import * as SdkRender from '@metagl/sdk-render';
|
|
2
|
+
|
|
3
|
+
// src/errors.ts
|
|
4
|
+
var MAP_TOKEN_APPLY_URL = "https://datacloud.geovisearth.com/";
|
|
5
|
+
var SmartEarthError = class extends Error {
|
|
6
|
+
code;
|
|
7
|
+
cause;
|
|
8
|
+
constructor(code, message, cause) {
|
|
9
|
+
super(message);
|
|
10
|
+
this.name = "SmartEarthError";
|
|
11
|
+
this.code = code;
|
|
12
|
+
if (cause !== void 0) this.cause = cause;
|
|
13
|
+
}
|
|
14
|
+
};
|
|
15
|
+
function isSmartEarthError(value) {
|
|
16
|
+
return value instanceof SmartEarthError;
|
|
17
|
+
}
|
|
18
|
+
var REDACTED = "***";
|
|
19
|
+
function redactUrlQueries(text) {
|
|
20
|
+
return text.replace(/(\b(?:https?|wss?):\/\/[^\s?#'"]+)\?[^\s'"]*/gi, `$1?${REDACTED}`);
|
|
21
|
+
}
|
|
22
|
+
function describeLayerCause(cause) {
|
|
23
|
+
return redactUrlQueries(describeCause(cause));
|
|
24
|
+
}
|
|
25
|
+
var MIN_SECRET_LENGTH = 8;
|
|
26
|
+
function describeCause(cause, secrets = []) {
|
|
27
|
+
let text = cause instanceof Error ? cause.message : typeof cause === "string" ? cause : "\u672A\u77E5\u9519\u8BEF";
|
|
28
|
+
for (const secret of secrets) {
|
|
29
|
+
if (!secret || secret.length < MIN_SECRET_LENGTH) continue;
|
|
30
|
+
text = text.split(secret).join(REDACTED).split(encodeURIComponent(secret)).join(REDACTED);
|
|
31
|
+
}
|
|
32
|
+
return text;
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
// src/environment/sdk.ts
|
|
36
|
+
function supportsEnvironment(render) {
|
|
37
|
+
const candidate = render;
|
|
38
|
+
return typeof candidate?.applyPreset === "function" && typeof candidate.transitionToPreset === "function" && typeof candidate.clearPreset === "function" && typeof candidate.getActivePreset === "function" && typeof candidate.toggleSystem === "function" && typeof candidate.getSystemStatus === "function" && typeof candidate.getSystemConfig === "function" && typeof candidate.updateSystemConfig === "function";
|
|
39
|
+
}
|
|
40
|
+
function call(action, run) {
|
|
41
|
+
try {
|
|
42
|
+
return run();
|
|
43
|
+
} catch (error) {
|
|
44
|
+
if (error instanceof SmartEarthError) throw error;
|
|
45
|
+
throw new SmartEarthError("RENDER_INIT_FAILED", `${action}\u5931\u8D25\uFF1A${describeCause(error)}`, error);
|
|
46
|
+
}
|
|
47
|
+
}
|
|
48
|
+
function requireEnvironment(render, action) {
|
|
49
|
+
if (supportsEnvironment(render)) return render;
|
|
50
|
+
throw new SmartEarthError(
|
|
51
|
+
"ENVIRONMENT_UNSUPPORTED",
|
|
52
|
+
`\u5F53\u524D @metagl/sdk-render \u4E0D\u652F\u6301${action}\uFF08\u9700\u8981 4.x\uFF09\uFF1B\u8BBE\u65F6\u95F4\u4ECD\u53EF\u7528\u3002`
|
|
53
|
+
);
|
|
54
|
+
}
|
|
55
|
+
var ENVIRONMENT_SYSTEMS = [
|
|
56
|
+
"lighting",
|
|
57
|
+
"shadow",
|
|
58
|
+
"wind",
|
|
59
|
+
"volumetricClouds",
|
|
60
|
+
"atmosphereScattering",
|
|
61
|
+
"distanceFog",
|
|
62
|
+
"heightFog",
|
|
63
|
+
"postProcessing",
|
|
64
|
+
"gBuffer",
|
|
65
|
+
"hbao",
|
|
66
|
+
"ssgi",
|
|
67
|
+
"ssrt",
|
|
68
|
+
"ssr"
|
|
69
|
+
];
|
|
70
|
+
function syncEnabledFlags(render, config) {
|
|
71
|
+
const systems = config?.systems;
|
|
72
|
+
if (typeof systems !== "object" || systems === null) return;
|
|
73
|
+
const target = render;
|
|
74
|
+
if (typeof target.getSystemStatus !== "function" || typeof target.toggleSystem !== "function") return;
|
|
75
|
+
for (const name of ENVIRONMENT_SYSTEMS) {
|
|
76
|
+
const enabled = systems[name]?.enabled;
|
|
77
|
+
if (typeof enabled !== "boolean") continue;
|
|
78
|
+
try {
|
|
79
|
+
if (target.getSystemStatus(name) !== enabled) target.toggleSystem(name, enabled);
|
|
80
|
+
} catch {
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
// src/environment/terrainAdjust.ts
|
|
86
|
+
var FIELDS = {
|
|
87
|
+
enabled: { get: "isTerrainAdjustEnabled", set: "setTerrainAdjustEnabled", kind: "boolean" },
|
|
88
|
+
showAppliedViz: { get: "getAppliedVizVisible", set: "setAppliedVizVisible", kind: "boolean" },
|
|
89
|
+
precision: { get: "getTerrainAdjustSSE", set: "setTerrainAdjustSSE", kind: "number" },
|
|
90
|
+
hysteresisTiles: { get: "getTerrainAdjustHysteresisTiles", set: "setTerrainAdjustHysteresisTiles", kind: "number" },
|
|
91
|
+
triangulate: { get: "getTerrainAdjustTriangulate", set: "setTerrainAdjustTriangulate", kind: "boolean" },
|
|
92
|
+
expandMeters: { get: "getTerrainAdjustExpand", set: "setTerrainAdjustExpand", kind: "number" },
|
|
93
|
+
vertexSpacing: { get: "getTerrainAdjustVertexSpacing", set: "setTerrainAdjustVertexSpacing", kind: "number" },
|
|
94
|
+
shaderMode: { get: "getShaderFlattingMode", set: "setShaderFlattingMode", kind: "boolean" }
|
|
95
|
+
};
|
|
96
|
+
function waterSystemOf(render) {
|
|
97
|
+
const getSystem = render?.getSystem;
|
|
98
|
+
const water = typeof getSystem === "function" ? getSystem.call(render, "water") : void 0;
|
|
99
|
+
if (!water || typeof water.setTerrainAdjustEnabled !== "function") {
|
|
100
|
+
throw new SmartEarthError("ENVIRONMENT_UNSUPPORTED", "\u5F53\u524D @metagl/sdk-render \u6CA1\u6709\u5730\u5F62\u6316\u5751\u63A5\u53E3\uFF08\u9700\u8981 4.x\uFF09\u3002");
|
|
101
|
+
}
|
|
102
|
+
return water;
|
|
103
|
+
}
|
|
104
|
+
function readTerrainAdjust(render) {
|
|
105
|
+
const water = waterSystemOf(render);
|
|
106
|
+
const entries = Object.keys(FIELDS).flatMap((field) => {
|
|
107
|
+
const getter = water[FIELDS[field].get];
|
|
108
|
+
return typeof getter === "function" ? [[field, getter.call(water)]] : [];
|
|
109
|
+
});
|
|
110
|
+
return Object.fromEntries(entries);
|
|
111
|
+
}
|
|
112
|
+
function writeTerrainAdjust(render, options) {
|
|
113
|
+
const water = waterSystemOf(render);
|
|
114
|
+
for (const [field, value] of Object.entries(options)) {
|
|
115
|
+
const spec = FIELDS[field];
|
|
116
|
+
if (!spec) {
|
|
117
|
+
throw new SmartEarthError("INVALID_OPTIONS", `\u5730\u5F62\u6316\u5751\u6CA1\u6709\u53C2\u6570 ${field}\uFF1B\u53EF\u9009 ${Object.keys(FIELDS).join("\u3001")}\u3002`);
|
|
118
|
+
}
|
|
119
|
+
const ok = spec.kind === "boolean" ? typeof value === "boolean" : typeof value === "number" && Number.isFinite(value);
|
|
120
|
+
if (!ok) throw new SmartEarthError("INVALID_OPTIONS", `\u5730\u5F62\u6316\u5751\u53C2\u6570 ${field} \u5FC5\u987B\u662F${spec.kind === "boolean" ? "\u5E03\u5C14\u503C" : "\u6570\u5B57"}\u3002`);
|
|
121
|
+
const setter = water[spec.set];
|
|
122
|
+
if (typeof setter !== "function") {
|
|
123
|
+
throw new SmartEarthError("ENVIRONMENT_UNSUPPORTED", `\u5F53\u524D @metagl/sdk-render \u4E0D\u652F\u6301\u5730\u5F62\u6316\u5751\u53C2\u6570 ${field}\u3002`);
|
|
124
|
+
}
|
|
125
|
+
setter.call(water, value);
|
|
126
|
+
}
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
// src/environment/effects.ts
|
|
130
|
+
var EFFECT_SYSTEMS = {
|
|
131
|
+
/** 光照系统整体(面板「光照」里的「关闭光照」)。 */
|
|
132
|
+
lighting: "lighting",
|
|
133
|
+
shadow: "shadow",
|
|
134
|
+
clouds: "volumetricClouds",
|
|
135
|
+
distanceFog: "distanceFog",
|
|
136
|
+
heightFog: "heightFog",
|
|
137
|
+
wind: "wind",
|
|
138
|
+
atmosphere: "atmosphereScattering",
|
|
139
|
+
/** 屏幕空间反射(SSR)。默认强度为 0,开了要调 intensity 才看得出。 */
|
|
140
|
+
reflection: "ssr",
|
|
141
|
+
/** 屏幕空间全局光照(SSGI)。 */
|
|
142
|
+
globalIllumination: "ssgi",
|
|
143
|
+
/** 环境光遮蔽(HBAO)。 */
|
|
144
|
+
ambientOcclusion: "hbao",
|
|
145
|
+
/** 屏幕空间光线追踪:体积光束、颜色溢出、镜面(SSRT)。 */
|
|
146
|
+
lightShafts: "ssrt",
|
|
147
|
+
/** 后处理整体(曝光、调色、泛光、抗锯齿、景深都挂在它上面)。 */
|
|
148
|
+
postProcessing: "postProcessing",
|
|
149
|
+
/** 延迟管线的 G-Buffer:全局光照、环境光遮蔽、光束、反射都依赖它,关掉它这些都会失效。 */
|
|
150
|
+
gBuffer: "gBuffer"
|
|
151
|
+
};
|
|
152
|
+
var POST_PROCESSING = "postProcessing";
|
|
153
|
+
var POST_FLAGS = {
|
|
154
|
+
bloom: "bloomEnabled",
|
|
155
|
+
hdr: "hdrEnabled",
|
|
156
|
+
fxaa: "fxaaEnabled",
|
|
157
|
+
msaa: "msaaEnabled",
|
|
158
|
+
depthOfField: "dofEnabled",
|
|
159
|
+
/** 后处理里的 Cesium 内置 AO(面板「后处理」页的 AO),与 HBAO(ambientOcclusion)不是一回事。 */
|
|
160
|
+
postAmbientOcclusion: "aoEnabled"
|
|
161
|
+
};
|
|
162
|
+
var SCENE_FOG = "sceneFog";
|
|
163
|
+
var COLOR_FILTERS = [
|
|
164
|
+
{ id: "standard", name: "\u6807\u51C6", params: { exposure: 1.1, contrast: 1.04, saturation: 1.16, temperature: 6700, tint: -0.1, sharpness: 0.45 } },
|
|
165
|
+
{ id: "warm", name: "\u6696\u8272\u8C03", params: { exposure: 1.2, contrast: 1.06, saturation: 1.2, temperature: 5e3, tint: 0.05, sharpness: 0.3 } },
|
|
166
|
+
{ id: "cool", name: "\u51B7\u8272\u8C03", params: { exposure: 1.05, contrast: 1.08, saturation: 1.1, temperature: 8500, tint: -0.05, sharpness: 0.4 } },
|
|
167
|
+
{ id: "vivid", name: "\u9C9C\u8273", params: { exposure: 1.15, contrast: 1.12, saturation: 1.5, temperature: 6500, tint: 0, sharpness: 0.6 } },
|
|
168
|
+
{ id: "desaturate", name: "\u53BB\u8272", params: { exposure: 1.1, contrast: 1.1, saturation: 0.2, temperature: 6700, tint: 0, sharpness: 0.3 } },
|
|
169
|
+
{ id: "highcontrast", name: "\u9AD8\u5BF9\u6BD4\u5EA6", params: { exposure: 1.05, contrast: 1.3, saturation: 1.1, temperature: 6700, tint: 0, sharpness: 0.7 } }
|
|
170
|
+
];
|
|
171
|
+
var DEFAULT_LIGHTING_LINK = {
|
|
172
|
+
ssgiIntensityFromLighting: (intensity) => intensity * 0.2,
|
|
173
|
+
ssrtShaftIntensityFromLighting: (intensity) => intensity * 0.25
|
|
174
|
+
};
|
|
175
|
+
var OPTION_SYSTEMS = {
|
|
176
|
+
lighting: "lighting",
|
|
177
|
+
shadow: "shadow",
|
|
178
|
+
clouds: "volumetricClouds",
|
|
179
|
+
distanceFog: "distanceFog",
|
|
180
|
+
heightFog: "heightFog",
|
|
181
|
+
atmosphere: "atmosphereScattering",
|
|
182
|
+
reflection: "ssr",
|
|
183
|
+
globalIllumination: "ssgi",
|
|
184
|
+
ambientOcclusion: "hbao",
|
|
185
|
+
lightShafts: "ssrt",
|
|
186
|
+
postProcessing: POST_PROCESSING,
|
|
187
|
+
riverWater: "riverWater",
|
|
188
|
+
water: "water",
|
|
189
|
+
wind: "wind",
|
|
190
|
+
sceneFog: SCENE_FOG,
|
|
191
|
+
buildingMaterial: "material",
|
|
192
|
+
terrainAdjust: "water",
|
|
193
|
+
heightGating: "cameraListener"
|
|
194
|
+
};
|
|
195
|
+
var ALL_EFFECTS = [...Object.keys(EFFECT_SYSTEMS), ...Object.keys(POST_FLAGS), SCENE_FOG];
|
|
196
|
+
function isPlainObject(value) {
|
|
197
|
+
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
198
|
+
}
|
|
199
|
+
function readPostFlag(render, flag) {
|
|
200
|
+
if (render.getSystemStatus(POST_PROCESSING) !== true) return false;
|
|
201
|
+
const config = render.getSystemConfig(POST_PROCESSING);
|
|
202
|
+
return isPlainObject(config) && config[flag] === true;
|
|
203
|
+
}
|
|
204
|
+
function requireKnown(value, known, what) {
|
|
205
|
+
if (typeof value !== "string" || !known.includes(value)) {
|
|
206
|
+
throw new SmartEarthError("INVALID_OPTIONS", `\u6CA1\u6709\u8FD9\u4E2A${what}\uFF1A${String(value)}\uFF1B\u53EF\u9009 ${known.join("\u3001")}\u3002`);
|
|
207
|
+
}
|
|
208
|
+
return value;
|
|
209
|
+
}
|
|
210
|
+
function withoutEnabled(options) {
|
|
211
|
+
const { enabled: _enabled, ...rest } = options;
|
|
212
|
+
return rest;
|
|
213
|
+
}
|
|
214
|
+
function requireApplyConfig(render) {
|
|
215
|
+
if (typeof render?.applyConfig === "function") {
|
|
216
|
+
return render;
|
|
217
|
+
}
|
|
218
|
+
throw new SmartEarthError("ENVIRONMENT_UNSUPPORTED", "\u5F53\u524D @metagl/sdk-render \u4E0D\u652F\u6301\u5185\u7F6E\u96FE\u914D\u7F6E\uFF08\u9700\u8981 4.x\uFF09\u3002");
|
|
219
|
+
}
|
|
220
|
+
function readSceneFog(viewer) {
|
|
221
|
+
const fog = viewer?.scene?.fog;
|
|
222
|
+
return {
|
|
223
|
+
enabled: fog?.enabled === true,
|
|
224
|
+
...typeof fog?.density === "number" ? { density: fog.density } : {},
|
|
225
|
+
...typeof fog?.heightFalloff === "number" ? { heightFalloff: fog.heightFalloff } : {}
|
|
226
|
+
};
|
|
227
|
+
}
|
|
228
|
+
function writeSceneFog(render, viewer, patch) {
|
|
229
|
+
const { enabled, density, heightFalloff } = readSceneFog(viewer);
|
|
230
|
+
const current = Object.fromEntries(
|
|
231
|
+
Object.entries({ enabled, density, heightFalloff }).filter(([, value]) => value !== void 0)
|
|
232
|
+
);
|
|
233
|
+
requireApplyConfig(render).applyConfig({ builtinFog: { ...current, ...patch } });
|
|
234
|
+
}
|
|
235
|
+
function copyValue(value) {
|
|
236
|
+
if (typeof value !== "object" || value === null) return value;
|
|
237
|
+
if (typeof value.clone === "function") return value.clone();
|
|
238
|
+
if (Array.isArray(value)) return value.map(copyValue);
|
|
239
|
+
return Object.fromEntries(Object.entries(value).map(([key, inner]) => [key, copyValue(inner)]));
|
|
240
|
+
}
|
|
241
|
+
function copyOptions(config) {
|
|
242
|
+
return copyValue(config);
|
|
243
|
+
}
|
|
244
|
+
function createEffectApi(renderLike, assertAlive, viewer, lightingLink = DEFAULT_LIGHTING_LINK) {
|
|
245
|
+
const optionTargets = Object.keys(OPTION_SYSTEMS);
|
|
246
|
+
const toggle = (render, name, enabled) => {
|
|
247
|
+
if (name === SCENE_FOG) {
|
|
248
|
+
writeSceneFog(render, viewer, { enabled });
|
|
249
|
+
return;
|
|
250
|
+
}
|
|
251
|
+
if (Object.hasOwn(POST_FLAGS, name)) {
|
|
252
|
+
render.updateSystemConfig(POST_PROCESSING, { [POST_FLAGS[name]]: enabled });
|
|
253
|
+
if (enabled && render.getSystemStatus(POST_PROCESSING) !== true) render.toggleSystem(POST_PROCESSING, true);
|
|
254
|
+
return;
|
|
255
|
+
}
|
|
256
|
+
render.toggleSystem(EFFECT_SYSTEMS[name], enabled);
|
|
257
|
+
};
|
|
258
|
+
const status = (render, effect) => {
|
|
259
|
+
if (effect === SCENE_FOG) return readSceneFog(viewer).enabled;
|
|
260
|
+
if (Object.hasOwn(POST_FLAGS, effect)) return readPostFlag(render, POST_FLAGS[effect]);
|
|
261
|
+
return render.getSystemStatus(EFFECT_SYSTEMS[effect]) === true;
|
|
262
|
+
};
|
|
263
|
+
return {
|
|
264
|
+
setEffect(effect, enabled) {
|
|
265
|
+
assertAlive();
|
|
266
|
+
const name = requireKnown(effect, ALL_EFFECTS, "\u6548\u679C");
|
|
267
|
+
if (typeof enabled !== "boolean") throw new SmartEarthError("INVALID_OPTIONS", `\u6548\u679C ${name} \u7684\u5F00\u5173\u5FC5\u987B\u662F true / false\u3002`);
|
|
268
|
+
const render = requireEnvironment(renderLike, "\u6548\u679C\u5F00\u5173");
|
|
269
|
+
call(`\u5207\u6362 ${name} `, () => toggle(render, name, enabled));
|
|
270
|
+
},
|
|
271
|
+
getEffects() {
|
|
272
|
+
const render = supportsEnvironment(renderLike) ? renderLike : void 0;
|
|
273
|
+
const entries = ALL_EFFECTS.map((effect) => [effect, render ? status(render, effect) : false]);
|
|
274
|
+
return Object.fromEntries(entries);
|
|
275
|
+
},
|
|
276
|
+
getEffectOptions(target) {
|
|
277
|
+
assertAlive();
|
|
278
|
+
const name = requireKnown(target, optionTargets, "\u53EF\u8C03\u53C2\u6570\u7684\u6548\u679C");
|
|
279
|
+
const render = requireEnvironment(renderLike, "\u6548\u679C\u53C2\u6570");
|
|
280
|
+
if (name === SCENE_FOG) {
|
|
281
|
+
const { enabled: _enabled, ...fog } = readSceneFog(viewer);
|
|
282
|
+
return fog;
|
|
283
|
+
}
|
|
284
|
+
if (name === "terrainAdjust") {
|
|
285
|
+
return call("\u8BFB\u53D6\u5730\u5F62\u6316\u5751\u53C2\u6570", () => readTerrainAdjust(render));
|
|
286
|
+
}
|
|
287
|
+
if (name === "buildingMaterial") {
|
|
288
|
+
const material = call("\u8BFB\u53D6\u5EFA\u7B51\u6750\u8D28", () => render.getSystemConfig("material"));
|
|
289
|
+
const pbr = isPlainObject(material) && isPlainObject(material.pbr) ? material.pbr : {};
|
|
290
|
+
return { ...pbr };
|
|
291
|
+
}
|
|
292
|
+
const config = call(`\u8BFB\u53D6 ${name} \u53C2\u6570`, () => render.getSystemConfig(OPTION_SYSTEMS[name]));
|
|
293
|
+
return isPlainObject(config) ? copyOptions(config) : {};
|
|
294
|
+
},
|
|
295
|
+
setEffectOptions(target, options) {
|
|
296
|
+
assertAlive();
|
|
297
|
+
const name = requireKnown(target, optionTargets, "\u53EF\u8C03\u53C2\u6570\u7684\u6548\u679C");
|
|
298
|
+
if (!isPlainObject(options)) throw new SmartEarthError("INVALID_OPTIONS", "\u6548\u679C\u53C2\u6570\u5FC5\u987B\u662F\u5BF9\u8C61\u3002");
|
|
299
|
+
const render = requireEnvironment(renderLike, "\u6548\u679C\u53C2\u6570");
|
|
300
|
+
if (name === "terrainAdjust") {
|
|
301
|
+
call("\u4FEE\u6539\u5730\u5F62\u6316\u5751\u53C2\u6570", () => writeTerrainAdjust(render, options));
|
|
302
|
+
return;
|
|
303
|
+
}
|
|
304
|
+
const patch = withoutEnabled(options);
|
|
305
|
+
if (name === SCENE_FOG) {
|
|
306
|
+
call("\u4FEE\u6539\u5185\u7F6E\u96FE\u53C2\u6570", () => writeSceneFog(render, viewer, patch));
|
|
307
|
+
return;
|
|
308
|
+
}
|
|
309
|
+
if (name === "buildingMaterial") {
|
|
310
|
+
call("\u4FEE\u6539\u5EFA\u7B51\u6750\u8D28", () => render.updateSystemConfig("material", { pbr: patch }));
|
|
311
|
+
return;
|
|
312
|
+
}
|
|
313
|
+
call(`\u4FEE\u6539 ${name} \u53C2\u6570`, () => {
|
|
314
|
+
render.updateSystemConfig(OPTION_SYSTEMS[name], patch);
|
|
315
|
+
const intensity = patch.intensity;
|
|
316
|
+
if (name === "lighting" && typeof intensity === "number" && Number.isFinite(intensity)) {
|
|
317
|
+
render.updateSystemConfig("ssgi", { intensity: lightingLink.ssgiIntensityFromLighting(intensity) });
|
|
318
|
+
render.updateSystemConfig("ssrt", { shaftIntensity: lightingLink.ssrtShaftIntensityFromLighting(intensity) });
|
|
319
|
+
}
|
|
320
|
+
});
|
|
321
|
+
},
|
|
322
|
+
colorFilters: COLOR_FILTERS,
|
|
323
|
+
applyColorFilter(id) {
|
|
324
|
+
assertAlive();
|
|
325
|
+
const filter = COLOR_FILTERS.find((item) => item.id === id);
|
|
326
|
+
if (!filter) {
|
|
327
|
+
throw new SmartEarthError("INVALID_OPTIONS", `\u6CA1\u6709\u8FD9\u4E2A\u8C03\u8272\u6EE4\u955C\uFF1A${String(id)}\uFF1B\u53EF\u9009 ${COLOR_FILTERS.map((f) => f.id).join("\u3001")}\u3002`);
|
|
328
|
+
}
|
|
329
|
+
const render = requireEnvironment(renderLike, "\u8C03\u8272\u6EE4\u955C");
|
|
330
|
+
call(`\u5957\u7528\u6EE4\u955C ${id}`, () => render.updateSystemConfig(POST_PROCESSING, { ...filter.params }));
|
|
331
|
+
}
|
|
332
|
+
};
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
// src/environment/snapshot.ts
|
|
336
|
+
var PRESET_DOCUMENT_SCHEMA = "smartearth-preset/1";
|
|
337
|
+
function isRecord(value) {
|
|
338
|
+
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
339
|
+
}
|
|
340
|
+
function requireSnapshot(value, what = "\u73AF\u5883\u5FEB\u7167") {
|
|
341
|
+
if (!isRecord(value) || !isRecord(value.environment) || !isRecord(value.environment.systems)) {
|
|
342
|
+
throw new SmartEarthError("INVALID_OPTIONS", `${what}\u4E0D\u5408\u6CD5\uFF1A\u7F3A\u5C11 environment.systems\u3002`);
|
|
343
|
+
}
|
|
344
|
+
if (value.time !== void 0 && (typeof value.time !== "string" || Number.isNaN(Date.parse(value.time)))) {
|
|
345
|
+
throw new SmartEarthError("INVALID_OPTIONS", `${what}\u7684 time \u4E0D\u662F\u5408\u6CD5\u7684 ISO \u65F6\u95F4\u3002`);
|
|
346
|
+
}
|
|
347
|
+
const camera = value.camera;
|
|
348
|
+
if (camera !== void 0) {
|
|
349
|
+
const ok = isRecord(camera) && ["lon", "lat", "height", "heading", "pitch"].every((key) => Number.isFinite(camera[key]));
|
|
350
|
+
if (!ok) throw new SmartEarthError("INVALID_OPTIONS", `${what}\u7684 camera \u8981\u6709 lon / lat / height / heading / pitch\u3002`);
|
|
351
|
+
}
|
|
352
|
+
return value;
|
|
353
|
+
}
|
|
354
|
+
function requirePresetDocument(value, what = "\u9884\u8BBE\u6587\u4EF6") {
|
|
355
|
+
if (!isRecord(value) || value.schema !== PRESET_DOCUMENT_SCHEMA) {
|
|
356
|
+
throw new SmartEarthError("INVALID_OPTIONS", `${what}\u4E0D\u662F ${PRESET_DOCUMENT_SCHEMA} \u683C\u5F0F\u3002`);
|
|
357
|
+
}
|
|
358
|
+
return requireSnapshot(value.snapshot, what);
|
|
359
|
+
}
|
|
360
|
+
|
|
361
|
+
// src/environment/lighting.ts
|
|
362
|
+
var LIGHTING = "lighting";
|
|
363
|
+
var MODES = ["off", "manual", "sun"];
|
|
364
|
+
function isFiniteNumber(value) {
|
|
365
|
+
return typeof value === "number" && Number.isFinite(value);
|
|
366
|
+
}
|
|
367
|
+
function directionFromAngles(Cesium, viewer, angles) {
|
|
368
|
+
const runtime = Cesium;
|
|
369
|
+
const az = angles.azimuth * Math.PI / 180;
|
|
370
|
+
const el = angles.elevation * Math.PI / 180;
|
|
371
|
+
const toSun = new runtime.Cartesian3(Math.sin(az) * Math.cos(el), Math.cos(az) * Math.cos(el), Math.sin(el));
|
|
372
|
+
const enu = runtime.Transforms.eastNorthUpToFixedFrame(viewer.camera.positionWC);
|
|
373
|
+
const ecef = runtime.Matrix4.multiplyByPointAsVector(enu, toSun, new runtime.Cartesian3(0, 0, 0));
|
|
374
|
+
runtime.Cartesian3.normalize(ecef, ecef);
|
|
375
|
+
runtime.Cartesian3.negate(ecef, ecef);
|
|
376
|
+
return ecef;
|
|
377
|
+
}
|
|
378
|
+
function createLightingApi(renderLike, viewer, Cesium, assertAlive) {
|
|
379
|
+
return {
|
|
380
|
+
setLightingMode(mode) {
|
|
381
|
+
assertAlive();
|
|
382
|
+
if (!MODES.includes(mode)) {
|
|
383
|
+
throw new SmartEarthError("INVALID_OPTIONS", `\u5149\u7167\u6A21\u5F0F\u53EA\u80FD\u662F ${MODES.join(" / ")}\u3002`);
|
|
384
|
+
}
|
|
385
|
+
const render = requireEnvironment(renderLike, "\u5149\u7167\u6A21\u5F0F");
|
|
386
|
+
call("\u5207\u6362\u5149\u7167\u6A21\u5F0F", () => {
|
|
387
|
+
if (mode === "off") {
|
|
388
|
+
render.toggleSystem(LIGHTING, false);
|
|
389
|
+
return;
|
|
390
|
+
}
|
|
391
|
+
render.toggleSystem(LIGHTING, true);
|
|
392
|
+
render.updateSystemConfig(LIGHTING, { followSun: mode === "sun" });
|
|
393
|
+
});
|
|
394
|
+
},
|
|
395
|
+
getLightingMode() {
|
|
396
|
+
if (!supportsEnvironment(renderLike)) return "sun";
|
|
397
|
+
if (renderLike.getSystemStatus(LIGHTING) !== true) return "off";
|
|
398
|
+
const config = renderLike.getSystemConfig(LIGHTING);
|
|
399
|
+
return config?.followSun === false ? "manual" : "sun";
|
|
400
|
+
},
|
|
401
|
+
setLightDirection(direction) {
|
|
402
|
+
assertAlive();
|
|
403
|
+
if (!isFiniteNumber(direction?.azimuth) || !isFiniteNumber(direction.elevation)) {
|
|
404
|
+
throw new SmartEarthError("INVALID_OPTIONS", "\u5149\u7167\u65B9\u5411\u8981\u5199\u6210 { azimuth: \u65B9\u4F4D\u89D2, elevation: \u9AD8\u5EA6\u89D2 }\uFF08\u5EA6\uFF09\u3002");
|
|
405
|
+
}
|
|
406
|
+
if (direction.elevation < -90 || direction.elevation > 90) {
|
|
407
|
+
throw new SmartEarthError("INVALID_OPTIONS", "\u9AD8\u5EA6\u89D2 elevation \u8981\u5728 -90 ~ 90 \u5EA6\u4E4B\u95F4\u3002");
|
|
408
|
+
}
|
|
409
|
+
const render = requireEnvironment(renderLike, "\u5149\u7167\u65B9\u5411");
|
|
410
|
+
const vector = call("\u8BA1\u7B97\u5149\u7167\u65B9\u5411", () => directionFromAngles(Cesium, viewer, direction));
|
|
411
|
+
call("\u8BBE\u7F6E\u5149\u7167\u65B9\u5411", () => {
|
|
412
|
+
render.toggleSystem(LIGHTING, true);
|
|
413
|
+
render.updateSystemConfig(LIGHTING, { followSun: false, direction: vector });
|
|
414
|
+
});
|
|
415
|
+
}
|
|
416
|
+
};
|
|
417
|
+
}
|
|
418
|
+
|
|
419
|
+
// src/core/events.ts
|
|
420
|
+
var Emitter = class {
|
|
421
|
+
constructor(onError = () => void 0) {
|
|
422
|
+
this.onError = onError;
|
|
423
|
+
}
|
|
424
|
+
onError;
|
|
425
|
+
listeners = /* @__PURE__ */ new Map();
|
|
426
|
+
on(event, listener) {
|
|
427
|
+
const set = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
|
|
428
|
+
set.add(listener);
|
|
429
|
+
this.listeners.set(event, set);
|
|
430
|
+
return () => {
|
|
431
|
+
set.delete(listener);
|
|
432
|
+
};
|
|
433
|
+
}
|
|
434
|
+
emit(event, payload) {
|
|
435
|
+
for (const listener of this.listeners.get(event) ?? []) {
|
|
436
|
+
try {
|
|
437
|
+
listener(payload);
|
|
438
|
+
} catch (error) {
|
|
439
|
+
this.onError(error);
|
|
440
|
+
}
|
|
441
|
+
}
|
|
442
|
+
}
|
|
443
|
+
clear() {
|
|
444
|
+
this.listeners.clear();
|
|
445
|
+
}
|
|
446
|
+
};
|
|
447
|
+
|
|
448
|
+
// src/environment/time.ts
|
|
449
|
+
var BEIJING_OFFSET_HOURS = 8;
|
|
450
|
+
var MS_PER_HOUR = 36e5;
|
|
451
|
+
var MS_PER_MINUTE = 6e4;
|
|
452
|
+
function isInteger(value, min, max) {
|
|
453
|
+
return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
|
|
454
|
+
}
|
|
455
|
+
function resolveOffset(utcOffset) {
|
|
456
|
+
if (utcOffset === void 0) return BEIJING_OFFSET_HOURS;
|
|
457
|
+
if (typeof utcOffset !== "number" || !Number.isFinite(utcOffset) || utcOffset < -12 || utcOffset > 14) {
|
|
458
|
+
throw new SmartEarthError("INVALID_OPTIONS", "\u65F6\u533A utcOffset \u8981\u5728 -12 ~ 14 \u4E4B\u95F4\uFF08\u5C0F\u65F6\uFF0C\u5317\u4EAC\u65F6\u95F4\u4E3A 8\uFF09\u3002");
|
|
459
|
+
}
|
|
460
|
+
return utcOffset;
|
|
461
|
+
}
|
|
462
|
+
function atBeijingClock(current, clock) {
|
|
463
|
+
const minute = clock.minute ?? 0;
|
|
464
|
+
if (!isInteger(clock.hour, 0, 23) || !isInteger(minute, 0, 59)) {
|
|
465
|
+
throw new SmartEarthError("INVALID_OPTIONS", "\u65F6\u95F4\u8981\u5199\u6210 { hour: 0~23 \u7684\u6574\u6570, minute?: 0~59 \u7684\u6574\u6570 }\u3002");
|
|
466
|
+
}
|
|
467
|
+
const offset = resolveOffset(clock.utcOffset);
|
|
468
|
+
const local = new Date(current.getTime() + offset * MS_PER_HOUR);
|
|
469
|
+
const midnightUtc = Date.UTC(local.getUTCFullYear(), local.getUTCMonth(), local.getUTCDate());
|
|
470
|
+
return new Date(midnightUtc + (clock.hour - offset) * MS_PER_HOUR + minute * MS_PER_MINUTE);
|
|
471
|
+
}
|
|
472
|
+
function resolveTime(input, current) {
|
|
473
|
+
if (input instanceof Date) {
|
|
474
|
+
if (Number.isNaN(input.getTime())) throw new SmartEarthError("INVALID_OPTIONS", "\u65F6\u95F4\u4E0D\u662F\u6709\u6548\u7684\u65E5\u671F\u3002");
|
|
475
|
+
return new Date(input.getTime());
|
|
476
|
+
}
|
|
477
|
+
if (typeof input === "string") {
|
|
478
|
+
const parsed = new Date(input);
|
|
479
|
+
if (input.trim() === "" || Number.isNaN(parsed.getTime())) {
|
|
480
|
+
throw new SmartEarthError("INVALID_OPTIONS", `\u65F6\u95F4\u5B57\u7B26\u4E32\u65E0\u6CD5\u89E3\u6790\uFF1A${input}\uFF08\u8BF7\u7528 ISO 8601\uFF0C\u5982 2026-06-21T18:30:00+08:00\uFF09\u3002`);
|
|
481
|
+
}
|
|
482
|
+
return parsed;
|
|
483
|
+
}
|
|
484
|
+
if (typeof input === "object" && input !== null) return atBeijingClock(current, input);
|
|
485
|
+
throw new SmartEarthError("INVALID_OPTIONS", "\u65F6\u95F4\u8981\u4F20 Date\u3001ISO \u5B57\u7B26\u4E32\u6216 { hour, minute }\u3002");
|
|
486
|
+
}
|
|
487
|
+
function beijingClockOf(date, utcOffset) {
|
|
488
|
+
const offset = resolveOffset(utcOffset);
|
|
489
|
+
const local = new Date(date.getTime() + offset * MS_PER_HOUR);
|
|
490
|
+
return { hour: local.getUTCHours(), minute: local.getUTCMinutes(), utcOffset: offset };
|
|
491
|
+
}
|
|
492
|
+
|
|
493
|
+
// src/environment/portable.ts
|
|
494
|
+
var SDK_ASSET = /^(?:[a-z]+:\/\/[^/]+)?\/(?:.*\/)?(assets\/(?:Images|Textures)\/[\w.-]+)$/i;
|
|
495
|
+
function portableValue(value) {
|
|
496
|
+
if (typeof value === "string") {
|
|
497
|
+
const match = SDK_ASSET.exec(value);
|
|
498
|
+
return match ? `./${match[1]}` : value;
|
|
499
|
+
}
|
|
500
|
+
if (Array.isArray(value)) return value.map(portableValue);
|
|
501
|
+
if (typeof value === "object" && value !== null) {
|
|
502
|
+
return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, portableValue(item)]));
|
|
503
|
+
}
|
|
504
|
+
return value;
|
|
505
|
+
}
|
|
506
|
+
function portableAssetPaths(config) {
|
|
507
|
+
return portableValue(config);
|
|
508
|
+
}
|
|
509
|
+
function withoutClock(config) {
|
|
510
|
+
const settings = config.settings;
|
|
511
|
+
if (typeof settings !== "object" || settings === null || !("clockIsoTime" in settings)) return config;
|
|
512
|
+
const { clockIsoTime: _dropped, ...rest } = settings;
|
|
513
|
+
return { ...config, settings: rest };
|
|
514
|
+
}
|
|
515
|
+
|
|
516
|
+
// src/environment/index.ts
|
|
517
|
+
var ENVIRONMENT_PRESETS = [
|
|
518
|
+
{ id: "noon-clear", name: "\u6674\u5929\u6B63\u5348" },
|
|
519
|
+
{ id: "sunrise", name: "\u6E05\u6668\u65E5\u51FA" },
|
|
520
|
+
{ id: "sunset", name: "\u9EC4\u660F\u843D\u65E5" },
|
|
521
|
+
{ id: "cloudy-afternoon", name: "\u591A\u4E91\u5348\u540E" },
|
|
522
|
+
{ id: "overcast", name: "\u9634\u96E8\u5929\u6C14" },
|
|
523
|
+
{ id: "night", name: "\u591C\u95F4\u661F\u7A7A" },
|
|
524
|
+
{ id: "cinematic", name: "\u7535\u5F71\u7EA7" }
|
|
525
|
+
];
|
|
526
|
+
var DEFAULT_DEFER_ABOVE_METERS = 1e5;
|
|
527
|
+
var MIRROR_OFF_DELAY_MS = 100;
|
|
528
|
+
var MS_PER_SECOND = 1e3;
|
|
529
|
+
var PRESET_MANAGED_SYSTEMS = ENVIRONMENT_SYSTEMS;
|
|
530
|
+
var PRESET_IDS = new Set(ENVIRONMENT_PRESETS.map((preset) => preset.id));
|
|
531
|
+
function createClockApi(deps) {
|
|
532
|
+
const { viewer, Cesium, assertAlive } = deps;
|
|
533
|
+
const getTime = () => Cesium.JulianDate.toDate(viewer.clock.currentTime);
|
|
534
|
+
return {
|
|
535
|
+
setTime(time) {
|
|
536
|
+
assertAlive();
|
|
537
|
+
viewer.clock.currentTime = Cesium.JulianDate.fromDate(resolveTime(time, getTime()));
|
|
538
|
+
viewer.scene.requestRender();
|
|
539
|
+
},
|
|
540
|
+
getTime,
|
|
541
|
+
getClockOfDay: (utcOffset) => beijingClockOf(getTime(), utcOffset),
|
|
542
|
+
setClock(state) {
|
|
543
|
+
assertAlive();
|
|
544
|
+
if (state.multiplier !== void 0) {
|
|
545
|
+
if (typeof state.multiplier !== "number" || !Number.isFinite(state.multiplier)) {
|
|
546
|
+
throw new SmartEarthError("INVALID_OPTIONS", "\u65F6\u95F4\u6D41\u901F multiplier \u5FC5\u987B\u662F\u6709\u9650\u6570\u5B57\u3002");
|
|
547
|
+
}
|
|
548
|
+
viewer.clock.multiplier = state.multiplier;
|
|
549
|
+
}
|
|
550
|
+
if (state.animate !== void 0) viewer.clock.shouldAnimate = Boolean(state.animate);
|
|
551
|
+
},
|
|
552
|
+
getClock: () => ({ animate: viewer.clock.shouldAnimate, multiplier: viewer.clock.multiplier })
|
|
553
|
+
};
|
|
554
|
+
}
|
|
555
|
+
function takeSnapshot(render) {
|
|
556
|
+
return PRESET_MANAGED_SYSTEMS.flatMap((name) => {
|
|
557
|
+
const enabled = render.getSystemStatus(name);
|
|
558
|
+
if (enabled === void 0) return [];
|
|
559
|
+
return [{ name, enabled: enabled === true, config: render.getSystemConfig(name) }];
|
|
560
|
+
});
|
|
561
|
+
}
|
|
562
|
+
function restoreSnapshot(render, snapshot) {
|
|
563
|
+
for (const system of snapshot) {
|
|
564
|
+
if (system.config !== void 0) render.updateSystemConfig(system.name, system.config);
|
|
565
|
+
render.toggleSystem(system.name, system.enabled);
|
|
566
|
+
}
|
|
567
|
+
}
|
|
568
|
+
function validatePresetArgs(id, transition) {
|
|
569
|
+
if (typeof id !== "string" || !PRESET_IDS.has(id)) {
|
|
570
|
+
throw new SmartEarthError("INVALID_OPTIONS", `\u6CA1\u6709\u8FD9\u4E2A\u9884\u8BBE\uFF1A${String(id)}\uFF1B\u53EF\u9009 ${[...PRESET_IDS].join("\u3001")}\u3002`);
|
|
571
|
+
}
|
|
572
|
+
if (typeof transition !== "number" || !Number.isFinite(transition) || transition < 0) {
|
|
573
|
+
throw new SmartEarthError("INVALID_OPTIONS", "\u9884\u8BBE\u8FC7\u6E21\u79D2\u6570 transition \u5FC5\u987B\u662F\u4E0D\u5C0F\u4E8E 0 \u7684\u6570\u5B57\u3002");
|
|
574
|
+
}
|
|
575
|
+
}
|
|
576
|
+
function createPresetApi(deps, notify) {
|
|
577
|
+
let baseline;
|
|
578
|
+
const getPreset = () => {
|
|
579
|
+
if (!supportsEnvironment(deps.render)) return null;
|
|
580
|
+
const active = deps.render.getActivePreset();
|
|
581
|
+
return active !== null && PRESET_IDS.has(active) ? active : null;
|
|
582
|
+
};
|
|
583
|
+
const cameraHeight = () => deps.viewer.camera?.positionCartographic?.height ?? 0;
|
|
584
|
+
let mirrorTimer;
|
|
585
|
+
const turnMirrorOffAfter = (transition) => {
|
|
586
|
+
if (mirrorTimer !== void 0) clearTimeout(mirrorTimer);
|
|
587
|
+
const off = () => {
|
|
588
|
+
mirrorTimer = void 0;
|
|
589
|
+
if (!supportsEnvironment(deps.render) || getPreset() === null) return;
|
|
590
|
+
try {
|
|
591
|
+
deps.render.updateSystemConfig("ssrt", { mirrorEnabled: false });
|
|
592
|
+
} catch {
|
|
593
|
+
}
|
|
594
|
+
};
|
|
595
|
+
if (transition > 0) mirrorTimer = setTimeout(off, transition * MS_PER_SECOND + MIRROR_OFF_DELAY_MS);
|
|
596
|
+
else off();
|
|
597
|
+
};
|
|
598
|
+
let pending;
|
|
599
|
+
let removeCameraListener;
|
|
600
|
+
const cancelPending = () => {
|
|
601
|
+
removeCameraListener?.();
|
|
602
|
+
removeCameraListener = void 0;
|
|
603
|
+
pending = void 0;
|
|
604
|
+
};
|
|
605
|
+
const waitForLowAltitude = (next) => {
|
|
606
|
+
pending = next;
|
|
607
|
+
const camera = deps.viewer.camera;
|
|
608
|
+
const check = () => {
|
|
609
|
+
if (!pending || cameraHeight() > pending.deferAbove) return;
|
|
610
|
+
const { id, transition, keepMirror } = pending;
|
|
611
|
+
cancelPending();
|
|
612
|
+
try {
|
|
613
|
+
applyNow(id, transition, keepMirror);
|
|
614
|
+
notify("preset");
|
|
615
|
+
} catch (error) {
|
|
616
|
+
console.error("[smartearth-base] \u5EF6\u540E\u7684\u9884\u8BBE\u5207\u6362\u5931\u8D25", error);
|
|
617
|
+
}
|
|
618
|
+
};
|
|
619
|
+
if (camera.changed) {
|
|
620
|
+
if (typeof camera.percentageChanged === "number") camera.percentageChanged = Math.min(camera.percentageChanged, 0.02);
|
|
621
|
+
removeCameraListener = camera.changed.addEventListener(check);
|
|
622
|
+
}
|
|
623
|
+
};
|
|
624
|
+
const applyNow = (id, transition, keepMirror) => {
|
|
625
|
+
const render = requireEnvironment(deps.render, "\u573A\u666F\u9884\u8BBE");
|
|
626
|
+
const isFirst = baseline === void 0;
|
|
627
|
+
if (isFirst) baseline = call("\u8BB0\u5F55\u5F53\u524D\u73AF\u5883", () => takeSnapshot(render));
|
|
628
|
+
try {
|
|
629
|
+
call(
|
|
630
|
+
`\u5207\u6362\u9884\u8BBE ${id} `,
|
|
631
|
+
() => transition > 0 ? render.transitionToPreset(id, transition) : render.applyPreset(id)
|
|
632
|
+
);
|
|
633
|
+
} catch (error) {
|
|
634
|
+
if (isFirst && baseline) {
|
|
635
|
+
const snapshot = baseline;
|
|
636
|
+
baseline = void 0;
|
|
637
|
+
try {
|
|
638
|
+
restoreSnapshot(render, snapshot);
|
|
639
|
+
} catch {
|
|
640
|
+
}
|
|
641
|
+
}
|
|
642
|
+
throw error;
|
|
643
|
+
}
|
|
644
|
+
if (!keepMirror) turnMirrorOffAfter(transition);
|
|
645
|
+
};
|
|
646
|
+
return {
|
|
647
|
+
setPreset(id, options) {
|
|
648
|
+
deps.assertAlive();
|
|
649
|
+
const transition = options?.transition ?? 0;
|
|
650
|
+
validatePresetArgs(id, transition);
|
|
651
|
+
requireEnvironment(deps.render, "\u573A\u666F\u9884\u8BBE");
|
|
652
|
+
const deferAbove = options?.deferAboveMeters ?? DEFAULT_DEFER_ABOVE_METERS;
|
|
653
|
+
if (deferAbove !== false && (typeof deferAbove !== "number" || !(deferAbove > 0))) {
|
|
654
|
+
throw new SmartEarthError("INVALID_OPTIONS", "deferAboveMeters \u8981\u662F\u6B63\u6570\uFF08\u7C73\uFF09\u6216 false\u3002");
|
|
655
|
+
}
|
|
656
|
+
cancelPending();
|
|
657
|
+
const keepMirror = options?.keepMirror === true;
|
|
658
|
+
if (deferAbove !== false && cameraHeight() > deferAbove) {
|
|
659
|
+
waitForLowAltitude({ id, transition, keepMirror, deferAbove });
|
|
660
|
+
return;
|
|
661
|
+
}
|
|
662
|
+
applyNow(id, transition, keepMirror);
|
|
663
|
+
},
|
|
664
|
+
getPendingPreset: () => pending?.id ?? null,
|
|
665
|
+
getPreset,
|
|
666
|
+
clearPreset() {
|
|
667
|
+
deps.assertAlive();
|
|
668
|
+
const render = requireEnvironment(deps.render, "\u573A\u666F\u9884\u8BBE");
|
|
669
|
+
cancelPending();
|
|
670
|
+
if (baseline === void 0 && getPreset() === null) return;
|
|
671
|
+
const snapshot = baseline;
|
|
672
|
+
call("\u6E05\u9664\u9884\u8BBE", () => {
|
|
673
|
+
render.clearPreset();
|
|
674
|
+
if (snapshot) restoreSnapshot(render, snapshot);
|
|
675
|
+
});
|
|
676
|
+
baseline = void 0;
|
|
677
|
+
},
|
|
678
|
+
/** 画质切换会改系统配置,进预设前的快照随之作废。 */
|
|
679
|
+
forgetBaseline() {
|
|
680
|
+
baseline = void 0;
|
|
681
|
+
},
|
|
682
|
+
/** 销毁地球时:取消等待中的预设与镜面定时器。 */
|
|
683
|
+
disposePresets() {
|
|
684
|
+
cancelPending();
|
|
685
|
+
if (mirrorTimer !== void 0) clearTimeout(mirrorTimer);
|
|
686
|
+
}
|
|
687
|
+
};
|
|
688
|
+
}
|
|
689
|
+
function requireConfigIo(render) {
|
|
690
|
+
const candidate = render;
|
|
691
|
+
if (typeof candidate?.getConfig === "function" && typeof candidate.loadConfig === "function") {
|
|
692
|
+
return candidate;
|
|
693
|
+
}
|
|
694
|
+
throw new SmartEarthError("ENVIRONMENT_UNSUPPORTED", "\u5F53\u524D @metagl/sdk-render \u4E0D\u652F\u6301\u73AF\u5883\u914D\u7F6E\u5BFC\u5165\u5BFC\u51FA\uFF08\u9700\u8981 4.x\uFF09\u3002");
|
|
695
|
+
}
|
|
696
|
+
var DISABLE_ALL_SYSTEMS = [
|
|
697
|
+
"lighting",
|
|
698
|
+
"shadow",
|
|
699
|
+
"atmosphereScattering",
|
|
700
|
+
"volumetricClouds",
|
|
701
|
+
"distanceFog",
|
|
702
|
+
"heightFog",
|
|
703
|
+
"postProcessing"
|
|
704
|
+
];
|
|
705
|
+
function requireAllSystems(render) {
|
|
706
|
+
if (supportsEnvironment(render) && typeof render.enableAllWithDefaults === "function") {
|
|
707
|
+
return render;
|
|
708
|
+
}
|
|
709
|
+
throw new SmartEarthError("ENVIRONMENT_UNSUPPORTED", "\u5F53\u524D @metagl/sdk-render \u4E0D\u652F\u6301\u4E00\u952E\u5F00\u5173\u5168\u90E8\u6E32\u67D3\u7CFB\u7EDF\u3002");
|
|
710
|
+
}
|
|
711
|
+
function isConfigObject(value) {
|
|
712
|
+
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
713
|
+
}
|
|
714
|
+
function createConfigApi(deps, leavePreset) {
|
|
715
|
+
return {
|
|
716
|
+
async exportConfig() {
|
|
717
|
+
deps.assertAlive();
|
|
718
|
+
const render = requireConfigIo(deps.render);
|
|
719
|
+
const read = () => call("\u5BFC\u51FA\u73AF\u5883\u914D\u7F6E", () => render.getConfig());
|
|
720
|
+
const config = deps.withBaseQuality ? await deps.withBaseQuality(read) : read();
|
|
721
|
+
return isConfigObject(config) ? portableAssetPaths(JSON.parse(JSON.stringify(config))) : {};
|
|
722
|
+
},
|
|
723
|
+
async importConfig(config) {
|
|
724
|
+
deps.assertAlive();
|
|
725
|
+
if (!isConfigObject(config) || !isConfigObject(config.systems)) {
|
|
726
|
+
throw new SmartEarthError("INVALID_OPTIONS", "\u73AF\u5883\u914D\u7F6E\u8981\u662F exportConfig \u5BFC\u51FA\u7684\u5BF9\u8C61\uFF08\u542B systems\uFF09\u3002");
|
|
727
|
+
}
|
|
728
|
+
const render = requireConfigIo(deps.render);
|
|
729
|
+
leavePreset();
|
|
730
|
+
try {
|
|
731
|
+
await render.loadConfig(portableAssetPaths(withoutClock(structuredClone(config))));
|
|
732
|
+
syncEnabledFlags(render, config);
|
|
733
|
+
} catch (error) {
|
|
734
|
+
throw new SmartEarthError("RENDER_INIT_FAILED", `\u5BFC\u5165\u73AF\u5883\u914D\u7F6E\u5931\u8D25\uFF1A${describeCause(error)}`, error);
|
|
735
|
+
}
|
|
736
|
+
},
|
|
737
|
+
enableAll() {
|
|
738
|
+
deps.assertAlive();
|
|
739
|
+
const render = requireAllSystems(deps.render);
|
|
740
|
+
leavePreset();
|
|
741
|
+
call("\u6253\u5F00\u5168\u90E8\u6E32\u67D3\u7CFB\u7EDF", () => render.enableAllWithDefaults());
|
|
742
|
+
},
|
|
743
|
+
disableAll() {
|
|
744
|
+
deps.assertAlive();
|
|
745
|
+
const render = requireAllSystems(deps.render);
|
|
746
|
+
leavePreset();
|
|
747
|
+
call("\u5173\u95ED\u5168\u90E8\u6E32\u67D3\u7CFB\u7EDF", () => {
|
|
748
|
+
for (const system of DISABLE_ALL_SYSTEMS) render.toggleSystem(system, false);
|
|
749
|
+
});
|
|
750
|
+
},
|
|
751
|
+
async resetConfig() {
|
|
752
|
+
deps.assertAlive();
|
|
753
|
+
if (!deps.resetToBaseline) {
|
|
754
|
+
throw new SmartEarthError("ENVIRONMENT_UNSUPPORTED", "\u5F53\u524D @metagl/sdk-render \u4E0D\u652F\u6301\u91CD\u7F6E\u73AF\u5883\u914D\u7F6E\uFF08\u9700\u8981 4.x\uFF09\u3002");
|
|
755
|
+
}
|
|
756
|
+
leavePreset();
|
|
757
|
+
await deps.resetToBaseline();
|
|
758
|
+
}
|
|
759
|
+
};
|
|
760
|
+
}
|
|
761
|
+
var CHANGE_SOURCES = {
|
|
762
|
+
setTime: "time",
|
|
763
|
+
setClock: "time",
|
|
764
|
+
setPreset: "preset",
|
|
765
|
+
clearPreset: "preset",
|
|
766
|
+
setEffect: "effect",
|
|
767
|
+
setEffectOptions: "effect",
|
|
768
|
+
applyColorFilter: "effect",
|
|
769
|
+
setLightingMode: "effect",
|
|
770
|
+
setLightDirection: "effect",
|
|
771
|
+
enableAll: "config",
|
|
772
|
+
disableAll: "config",
|
|
773
|
+
importConfig: "config",
|
|
774
|
+
resetConfig: "config"
|
|
775
|
+
};
|
|
776
|
+
var RADIANS_TO_DEGREES = 180 / Math.PI;
|
|
777
|
+
var DEGREES_TO_RADIANS = Math.PI / 180;
|
|
778
|
+
function readCamera(viewer) {
|
|
779
|
+
const camera = viewer.camera;
|
|
780
|
+
const position = camera?.positionCartographic;
|
|
781
|
+
if (!camera || !position) return void 0;
|
|
782
|
+
const pose = {
|
|
783
|
+
lon: position.longitude * RADIANS_TO_DEGREES,
|
|
784
|
+
lat: position.latitude * RADIANS_TO_DEGREES,
|
|
785
|
+
height: position.height,
|
|
786
|
+
heading: (camera.heading ?? 0) * RADIANS_TO_DEGREES,
|
|
787
|
+
pitch: (camera.pitch ?? 0) * RADIANS_TO_DEGREES
|
|
788
|
+
};
|
|
789
|
+
return Object.values(pose).every(Number.isFinite) ? pose : void 0;
|
|
790
|
+
}
|
|
791
|
+
function setCamera(viewer, Cesium, pose) {
|
|
792
|
+
const runtime = Cesium;
|
|
793
|
+
viewer.camera.setView({
|
|
794
|
+
destination: runtime.Cartesian3.fromDegrees(pose.lon, pose.lat, pose.height),
|
|
795
|
+
orientation: { heading: pose.heading * DEGREES_TO_RADIANS, pitch: pose.pitch * DEGREES_TO_RADIANS, roll: 0 }
|
|
796
|
+
});
|
|
797
|
+
}
|
|
798
|
+
function cameraOf(viewer) {
|
|
799
|
+
const camera = readCamera(viewer);
|
|
800
|
+
return camera ? { camera } : {};
|
|
801
|
+
}
|
|
802
|
+
function withChangeEvents(api, notify) {
|
|
803
|
+
const wrapped = { ...api };
|
|
804
|
+
for (const [name, source] of Object.entries(CHANGE_SOURCES)) {
|
|
805
|
+
const original = wrapped[name];
|
|
806
|
+
if (typeof original !== "function") continue;
|
|
807
|
+
wrapped[name] = (...args) => {
|
|
808
|
+
const result = original(...args);
|
|
809
|
+
if (result instanceof Promise) return result.then((value) => (notify(source), value));
|
|
810
|
+
notify(source);
|
|
811
|
+
return result;
|
|
812
|
+
};
|
|
813
|
+
}
|
|
814
|
+
return wrapped;
|
|
815
|
+
}
|
|
816
|
+
function createEarthEnvironment(deps) {
|
|
817
|
+
const emitter = new Emitter((error) => {
|
|
818
|
+
console.error("[smartearth-base] \u73AF\u5883\u53D8\u5316\u76D1\u542C\u5668\u51FA\u9519", error);
|
|
819
|
+
});
|
|
820
|
+
const notify = (source) => emitter.emit("change", { source });
|
|
821
|
+
const { forgetBaseline, disposePresets, ...presetApi } = createPresetApi(deps, notify);
|
|
822
|
+
const configApi = createConfigApi(deps, () => {
|
|
823
|
+
if (presetApi.getPreset()) presetApi.clearPreset();
|
|
824
|
+
forgetBaseline();
|
|
825
|
+
});
|
|
826
|
+
const clockApi = createClockApi(deps);
|
|
827
|
+
const api = withChangeEvents(
|
|
828
|
+
{
|
|
829
|
+
...clockApi,
|
|
830
|
+
presets: ENVIRONMENT_PRESETS,
|
|
831
|
+
...presetApi,
|
|
832
|
+
...createEffectApi(deps.render, deps.assertAlive, deps.viewer, deps.lightingLink),
|
|
833
|
+
...createLightingApi(deps.render, deps.viewer, deps.Cesium, deps.assertAlive),
|
|
834
|
+
...configApi
|
|
835
|
+
},
|
|
836
|
+
notify
|
|
837
|
+
);
|
|
838
|
+
return {
|
|
839
|
+
...api,
|
|
840
|
+
async captureSnapshot(options = {}) {
|
|
841
|
+
deps.assertAlive();
|
|
842
|
+
const environment = await configApi.exportConfig();
|
|
843
|
+
return {
|
|
844
|
+
environment,
|
|
845
|
+
...options.time === false ? {} : { time: clockApi.getTime().toISOString() },
|
|
846
|
+
...options.camera === false ? {} : cameraOf(deps.viewer),
|
|
847
|
+
quality: deps.getQuality?.() ?? "high",
|
|
848
|
+
preset: presetApi.getPreset()
|
|
849
|
+
};
|
|
850
|
+
},
|
|
851
|
+
async restoreSnapshot(snapshot, options = {}) {
|
|
852
|
+
deps.assertAlive();
|
|
853
|
+
const valid = requireSnapshot(snapshot);
|
|
854
|
+
await configApi.importConfig(valid.environment);
|
|
855
|
+
if (options.time !== false && valid.time) clockApi.setTime(new Date(valid.time));
|
|
856
|
+
if (options.camera && valid.camera) setCamera(deps.viewer, deps.Cesium, valid.camera);
|
|
857
|
+
notify("snapshot");
|
|
858
|
+
},
|
|
859
|
+
on: (event, listener) => emitter.on(event, listener),
|
|
860
|
+
notify,
|
|
861
|
+
suspendPreset() {
|
|
862
|
+
const active = presetApi.getPreset();
|
|
863
|
+
if (active) presetApi.clearPreset();
|
|
864
|
+
forgetBaseline();
|
|
865
|
+
return active;
|
|
866
|
+
},
|
|
867
|
+
destroy() {
|
|
868
|
+
disposePresets();
|
|
869
|
+
emitter.clear();
|
|
870
|
+
}
|
|
871
|
+
};
|
|
872
|
+
}
|
|
873
|
+
function readSdkRenderVersion() {
|
|
874
|
+
try {
|
|
875
|
+
const info = SdkRender.getVersionInfo?.();
|
|
876
|
+
return typeof info?.version === "string" ? info.version : void 0;
|
|
877
|
+
} catch {
|
|
878
|
+
return void 0;
|
|
879
|
+
}
|
|
880
|
+
}
|
|
881
|
+
|
|
882
|
+
// src/version.ts
|
|
883
|
+
var BASE_VERSION = "0.3.0";
|
|
884
|
+
|
|
885
|
+
export { ALL_EFFECTS, BASE_VERSION, COLOR_FILTERS, ENVIRONMENT_PRESETS, Emitter, MAP_TOKEN_APPLY_URL, PRESET_DOCUMENT_SCHEMA, SmartEarthError, createEarthEnvironment, describeCause, describeLayerCause, isSmartEarthError, readSdkRenderVersion, requirePresetDocument, requireSnapshot, supportsEnvironment, syncEnabledFlags, withoutClock };
|