Files
gods-eye-view/src/globe/navara/viewOptions.js
T
German Khokhlov 5188e8869d fix(globe): the cinematic look's atmosphere scale, warm-up and sunset clouds
- The takram uniform paths move to internals.js (forEachLuminanceUniform,
  loud in dev when a path is gone); look.js sets each factor to scale x
  the recorded base value, so shared or copied vectors are never scaled
  twice, and the stars keep the base value (own vector when shared).
  Stars at intensity 120: a starfield shows from space.
- Both night-side shader variants compile on the first two frames.
- The clouds hide once the sun sets at the camera (dark puffs at dusk).
- No allocation on look frames that change nothing (frozen updates, a
  scratch camera place from livePosition).
Gallery regenerated.
2026-10-16 15:06:15 +04:00

245 lines
9.4 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// How the product builds its Navara view (S4, S5): render on demand (the
// engine's render.setContinuous turns animation on), MSAA 4 as Cesium's
// msaaSamples, the device pixel ratio unless a measurement pins one, a canvas
// whose WebGL2 context keeps its drawing buffer (Cesium's
// contextOptions.webgl.preserveDrawingBuffer, for captures), and a look:
// `cinematic` by default (navaraScenePlan below), Navara's own `photoreal`
// scene (aerial perspective, tone mapping and SMAA, about 5 ms a frame, S5)
// with `?look=photoreal`, and `minimal` (sky, stars, sky light and sun
// without post effects) for benches.
/** WebGL2 attributes Navara 0.2.1 asks for, plus preserveDrawingBuffer. */
export const NAVARA_CONTEXT_ATTRIBUTES = Object.freeze({
alpha: true,
antialias: true,
depth: true,
stencil: true,
premultipliedAlpha: true,
preserveDrawingBuffer: true,
powerPreference: 'default',
});
const MSAA_SAMPLES = 4;
/** ThreeView options; `pixelRatio` only when a measurement pins it. */
export function navaraViewOptions({ container, canvas, pixelRatio } = {}) {
return {
container,
...(canvas ? { canvas } : {}),
animation: false,
multisampling: MSAA_SAMPLES,
...(pixelRatio !== undefined ? { pixelRatio } : {}),
};
}
/** The looks the view can build; the app takes `?look=` (cinematic by default). */
export const NAVARA_LOOKS = Object.freeze([
'minimal',
'photoreal',
'cinematic',
]);
export const DEFAULT_NAVARA_LOOK = 'cinematic';
/** The look named by `?look=` in `search`, else the default (cinematic). */
export function resolveNavaraLook(search = '') {
const value = String(new URLSearchParams(search).get('look') ?? '')
.trim()
.toLowerCase();
return NAVARA_LOOKS.includes(value) ? value : DEFAULT_NAVARA_LOOK;
}
// postprocessing's ToneMappingMode.ACES_FILMIC (Navara's default is AGX, 7).
const ACES_FILMIC = 6;
// Camera heights (m) where the cinematic look switches the globe to
// atmosphere lighting (night side and terminator) and back. The gap keeps a
// camera hovering near one height from toggling.
export const GLOBE_LIGHTING_ENTER_M = 1_500_000;
export const GLOBE_LIGHTING_EXIT_M = 1_000_000;
/**
* Whether the cinematic look lights the globe from the atmosphere (deferred
* irradiance: a real night side) at this camera height. Up close the Google
* tiles keep their baked lighting: relit, they turn grey and dark (their
* shadows and shading would count twice). Hysteresis between the two heights.
*/
export function globeLightingAt(height, current = false) {
if (!Number.isFinite(height)) return current;
return current
? height > GLOBE_LIGHTING_EXIT_M
: height >= GLOBE_LIGHTING_ENTER_M;
}
// Where the cinematic clouds show. Their layers span 1,500 to 3,000 m above
// the ellipsoid. Above 4 km the camera would look down on them, and they
// would hide the map under clouds that are a backdrop, not weather; over
// ground above 1,000 m (canyons, the Alps) they would cut into the terrain
// as dark puffs.
// Each limit has a gap so a camera near it does not flicker them.
export const CLOUDS_HIDE_ABOVE_M = 4_000;
export const CLOUDS_SHOW_BELOW_M = 3_500;
export const CLOUDS_HIDE_OVER_GROUND_M = 1_000;
export const CLOUDS_SHOW_OVER_GROUND_M = 800;
/**
* Whether the cinematic clouds show for a camera at `height` looking at
* ground at `ground` (both metres above the ellipsoid; an unknown ground
* counts as low).
*/
export function cloudsVisibleAt(height, ground, current = true) {
if (!Number.isFinite(height)) return current;
const low = Number.isFinite(ground) ? ground : 0;
return current
? height <= CLOUDS_HIDE_ABOVE_M && low <= CLOUDS_HIDE_OVER_GROUND_M
: height < CLOUDS_SHOW_BELOW_M && low < CLOUDS_SHOW_OVER_GROUND_M;
}
// Navara's sky, clouds and haze come from the atmosphere model in physical
// radiance, scaled for a tone-mapping exposure near 10, while the Google
// tiles carry baked colours that need exposure 1. At exposure 1 the noon sky
// came out dark navy (sRGB about 39, 58, 90 at Manhattan facing the
// horizon), and the stars showed through it. The cinematic look multiplies
// the atmosphere's radiance-to-luminance factors (sky, clouds, aerial
// perspective; not the stars) by this scale instead of raising
// the exposure, so the sky turns daylight blue and the tiles keep their
// colours.
export const ATMOSPHERE_LUMINANCE_SCALE = 3;
// Stars show from space or once the sun is well below the horizon at the
// camera (civil twilight), and hide in a daylit sky. Gaps keep a camera
// near a limit from flickering them.
export const STARS_SHOW_SUN_BELOW_DEG = -6;
export const STARS_HIDE_SUN_ABOVE_DEG = -4;
export const STARS_SPACE_ENTER_M = 100_000;
export const STARS_SPACE_EXIT_M = 80_000;
// The cinematic clouds hide once the sun at the camera sets (below 0°):
// unlit, they read as dark puffs over a dusk sky. They show again above 2°.
export const CLOUDS_HIDE_SUN_BELOW_DEG = 0;
export const CLOUDS_SHOW_SUN_ABOVE_DEG = 2;
/** Whether the sun is up enough for the cinematic clouds; NaN keeps `current`. */
export function cloudsSunlitAt(sunElevation, current = true) {
if (!Number.isFinite(sunElevation)) return current;
return current
? sunElevation >= CLOUDS_HIDE_SUN_BELOW_DEG
: sunElevation > CLOUDS_SHOW_SUN_ABOVE_DEG;
}
/**
* Whether the cinematic stars show for a camera at `height` (metres above
* the ellipsoid) with the sun `sunElevation` degrees above its horizon; an
* unknown height or sun elevation keeps `current`.
*/
export function starsVisibleAt(height, sunElevation, current = true) {
if (!Number.isFinite(height)) return current;
if (current ? height > STARS_SPACE_EXIT_M : height >= STARS_SPACE_ENTER_M)
return true;
if (!Number.isFinite(sunElevation)) return current;
return current
? sunElevation <= STARS_HIDE_SUN_ABOVE_DEG
: sunElevation < STARS_SHOW_SUN_BELOW_DEG;
}
/**
* Whether the atmosphere's sun date has drifted from the wall clock (the
* HUD's SUN elevation uses `new Date()`) by more than a minute.
*/
export function sunDateStale(atmosphereMs, nowMs, toleranceMs = 60_000) {
return !(Math.abs(nowMs - atmosphereMs) <= toleranceMs);
}
const cinematic = (mobile) => ({
pluginDefault: false,
// Brighter, larger stars (defaults 10 and 1 px) so the night sky and the
// globe from space keep a visible starfield next to a sunlit Earth. The
// atmosphere scale leaves the stars at their base factor (look.js).
meshes: [
{ sky: {} },
{
stars: {
intensity: 120,
pointSize: 2,
},
},
],
// The tiles carry baked sunlight, so the sun casts no shadow maps (CSM
// would cost every frame and darken nothing the tiles show).
lights: [{ skyLightProbe: {} }, { sun: { castShadow: false } }],
effects: [
// Depth-reconstructed normals: Navara 0.2.1's G-buffer normals are zero
// for Google tiles and the globe, which turns atmosphere lighting black.
// albedoScale brightens that lighting's day side to the photoreal
// look's (it scales the albedo only where the atmosphere lights it).
{ aerialPerspective: { useNormalBuffer: false, albedoScale: 2 } },
...(mobile
? []
: [
{
clouds: {
// 'low' looks the same here and costs about 1 ms less than
// 'medium' (clouds cost about 3 ms a frame at 1280×800).
qualityPreset: 'low',
coverage: 0.2,
// No cloud shadows on the ground: dark patches over the map
// read as features (and cost nothing measurable either way).
shadows: false,
// The two cumulus layers start at 1,500 m instead of 750 and
// 1,000 m, above the city views (Austin's 600 m, Manhattan's
// 900 m): clouds fill the sky without hiding the streets.
cloudLayers: [{ altitude: 1500 }, { altitude: 1800 }],
},
},
{ lensFlare: {} },
]),
{ toneMapping: { mode: ACES_FILMIC } },
mobile ? { fxaa: {} } : { smaa: {} },
],
globeLighting: true,
atmosphereLuminance: ATMOSPHERE_LUMINANCE_SCALE,
daylightHidesStars: true,
});
const PLANS = {
minimal: () => ({
pluginDefault: false,
meshes: [{ sky: {} }, { stars: {} }],
lights: [{ skyLightProbe: {} }, { sun: {} }],
effects: [],
globeLighting: false,
atmosphereLuminance: 1,
daylightHidesStars: false,
}),
photoreal: () => ({
pluginDefault: true,
meshes: [],
lights: [],
effects: [],
globeLighting: false,
atmosphereLuminance: 1,
daylightHidesStars: false,
}),
cinematic,
};
/**
* What the view adds for a look, as Navara descriptors ({ name: config }):
* - `minimal`: sky, stars, sky light and sun, no post effects (benches);
* - `photoreal`: the default plugin's addDefaultPhotorealScene (sky, sun,
* aerial perspective, lens flare, AgX tone mapping, SMAA);
* - `cinematic` (the app's default): photoreal plus volumetric clouds for
* low views over low ground (cloudsVisibleAt), ACES tone mapping, brighter stars, no sun shadow
* maps, and atmosphere lighting of the globe from space (`globeLighting`,
* see globeLightingAt), a brighter atmosphere (ATMOSPHERE_LUMINANCE_SCALE)
* and stars only at night or from space (starsVisibleAt). On a mobile-optimized
* view it drops the clouds and the lens flare and uses FXAA.
*/
export function navaraScenePlan(
look = DEFAULT_NAVARA_LOOK,
{ mobile = false } = {},
) {
if (!Object.hasOwn(PLANS, look))
throw new RangeError(`Unknown Navara look: ${look}`);
return PLANS[look](mobile);
}