905 lines
33 KiB
TypeScript
905 lines
33 KiB
TypeScript
import * as THREE from 'three'
|
|
|
|
import { APP_CONFIG } from '@/constants/config'
|
|
|
|
type PointerTarget = {
|
|
x: number
|
|
y: number
|
|
}
|
|
|
|
type TravelSceneController = {
|
|
setStarted: (started: boolean) => void
|
|
setSpeed: (speed: number) => void
|
|
setPointerTarget: (pointer: PointerTarget) => void
|
|
dispose: () => void
|
|
}
|
|
|
|
type StarState = {
|
|
x: number
|
|
y: number
|
|
z: number
|
|
vx: number
|
|
vy: number
|
|
vz: number
|
|
ax: number
|
|
ay: number
|
|
az: number
|
|
delay: number
|
|
baseSize: number
|
|
baseAlpha: number
|
|
}
|
|
|
|
type SmokeState = {
|
|
mesh: THREE.Mesh<THREE.PlaneGeometry, THREE.MeshBasicMaterial>
|
|
x: number
|
|
y: number
|
|
z: number
|
|
age: number
|
|
vx: number
|
|
vy: number
|
|
vz: number
|
|
rotation: number
|
|
spin: number
|
|
baseScaleX: number
|
|
baseScaleY: number
|
|
opacity: number
|
|
wobble: number
|
|
wobbleSpeed: number
|
|
}
|
|
|
|
const STAR_COUNT = APP_CONFIG.starfield.count
|
|
const STAR_SOURCE_RADIUS = APP_CONFIG.starfield.sourceRadius
|
|
const STAR_FAR_Z = APP_CONFIG.starfield.farZ
|
|
const STAR_RESET_Z = APP_CONFIG.starfield.resetZ
|
|
const STAR_BOUNDS_X = APP_CONFIG.starfield.boundsX
|
|
const STAR_BOUNDS_Y = APP_CONFIG.starfield.boundsY
|
|
|
|
const SMOKE_COUNT = APP_CONFIG.smoke.count
|
|
const SMOKE_SOURCE_RADIUS = APP_CONFIG.smoke.sourceRadius
|
|
const SMOKE_FAR_Z = APP_CONFIG.smoke.farZ
|
|
const SMOKE_RESET_Z = APP_CONFIG.smoke.resetZ
|
|
const SMOKE_BOUNDS_X = APP_CONFIG.smoke.boundsX
|
|
const SMOKE_BOUNDS_Y = APP_CONFIG.smoke.boundsY
|
|
|
|
const STAR_COLORS = [
|
|
'#00e5ff', // 亮青
|
|
'#ff00ea', // 亮粉
|
|
'#ffcc00', // 亮金
|
|
'#00ff66', // 亮绿
|
|
'#ff3333', // 亮红
|
|
] as const
|
|
const SMOKE_COLORS = ['#8dd8ff', '#adc4ff', '#d6b5ff', '#ffe7ff'] as const
|
|
|
|
const STAR_VERTEX_SHADER = `
|
|
attribute float aSizeBase;
|
|
attribute float aAlphaBase;
|
|
attribute float aProgress;
|
|
attribute float aTail;
|
|
attribute vec2 aDir;
|
|
varying vec3 vColor;
|
|
varying float vAlpha;
|
|
varying float vTail;
|
|
varying vec2 vDir;
|
|
|
|
void main() {
|
|
vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
|
|
float scaledProgress = max(aProgress, 0.0);
|
|
// 放大精灵尺寸以容纳更长的拖尾
|
|
float pointSize = aSizeBase * (0.95 + scaledProgress * 2.85) * ${APP_CONFIG.starfield.pointScale.toFixed(1)} / max(1.0, -mvPosition.z) * 2.5;
|
|
gl_Position = projectionMatrix * mvPosition;
|
|
gl_PointSize = clamp(pointSize, ${APP_CONFIG.starfield.pointMinSize.toFixed(1)} * 2.5, ${APP_CONFIG.starfield.pointMaxSize.toFixed(1)} * 2.5);
|
|
vColor = color;
|
|
// 取消原本透明度的距离衰减，直接用最高的 baseAlpha 甚至更高，保持全局最亮
|
|
vAlpha = aAlphaBase * 1.5;
|
|
vTail = aTail;
|
|
vDir = aDir;
|
|
}
|
|
`
|
|
|
|
const STAR_FRAGMENT_SHADER = `
|
|
varying vec3 vColor;
|
|
varying float vAlpha;
|
|
varying float vTail;
|
|
varying vec2 vDir;
|
|
uniform float uSpeed;
|
|
|
|
void main() {
|
|
// 放大坐标系，这样中心点画得相对较小，留出极大空间画长尾巴
|
|
vec2 centered = (gl_PointCoord - vec2(0.5)) * 2.5;
|
|
float distanceToCenter = length(centered);
|
|
float hotspot = 1.0 - smoothstep(0.0, 0.06, distanceToCenter);
|
|
hotspot = pow(hotspot, 0.32);
|
|
float core = 1.0 - smoothstep(0.0, 0.13, distanceToCenter);
|
|
core = pow(core, 0.44);
|
|
float halo = 1.0 - smoothstep(0.015, 0.22, distanceToCenter);
|
|
halo = pow(halo, 1.95);
|
|
|
|
// 翻转 Y 轴以匹配 WebGL 纹理坐标系
|
|
vec2 dir = length(vDir) > 0.0001 ? normalize(vec2(vDir.x, -vDir.y)) : vec2(0.0, -1.0);
|
|
vec2 side = vec2(-dir.y, dir.x);
|
|
float along = dot(centered, dir);
|
|
float across = dot(centered, side);
|
|
|
|
float back = -along;
|
|
// 拖尾长度根据当前速度动态变化
|
|
float speedFactor = max(uSpeed, 0.1);
|
|
float tailLength = clamp(${(APP_CONFIG.starfield.trailLength).toFixed(2)} * 2.5 * speedFactor, 0.05, 2.5);
|
|
float tailFade = 1.0 - smoothstep(0.0, tailLength, back);
|
|
float tailMask = smoothstep(-0.02, 0.05, back);
|
|
|
|
float maxWidth = ${(APP_CONFIG.starfield.trailWidth).toFixed(2)};
|
|
float width = maxWidth * mix(0.1, 1.0, pow(tailFade, 0.8));
|
|
|
|
float tailProfile = 1.0 - smoothstep(0.0, width, abs(across));
|
|
float tailHotspot = 1.0 - smoothstep(0.0, width * 0.3, abs(across));
|
|
// 速度越快，尾巴亮度也适当增强
|
|
float tail = (tailProfile * 0.8 + tailHotspot * 1.5) * tailFade * tailMask * vTail * (0.4 + 0.6 * speedFactor);
|
|
|
|
// 极高的能量累加，不丢弃任何 alpha，强制发光
|
|
float alpha = (hotspot * 3.5 + core * 2.5 + halo * 0.5 + tail * 2.8) * vAlpha;
|
|
|
|
if (alpha < 0.01) {
|
|
discard;
|
|
}
|
|
|
|
vec3 color = vColor;
|
|
// 让高光点保持自身颜色的同时极度明亮，而不仅是变白
|
|
vec3 hotColor = mix(vColor, vec3(1.0), 0.5);
|
|
color = mix(color, hotColor, hotspot * 0.8 + core * 0.4);
|
|
color += hotColor * hotspot * 2.0;
|
|
color += vColor * core * 1.5;
|
|
color += vColor * tail * 1.8;
|
|
|
|
// 用极其暴力的颜色叠加
|
|
gl_FragColor = vec4(min(color, vec3(1.0)), min(alpha, 1.0));
|
|
}
|
|
`
|
|
|
|
const GALAXY_VERTEX_SHADER = `
|
|
varying vec2 vUv;
|
|
|
|
void main() {
|
|
vUv = uv;
|
|
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
|
|
}
|
|
`
|
|
|
|
const GALAXY_FRAGMENT_SHADER = `
|
|
varying vec2 vUv;
|
|
|
|
uniform float uTime;
|
|
uniform float uOpacity;
|
|
uniform float uArms;
|
|
uniform float uTwist;
|
|
uniform float uArmSharpness;
|
|
uniform float uNoiseScale;
|
|
uniform float uNoiseStrength;
|
|
uniform float uCoreRadius;
|
|
uniform float uCoreGlow;
|
|
uniform float uGlowStrength;
|
|
uniform float uSeed;
|
|
uniform vec3 uCoreWhite;
|
|
uniform vec3 uCoreGold;
|
|
uniform vec3 uWarmOrange;
|
|
uniform vec3 uWarmMagenta;
|
|
uniform vec3 uOuterBlue;
|
|
uniform vec3 uDeepBlue;
|
|
uniform vec3 uInnerColor;
|
|
uniform vec3 uOuterColor;
|
|
uniform vec3 uDustColor;
|
|
|
|
float hash(vec2 p) {
|
|
return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
|
|
}
|
|
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p);
|
|
vec2 f = fract(p);
|
|
vec2 u = f * f * (3.0 - 2.0 * f);
|
|
|
|
return mix(
|
|
mix(hash(i + vec2(0.0, 0.0)), hash(i + vec2(1.0, 0.0)), u.x),
|
|
mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), u.x),
|
|
u.y
|
|
);
|
|
}
|
|
|
|
float fbm(vec2 p) {
|
|
float value = 0.0;
|
|
float amplitude = 0.5;
|
|
|
|
for (int i = 0; i < 5; i += 1) {
|
|
value += amplitude * noise(p);
|
|
p = p * 2.03 + vec2(17.3, 9.2);
|
|
amplitude *= 0.5;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
vec3 sampleGalaxyRamp(float t) {
|
|
float value = clamp(t, 0.0, 1.0);
|
|
vec3 color = uCoreWhite;
|
|
|
|
color = mix(color, uCoreGold, smoothstep(0.03, 0.18, value));
|
|
color = mix(color, uWarmOrange, smoothstep(0.12, 0.32, value));
|
|
color = mix(color, uWarmMagenta, smoothstep(0.24, 0.58, value));
|
|
color = mix(color, uOuterBlue, smoothstep(0.5, 0.84, value));
|
|
color = mix(color, uDeepBlue, smoothstep(0.76, 1.0, value));
|
|
|
|
return color;
|
|
}
|
|
|
|
void main() {
|
|
vec2 p = vUv * 2.0 - 1.0;
|
|
p.x *= 1.08;
|
|
|
|
float radius = length(p);
|
|
float angle = atan(p.y, p.x);
|
|
float time = uTime * 0.045;
|
|
vec2 flowUv = p * uNoiseScale;
|
|
|
|
float lowNoise = fbm(flowUv + vec2(time * 0.35 + uSeed * 5.1, -time * 0.18));
|
|
float highNoise = fbm(flowUv * 2.1 - vec2(time * 0.42, time * 0.26 + uSeed * 3.7));
|
|
float veilNoise = fbm(p * (uNoiseScale * 0.55) + vec2(-time * 0.12, time * 0.08 + uSeed * 1.9));
|
|
float filamentNoise = fbm(flowUv * 3.4 + vec2(time * 0.18 - uSeed * 2.7, time * 0.24));
|
|
float clusterNoise = fbm(flowUv * 5.1 + vec2(-time * 0.32 + uSeed * 8.4, time * 0.21));
|
|
float grainNoise = noise(flowUv * 13.5 + vec2(time * 1.8 + uSeed * 14.0, -time * 1.3));
|
|
float fineNoise = fbm(flowUv * 8.2 - vec2(time * 0.65 - uSeed * 6.2, time * 0.52));
|
|
float warpedAngle = angle - radius * uTwist + (lowNoise - 0.5) * uNoiseStrength * 3.2;
|
|
vec2 swirlDir = vec2(cos(warpedAngle), sin(warpedAngle));
|
|
vec2 swirlUv = vec2(dot(p, swirlDir), dot(p, vec2(-swirlDir.y, swirlDir.x)));
|
|
float streakNoise = fbm(swirlUv * vec2(24.0, 3.2) + vec2(time * 0.12 + uSeed * 4.6, -time * 0.06));
|
|
float mottledNoise = fbm(swirlUv * vec2(10.0, 6.5) - vec2(time * 0.08 - uSeed * 5.2, time * 0.04));
|
|
float fineFiberNoise = fbm(swirlUv * vec2(46.0, 1.8) + vec2(time * 0.06 + uSeed * 11.4, -time * 0.03));
|
|
float occlusionNoise = fbm(swirlUv * vec2(5.4, 4.1) - vec2(time * 0.04 - uSeed * 2.6, time * 0.02));
|
|
float spiralWave = cos(warpedAngle * uArms);
|
|
float armBase = spiralWave * 0.5 + 0.5;
|
|
float armMask = smoothstep(1.0 - uArmSharpness, 1.0, armBase);
|
|
float softArms = smoothstep(0.2, 0.92, armBase + (lowNoise - 0.5) * 0.18);
|
|
float halo = 1.0 - smoothstep(0.12, 1.45, radius);
|
|
float outerHalo = 1.0 - smoothstep(0.4, 1.6, radius);
|
|
float core = 1.0 - smoothstep(0.0, uCoreRadius, radius);
|
|
float coreBloom = 1.0 - smoothstep(0.0, uCoreRadius * 1.6, radius);
|
|
float hotCore = 1.0 - smoothstep(0.0, uCoreRadius * 0.95, radius);
|
|
float dust = smoothstep(0.24, 0.9, highNoise);
|
|
float wisps = smoothstep(0.44, 0.9, lowNoise) * (1.0 - smoothstep(0.38, 1.08, radius));
|
|
float outerVeil = smoothstep(0.34, 0.88, veilNoise) * outerHalo;
|
|
float rim = smoothstep(0.3, 0.98, radius) * (1.0 - smoothstep(0.92, 1.3, radius));
|
|
float armRidge = pow(armMask, 1.45) * halo;
|
|
float lanePattern = 1.0 - smoothstep(0.2, 0.72, abs(sin(warpedAngle * (uArms * 0.55) + filamentNoise * 4.4)));
|
|
float dustLane = lanePattern * smoothstep(0.12, 0.88, radius) * halo * (0.35 + (1.0 - armMask) * 0.9);
|
|
float clumps = smoothstep(0.62, 0.9, filamentNoise) * softArms * rim;
|
|
float pulse = 0.5 + 0.5 * sin(uTime * 1.6 + uSeed * 9.0);
|
|
float shockRadius = uCoreRadius * (1.08 + pulse * 0.42);
|
|
float shockRing = smoothstep(shockRadius - 0.17, shockRadius - 0.04, radius) *
|
|
(1.0 - smoothstep(shockRadius + 0.03, shockRadius + 0.11, radius)) *
|
|
mix(0.55, 1.0, armMask);
|
|
float clusterMask = smoothstep(0.72, 0.9, clusterNoise) * pow(softArms, 1.45) * rim;
|
|
float clusterTwinkle = 0.55 + 0.45 * sin(uTime * 2.6 + angle * uArms * 3.2 + radius * 16.0 + uSeed * 12.0);
|
|
float armSpark = clusterMask * clusterTwinkle;
|
|
float edgeBreak = smoothstep(0.72, 0.95, veilNoise) * smoothstep(0.55, 1.08, radius) * outerHalo;
|
|
float grainMask = smoothstep(0.36, 0.84, grainNoise) * mix(0.32, 1.0, softArms) * halo;
|
|
float dustTexture = smoothstep(0.28, 0.78, fineNoise) * halo * (0.45 + (1.0 - armMask) * 0.8);
|
|
float fiberBands = smoothstep(0.48, 0.88, streakNoise) * halo * smoothstep(0.12, 0.92, radius);
|
|
float mottledDust = smoothstep(0.34, 0.82, mottledNoise) * halo;
|
|
float fineFibers = smoothstep(0.54, 0.9, fineFiberNoise) * halo * smoothstep(0.1, 0.96, radius);
|
|
float deepOcclusion = smoothstep(0.38, 0.8, occlusionNoise) * halo * smoothstep(0.18, 1.0, radius);
|
|
float dustFilaments = fiberBands * (0.4 + (1.0 - armMask) * 0.9) * (0.6 + dustLane * 0.8);
|
|
float outerSparseFibers = smoothstep(0.44, 0.88, streakNoise) *
|
|
smoothstep(0.48, 1.08, radius) *
|
|
outerHalo *
|
|
(0.45 + veilNoise * 0.8);
|
|
float microSpeckles = smoothstep(0.955, 0.992, grainNoise) * (0.18 + clusterTwinkle * 0.32) * softArms * rim;
|
|
float density = halo * mix(0.44, 1.0, armMask) * mix(0.88, 1.12, dust);
|
|
density = mix(density, halo * 0.96, 0.34);
|
|
float coreGlow = pow(core, uCoreGlow) * uGlowStrength;
|
|
float bloomGlow = pow(coreBloom, 1.8) * (uGlowStrength * 0.92);
|
|
float pulseCore = pow(coreBloom, 1.28) * (0.24 + pulse * 0.34);
|
|
float innerCloud = pow(core, 1.15) * 0.58 + pow(coreBloom, 1.3) * 0.38;
|
|
float starDust = smoothstep(0.9, 0.985, highNoise) * softArms * rim * 0.07;
|
|
|
|
density += wisps * 0.4 + outerVeil * 0.42 + innerCloud + coreGlow + bloomGlow + starDust;
|
|
density += armRidge * 0.2 + clumps * 0.24 + edgeBreak * 0.18 + shockRing * 0.28 + armSpark * 0.1 + pulseCore;
|
|
density += grainMask * 0.04 + microSpeckles * 0.018;
|
|
density *= 1.0 - dustLane * 0.34;
|
|
density *= 0.94 + grainNoise * 0.11;
|
|
density *= 1.0 - dustTexture * 0.1;
|
|
density *= 1.0 - dustFilaments * 0.26;
|
|
density *= 1.0 - fineFibers * 0.18;
|
|
density *= 1.0 - outerSparseFibers * 0.13;
|
|
density *= 1.0 - deepOcclusion * (0.12 + dustLane * 0.1);
|
|
density *= 0.9 + (1.0 - mottledDust) * 0.12;
|
|
density *= exp(-radius * 0.85);
|
|
|
|
float rampT = clamp(pow(radius, 0.72) + dustLane * 0.05 - coreBloom * 0.14 - armRidge * 0.03 + (1.0 - softArms) * 0.04, 0.0, 1.0);
|
|
vec3 rampColor = sampleGalaxyRamp(rampT);
|
|
vec3 layerTint = mix(uOuterColor, uInnerColor, clamp(core * 0.75 + armRidge * 0.24 + softArms * 0.12, 0.0, 1.0));
|
|
vec3 color = mix(rampColor, layerTint, 0.25); // 增加 layerTint 的比重，提亮
|
|
|
|
// 提亮灰尘的颜色，防止在纯黑背景下太暗
|
|
vec3 brightDust = mix(uDustColor, vec3(0.3, 0.5, 0.8), 0.3);
|
|
color = mix(color, brightDust, wisps * 0.12 + dustLane * 0.5 + (1.0 - softArms) * 0.1);
|
|
color = mix(color, brightDust, dustTexture * 0.15 + dustFilaments * 0.25 + fineFibers * 0.15 + mottledDust * 0.12 + deepOcclusion * 0.1);
|
|
color = mix(color, uWarmOrange, armRidge * 0.16 + shockRing * 0.1);
|
|
color = mix(color, uWarmMagenta, smoothstep(0.18, 0.62, radius) * (1.0 - armMask) * 0.24);
|
|
color = mix(color, uOuterBlue, outerVeil * 0.18 + edgeBreak * 0.12);
|
|
color = mix(color, mix(uOuterBlue, uDustColor, 0.4), outerSparseFibers * 0.36);
|
|
color += mix(rampColor, vec3(1.0, 0.98, 0.95), 0.4) * grainMask * 0.018;
|
|
color += mix(uCoreGold, vec3(1.0, 0.96, 0.86), 0.45) * armRidge * 0.18;
|
|
color += mix(uOuterBlue, vec3(0.9, 0.97, 1.0), 0.35) * clumps * 0.12;
|
|
color += mix(uCoreGold, uWarmOrange, 0.45) * shockRing * 0.34;
|
|
color += mix(uCoreWhite, uOuterBlue, 0.28) * armSpark * 0.12;
|
|
color += mix(uCoreWhite, uCoreGold, 0.4) * microSpeckles * 0.04;
|
|
color += uCoreWhite * pow(coreBloom, 1.8) * 0.65;
|
|
color += mix(uCoreWhite, uCoreGold, 0.22) * pow(hotCore, 1.2) * 1.0;
|
|
|
|
float alpha = density * uOpacity * (1.0 - smoothstep(1.25, 1.6, radius));
|
|
|
|
if (alpha < 0.01) {
|
|
discard;
|
|
}
|
|
|
|
gl_FragColor = vec4(color, clamp(alpha, 0.0, 1.0));
|
|
}
|
|
`
|
|
|
|
function clamp(value: number, min: number, max: number) {
|
|
return Math.min(max, Math.max(min, value))
|
|
}
|
|
|
|
function lerp(start: number, end: number, alpha: number) {
|
|
return start + (end - start) * alpha
|
|
}
|
|
|
|
function smoothstep(edge0: number, edge1: number, value: number) {
|
|
const t = clamp((value - edge0) / (edge1 - edge0), 0, 1)
|
|
return t * t * (3 - 2 * t)
|
|
}
|
|
|
|
function randomRange(min: number, max: number) {
|
|
return min + Math.random() * (max - min)
|
|
}
|
|
|
|
function getGalaxyBlending(blendMode: 'normal' | 'additive') {
|
|
return blendMode === 'additive' ? THREE.AdditiveBlending : THREE.NormalBlending
|
|
}
|
|
|
|
function sampleDisk(radius: number) {
|
|
const angle = Math.random() * Math.PI * 2
|
|
const distance = Math.pow(Math.random(), APP_CONFIG.starfield.radialExponent) * radius
|
|
|
|
return {
|
|
x: Math.cos(angle) * distance,
|
|
y: Math.sin(angle) * distance,
|
|
}
|
|
}
|
|
|
|
function pickTier() {
|
|
const roll = Math.random()
|
|
|
|
if (roll > 0.84) {
|
|
return 2
|
|
}
|
|
|
|
if (roll > 0.5) {
|
|
return 1
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
function createSmokeTexture() {
|
|
const canvas = document.createElement('canvas')
|
|
canvas.width = 256
|
|
canvas.height = 256
|
|
|
|
const context = canvas.getContext('2d')
|
|
if (!context) {
|
|
throw new Error('Unable to create smoke texture context.')
|
|
}
|
|
|
|
context.clearRect(0, 0, canvas.width, canvas.height)
|
|
context.globalCompositeOperation = 'screen'
|
|
|
|
for (let index = 0; index < 12; index += 1) {
|
|
const radius = randomRange(42, 94)
|
|
const x = randomRange(64, 192)
|
|
const y = randomRange(64, 192)
|
|
const gradient = context.createRadialGradient(x, y, radius * 0.12, x, y, radius)
|
|
|
|
gradient.addColorStop(0, 'rgba(255, 255, 255, 0.5)')
|
|
gradient.addColorStop(0.4, 'rgba(220, 235, 255, 0.26)')
|
|
gradient.addColorStop(1, 'rgba(255, 255, 255, 0)')
|
|
|
|
context.fillStyle = gradient
|
|
context.beginPath()
|
|
context.arc(x, y, radius, 0, Math.PI * 2)
|
|
context.fill()
|
|
}
|
|
|
|
const texture = new THREE.CanvasTexture(canvas)
|
|
texture.colorSpace = THREE.SRGBColorSpace
|
|
texture.needsUpdate = true
|
|
|
|
return texture
|
|
}
|
|
|
|
function normalizeDirection(x: number, y: number) {
|
|
const length = Math.hypot(x, y)
|
|
|
|
if (length < 1e-4) {
|
|
const angle = Math.random() * Math.PI * 2
|
|
|
|
return {
|
|
x: Math.cos(angle),
|
|
y: Math.sin(angle),
|
|
}
|
|
}
|
|
|
|
return {
|
|
x: x / length,
|
|
y: y / length,
|
|
}
|
|
}
|
|
|
|
export function createTravelScene(container: HTMLElement): TravelSceneController {
|
|
const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true })
|
|
renderer.setPixelRatio(Math.min(window.devicePixelRatio, APP_CONFIG.scene.maxPixelRatio))
|
|
renderer.setSize(container.clientWidth, container.clientHeight)
|
|
renderer.setClearColor(APP_CONFIG.scene.background, 1)
|
|
container.appendChild(renderer.domElement)
|
|
|
|
const scene = new THREE.Scene()
|
|
const camera = new THREE.PerspectiveCamera(
|
|
APP_CONFIG.camera.fov,
|
|
container.clientWidth / container.clientHeight,
|
|
APP_CONFIG.camera.near,
|
|
APP_CONFIG.camera.far,
|
|
)
|
|
camera.position.set(0, 0, APP_CONFIG.camera.initialZ)
|
|
|
|
const travelRoot = new THREE.Group()
|
|
scene.add(travelRoot)
|
|
|
|
const ambientLight = new THREE.AmbientLight('#d9efff', 0.45)
|
|
scene.add(ambientLight)
|
|
|
|
const galaxyGroup = new THREE.Group()
|
|
galaxyGroup.position.z = APP_CONFIG.galaxy.zPosition
|
|
galaxyGroup.rotation.x = APP_CONFIG.galaxy.tiltX
|
|
galaxyGroup.rotation.y = APP_CONFIG.galaxy.tiltY
|
|
galaxyGroup.rotation.z = APP_CONFIG.galaxy.tiltZ
|
|
scene.add(galaxyGroup)
|
|
|
|
const galaxyGeometry = new THREE.PlaneGeometry(APP_CONFIG.galaxy.width, APP_CONFIG.galaxy.height, 1, 1)
|
|
const galaxyLayers: THREE.Mesh<THREE.PlaneGeometry, THREE.ShaderMaterial>[] = []
|
|
const galaxyMaterials: THREE.ShaderMaterial[] = []
|
|
|
|
const starsGeometry = new THREE.BufferGeometry()
|
|
const starPositions = new Float32Array(STAR_COUNT * 3)
|
|
const starColors = new Float32Array(STAR_COUNT * 3)
|
|
const starProgress = new Float32Array(STAR_COUNT)
|
|
const starSizes = new Float32Array(STAR_COUNT)
|
|
const starAlpha = new Float32Array(STAR_COUNT)
|
|
const starTail = new Float32Array(STAR_COUNT)
|
|
const starDirections = new Float32Array(STAR_COUNT * 2)
|
|
const starStates = new Array<StarState>(STAR_COUNT)
|
|
const starColor = new THREE.Color()
|
|
|
|
const smokeGeometry = new THREE.PlaneGeometry(1, 1, 1, 1)
|
|
const smokeTexture = createSmokeTexture()
|
|
const smokeStates: SmokeState[] = []
|
|
|
|
const pointerTarget = { x: 0, y: 0 }
|
|
const pointerCurrent = { x: 0, y: 0 }
|
|
|
|
let started = false
|
|
let targetSpeed: number = APP_CONFIG.animation.defaultSpeed
|
|
let currentSpeed = 0
|
|
let accumulatedWobbleTime = 0
|
|
let animationFrameId = 0
|
|
let disposed = false
|
|
|
|
const starMaterial = new THREE.ShaderMaterial({
|
|
vertexShader: STAR_VERTEX_SHADER,
|
|
fragmentShader: STAR_FRAGMENT_SHADER,
|
|
transparent: true,
|
|
depthWrite: false,
|
|
vertexColors: true,
|
|
blending: THREE.AdditiveBlending,
|
|
uniforms: {
|
|
uSpeed: { value: 1.0 },
|
|
},
|
|
})
|
|
|
|
function spawnStar(index: number, seededProgress?: number) {
|
|
const tier = pickTier()
|
|
const source = sampleDisk(STAR_SOURCE_RADIUS)
|
|
const direction = normalizeDirection(
|
|
source.x + randomRange(-1.3, 1.3),
|
|
source.y + randomRange(-1.3, 1.3),
|
|
)
|
|
const progress = seededProgress ?? 0
|
|
const tierSpeed = [18, 26, 36][tier]
|
|
const tierDrift = [3.2, 5.2, 8.2][tier]
|
|
const tierScale = [0.95, 1.25, 1.65][tier]
|
|
const z = lerp(STAR_FAR_Z, STAR_RESET_Z - 3, progress)
|
|
const radialTravel = Math.pow(progress, APP_CONFIG.starfield.progressExponent) * (18 + tier * 10)
|
|
|
|
const state: StarState = {
|
|
x: source.x + direction.x * radialTravel + randomRange(-0.6, 0.6) * progress,
|
|
y: source.y + direction.y * radialTravel + randomRange(-0.6, 0.6) * progress,
|
|
z,
|
|
vx: direction.x * tierDrift * (1 + progress * 0.7),
|
|
vy: direction.y * tierDrift * (1 + progress * 0.7),
|
|
vz: tierSpeed * randomRange(0.9, 1.16) * (1 + progress * 0.5),
|
|
ax: direction.x * randomRange(1.4, 3.6),
|
|
ay: direction.y * randomRange(1.4, 3.6),
|
|
az: randomRange(5.5, 10.5),
|
|
delay: seededProgress === undefined ? randomRange(0.03, 0.42) : randomRange(0, 0.12),
|
|
baseSize: randomRange(APP_CONFIG.starfield.baseSizeMin, APP_CONFIG.starfield.baseSizeMax) * tierScale,
|
|
baseAlpha: randomRange(APP_CONFIG.starfield.baseAlphaMin, APP_CONFIG.starfield.baseAlphaMax),
|
|
}
|
|
|
|
starStates[index] = state
|
|
starSizes[index] = state.baseSize
|
|
starAlpha[index] = state.baseAlpha
|
|
starTail[index] = 0
|
|
starDirections[index * 2] = direction.x
|
|
starDirections[index * 2 + 1] = direction.y
|
|
|
|
if (Math.random() < 0.9) {
|
|
starColor.set('#ffffff')
|
|
} else {
|
|
starColor.set(STAR_COLORS[Math.floor(Math.random() * STAR_COLORS.length)])
|
|
}
|
|
starColors[index * 3] = starColor.r
|
|
starColors[index * 3 + 1] = starColor.g
|
|
starColors[index * 3 + 2] = starColor.b
|
|
|
|
starPositions[index * 3] = state.x
|
|
starPositions[index * 3 + 1] = state.y
|
|
starPositions[index * 3 + 2] = state.z
|
|
starProgress[index] = seededProgress ?? 0
|
|
}
|
|
|
|
function spawnSmoke(mesh?: SmokeState['mesh']) {
|
|
const source = sampleDisk(SMOKE_SOURCE_RADIUS)
|
|
const direction = normalizeDirection(
|
|
source.x + randomRange(-2.2, 2.2),
|
|
source.y + randomRange(-2.2, 2.2),
|
|
)
|
|
const scaleBase = randomRange(5.8, 14.5)
|
|
const material = mesh
|
|
? mesh.material
|
|
: new THREE.MeshBasicMaterial({
|
|
map: smokeTexture,
|
|
transparent: true,
|
|
depthWrite: false,
|
|
side: THREE.DoubleSide,
|
|
blending: THREE.AdditiveBlending,
|
|
})
|
|
material.color.set(SMOKE_COLORS[Math.floor(Math.random() * SMOKE_COLORS.length)])
|
|
|
|
const smokeMesh =
|
|
mesh ??
|
|
new THREE.Mesh<THREE.PlaneGeometry, THREE.MeshBasicMaterial>(smokeGeometry, material)
|
|
|
|
const state: SmokeState = {
|
|
mesh: smokeMesh,
|
|
x: source.x,
|
|
y: source.y,
|
|
z: randomRange(SMOKE_FAR_Z, SMOKE_FAR_Z + 16),
|
|
age: 0,
|
|
vx: direction.x * randomRange(1.8, 4.6),
|
|
vy: direction.y * randomRange(1.8, 4.6),
|
|
vz: randomRange(9.5, 17.5),
|
|
rotation: randomRange(0, Math.PI * 2),
|
|
spin: randomRange(-0.16, 0.16),
|
|
baseScaleX: scaleBase * randomRange(0.8, 1.2),
|
|
baseScaleY: scaleBase * randomRange(0.75, 1.25),
|
|
opacity: randomRange(0.05, 0.13),
|
|
wobble: randomRange(0.5, 1.2),
|
|
wobbleSpeed: randomRange(0.35, 0.9),
|
|
}
|
|
|
|
smokeMesh.position.set(state.x, state.y, state.z)
|
|
smokeMesh.scale.set(state.baseScaleX, state.baseScaleY, 1)
|
|
smokeMesh.material.opacity = 0
|
|
|
|
return state
|
|
}
|
|
|
|
for (let index = 0; index < STAR_COUNT; index += 1) {
|
|
spawnStar(index, Math.pow(Math.random(), APP_CONFIG.starfield.seedProgressExponent))
|
|
}
|
|
|
|
starsGeometry.setAttribute('position', new THREE.BufferAttribute(starPositions, 3))
|
|
starsGeometry.setAttribute('color', new THREE.BufferAttribute(starColors, 3))
|
|
starsGeometry.setAttribute('aProgress', new THREE.BufferAttribute(starProgress, 1))
|
|
starsGeometry.setAttribute('aSizeBase', new THREE.BufferAttribute(starSizes, 1))
|
|
starsGeometry.setAttribute('aAlphaBase', new THREE.BufferAttribute(starAlpha, 1))
|
|
starsGeometry.setAttribute('aTail', new THREE.BufferAttribute(starTail, 1))
|
|
starsGeometry.setAttribute('aDir', new THREE.BufferAttribute(starDirections, 2))
|
|
|
|
const stars = new THREE.Points(starsGeometry, starMaterial)
|
|
travelRoot.add(stars)
|
|
|
|
for (let index = 0; index < SMOKE_COUNT; index += 1) {
|
|
const state = spawnSmoke()
|
|
smokeStates.push(state)
|
|
travelRoot.add(state.mesh)
|
|
}
|
|
|
|
APP_CONFIG.galaxy.layers.forEach((layerConfig, index) => {
|
|
const galaxyMaterial = new THREE.ShaderMaterial({
|
|
vertexShader: GALAXY_VERTEX_SHADER,
|
|
fragmentShader: GALAXY_FRAGMENT_SHADER,
|
|
transparent: true,
|
|
depthWrite: false,
|
|
side: THREE.DoubleSide,
|
|
blending: getGalaxyBlending(layerConfig.blendMode),
|
|
uniforms: {
|
|
uTime: { value: 0 },
|
|
uOpacity: { value: layerConfig.opacity },
|
|
uArms: { value: layerConfig.armCount },
|
|
uTwist: { value: layerConfig.twist },
|
|
uArmSharpness: { value: layerConfig.armSharpness },
|
|
uNoiseScale: { value: layerConfig.noiseScale },
|
|
uNoiseStrength: { value: layerConfig.noiseStrength },
|
|
uCoreRadius: { value: layerConfig.coreRadius },
|
|
uCoreGlow: { value: layerConfig.coreGlow },
|
|
uGlowStrength: { value: layerConfig.glowStrength },
|
|
uSeed: { value: index * 0.173 + 0.31 },
|
|
uCoreWhite: { value: new THREE.Color(APP_CONFIG.galaxy.palette.coreWhite) },
|
|
uCoreGold: { value: new THREE.Color(APP_CONFIG.galaxy.palette.coreGold) },
|
|
uWarmOrange: { value: new THREE.Color(APP_CONFIG.galaxy.palette.warmOrange) },
|
|
uWarmMagenta: { value: new THREE.Color(APP_CONFIG.galaxy.palette.warmMagenta) },
|
|
uOuterBlue: { value: new THREE.Color(APP_CONFIG.galaxy.palette.outerBlue) },
|
|
uDeepBlue: { value: new THREE.Color(APP_CONFIG.galaxy.palette.deepBlue) },
|
|
uInnerColor: { value: new THREE.Color(layerConfig.innerColor) },
|
|
uOuterColor: { value: new THREE.Color(layerConfig.outerColor) },
|
|
uDustColor: { value: new THREE.Color(layerConfig.dustColor) },
|
|
},
|
|
})
|
|
|
|
const galaxyMesh = new THREE.Mesh(galaxyGeometry, galaxyMaterial)
|
|
galaxyMesh.scale.setScalar(layerConfig.scale)
|
|
galaxyMesh.position.z = layerConfig.zOffset
|
|
galaxyMesh.rotation.z = index * 0.8
|
|
galaxyGroup.add(galaxyMesh)
|
|
galaxyLayers.push(galaxyMesh)
|
|
galaxyMaterials.push(galaxyMaterial)
|
|
})
|
|
|
|
const clock = new THREE.Clock()
|
|
|
|
const onResize = () => {
|
|
const width = container.clientWidth || window.innerWidth
|
|
const height = container.clientHeight || window.innerHeight
|
|
|
|
camera.aspect = width / height
|
|
camera.updateProjectionMatrix()
|
|
renderer.setPixelRatio(Math.min(window.devicePixelRatio, APP_CONFIG.scene.maxPixelRatio))
|
|
renderer.setSize(width, height)
|
|
}
|
|
|
|
function updateStars(delta: number) {
|
|
const positionAttribute = starsGeometry.getAttribute('position') as THREE.BufferAttribute
|
|
const progressAttribute = starsGeometry.getAttribute('aProgress') as THREE.BufferAttribute
|
|
const tailAttribute = starsGeometry.getAttribute('aTail') as THREE.BufferAttribute
|
|
const directionAttribute = starsGeometry.getAttribute('aDir') as THREE.BufferAttribute
|
|
|
|
for (let index = 0; index < STAR_COUNT; index += 1) {
|
|
const state = starStates[index]
|
|
|
|
if (state.delay > 0) {
|
|
state.delay = Math.max(0, state.delay - delta)
|
|
progressAttribute.array[index] = 0
|
|
continue
|
|
}
|
|
|
|
const progress = clamp((state.z - STAR_FAR_Z) / (STAR_RESET_Z - STAR_FAR_Z), 0, 1)
|
|
const edgeRatio = clamp(
|
|
Math.max(Math.abs(state.x) / STAR_BOUNDS_X, Math.abs(state.y) / STAR_BOUNDS_Y),
|
|
0,
|
|
1.2,
|
|
)
|
|
const nearBoost = 1 + Math.pow(progress, 2.2) * APP_CONFIG.starfield.nearFieldBoost
|
|
const edgeBoost = 1 + Math.pow(edgeRatio, 3.1) * APP_CONFIG.starfield.edgeBoost
|
|
const burstBoost = 1 + Math.pow(edgeRatio, 4.2) * APP_CONFIG.starfield.edgeBurst
|
|
|
|
state.vx += state.ax * delta * APP_CONFIG.starfield.accelerationXY * nearBoost * edgeBoost
|
|
state.vy += state.ay * delta * APP_CONFIG.starfield.accelerationXY * nearBoost * edgeBoost
|
|
state.vz += state.az * delta * APP_CONFIG.starfield.accelerationZ * nearBoost * edgeBoost
|
|
|
|
state.x += state.vx * delta * burstBoost
|
|
state.y += state.vy * delta * burstBoost
|
|
state.z += state.vz * delta * (1 + (burstBoost - 1) * 0.45)
|
|
|
|
const nextProgress = clamp((state.z - STAR_FAR_Z) / (STAR_RESET_Z - STAR_FAR_Z), 0, 1)
|
|
const nextEdgeRatio = clamp(
|
|
Math.max(Math.abs(state.x) / STAR_BOUNDS_X, Math.abs(state.y) / STAR_BOUNDS_Y),
|
|
0,
|
|
1,
|
|
)
|
|
const progressTrail = clamp(
|
|
(nextProgress - APP_CONFIG.starfield.trailStartProgress) / (1 - APP_CONFIG.starfield.trailStartProgress),
|
|
0,
|
|
1,
|
|
)
|
|
const edgeTrail = Math.pow(nextEdgeRatio, 2.4)
|
|
const direction = normalizeDirection(state.vx, state.vy)
|
|
const tailStrength = clamp(
|
|
Math.max(progressTrail * 0.75, edgeTrail) * APP_CONFIG.starfield.trailStrength,
|
|
0,
|
|
1,
|
|
)
|
|
const offset = index * 3
|
|
const directionOffset = index * 2
|
|
|
|
if (
|
|
state.z > STAR_RESET_Z ||
|
|
Math.abs(state.x) > STAR_BOUNDS_X ||
|
|
Math.abs(state.y) > STAR_BOUNDS_Y
|
|
) {
|
|
spawnStar(index)
|
|
continue
|
|
}
|
|
|
|
positionAttribute.array[offset] = state.x
|
|
positionAttribute.array[offset + 1] = state.y
|
|
positionAttribute.array[offset + 2] = state.z
|
|
progressAttribute.array[index] = nextProgress
|
|
tailAttribute.array[index] = tailStrength
|
|
directionAttribute.array[directionOffset] = direction.x
|
|
directionAttribute.array[directionOffset + 1] = direction.y
|
|
}
|
|
|
|
positionAttribute.needsUpdate = true
|
|
progressAttribute.needsUpdate = true
|
|
tailAttribute.needsUpdate = true
|
|
directionAttribute.needsUpdate = true
|
|
}
|
|
|
|
function updateSmoke(delta: number, elapsed: number) {
|
|
for (const state of smokeStates) {
|
|
state.age += delta
|
|
state.x += state.vx * delta
|
|
state.y += state.vy * delta
|
|
state.z += state.vz * delta
|
|
state.rotation += state.spin * delta
|
|
|
|
if (
|
|
state.z > SMOKE_RESET_Z ||
|
|
Math.abs(state.x) > SMOKE_BOUNDS_X ||
|
|
Math.abs(state.y) > SMOKE_BOUNDS_Y
|
|
) {
|
|
const resetState = spawnSmoke(state.mesh)
|
|
Object.assign(state, resetState)
|
|
}
|
|
|
|
const progress = clamp((state.z - SMOKE_FAR_Z) / (SMOKE_RESET_Z - SMOKE_FAR_Z), 0, 1)
|
|
const depthFadeIn = smoothstep(0.02, 0.28, progress)
|
|
const ageFadeIn = smoothstep(0, 0.55, state.age)
|
|
const fadeIn = depthFadeIn * ageFadeIn
|
|
const fadeOut = 1 - smoothstep(0.68, 1, progress)
|
|
const pulse = 1 + Math.sin(elapsed * state.wobbleSpeed + state.rotation) * 0.12 * state.wobble
|
|
const scale = lerp(0.56, 1.9, progress) * pulse
|
|
|
|
state.mesh.position.set(state.x, state.y, state.z)
|
|
state.mesh.lookAt(camera.position)
|
|
state.mesh.rotateZ(state.rotation)
|
|
state.mesh.scale.set(state.baseScaleX * scale, state.baseScaleY * scale, 1)
|
|
state.mesh.material.opacity = state.opacity * fadeIn * fadeOut
|
|
}
|
|
}
|
|
|
|
function render() {
|
|
if (disposed) {
|
|
return
|
|
}
|
|
|
|
const deltaSeconds = Math.min(clock.getDelta(), 0.033)
|
|
const elapsed = clock.elapsedTime
|
|
|
|
pointerCurrent.x = lerp(pointerCurrent.x, pointerTarget.x, APP_CONFIG.interaction.pointerSmoothing)
|
|
pointerCurrent.y = lerp(pointerCurrent.y, pointerTarget.y, APP_CONFIG.interaction.pointerSmoothing)
|
|
|
|
const speedGoal = started ? targetSpeed : 0
|
|
currentSpeed = lerp(currentSpeed, speedGoal, 0.06)
|
|
|
|
const motionDelta = deltaSeconds * currentSpeed
|
|
updateStars(motionDelta)
|
|
updateSmoke(motionDelta * 0.62, elapsed)
|
|
|
|
starMaterial.uniforms.uSpeed.value = currentSpeed
|
|
|
|
galaxyLayers.forEach((galaxyLayer, index) => {
|
|
galaxyLayer.rotation.z -= APP_CONFIG.galaxy.layers[index].rotationSpeed * currentSpeed
|
|
})
|
|
galaxyMaterials.forEach((material, index) => {
|
|
material.uniforms.uTime.value = elapsed + index * 0.37
|
|
})
|
|
|
|
// 自动视角随机摆动，摆动速度跟随当前速度 (currentSpeed) 动态变化
|
|
// 修复抖动：通过 deltaSeconds 累加时间，而不是直接用 elapsed 乘以可变的速度，避免相位突变
|
|
accumulatedWobbleTime += deltaSeconds * (0.8 + currentSpeed * 2.0)
|
|
|
|
// 利用多个不同频率的三角函数叠加，生成平滑且看似随机的摆动
|
|
const wobbleX = (Math.sin(accumulatedWobbleTime * 0.8) + Math.sin(accumulatedWobbleTime * 1.7 + 2.1) + Math.sin(accumulatedWobbleTime * 0.5 + 4.3)) / 3
|
|
const wobbleY = (Math.cos(accumulatedWobbleTime * 0.9) + Math.cos(accumulatedWobbleTime * 1.5 + 1.2) + Math.cos(accumulatedWobbleTime * 0.6 + 3.5)) / 3
|
|
|
|
// 基础摆动幅度 + 随速度增加的额外幅度 (显著增加摆动幅度)
|
|
const wobbleAmpX = 0.8 + currentSpeed * 0.8
|
|
const wobbleAmpY = 0.5 + currentSpeed * 0.5
|
|
|
|
// 综合鼠标位置与自动摆动
|
|
const viewX = pointerCurrent.x + wobbleX * wobbleAmpX
|
|
const viewY = pointerCurrent.y + wobbleY * wobbleAmpY
|
|
|
|
// 较大幅度地影响场景根节点，增加整体动感
|
|
travelRoot.rotation.z = viewX * 0.06
|
|
travelRoot.position.x = -viewX * 1.8
|
|
travelRoot.position.y = -viewY * 1.0
|
|
|
|
// 加大相机的偏移幅度和观察点偏移
|
|
// 增加一点默认偏移，让相机的中心略微向左上，从而使画面整体偏向右下，填补空旷
|
|
const baseLookX = -3.0
|
|
const baseLookY = 5.0
|
|
camera.position.x = viewX * APP_CONFIG.interaction.maxOffset * 4.5
|
|
camera.position.y = viewY * APP_CONFIG.interaction.maxOffset * 3.0
|
|
camera.lookAt(baseLookX + viewX * 2.5, baseLookY + viewY * 1.5, -30)
|
|
|
|
renderer.render(scene, camera)
|
|
animationFrameId = window.requestAnimationFrame(render)
|
|
}
|
|
|
|
window.addEventListener('resize', onResize)
|
|
render()
|
|
|
|
return {
|
|
setStarted(nextStarted) {
|
|
started = nextStarted
|
|
},
|
|
setSpeed(nextSpeed) {
|
|
targetSpeed = clamp(nextSpeed, APP_CONFIG.animation.speedMin, APP_CONFIG.animation.speedMax)
|
|
},
|
|
setPointerTarget(pointer) {
|
|
pointerTarget.x = clamp(pointer.x, -1, 1)
|
|
pointerTarget.y = clamp(pointer.y, -1, 1)
|
|
},
|
|
dispose() {
|
|
if (disposed) {
|
|
return
|
|
}
|
|
|
|
disposed = true
|
|
window.cancelAnimationFrame(animationFrameId)
|
|
window.removeEventListener('resize', onResize)
|
|
|
|
for (const smokeState of smokeStates) {
|
|
smokeState.mesh.material.dispose()
|
|
travelRoot.remove(smokeState.mesh)
|
|
}
|
|
|
|
galaxyMaterials.forEach((material) => material.dispose())
|
|
galaxyGeometry.dispose()
|
|
|
|
starsGeometry.dispose()
|
|
starMaterial.dispose()
|
|
smokeGeometry.dispose()
|
|
smokeTexture.dispose()
|
|
renderer.dispose()
|
|
scene.clear()
|
|
|
|
if (renderer.domElement.parentElement === container) {
|
|
container.removeChild(renderer.domElement)
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
export type { PointerTarget, TravelSceneController }
|