takibi-design-system 0.1.0 → 0.2.1
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/LICENSES/CC-BY-SA-4.0.txt +428 -0
- package/README.md +13 -1
- package/dist/tokens.css +94 -52
- package/dist/tokens.json +269 -120
- package/package.json +17 -4
- package/src/components/accordion.tsx +1 -1
- package/src/components/alert-dialog.tsx +1 -1
- package/src/components/animated-number.tsx +4 -4
- package/src/components/avatar.tsx +1 -1
- package/src/components/banner.tsx +1 -1
- package/src/components/button.tsx +8 -31
- package/src/components/calendar.tsx +4 -4
- package/src/components/collapsible.tsx +1 -1
- package/src/components/combobox.tsx +3 -3
- package/src/components/command.tsx +1 -1
- package/src/components/dialog.tsx +1 -1
- package/src/components/drawer.tsx +4 -4
- package/src/components/empty-state.tsx +1 -1
- package/src/components/file-drop.tsx +2 -2
- package/src/components/interactive-card.tsx +21 -8
- package/src/components/link.tsx +1 -1
- package/src/components/list.tsx +3 -3
- package/src/components/meter.tsx +3 -1
- package/src/components/nav-list.tsx +1 -1
- package/src/components/navigation-menu.tsx +5 -5
- package/src/components/number-field.tsx +31 -5
- package/src/components/otp-field.tsx +1 -1
- package/src/components/preview-card.tsx +1 -1
- package/src/components/progress.tsx +1 -1
- package/src/components/radio-group.tsx +1 -1
- package/src/components/rating.tsx +3 -3
- package/src/components/scroll-area.tsx +1 -1
- package/src/components/select.tsx +1 -1
- package/src/components/skip-link.tsx +2 -2
- package/src/components/slider.tsx +7 -7
- package/src/components/sparks.tsx +110 -0
- package/src/components/steps.tsx +1 -1
- package/src/components/table.tsx +1 -1
- package/src/components/tag.tsx +3 -3
- package/src/components/theme-toggle.tsx +43 -15
- package/src/components/tree-view.tsx +2 -2
- package/src/embers.d.ts +3 -5
- package/src/embers.js +138 -247
- package/src/fire/base-day.webp +0 -0
- package/src/fire/base-night.webp +0 -0
- package/src/fire/engine.js +1067 -0
- package/src/fire/flame-still.webp +0 -0
- package/src/fire/flame.mp4 +0 -0
- package/src/fire/lit.webp +0 -0
- package/src/fire.d.ts +108 -0
- package/src/fire.js +618 -0
- package/src/index.ts +13 -1
- package/src/lib/daylight.ts +80 -0
- package/src/lib/glide.tsx +1 -1
- package/src/lib/motion.ts +21 -14
- package/src/lib/theme.ts +11 -4
- package/src/lib/warmth.ts +12 -0
- package/src/motion.css +370 -58
- package/src/stars-data.js +14 -0
- package/src/stars.d.ts +21 -0
- package/src/stars.js +181 -0
- package/src/tokens.css +275 -135
|
@@ -0,0 +1,1067 @@
|
|
|
1
|
+
/* ============================================================
|
|
2
|
+
焚き火の計算モデル(<takibi-fire> と labs/fire3d が使う)
|
|
3
|
+
------------------------------------------------------------
|
|
4
|
+
薪、熾、地面を立体の形にして、炎を 3 次元の流れとして WebGL2 で計算して描く。
|
|
5
|
+
|
|
6
|
+
薪の組み方: ロングファイヤー型。太い丸太 2 本を、内側の面が 15cm 離れるように地面へ平行に置く。
|
|
7
|
+
その間に、四つ割りの細い薪を丸太と同じ向きに 2 段でくべる。丸太は太くて火がつきにくく、燃えるのは間の薪。
|
|
8
|
+
|
|
9
|
+
形の作り方: 画面の 1 点ごとに視線を伸ばし、薪までの距離を返す関数(距離関数)に当たる所を探す。
|
|
10
|
+
薪は絵ではなく形なので、どの角度から見ても輪郭、重なり、影が合う。
|
|
11
|
+
- 丸太: 円柱。太さは長さ方向にゆるく変わり、少し曲がっている。樹皮は縦の溝を凹凸として持つ
|
|
12
|
+
- 割った薪: 円柱を、芯を通る 1 枚か 2 枚の面で切った形。割り面は繊維に沿った細かい凹凸を持つ
|
|
13
|
+
- 切り口: 軸に対して数度傾いた平面。年輪は木の芯を中心に広がる(割った薪では、芯は割り面の角にある)
|
|
14
|
+
- 焦げ: 火に近い面が炭になる。炭は木目に沿って長い四角に割れ、割れ目は 3mm ほどくぼむ。上を向いた面には白い灰が乗る
|
|
15
|
+
- 熾: 枕木の間に積もった炭のかたまり。1 個ずつが形を持つ
|
|
16
|
+
|
|
17
|
+
炎: 0.8m × 0.8m × 0.53m の空間を 96 × 96 × 64 のマスに分け、速度、温度、燃料のガス、酸素、すすを毎コマ解く。
|
|
18
|
+
燃料は熱い薪の表面と熾から出て、空気と混ざった所で燃える。色はすすの温度から黒体放射の式で決める。
|
|
19
|
+
炎全体の明るさと重心を毎コマ測り、その位置の光源で薪と地面を照らす。
|
|
20
|
+
|
|
21
|
+
負荷の抑え方:
|
|
22
|
+
- 計算も描画も GPU で行う。JS が毎コマ行うのは、薪の状態の更新と、火の粉(最大 300 個)の移動だけ
|
|
23
|
+
- GPU から値を読むときは待たない(reader)。炎の光は GPU の上でまとめ、合成がそのまま読む
|
|
24
|
+
- 薪と地面は、形か視点が変わったときだけ描き直す。描き直しは rebuildFrames コマに分け、1 コマの重さを抑える。
|
|
25
|
+
薪が落ちる、折れる、視点を動かす、の間だけは 4 割の解像度で毎コマ描く
|
|
26
|
+
|
|
27
|
+
使い方:
|
|
28
|
+
const engine = createFireEngine(canvas, { params, view, onEvent, manual });
|
|
29
|
+
await engine.ready; // シェーダーが組み上がるまで待つ
|
|
30
|
+
engine.resize(w, h); // 描く大きさ(画素)
|
|
31
|
+
engine.render(performance.now()); // 1 コマ進めて描く。呼ぶ間隔が時間の進みになる(上限 0.05 秒)
|
|
32
|
+
manual を true にすると焼き出し用になり、GPU の値をその場で読む(毎コマの値がそろう代わりに、GPU を待つ)。
|
|
33
|
+
============================================================ */
|
|
34
|
+
|
|
35
|
+
/** 薪の向きから横へ回った角度 az、見下ろす角度 el、中心からの距離 dist(m)、縦の画角 fov(度)の候補 */
|
|
36
|
+
export const ANGLES = [
|
|
37
|
+
{ name: "斜め前・低め", az: 28, el: 12, dist: 1.5, fov: 34 },
|
|
38
|
+
{ name: "薪の端から", az: 8, el: 16, dist: 1.2, fov: 34 },
|
|
39
|
+
{ name: "真横", az: 90, el: 10, dist: 1.3, fov: 34 },
|
|
40
|
+
{ name: "見下ろす", az: 40, el: 38, dist: 1.25, fov: 34 },
|
|
41
|
+
];
|
|
42
|
+
|
|
43
|
+
export function createFireEngine(canvas, options = {}) {
|
|
44
|
+
const manual = !!options.manual;
|
|
45
|
+
const gl = canvas.getContext("webgl2", { antialias: false, alpha: true, premultipliedAlpha: true, powerPreference: options.powerPreference ?? "default" });
|
|
46
|
+
function fail(msg) { throw new Error(msg); }
|
|
47
|
+
if (!gl) fail("このブラウザでは WebGL2 が使えない");
|
|
48
|
+
if (!gl.getExtension("EXT_color_buffer_float") && !gl.getExtension("EXT_color_buffer_half_float")) fail("浮動小数のテクスチャに描けない");
|
|
49
|
+
gl.getExtension("OES_texture_float_linear");
|
|
50
|
+
const timerExt = gl.getExtension("EXT_disjoint_timer_query_webgl2");
|
|
51
|
+
|
|
52
|
+
// ---------- 薪の並び(単位はメートル。x は薪の向き、y は上、z は横) ----------
|
|
53
|
+
// type: 0 丸太、1 半割り、2 四つ割り。r は太さの半分。spin は軸まわりの向き、bend は曲がり、heat は火の当たり方
|
|
54
|
+
const LOGS = [
|
|
55
|
+
// 両脇の丸太。地面に直に置く。太いので火はつきにくく、内側の面が焦げるだけ
|
|
56
|
+
{ a: [-0.31, 0.06, -0.142], b: [0.29, 0.06, -0.13], r: 0.06, type: 0, spin: 0.3, bend: 0.005, heat: 0.3 },
|
|
57
|
+
{ a: [-0.28, 0.057, 0.128], b: [0.31, 0.057, 0.14], r: 0.057, type: 0, spin: 2.1, bend: -0.004, heat: 0.3 },
|
|
58
|
+
// 間にくべた薪。四つ割りを丸太と同じ向きに、2 段に重ねる
|
|
59
|
+
{ a: [-0.2, 0.062, -0.04], b: [0.19, 0.066, -0.032], r: 0.04, type: 2, spin: 3.9, bend: 0.002, heat: 1 },
|
|
60
|
+
{ a: [-0.17, 0.064, 0.03], b: [0.215, 0.06, 0.04], r: 0.038, type: 2, spin: 5.4, bend: -0.002, heat: 1 },
|
|
61
|
+
{ a: [-0.215, 0.118, -0.012], b: [0.17, 0.126, 0.012], r: 0.039, type: 2, spin: 4.5, bend: 0.002, heat: 1 },
|
|
62
|
+
{ a: [-0.15, 0.115, 0.058], b: [0.225, 0.122, 0.03], r: 0.034, type: 1, spin: 3.3, bend: -0.002, heat: 1 },
|
|
63
|
+
];
|
|
64
|
+
const MAX_LOGS = 14;
|
|
65
|
+
|
|
66
|
+
// ---------- WebGL の道具 ----------
|
|
67
|
+
const VS = `#version 300 es
|
|
68
|
+
in vec2 p; out vec2 uv;
|
|
69
|
+
void main(){ uv = p * 0.5 + 0.5; gl_Position = vec4(p, 0.0, 1.0); }`;
|
|
70
|
+
// シェーダーは、できるブラウザでは裏で組み立てる(KHR_parallel_shader_compile)。組み上がるまで ready は終わらない
|
|
71
|
+
const parallel = gl.getExtension("KHR_parallel_shader_compile");
|
|
72
|
+
const pending = [];
|
|
73
|
+
function compile(type, src) { const s = gl.createShader(type); gl.shaderSource(s, src); gl.compileShader(s); return s; }
|
|
74
|
+
function program(fs) {
|
|
75
|
+
const vs = compile(gl.VERTEX_SHADER, VS), fsh = compile(gl.FRAGMENT_SHADER, `#version 300 es\nprecision highp float;\nprecision highp sampler2D;\n${fs}`);
|
|
76
|
+
const p = gl.createProgram(); gl.attachShader(p, vs); gl.attachShader(p, fsh); gl.bindAttribLocation(p, 0, "p"); gl.linkProgram(p);
|
|
77
|
+
const prog = { p, u: {} }; pending.push({ prog, fsh }); return prog;
|
|
78
|
+
}
|
|
79
|
+
const programsDone = () => !parallel || pending.every(({ prog }) => gl.getProgramParameter(prog.p, parallel.COMPLETION_STATUS_KHR));
|
|
80
|
+
function finishPrograms() {
|
|
81
|
+
for (const { prog, fsh } of pending) {
|
|
82
|
+
if (!gl.getProgramParameter(prog.p, gl.LINK_STATUS)) fail(`シェーダーの組み立てに失敗: ${gl.getProgramInfoLog(prog.p)} ${gl.getShaderInfoLog(fsh) ?? ""}`);
|
|
83
|
+
const n = gl.getProgramParameter(prog.p, gl.ACTIVE_UNIFORMS);
|
|
84
|
+
for (let i = 0; i < n; i++) { const info = gl.getActiveUniform(prog.p, i); const name = info.name.replace(/\[0\]$/, ""); prog.u[name] = gl.getUniformLocation(prog.p, name); }
|
|
85
|
+
}
|
|
86
|
+
pending.length = 0;
|
|
87
|
+
}
|
|
88
|
+
const quad = gl.createVertexArray(); gl.bindVertexArray(quad);
|
|
89
|
+
gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
|
|
90
|
+
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);
|
|
91
|
+
gl.enableVertexAttribArray(0); gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
|
|
92
|
+
function target(w, h) {
|
|
93
|
+
const tex = gl.createTexture(); gl.bindTexture(gl.TEXTURE_2D, tex);
|
|
94
|
+
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, w, h, 0, gl.RGBA, gl.HALF_FLOAT, null);
|
|
95
|
+
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
|
|
96
|
+
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
97
|
+
const fbo = gl.createFramebuffer(); gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
|
|
98
|
+
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0);
|
|
99
|
+
return { tex, fbo, w, h };
|
|
100
|
+
}
|
|
101
|
+
function draw(prog, dst, set) {
|
|
102
|
+
gl.useProgram(prog.p);
|
|
103
|
+
gl.bindFramebuffer(gl.FRAMEBUFFER, dst ? dst.fbo : null);
|
|
104
|
+
gl.viewport(0, 0, dst ? dst.w : canvas.width, dst ? dst.h : canvas.height);
|
|
105
|
+
let unit = 0;
|
|
106
|
+
const api = {
|
|
107
|
+
tex(name, t) { gl.activeTexture(gl.TEXTURE0 + unit); gl.bindTexture(gl.TEXTURE_2D, t.tex ?? t); gl.uniform1i(prog.u[name], unit++); return api; },
|
|
108
|
+
f(name, ...v) { if (prog.u[name]) gl[`uniform${v.length}f`](prog.u[name], ...v); return api; },
|
|
109
|
+
i(name, v) { if (prog.u[name]) gl.uniform1i(prog.u[name], v); return api; },
|
|
110
|
+
fv(name, size, arr) { if (prog.u[name]) gl[`uniform${size}fv`](prog.u[name], arr); return api; },
|
|
111
|
+
};
|
|
112
|
+
set(api);
|
|
113
|
+
gl.bindVertexArray(quad); gl.drawArrays(gl.TRIANGLES, 0, 3);
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
// ---------- 炎の計算(3 次元の格子を、1 枚の画像に 8 × 8 枚の断面として並べて持つ) ----------
|
|
117
|
+
const NX = 96, NY = 96, NZ = 64, TX = 8, TY = 8;
|
|
118
|
+
const CELL = 0.8 / NX; // 1 マス 8.3mm
|
|
119
|
+
const ORIGIN = [-0.4, 0, (-NZ * CELL) / 2];
|
|
120
|
+
const SIMLIB = `
|
|
121
|
+
const ivec3 N = ivec3(${NX}, ${NY}, ${NZ}); const ivec2 TILES = ivec2(${TX}, ${TY});
|
|
122
|
+
const float CELL = ${CELL.toFixed(6)}; const vec3 ORIGIN = vec3(${ORIGIN.map((v) => v.toFixed(5)).join(", ")});
|
|
123
|
+
ivec3 cellOf(ivec2 f){ ivec2 t = f / N.xy; return ivec3(f - t * N.xy, t.x + t.y * TILES.x); }
|
|
124
|
+
vec4 fetch(sampler2D s, ivec3 c){ c = clamp(c, ivec3(0), N - 1); return texelFetch(s, ivec2(c.x + (c.z % TILES.x) * N.x, c.y + (c.z / TILES.x) * N.y), 0); }
|
|
125
|
+
vec4 tile(sampler2D s, vec2 xy, int k){ k = clamp(k, 0, N.z - 1); vec2 o = vec2(float(k % TILES.x), float(k / TILES.x)) * vec2(N.xy); return texture(s, (o + clamp(xy, vec2(0.5), vec2(N.xy) - 0.5)) / vec2(N.xy * TILES)); }
|
|
126
|
+
// マスの単位の位置 g での値。断面の中は線形補間、断面の間は 2 枚を混ぜる
|
|
127
|
+
vec4 samp(sampler2D s, vec3 g){ float z = g.z - 0.5; float k0 = floor(z); return mix(tile(s, g.xy, int(k0)), tile(s, g.xy, int(k0) + 1), z - k0); }
|
|
128
|
+
`;
|
|
129
|
+
const PLANCK = `
|
|
130
|
+
vec3 planck(float T){
|
|
131
|
+
vec3 lam = vec3(610e-9, 550e-9, 465e-9);
|
|
132
|
+
vec3 x = 0.0143877 / (lam * T);
|
|
133
|
+
vec3 b = 1.0 / (pow(lam / 610e-9, vec3(5.0)) * (exp(x) - 1.0));
|
|
134
|
+
return b / (1.0 / (exp(0.0143877 / (610e-9 * 1500.0)) - 1.0));
|
|
135
|
+
}
|
|
136
|
+
// 炎が 1m あたりに出す光。すすの量 × その温度の黒体放射。根元の反応している所には、すすのない青い光が少しある
|
|
137
|
+
vec3 flameEmit(vec4 s){
|
|
138
|
+
vec3 e = planck(s.x) * (1.0 - exp(-s.w * 1.6)) * smoothstep(800.0, 1000.0, s.x) * 260.0;
|
|
139
|
+
e += vec3(0.04, 0.1, 0.4) * min(s.y * s.z, 0.3) * smoothstep(700.0, 1100.0, s.x) * exp(-s.w * 6.0) * 5.0;
|
|
140
|
+
return e;
|
|
141
|
+
}`;
|
|
142
|
+
const SIMLOGS = `
|
|
143
|
+
uniform vec4 uLogA[${MAX_LOGS}]; uniform vec4 uLogB[${MAX_LOGS}]; uniform vec4 uLogC[${MAX_LOGS}]; uniform vec4 uLogD[${MAX_LOGS}]; uniform int uLogN; uniform float uBed;
|
|
144
|
+
float hash3(vec3 p){ p = fract(p * vec3(0.1031, 0.1030, 0.0973)); p += dot(p, p.yxz + 33.33); return fract((p.x + p.y) * p.z); }
|
|
145
|
+
float vnoise3(vec3 p){ vec3 i = floor(p), f = fract(p); f = f*f*(3.0-2.0*f);
|
|
146
|
+
return mix(mix(mix(hash3(i), hash3(i+vec3(1,0,0)), f.x), mix(hash3(i+vec3(0,1,0)), hash3(i+vec3(1,1,0)), f.x), f.y),
|
|
147
|
+
mix(mix(hash3(i+vec3(0,0,1)), hash3(i+vec3(1,0,1)), f.x), mix(hash3(i+vec3(0,1,1)), hash3(i+vec3(1,1,1)), f.x), f.y), f.z); }
|
|
148
|
+
float heatAt(vec3 p){ vec3 q = (p - vec3(0.0, 0.075, 0.0)) / vec3(0.21, 0.1, 0.1); return exp(-dot(q, q)); }
|
|
149
|
+
// 薪の表面までの距離(円柱として)と、その薪への火の当たり方
|
|
150
|
+
float logDist(vec3 p, int i){ vec3 A = uLogA[i].xyz, ba = uLogB[i].xyz - A; vec3 pa = p - A; float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0); return length(pa - ba * h) - uLogA[i].w * 0.9; }
|
|
151
|
+
`;
|
|
152
|
+
const ADVECT = program(`
|
|
153
|
+
out vec4 o; uniform sampler2D uVel, uSrc; uniform float uDt;
|
|
154
|
+
${SIMLIB}
|
|
155
|
+
void main(){
|
|
156
|
+
ivec3 c = cellOf(ivec2(gl_FragCoord.xy)); vec3 g = vec3(c) + 0.5;
|
|
157
|
+
vec3 v = fetch(uVel, c).xyz;
|
|
158
|
+
vec3 mid = g - 0.5 * uDt * v / CELL;
|
|
159
|
+
o = samp(uSrc, g - uDt * samp(uVel, mid).xyz / CELL);
|
|
160
|
+
}`);
|
|
161
|
+
// 燃料の出る所、反応、冷却。状態は (温度 T, 燃料のガス F, 酸素 O, すす S)
|
|
162
|
+
const REACT = program(`
|
|
163
|
+
out vec4 o; uniform sampler2D uState; uniform float uDt, uTime, uIntensity, uBurn;
|
|
164
|
+
${SIMLIB}${SIMLOGS}
|
|
165
|
+
void main(){
|
|
166
|
+
ivec3 c = cellOf(ivec2(gl_FragCoord.xy)); vec3 p = ORIGIN + (vec3(c) + 0.5) * CELL;
|
|
167
|
+
// 外の縁は外気: 300 K、燃料なし、酸素あり
|
|
168
|
+
if (c.x == 0 || c.x == N.x - 1 || c.z == 0 || c.z == N.z - 1 || c.y == N.y - 1) { o = vec4(300.0, 0.0, 1.0, 0.0); return; }
|
|
169
|
+
vec4 s = fetch(uState, c);
|
|
170
|
+
// 熱と気体の拡散: 隣の 6 マスと少し混ぜる
|
|
171
|
+
vec4 nb = fetch(uState, c + ivec3(1,0,0)) + fetch(uState, c - ivec3(1,0,0)) + fetch(uState, c + ivec3(0,1,0)) + fetch(uState, c - ivec3(0,1,0)) + fetch(uState, c + ivec3(0,0,1)) + fetch(uState, c - ivec3(0,0,1));
|
|
172
|
+
s = mix(s, nb / 6.0, 0.12);
|
|
173
|
+
float T = max(s.x, 300.0), F = max(s.y, 0.0), O = clamp(s.z, 0.0, 1.0), S = max(s.w, 0.0);
|
|
174
|
+
// 燃料は、熱い薪の表面から 3cm までの空気と、熾の上に出る。太い丸太は火の当たり方が小さいので、ほとんど出さない
|
|
175
|
+
float src = 0.0; float solid = 0.0; float smoke = 0.0;
|
|
176
|
+
for (int i = 0; i < ${MAX_LOGS}; i++) {
|
|
177
|
+
if (i >= uLogN) break;
|
|
178
|
+
float d = logDist(p, i);
|
|
179
|
+
if (d < 0.0) solid = 1.0;
|
|
180
|
+
float band = smoothstep(0.03, 0.004, d) * step(0.0, d);
|
|
181
|
+
src += band * uLogD[i].y;
|
|
182
|
+
// 火が移る前の薪からは、燃えないガスと水蒸気(煙)が出る
|
|
183
|
+
smoke += band * uLogD[i].z;
|
|
184
|
+
}
|
|
185
|
+
src = min(src, 1.3) * heatAt(p);
|
|
186
|
+
// 熾からも少し出る。熾の山が大きいほど多い
|
|
187
|
+
src += (0.2 + 0.5 * uBed) * smoothstep(0.07, 0.03, p.y) * step(abs(p.x), 0.22) * step(abs(p.z), 0.075);
|
|
188
|
+
// 出る量は場所と時刻でむらがある。長さ方向に、よく燃える所が 10cm ほどの幅でゆっくり入れ替わる
|
|
189
|
+
float n = vnoise3(vec3(p.x * 14.0, p.y * 14.0 - uTime * 1.1, p.z * 14.0 + uTime * 0.3));
|
|
190
|
+
float n2 = vnoise3(vec3(p.x * 7.0 + uTime * 0.2, uTime * 0.5, p.z * 5.0));
|
|
191
|
+
src *= (0.15 + 1.7 * n) * (0.4 + 1.2 * n2) * uIntensity;
|
|
192
|
+
F += src * 8.0 * uDt;
|
|
193
|
+
S += smoke * heatAt(p) * 2.5 * uDt;
|
|
194
|
+
T += (980.0 - T) * clamp(src * 14.0 * uDt, 0.0, 1.0) * step(T, 980.0);
|
|
195
|
+
// 反応: 燃料 1 に対して酸素 1.6 を使う。発火点(約 700 K)より上でだけ進む
|
|
196
|
+
float ign = smoothstep(620.0, 780.0, T);
|
|
197
|
+
float r = min(min(F, O / 1.6), 60.0 * F * O * ign * uDt);
|
|
198
|
+
F -= r; O -= 1.6 * r; T += 2300.0 * r; S += 1.6 * r;
|
|
199
|
+
// すすは、酸素のある熱い所で燃えてなくなる
|
|
200
|
+
S -= S * O * smoothstep(1000.0, 1350.0, T) * 5.0 * uDt;
|
|
201
|
+
// 冷却: すすの放射(T の 4 乗)と、周りの空気との混合
|
|
202
|
+
float t4 = T * T * T * T - 8.1e9;
|
|
203
|
+
T -= (1.3e-9 * min(S, 1.5) * t4 + 0.8 * (T - 300.0)) * uDt;
|
|
204
|
+
F *= 1.0 - 0.4 * uDt;
|
|
205
|
+
S *= 1.0 - (T < 700.0 ? 0.7 : 0.1) * uDt;
|
|
206
|
+
// 薪の中には気体がない
|
|
207
|
+
if (solid > 0.5) { F = 0.0; S = 0.0; O = 0.3; }
|
|
208
|
+
o = vec4(clamp(T, 300.0, 1900.0), F, clamp(O, 0.0, 1.0), max(S, 0.0));
|
|
209
|
+
}`);
|
|
210
|
+
const FORCE = program(`
|
|
211
|
+
out vec4 o; uniform sampler2D uVel, uState; uniform float uDt, uTime, uWind;
|
|
212
|
+
${SIMLIB}${SIMLOGS}
|
|
213
|
+
vec3 pot(vec3 p){ return vec3(vnoise3(p * 15.0 + vec3(0.0, -uTime * 2.0, 3.1)), vnoise3(p * 15.0 + vec3(7.3, -uTime * 2.0, 0.0)), vnoise3(p * 15.0 + vec3(1.7, -uTime * 2.0, 9.2))); }
|
|
214
|
+
void main(){
|
|
215
|
+
ivec3 c = cellOf(ivec2(gl_FragCoord.xy)); vec3 p = ORIGIN + (vec3(c) + 0.5) * CELL;
|
|
216
|
+
vec3 v = fetch(uVel, c).xyz; float T = fetch(uState, c).x;
|
|
217
|
+
// 浮力: 熱い気体は軽いので上へ加速する。加速度は g (T/Ta − 1)
|
|
218
|
+
v.y += 9.8 * (T / 300.0 - 1.0) * uDt;
|
|
219
|
+
// マスより細かい乱れ: 発散のない小さな渦(ベクトルポテンシャルの回転)を、熱い所にだけ足す
|
|
220
|
+
float e = 0.004;
|
|
221
|
+
vec3 dx = pot(p + vec3(e, 0, 0)) - pot(p - vec3(e, 0, 0)), dy = pot(p + vec3(0, e, 0)) - pot(p - vec3(0, e, 0)), dz = pot(p + vec3(0, 0, e)) - pot(p - vec3(0, 0, e));
|
|
222
|
+
vec3 curl = vec3(dy.z - dz.y, dz.x - dx.z, dx.y - dy.x) / (2.0 * e);
|
|
223
|
+
v += curl * 0.03 * smoothstep(500.0, 1100.0, T) * uDt * 60.0;
|
|
224
|
+
v.x += (uWind - v.x) * 0.6 * uDt * smoothstep(900.0, 320.0, T);
|
|
225
|
+
v *= 1.0 - 0.35 * uDt;
|
|
226
|
+
// 地面と薪は通り抜けない
|
|
227
|
+
if (c.y == 0) v.y = 0.0;
|
|
228
|
+
for (int i = 0; i < ${MAX_LOGS}; i++) { if (i >= uLogN) break; if (logDist(p, i) < 0.0) v *= 0.0; }
|
|
229
|
+
o = vec4(v, 1.0);
|
|
230
|
+
}`);
|
|
231
|
+
const DIVERGENCE = program(`
|
|
232
|
+
out vec4 o; uniform sampler2D uVel;
|
|
233
|
+
${SIMLIB}
|
|
234
|
+
void main(){
|
|
235
|
+
ivec3 c = cellOf(ivec2(gl_FragCoord.xy));
|
|
236
|
+
float d = fetch(uVel, c + ivec3(1,0,0)).x - fetch(uVel, c - ivec3(1,0,0)).x + fetch(uVel, c + ivec3(0,1,0)).y - (c.y == 0 ? 0.0 : fetch(uVel, c - ivec3(0,1,0)).y) + fetch(uVel, c + ivec3(0,0,1)).z - fetch(uVel, c - ivec3(0,0,1)).z;
|
|
237
|
+
o = vec4(d / (2.0 * CELL), 0, 0, 1);
|
|
238
|
+
}`);
|
|
239
|
+
const PRESSURE_LIB = `
|
|
240
|
+
// 上と横は開いている(圧力 0)。地面は閉じている(勾配 0)
|
|
241
|
+
float P(sampler2D s, ivec3 c){ if (c.x < 0 || c.x >= N.x || c.z < 0 || c.z >= N.z || c.y >= N.y) return 0.0; c.y = max(c.y, 0); return fetch(s, c).x; }
|
|
242
|
+
`;
|
|
243
|
+
const JACOBI = program(`
|
|
244
|
+
out vec4 o; uniform sampler2D uP, uDiv;
|
|
245
|
+
${SIMLIB}${PRESSURE_LIB}
|
|
246
|
+
void main(){
|
|
247
|
+
ivec3 c = cellOf(ivec2(gl_FragCoord.xy));
|
|
248
|
+
float sum = P(uP, c + ivec3(1,0,0)) + P(uP, c - ivec3(1,0,0)) + P(uP, c + ivec3(0,1,0)) + P(uP, c - ivec3(0,1,0)) + P(uP, c + ivec3(0,0,1)) + P(uP, c - ivec3(0,0,1));
|
|
249
|
+
o = vec4((sum - CELL * CELL * fetch(uDiv, c).x) / 6.0, 0, 0, 1);
|
|
250
|
+
}`);
|
|
251
|
+
const GRADIENT = program(`
|
|
252
|
+
out vec4 o; uniform sampler2D uP, uVel;
|
|
253
|
+
${SIMLIB}${PRESSURE_LIB}
|
|
254
|
+
void main(){
|
|
255
|
+
ivec3 c = cellOf(ivec2(gl_FragCoord.xy));
|
|
256
|
+
vec3 v = fetch(uVel, c).xyz;
|
|
257
|
+
v -= vec3(P(uP, c + ivec3(1,0,0)) - P(uP, c - ivec3(1,0,0)), P(uP, c + ivec3(0,1,0)) - P(uP, c - ivec3(0,1,0)), P(uP, c + ivec3(0,0,1)) - P(uP, c - ivec3(0,0,1))) / (2.0 * CELL);
|
|
258
|
+
if (c.y == 0) v.y = 0.0;
|
|
259
|
+
o = vec4(v, 1.0);
|
|
260
|
+
}`);
|
|
261
|
+
// 炎の光を、断面 1 枚につき 8 × 8 に縮めた画像。合計の色と重心を求めるために読む
|
|
262
|
+
const LIGHTMAP = program(`
|
|
263
|
+
in vec2 uv; out vec4 o; uniform sampler2D uState;
|
|
264
|
+
${PLANCK}
|
|
265
|
+
void main(){
|
|
266
|
+
vec3 e = vec3(0.0); vec2 px = 1.0 / vec2(textureSize(uState, 0));
|
|
267
|
+
for (int j = -1; j <= 1; j++) for (int i = -1; i <= 1; i++) e += flameEmit(texture(uState, uv + vec2(i, j) * px * 4.0));
|
|
268
|
+
e /= 9.0; o = vec4(e, dot(e, vec3(0.3, 0.6, 0.1)));
|
|
269
|
+
}`);
|
|
270
|
+
|
|
271
|
+
// ---------- シェーダー ----------
|
|
272
|
+
const SCENE = program(`
|
|
273
|
+
in vec2 uv; layout(location = 0) out vec4 o0; layout(location = 1) out vec4 o1; layout(location = 2) out vec4 o2; layout(location = 3) out vec4 o3;
|
|
274
|
+
uniform vec2 uRes; uniform vec3 uCam, uRight, uUp, uFwd; uniform float uFocal, uTime, uBurn, uWhite; uniform vec2 uCenter;
|
|
275
|
+
uniform sampler2D uState; uniform vec3 uLightPos, uLightCol;
|
|
276
|
+
${SIMLIB}
|
|
277
|
+
uniform vec4 uLogA[${MAX_LOGS}]; // 端 a (x, y, z) と太さの半分
|
|
278
|
+
uniform vec4 uLogB[${MAX_LOGS}]; // 端 b (x, y, z) と種類
|
|
279
|
+
uniform vec4 uLogC[${MAX_LOGS}]; // (軸まわりの向き, 曲がり, 火の当たり方, 乱数)
|
|
280
|
+
uniform vec4 uLogD[${MAX_LOGS}]; // (燃え進み 0〜1.3, 燃料の出方, 生木の度合い, 0)
|
|
281
|
+
uniform float uBed; // 熾の山の量(0〜1)
|
|
282
|
+
uniform int uLogN;
|
|
283
|
+
|
|
284
|
+
float hash(vec2 p){ p = fract(p * vec2(123.34, 456.21)); p += dot(p, p + 45.32); return fract(p.x * p.y); }
|
|
285
|
+
float hash3(vec3 p){ p = fract(p * vec3(0.1031, 0.1030, 0.0973)); p += dot(p, p.yxz + 33.33); return fract((p.x + p.y) * p.z); }
|
|
286
|
+
float vnoise(vec2 p){ vec2 i = floor(p), f = fract(p); f = f*f*(3.0-2.0*f);
|
|
287
|
+
return mix(mix(hash(i), hash(i+vec2(1,0)), f.x), mix(hash(i+vec2(0,1)), hash(i+vec2(1,1)), f.x), f.y); }
|
|
288
|
+
float fbm(vec2 p){ float a = 0.5, s = 0.0; for(int i=0;i<4;i++){ s += a*vnoise(p); p = p*2.03 + 17.1; a *= 0.5; } return s; }
|
|
289
|
+
float vnoise3(vec3 p){ vec3 i = floor(p), f = fract(p); f = f*f*(3.0-2.0*f);
|
|
290
|
+
return mix(mix(mix(hash3(i), hash3(i+vec3(1,0,0)), f.x), mix(hash3(i+vec3(0,1,0)), hash3(i+vec3(1,1,0)), f.x), f.y),
|
|
291
|
+
mix(mix(hash3(i+vec3(0,0,1)), hash3(i+vec3(1,0,1)), f.x), mix(hash3(i+vec3(0,1,1)), hash3(i+vec3(1,1,1)), f.x), f.y), f.z); }
|
|
292
|
+
// 炭の割れ: 木目(x)の向きに長い四角の区画。返す値は (割れ目からの距離, 区画ごとの乱数)
|
|
293
|
+
vec2 cracks(vec2 p){
|
|
294
|
+
vec2 i = floor(p), f = fract(p); float d1 = 9.0, d2 = 9.0, id = 0.0;
|
|
295
|
+
for(int y=-1;y<=1;y++) for(int x=-1;x<=1;x++){
|
|
296
|
+
vec2 g = vec2(x, y); vec2 c = g + vec2(hash(i + g), hash(i + g + 7.7)) * 0.7 + 0.15;
|
|
297
|
+
vec2 dv = (c - f) * vec2(1.0, 1.25); float d = max(abs(dv.x), abs(dv.y));
|
|
298
|
+
if (d < d1) { d2 = d1; d1 = d; id = hash(i + g + 3.1); } else if (d < d2) d2 = d;
|
|
299
|
+
}
|
|
300
|
+
return vec2(d2 - d1, id);
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
// 火に近い度合い(0〜1)。火は丸太の間にある
|
|
304
|
+
float heatAt(vec3 p){
|
|
305
|
+
vec3 q = (p - vec3(0.0, 0.075, 0.0)) / vec3(0.21, 0.1, 0.1);
|
|
306
|
+
return exp(-dot(q, q));
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
// 薪 1 本の座標。返す値: x は端 a からの長さ、yz は軸に垂直な面での位置(向きを回したあと)
|
|
310
|
+
struct LogP { float x; vec2 q; float len; float r; float kind; float seed; float heat; float burn; };
|
|
311
|
+
LogP logLocal(vec3 p, int i){
|
|
312
|
+
vec3 A = uLogA[i].xyz, B = uLogB[i].xyz; vec3 ax = B - A; float len = length(ax); ax /= len;
|
|
313
|
+
vec3 e1 = normalize(cross(ax, vec3(0.0, 1.0, 0.0))); vec3 e2 = cross(e1, ax);
|
|
314
|
+
vec3 d = p - A; float x = dot(d, ax);
|
|
315
|
+
// 木は少し曲がっている
|
|
316
|
+
float tt = clamp(x / len, 0.0, 1.0);
|
|
317
|
+
vec3 c = d - ax * x - e2 * uLogC[i].y * sin(3.1416 * tt) * 4.0 * 0.25 - e1 * uLogC[i].y * sin(6.2832 * tt) * 0.4;
|
|
318
|
+
float cs = cos(uLogC[i].x), sn = sin(uLogC[i].x);
|
|
319
|
+
vec2 q = vec2(dot(c, e1), dot(c, e2)); q = vec2(q.x * cs - q.y * sn, q.x * sn + q.y * cs);
|
|
320
|
+
return LogP(x, q, len, uLogA[i].w, uLogB[i].w, uLogC[i].w, uLogC[i].z, uLogD[i].x);
|
|
321
|
+
}
|
|
322
|
+
// 焦げの度合い(0〜1): 火に近く、長く燃えたほど進む。場所ごとにむらがある
|
|
323
|
+
float charOf(vec3 p, LogP L){
|
|
324
|
+
float n = fbm(vec2(L.x * 9.0 + L.seed * 30.0, atan(L.q.y, L.q.x) * 1.3));
|
|
325
|
+
float h = heatAt(p) * L.heat;
|
|
326
|
+
float ch = smoothstep(0.0, 1.0, (h * 1.25 + (n - 0.5) * 0.45) * (0.35 + 2.3 * L.burn) - 0.22);
|
|
327
|
+
// 燃え進みが 0.85 を超えた薪は、火から遠い所まで炭になる
|
|
328
|
+
return max(ch, smoothstep(0.85, 1.15, L.burn + (n - 0.5) * 0.2));
|
|
329
|
+
}
|
|
330
|
+
// 薪 1 本までの距離。detail が 1 のときは、表面の細かい凹凸まで入れる
|
|
331
|
+
float sdLog(vec3 p, int i, float detail, out float face){
|
|
332
|
+
LogP L = logLocal(p, i);
|
|
333
|
+
float tt = L.x / L.len; float ang = atan(L.q.y, L.q.x); float rr = length(L.q);
|
|
334
|
+
// 太さ: 長さ方向にゆるく変わる。節の所は 6% ほど太い
|
|
335
|
+
float knot = exp(-pow((tt - 0.3 - 0.4 * L.seed) * 9.0, 2.0)) * exp(-pow(sin((ang - L.seed * 6.0) * 0.5) * 2.2, 2.0));
|
|
336
|
+
float R = L.r * (1.0 + 0.05 * sin(tt * 5.0 + L.seed * 20.0) + 0.04 * sin(ang * 2.0 + L.seed * 9.0) + 0.14 * knot);
|
|
337
|
+
float ch = charOf(p, L);
|
|
338
|
+
// 炭になった所だけが痩せる。火に近い中ほどから細り、端は太いまま残る。最大で元の 3 割の太さになる
|
|
339
|
+
R *= 1.0 - min(0.7, 0.58 * smoothstep(0.35, 1.0, ch) * L.burn);
|
|
340
|
+
float dCyl = rr - R; float d = dCyl; face = 0.0; // 0: 樹皮
|
|
341
|
+
// 割り面
|
|
342
|
+
if (L.kind > 0.5) {
|
|
343
|
+
float off = L.r * 0.08;
|
|
344
|
+
float d1 = L.q.y - off; // 半割り: 上半分を落とす
|
|
345
|
+
if (L.kind > 1.5) { float d2 = L.q.x - off; if (d2 > d1) d1 = d2; }
|
|
346
|
+
// 割り面は、裂けた繊維で少し波打つ
|
|
347
|
+
d1 += (vnoise(vec2(L.x * 14.0, L.seed * 50.0)) - 0.5) * 0.006 + (vnoise(vec2(L.x * 5.0 + 3.0, L.q.x * 40.0)) - 0.5) * 0.005;
|
|
348
|
+
if (L.kind > 1.5) d1 = max(L.q.y - off + (vnoise(vec2(L.x * 14.0, L.seed * 50.0)) - 0.5) * 0.006, L.q.x - off + (vnoise(vec2(L.x * 11.0, L.seed * 80.0)) - 0.5) * 0.006);
|
|
349
|
+
if (d1 > d) { d = d1; face = 1.0; } // 1: 割り面
|
|
350
|
+
}
|
|
351
|
+
// 切り口: 軸に対して少し傾いている
|
|
352
|
+
float capA = -L.x + L.q.x * (L.seed - 0.5) * 0.25, capB = L.x - L.len + L.q.y * (L.seed - 0.3) * 0.2;
|
|
353
|
+
float cap = max(capA, capB);
|
|
354
|
+
if (cap > d) { d = cap; face = 2.0; } // 2: 切り口
|
|
355
|
+
if (detail > 0.5 && d < 0.02) {
|
|
356
|
+
float bump = 0.0;
|
|
357
|
+
if (face < 0.5) {
|
|
358
|
+
// 樹皮: 縦に長い板が重なり、間に深い溝がある
|
|
359
|
+
float f1 = vnoise(vec2(ang * R * 230.0 + L.seed * 40.0, L.x * 8.0 + 2.0 * vnoise(vec2(ang * 3.0, L.x * 5.0))));
|
|
360
|
+
float f2 = vnoise(vec2(ang * R * 700.0, L.x * 60.0 + 4.0));
|
|
361
|
+
bump = (smoothstep(0.2, 0.7, f1) - 0.5) * 0.003 + (f2 - 0.5) * 0.001;
|
|
362
|
+
} else if (face < 1.5) {
|
|
363
|
+
// 割り面: 繊維に沿った細い筋
|
|
364
|
+
bump = (vnoise(vec2(L.x * 30.0, (L.q.x + L.q.y) * 900.0)) - 0.5) * 0.0012 + (vnoise(vec2(L.x * 8.0, (L.q.x - L.q.y) * 260.0 + L.seed * 9.0)) - 0.5) * 0.0018;
|
|
365
|
+
} else {
|
|
366
|
+
// 切り口: のこぎりの跡と、乾燥で入った放射状の割れ
|
|
367
|
+
float rad = abs(sin(ang * 3.0 + L.seed * 20.0 + rr * 30.0));
|
|
368
|
+
bump = -smoothstep(0.08, 0.0, rad * rr / L.r) * 0.003 * smoothstep(0.1, 0.5, rr / L.r) + (vnoise(vec2(L.q.x * 500.0, L.q.y * 80.0)) - 0.5) * 0.0006;
|
|
369
|
+
}
|
|
370
|
+
// 炭: 木目の向きに長い四角に割れる。割れ目は 3mm ほどくぼみ、区画の面は少しふくらむ
|
|
371
|
+
if (ch > 0.3) {
|
|
372
|
+
vec2 cp = face > 1.5 ? L.q * 70.0 : vec2(L.x * 34.0 + L.seed * 7.0, (face < 0.5 ? ang * R : (L.q.x + L.q.y) * 0.7) * 62.0);
|
|
373
|
+
vec2 c = cracks(cp);
|
|
374
|
+
float k = smoothstep(0.3, 0.75, ch);
|
|
375
|
+
bump = mix(bump, -smoothstep(0.16, 0.0, c.x) * 0.0034 + (c.y - 0.5) * 0.0012, k);
|
|
376
|
+
}
|
|
377
|
+
d -= bump;
|
|
378
|
+
}
|
|
379
|
+
return d;
|
|
380
|
+
}
|
|
381
|
+
// 熾: 丸太の間の地面に積もった炭のかたまり。大きいもの(約 3cm)と小さいもの(約 1.6cm)を混ぜ、形は 1 個ずつ欠けさせる
|
|
382
|
+
float sdCoals(vec3 p, out float id){
|
|
383
|
+
id = 0.0;
|
|
384
|
+
float env = max(abs(p.x) - 0.23, abs(p.z) - 0.078);
|
|
385
|
+
if (env > 0.04) return env;
|
|
386
|
+
// 山の高さ: 中央が高く、燃えるほど増える
|
|
387
|
+
float top = (0.014 + 0.04 * uBed) * (1.0 - 0.5 * smoothstep(0.1, 0.23, abs(p.x))) + 0.014 * vnoise(p.xz * 16.0);
|
|
388
|
+
float d = 9.0;
|
|
389
|
+
for (int j = 0; j < 3; j++) {
|
|
390
|
+
vec3 g = j == 2 ? vec3(0.017, 0.013, 0.017) : vec3(0.032, 0.022, 0.03);
|
|
391
|
+
vec3 q = p + float(j) * vec3(0.0137, 0.0091, 0.0113);
|
|
392
|
+
vec3 ci = floor(q / g); vec3 f = q - (ci + 0.5) * g;
|
|
393
|
+
float h = hash3(ci + float(j) * 17.0);
|
|
394
|
+
// 3 割の区画には何も置かない。すき間ができて、奥の熾が見える
|
|
395
|
+
if (hash3(ci + 2.9 + float(j)) < 0.3) continue;
|
|
396
|
+
float sz = (j == 2 ? 0.0042 : 0.0072) + (j == 2 ? 0.003 : 0.0065) * h;
|
|
397
|
+
vec3 off = (vec3(hash3(ci + 1.3), hash3(ci + 5.7), hash3(ci + 9.1)) - 0.5) * g * 0.3;
|
|
398
|
+
// かたまりごとに向きを変える
|
|
399
|
+
float a = h * 6.2832; vec3 r = f - off; r.xz = mat2(cos(a), -sin(a), sin(a), cos(a)) * r.xz;
|
|
400
|
+
vec3 b = abs(r) - vec3(sz * 1.5, sz * 0.75, sz);
|
|
401
|
+
float dd = length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) - sz * 0.45;
|
|
402
|
+
// 欠けた角と、表面の割れ
|
|
403
|
+
dd += (vnoise3(q * 170.0 + h * 9.0) - 0.5) * sz * 0.9 + (vnoise3(q * 520.0) - 0.5) * 0.0012;
|
|
404
|
+
float cy = (ci.y + 0.5) * g.y;
|
|
405
|
+
if (cy > top || cy < 0.0) continue;
|
|
406
|
+
if (dd < d) { d = dd; id = h; }
|
|
407
|
+
}
|
|
408
|
+
return max(min(d, 0.03), env);
|
|
409
|
+
}
|
|
410
|
+
// 全体までの距離。mat: 0 地面、1 薪、2 熾
|
|
411
|
+
float map(vec3 p, float detail, out int mat, out int idx, out float face){
|
|
412
|
+
float d = p.y; mat = 0; idx = -1; face = 0.0;
|
|
413
|
+
if (detail > 0.5) d -= (vnoise(p.xz * 40.0) - 0.5) * 0.003 + (vnoise(p.xz * 9.0) - 0.5) * 0.004;
|
|
414
|
+
// 薪の束の外では、束までの距離だけを返して速く進む
|
|
415
|
+
vec3 bb = abs(p - vec3(0.0, 0.1, 0.0)) - vec3(0.36, 0.14, 0.23);
|
|
416
|
+
float dbb = length(max(bb, 0.0));
|
|
417
|
+
if (dbb > 0.05) { if (dbb < d) d = dbb; return d; }
|
|
418
|
+
for (int i = 0; i < ${MAX_LOGS}; i++) {
|
|
419
|
+
if (i >= uLogN) break;
|
|
420
|
+
float f; float dl = sdLog(p, i, detail, f);
|
|
421
|
+
if (dl < d) { d = dl; mat = 1; idx = i; face = f; }
|
|
422
|
+
}
|
|
423
|
+
float cid; float dc = sdCoals(p, cid);
|
|
424
|
+
if (dc < d) { d = dc; mat = 2; idx = -1; face = cid; }
|
|
425
|
+
return d;
|
|
426
|
+
}
|
|
427
|
+
float mapD(vec3 p){ int m, i; float f; return map(p, 1.0, m, i, f); }
|
|
428
|
+
float mapC(vec3 p){ int m, i; float f; return map(p, 0.0, m, i, f); }
|
|
429
|
+
vec3 normalAt(vec3 p){
|
|
430
|
+
vec2 e = vec2(0.0007, 0.0);
|
|
431
|
+
return normalize(vec3(mapD(p + e.xyy) - mapD(p - e.xyy), mapD(p + e.yxy) - mapD(p - e.yxy), mapD(p + e.yyx) - mapD(p - e.yyx)));
|
|
432
|
+
}
|
|
433
|
+
// 光源へ向かう途中で、どれだけ遮られるか(0 が影、1 が日なた)。k が大きいほど影の縁が硬い
|
|
434
|
+
float shadow(vec3 p, vec3 l, float maxT, float k){
|
|
435
|
+
float res = 1.0, t = 0.006;
|
|
436
|
+
for (int i = 0; i < 28; i++) {
|
|
437
|
+
float h = mapC(p + l * t);
|
|
438
|
+
res = min(res, k * h / t);
|
|
439
|
+
t += clamp(h, 0.004, 0.05);
|
|
440
|
+
if (res < 0.02 || t > maxT) break;
|
|
441
|
+
}
|
|
442
|
+
return clamp(res, 0.0, 1.0);
|
|
443
|
+
}
|
|
444
|
+
// くぼみやすき間の暗さ
|
|
445
|
+
float occlusion(vec3 p, vec3 n){
|
|
446
|
+
float o = 0.0, s = 1.0;
|
|
447
|
+
for (int i = 1; i <= 4; i++) { float h = 0.012 * float(i); o += (h - mapC(p + n * h)) * s; s *= 0.6; }
|
|
448
|
+
return clamp(1.0 - 9.0 * o, 0.0, 1.0);
|
|
449
|
+
}
|
|
450
|
+
${PLANCK}
|
|
451
|
+
|
|
452
|
+
void main(){
|
|
453
|
+
vec2 ndc = (gl_FragCoord.xy - 0.5 * uRes) / uRes.y + uCenter;
|
|
454
|
+
vec3 rd = normalize(uFwd * uFocal + uRight * ndc.x + uUp * ndc.y);
|
|
455
|
+
vec3 ro = uCam;
|
|
456
|
+
// 視線を進めて、形に当たる所を探す
|
|
457
|
+
float t = 0.0; bool hit = false;
|
|
458
|
+
for (int i = 0; i < 110; i++) {
|
|
459
|
+
vec3 p = ro + rd * t;
|
|
460
|
+
float d = t < 0.0 ? 1.0 : mapD(p);
|
|
461
|
+
if (d < 0.0006 * (1.0 + t * 2.0)) { hit = true; break; }
|
|
462
|
+
t += d * 0.85;
|
|
463
|
+
if (t > 9.0) break;
|
|
464
|
+
}
|
|
465
|
+
// 形に当たらずに終わった視線は、地面との交点を直に求める
|
|
466
|
+
if (!hit && rd.y < -0.001) { float tg = -ro.y / rd.y; if (tg < 9.0) { t = tg; hit = true; } }
|
|
467
|
+
float fire = 1.0;
|
|
468
|
+
vec4 gAlb = vec4(0.0), gEmit = vec4(0.0), gMisc = vec4(1.0); vec3 gN = vec3(0.0, 1.0, 0.0);
|
|
469
|
+
// 空: 夜は暗い青、白い光のときは明るい灰色
|
|
470
|
+
vec3 sky = mix(vec3(0.004, 0.005, 0.008), vec3(0.55, 0.6, 0.66), uWhite);
|
|
471
|
+
vec3 col = sky;
|
|
472
|
+
if (hit) {
|
|
473
|
+
vec3 p = ro + rd * t;
|
|
474
|
+
int mat, idx; float face; map(p, 1.0, mat, idx, face);
|
|
475
|
+
vec3 n = normalAt(p);
|
|
476
|
+
vec3 alb = vec3(0.1); float rough = 0.9; vec3 emit = vec3(0.0);
|
|
477
|
+
float h = heatAt(p);
|
|
478
|
+
if (mat == 0) {
|
|
479
|
+
// 地面: 土と、火のまわりに積もった灰
|
|
480
|
+
float n1 = fbm(p.xz * 12.0), n2 = fbm(p.xz * 55.0 + 3.0);
|
|
481
|
+
vec3 soil = mix(vec3(0.07, 0.052, 0.038), vec3(0.14, 0.11, 0.085), n1) * (0.75 + 0.5 * n2);
|
|
482
|
+
vec3 ash = vec3(0.27, 0.255, 0.24) * (0.65 + 0.5 * n2);
|
|
483
|
+
float r = length(p.xz * vec2(1.1, 0.9));
|
|
484
|
+
alb = mix(ash, soil, smoothstep(0.16, 0.42, r + (n1 - 0.5) * 0.14));
|
|
485
|
+
// 落ち葉や小枝のかけらが、所々に暗く散る
|
|
486
|
+
alb *= 1.0 - 0.35 * smoothstep(0.62, 0.75, fbm(p.xz * 30.0 + 7.0));
|
|
487
|
+
} else if (mat == 1) {
|
|
488
|
+
LogP L = logLocal(p, idx);
|
|
489
|
+
float ang = atan(L.q.y, L.q.x); float rr = length(L.q);
|
|
490
|
+
float ch = charOf(p, L);
|
|
491
|
+
if (face < 0.5) {
|
|
492
|
+
// 樹皮: 灰茶色。溝の底は暗く、所々に地衣類の明るい斑点がある
|
|
493
|
+
float f1 = vnoise(vec2(ang * L.r * 230.0 + L.seed * 40.0, L.x * 8.0 + 2.0 * vnoise(vec2(ang * 3.0, L.x * 5.0))));
|
|
494
|
+
float tone = fbm(vec2(ang * 3.0 + L.seed * 5.0, L.x * 6.0));
|
|
495
|
+
alb = mix(vec3(0.1, 0.075, 0.058), vec3(0.2, 0.158, 0.125), smoothstep(0.2, 0.7, f1)) * (0.7 + 0.6 * tone);
|
|
496
|
+
alb = mix(alb, vec3(0.32, 0.34, 0.27), smoothstep(0.7, 0.8, fbm(vec2(ang * 5.0, L.x * 14.0 + L.seed * 3.0))) * 0.5);
|
|
497
|
+
} else if (face < 1.5) {
|
|
498
|
+
// 割り面: 明るい木の色。繊維に沿った濃淡がある。芯に近い所は少し濃い
|
|
499
|
+
float g1 = fbm(vec2(L.x * 6.0 + L.seed * 4.0, (L.q.x + L.q.y) * 700.0));
|
|
500
|
+
float g2 = vnoise(vec2(L.x * 2.0, (L.q.x - L.q.y) * 160.0 + L.seed * 20.0));
|
|
501
|
+
alb = mix(vec3(0.5, 0.36, 0.2), vec3(0.74, 0.6, 0.4), g1) * (0.82 + 0.3 * g2);
|
|
502
|
+
alb = mix(alb, vec3(0.42, 0.26, 0.14), smoothstep(0.5, 0.0, rr / L.r) * 0.45);
|
|
503
|
+
} else {
|
|
504
|
+
// 切り口: 年輪。割った薪では、芯は割り面の角にある
|
|
505
|
+
vec2 c = L.kind > 1.5 ? L.q - vec2(L.r * 0.08) : (L.kind > 0.5 ? L.q - vec2(0.0, L.r * 0.08) : L.q);
|
|
506
|
+
float ring = 0.5 + 0.5 * sin(length(c) * 950.0 + fbm(c * 60.0 + L.seed * 9.0) * 5.0);
|
|
507
|
+
alb = mix(vec3(0.46, 0.32, 0.18), vec3(0.72, 0.58, 0.38), ring) * (0.9 + 0.2 * vnoise(c * 300.0));
|
|
508
|
+
// 外側の樹皮の輪
|
|
509
|
+
if (rr > L.r * 0.9) alb = vec3(0.1, 0.075, 0.055);
|
|
510
|
+
}
|
|
511
|
+
// 焦げ: 茶色に焼けてから黒い炭になる。炭は少しつやがある
|
|
512
|
+
alb = mix(alb, vec3(0.2, 0.11, 0.05), smoothstep(0.05, 0.3, ch) * 0.8);
|
|
513
|
+
alb = mix(alb, vec3(0.016, 0.015, 0.016), smoothstep(0.25, 0.55, ch));
|
|
514
|
+
rough = mix(0.92, 0.55, smoothstep(0.4, 0.8, ch));
|
|
515
|
+
vec2 cp = face > 1.5 ? L.q * 70.0 : vec2(L.x * 34.0 + L.seed * 7.0, (face < 0.5 ? ang * L.r : (L.q.x + L.q.y) * 0.7) * 62.0);
|
|
516
|
+
vec2 c = cracks(cp);
|
|
517
|
+
// 灰: 炭の上を向いた面と区画の角に、白い灰が薄く乗る
|
|
518
|
+
float ashN = fbm(vec2(L.x * 40.0, ang * 4.0 + L.seed * 12.0));
|
|
519
|
+
float ashy = smoothstep(0.6, 0.9, ch) * smoothstep(0.45, 0.8, ashN + 0.25 * n.y) * (0.4 + 0.6 * vnoise(cp * 0.7));
|
|
520
|
+
alb = mix(alb, vec3(0.4, 0.385, 0.37), ashy * 0.6);
|
|
521
|
+
// 熾火: 炭の割れ目の奥と、空気の当たる下の面が赤く光る。灰をかぶった所は光らない
|
|
522
|
+
float breath = 0.5 + 0.5 * sin(uTime * (0.6 + c.y * 1.6) + c.y * 40.0 + L.seed * 30.0);
|
|
523
|
+
float glow = smoothstep(0.55, 0.95, ch) * h * L.heat * (0.35 + 0.65 * smoothstep(0.3, -0.6, n.y));
|
|
524
|
+
float T = mix(950.0, 1300.0, clamp(glow * (0.6 + 0.4 * breath), 0.0, 1.0));
|
|
525
|
+
float crack = smoothstep(0.2, 0.0, c.x);
|
|
526
|
+
emit = planck(T + crack * 110.0) * (crack * 1.2 + 0.35 * (0.3 + 0.7 * c.y)) * (1.0 - 0.9 * ashy) * smoothstep(0.0, 0.3, glow) * 16.0 * fire;
|
|
527
|
+
} else {
|
|
528
|
+
// 熾: かたまりの 3 割は冷えて黒く、灰をかぶる。残りは、空気の当たる縁と割れ目から赤くなる。
|
|
529
|
+
// 明るい所は、風の通り道に沿って数秒かけて移る
|
|
530
|
+
float id = face;
|
|
531
|
+
float air = fbm(p.xz * 9.0 + vec2(uTime * 0.11, -uTime * 0.07)) + 0.07 * sin(uTime * 0.9 + p.x * 14.0);
|
|
532
|
+
float alive = smoothstep(0.3, 0.42, id) * smoothstep(0.32, 0.6, air + 0.25 * id);
|
|
533
|
+
float deep = clamp(1.0 - occlusion(p, n), 0.0, 1.0);
|
|
534
|
+
vec2 c = cracks(vec2(p.x * 190.0 + id * 30.0, (p.z + p.y) * 150.0));
|
|
535
|
+
float ashy = smoothstep(0.42, 0.7, fbm(p.xz * 120.0 + id * 9.0) + 0.35 * n.y - 0.25 * alive);
|
|
536
|
+
alb = mix(vec3(0.02, 0.019, 0.02), vec3(0.4, 0.385, 0.37), ashy * 0.75);
|
|
537
|
+
// 縁(面の向きが視線に対して斜めの所)と割れ目は灰が落ちやすく、温度がそのまま見える
|
|
538
|
+
float rim = pow(1.0 - abs(dot(n, -rd)), 2.0);
|
|
539
|
+
float crack = smoothstep(0.14, 0.0, c.x);
|
|
540
|
+
float T = mix(930.0, 1290.0, clamp(0.25 + 0.55 * alive + 0.3 * deep, 0.0, 1.0));
|
|
541
|
+
float bare = clamp(0.12 + 0.55 * crack + 0.5 * rim + 0.6 * deep, 0.0, 1.3) * (1.0 - 0.8 * ashy);
|
|
542
|
+
emit = planck(T + 60.0 * crack) * bare * (0.08 + 0.92 * alive) * 20.0 * fire * smoothstep(0.26, 0.16, abs(p.x));
|
|
543
|
+
}
|
|
544
|
+
// 視点と薪が変わらない間は使い回す値を書き出す: 色、面の向き、熾の光、すき間の暗さ、3 つの光源からの影
|
|
545
|
+
float ao = occlusion(p, n);
|
|
546
|
+
float lift = mat == 0 ? 0.012 : 0.003;
|
|
547
|
+
float shSun = shadow(p + n * 0.002, normalize(vec3(0.45, 0.8, 0.4)), 1.2, 14.0);
|
|
548
|
+
vec3 l0 = vec3(0.0, 0.05, 0.0) - p; float d0 = length(l0);
|
|
549
|
+
vec3 l1 = vec3(0.0, 0.32, 0.0) - p; float d1 = length(l1);
|
|
550
|
+
gAlb = vec4(alb, rough); gN = n; gEmit = vec4(emit, shSun);
|
|
551
|
+
gMisc = vec4(ao, shadow(p + n * lift, l0 / d0, d0, 5.0), shadow(p + n * lift, l1 / d1, d1, 4.0), 0.0);
|
|
552
|
+
}
|
|
553
|
+
o0 = gAlb; o1 = vec4(gN, hit ? t : -1.0); o2 = gEmit; o3 = gMisc;
|
|
554
|
+
}`);
|
|
555
|
+
// 炎: 計算した空間の中を視線に沿って刻み、その場の光を足していく。冷えたすす(煙)は奥の光を弱める。画面の半分の解像度で描く
|
|
556
|
+
const VOLUME = program(`
|
|
557
|
+
in vec2 uv; out vec4 o;
|
|
558
|
+
uniform sampler2D uG1, uState; uniform vec2 uRes; uniform vec3 uCam, uRight, uUp, uFwd; uniform float uFocal, uTime; uniform int uSteps; uniform vec2 uCenter;
|
|
559
|
+
${SIMLIB}${PLANCK}
|
|
560
|
+
float hash(vec2 p){ p = fract(p * vec2(123.34, 456.21)); p += dot(p, p + 45.32); return fract(p.x * p.y); }
|
|
561
|
+
void main(){
|
|
562
|
+
vec2 ndc = (uv - 0.5) * vec2(uRes.x / uRes.y, 1.0) + uCenter;
|
|
563
|
+
vec3 rd = normalize(uFwd * uFocal + uRight * ndc.x + uUp * ndc.y); vec3 ro = uCam;
|
|
564
|
+
float t = texture(uG1, uv).a;
|
|
565
|
+
vec3 bmin = ORIGIN, bmax = ORIGIN + vec3(N) * CELL; vec3 inv = 1.0 / rd;
|
|
566
|
+
vec3 t0 = (bmin - ro) * inv, t1 = (bmax - ro) * inv; vec3 ta = min(t0, t1), tb = max(t0, t1);
|
|
567
|
+
float tn = max(max(ta.x, ta.y), max(ta.z, 0.0)), tf = min(min(tb.x, tb.y), min(tb.z, t > 0.0 ? t : 9.0));
|
|
568
|
+
vec3 acc = vec3(0.0); float tr = 1.0;
|
|
569
|
+
if (tf > tn) {
|
|
570
|
+
// 刻みの始まりを画素ごとにずらして、層の縞を防ぐ。ずらし方は隣どうしで偏らない並び(interleaved gradient noise)にする
|
|
571
|
+
float ds = (tf - tn) / float(uSteps); float jit = fract(52.9829189 * fract(dot(gl_FragCoord.xy + 5.588 * floor(mod(uTime * 60.0, 8.0)), vec2(0.06711056, 0.00583715))));
|
|
572
|
+
for (int i = 0; i < 64; i++) {
|
|
573
|
+
if (i >= uSteps) break;
|
|
574
|
+
vec4 st = samp(uState, (ro + rd * (tn + (float(i) + jit) * ds) - ORIGIN) / CELL);
|
|
575
|
+
acc += tr * flameEmit(st) * ds;
|
|
576
|
+
tr *= exp(-st.w * smoothstep(900.0, 600.0, st.x) * ds * 5.0);
|
|
577
|
+
}
|
|
578
|
+
}
|
|
579
|
+
o = vec4(acc, tr);
|
|
580
|
+
}`);
|
|
581
|
+
// 仕上げ: 使い回す値に、このコマの炎の光を当て、炎を重ねる
|
|
582
|
+
const COMPOSITE = program(`
|
|
583
|
+
in vec2 uv; out vec4 o;
|
|
584
|
+
uniform sampler2D uG0, uG1, uG2, uG3, uVol; uniform vec2 uRes; uniform vec3 uCam, uRight, uUp, uFwd; uniform float uFocal, uTime, uWhite, uDay, uMask, uLightFix; uniform vec3 uLightPos, uLightCol; uniform int uMode; uniform sampler2D uLight0, uLight1; uniform vec2 uCenter;
|
|
585
|
+
${PLANCK}
|
|
586
|
+
float hash(vec2 p){ p = fract(p * vec2(123.34, 456.21)); p += dot(p, p + 45.32); return fract(p.x * p.y); }
|
|
587
|
+
float vnoise(vec2 p){ vec2 i = floor(p), f = fract(p); f = f*f*(3.0-2.0*f);
|
|
588
|
+
return mix(mix(hash(i), hash(i+vec2(1,0)), f.x), mix(hash(i+vec2(0,1)), hash(i+vec2(1,1)), f.x), f.y); }
|
|
589
|
+
void main(){
|
|
590
|
+
vec2 ndc = (uv - 0.5) * vec2(uRes.x / uRes.y, 1.0) + uCenter;
|
|
591
|
+
vec3 rd = normalize(uFwd * uFocal + uRight * ndc.x + uUp * ndc.y); vec3 ro = uCam;
|
|
592
|
+
vec4 g0 = texture(uG0, uv), g1 = texture(uG1, uv), g2 = texture(uG2, uv), g3 = texture(uG3, uv);
|
|
593
|
+
// 空: 夜は暗い青、昼と白い光のときは明るい灰色
|
|
594
|
+
vec3 sky = mix(vec3(0.004, 0.005, 0.008), vec3(0.55, 0.6, 0.66), max(uWhite, uDay));
|
|
595
|
+
// 炎の光: 毎コマ GPU の上で測った色と重心(1 × 1 の画像)を読む。焼き出しのときだけ、決まった値を使う
|
|
596
|
+
vec3 lightCol = uLightFix > 0.5 ? uLightCol : texelFetch(uLight0, ivec2(0), 0).rgb;
|
|
597
|
+
vec3 lightPos = uLightFix > 0.5 ? uLightPos : texelFetch(uLight1, ivec2(0), 0).xyz;
|
|
598
|
+
// 焼き出し用: 1 は炎の光と炎を抜いた絵、2 は炎の光だけ、3 は炎と火の粉だけ
|
|
599
|
+
if (uMode >= 2) sky = vec3(0.0);
|
|
600
|
+
vec3 col = sky; float t = g1.a;
|
|
601
|
+
// 縁を透明にするとき(uMask)は、何もない所を黒にして、炎の後ろに空の色が混ざらないようにする
|
|
602
|
+
if (t <= 0.0 && uMask > 0.5) col = vec3(0.0);
|
|
603
|
+
if (t > 0.0) {
|
|
604
|
+
vec3 p = ro + rd * t; vec3 n = normalize(g1.xyz); vec3 alb = g0.rgb; float rough = g0.a; vec3 v = -rd; float ao = g3.x;
|
|
605
|
+
// 白い光: 斜め上からの太陽と、空からの光
|
|
606
|
+
vec3 sunDir = normalize(vec3(0.45, 0.8, 0.4));
|
|
607
|
+
float spec = pow(max(dot(n, normalize(sunDir + v)), 0.0), mix(60.0, 8.0, rough)) * (1.0 - rough) * 0.6;
|
|
608
|
+
vec3 white = alb * (vec3(1.0, 0.96, 0.9) * max(dot(n, sunDir), 0.0) * g2.a * 2.2 + vec3(0.5, 0.56, 0.66) * (0.5 + 0.5 * n.y) * ao * 0.75) + spec * g2.a * vec3(2.2);
|
|
609
|
+
// 火の光: 熾(丸太の間、低い位置)と、炎(毎コマ測った明るさと重心)。影は、炎の中心を高さ 32cm に置いたときのものを使い回す
|
|
610
|
+
vec3 night = alb * vec3(0.022, 0.026, 0.038) * (0.5 + 0.5 * n.y) * ao; vec3 fireLit = vec3(0.0);
|
|
611
|
+
for (int k = 0; k < 2; k++) {
|
|
612
|
+
vec3 lp = k == 0 ? vec3(0.0, 0.05, 0.0) : lightPos;
|
|
613
|
+
vec3 lc = k == 0 ? planck(1250.0) * 1.2 : lightCol;
|
|
614
|
+
vec3 l = lp - p; float d2 = dot(l, l); l /= sqrt(d2);
|
|
615
|
+
float sp = pow(max(dot(n, normalize(l + v)), 0.0), mix(60.0, 8.0, rough)) * (1.0 - rough) * 0.7;
|
|
616
|
+
vec3 term = (alb * max(dot(n, l), 0.0) + sp) * lc * (k == 0 ? g3.y : g3.z) * 0.085 / (d2 + 0.01);
|
|
617
|
+
if (k == 0) night += term; else fireLit = term;
|
|
618
|
+
}
|
|
619
|
+
// 熾の明るさは、空気の当たり方で数秒かけて上下する
|
|
620
|
+
float breath = 0.72 + 0.5 * vnoise(p.xz * 26.0 + uTime * vec2(0.35, -0.22)) * vnoise(p.xz * 7.0 - uTime * 0.15) * 1.6;
|
|
621
|
+
// 昼は日の光のほうが強いので、炎が照らす分は 12% だけ足す。熾の光はそのまま足す
|
|
622
|
+
col = mix(night + fireLit + g2.rgb * breath, white + fireLit * 0.12 + g2.rgb * breath, uDay);
|
|
623
|
+
col = mix(col, white, uWhite);
|
|
624
|
+
if (uMode == 1) col = night + g2.rgb * breath;
|
|
625
|
+
if (uMode == 2) col = fireLit;
|
|
626
|
+
if (uMode == 3) col = vec3(0.0);
|
|
627
|
+
// 遠くの地面は、空の色へ薄れる
|
|
628
|
+
col = mix(col, sky, smoothstep(2.5, 8.0, t));
|
|
629
|
+
}
|
|
630
|
+
// a には、炎そのものの明るさを入れる。仕上げで、縁の外でも炎と火の粉だけは残すために使う
|
|
631
|
+
float glow = 0.0;
|
|
632
|
+
if (uWhite < 0.5 && uMode != 1 && uMode != 2) { vec4 vol = texture(uVol, uv); col = col * vol.a + vol.rgb; glow = max(vol.r, max(vol.g, vol.b)); }
|
|
633
|
+
o = vec4(col, glow);
|
|
634
|
+
}`);
|
|
635
|
+
// 火の粉: 1/30 秒ぶんの軌跡を線で描く
|
|
636
|
+
const SPARK = (() => {
|
|
637
|
+
const p = gl.createProgram();
|
|
638
|
+
gl.attachShader(p, compile(gl.VERTEX_SHADER, `#version 300 es
|
|
639
|
+
in vec2 aPos; in vec3 aCol; out vec3 vCol; void main(){ vCol = aCol; gl_Position = vec4(aPos, 0.0, 1.0); }`));
|
|
640
|
+
gl.attachShader(p, compile(gl.FRAGMENT_SHADER, `#version 300 es
|
|
641
|
+
precision highp float; in vec3 vCol; out vec4 o; void main(){ o = vec4(vCol, max(vCol.r, max(vCol.g, vCol.b))); }`));
|
|
642
|
+
gl.bindAttribLocation(p, 0, "aPos"); gl.bindAttribLocation(p, 1, "aCol"); gl.linkProgram(p);
|
|
643
|
+
return p;
|
|
644
|
+
})();
|
|
645
|
+
const sparkVao = gl.createVertexArray(); const sparkBuf = gl.createBuffer();
|
|
646
|
+
gl.bindVertexArray(sparkVao); gl.bindBuffer(gl.ARRAY_BUFFER, sparkBuf);
|
|
647
|
+
gl.enableVertexAttribArray(0); gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 20, 0);
|
|
648
|
+
gl.enableVertexAttribArray(1); gl.vertexAttribPointer(1, 3, gl.FLOAT, false, 20, 8);
|
|
649
|
+
const DOWN = program(`
|
|
650
|
+
in vec2 uv; out vec4 o; uniform sampler2D uSrc; uniform vec2 uTexel;
|
|
651
|
+
void main(){
|
|
652
|
+
// a(炎そのものの明るさ)も一緒ににじませる。仕上げで、にじみのうち炎の分だけを取り出すのに使う
|
|
653
|
+
vec4 c = texture(uSrc, uv) * 4.0;
|
|
654
|
+
c += texture(uSrc, uv + uTexel * vec2(-1, -1)) + texture(uSrc, uv + uTexel * vec2(1, -1)) + texture(uSrc, uv + uTexel * vec2(-1, 1)) + texture(uSrc, uv + uTexel * vec2(1, 1));
|
|
655
|
+
o = c / 8.0;
|
|
656
|
+
}`);
|
|
657
|
+
const UP = program(`
|
|
658
|
+
in vec2 uv; out vec4 o; uniform sampler2D uSrc, uBase; uniform vec2 uTexel; uniform float uMix;
|
|
659
|
+
void main(){
|
|
660
|
+
vec4 c = texture(uSrc, uv + uTexel * vec2(-1, 0)) + texture(uSrc, uv + uTexel * vec2(1, 0)) + texture(uSrc, uv + uTexel * vec2(0, -1)) + texture(uSrc, uv + uTexel * vec2(0, 1));
|
|
661
|
+
c += texture(uSrc, uv + uTexel * vec2(-0.7, -0.7)) + texture(uSrc, uv + uTexel * vec2(0.7, -0.7)) + texture(uSrc, uv + uTexel * vec2(-0.7, 0.7)) + texture(uSrc, uv + uTexel * vec2(0.7, 0.7));
|
|
662
|
+
o = mix(texture(uBase, uv), c / 8.0, uMix);
|
|
663
|
+
}`);
|
|
664
|
+
// 仕上げ: 明るさを画面の範囲に収める。uMask のときは、地面の縁を楕円で透明にし、縁の外は炎と火の粉だけを残す
|
|
665
|
+
const FINAL = program(`
|
|
666
|
+
in vec2 uv; out vec4 o; uniform sampler2D uScene, uBloom; uniform float uExposure, uBloomAmt, uTime, uMask, uDay;
|
|
667
|
+
float hash(vec2 p){ p = fract(p * vec2(123.34, 456.21)); p += dot(p, p + 45.32); return fract(p.x * p.y); }
|
|
668
|
+
vec3 aces(vec3 x){ return clamp((x * (2.51 * x + 0.03)) / (x * (2.43 * x + 0.59) + 0.14), 0.0, 1.0); }
|
|
669
|
+
void main(){
|
|
670
|
+
vec4 s = texture(uScene, uv); vec4 bb = texture(uBloom, uv) * uBloomAmt; vec3 b = bb.rgb;
|
|
671
|
+
vec3 c = aces((s.rgb + b) * uExposure);
|
|
672
|
+
c = pow(c, vec3(1.0 / 2.2));
|
|
673
|
+
c += (hash(gl_FragCoord.xy + fract(uTime) * 61.0) - 0.5) / 255.0;
|
|
674
|
+
if (uMask < 0.5) { o = vec4(c, 1.0); return; }
|
|
675
|
+
// 地面: 画面の下から 28.5% の高さを中心に、横 49%、縦 38.5% の楕円。中心から 58% までは不透明で、縁で消える
|
|
676
|
+
vec2 q = (uv - vec2(0.5, 0.2846)) / vec2(0.4904, 0.3846);
|
|
677
|
+
float m = clamp((1.0 - length(q)) / 0.42, 0.0, 1.0); m = m * m * (3.0 - 2.0 * m);
|
|
678
|
+
// 縁の外には、炎、火の粉、そのにじみだけを残す。薪と地面の色は入れない。
|
|
679
|
+
// 炎の色は、その画素の光のうち炎が占める割合(a に入れてある炎そのものの明るさ ÷ 全体の明るさ)で取り出す。にじみも同じ
|
|
680
|
+
float w = clamp(s.a / max(max(s.r, max(s.g, s.b)), 1e-5), 0.0, 1.0);
|
|
681
|
+
float wb = clamp(bb.a / max(max(b.r, max(b.g, b.b)), 1e-5), 0.0, 1.0);
|
|
682
|
+
vec3 e = pow(aces((s.rgb * w + b * wb) * uExposure), vec3(1.0 / 2.2));
|
|
683
|
+
// 夜は、光の明るさをそのまま不透明さにして重ねる(赤 1.5、緑 1.2、青 0.6 の重み。書き出した動画と同じ)
|
|
684
|
+
float ae = clamp(dot(e, vec3(1.5, 1.2, 0.6)), 0.0, 1.0);
|
|
685
|
+
// 昼は明るい背景の上に置かれるので、光を不透明にすると暗い色の炎が背景を汚す。昼だけは、光を足すだけにする(a を増やさない)
|
|
686
|
+
float a = max(m, ae * (1.0 - uDay));
|
|
687
|
+
// 高い炎や風で流れた炎が画面の端で切れないよう、上の 12% と左右の 6% で消す
|
|
688
|
+
float edge = smoothstep(1.0, 0.88, uv.y) * smoothstep(0.0, 0.06, uv.x) * smoothstep(1.0, 0.94, uv.x);
|
|
689
|
+
o = vec4(min(max(c, 0.0) * m + e * (1.0 - m), vec3(mix(a, 1.0, uDay))), a) * edge;
|
|
690
|
+
}`);
|
|
691
|
+
// 炎の光の合計: 断面ごとに縮めた画像(LIGHTMAP)を 1 画素にまとめる。uWhich が 0 なら色と明るさ、1 なら重心
|
|
692
|
+
const LIGHTSUM = program(`
|
|
693
|
+
in vec2 uv; out vec4 o; uniform sampler2D uL; uniform int uWhich;
|
|
694
|
+
${SIMLIB}
|
|
695
|
+
void main(){
|
|
696
|
+
vec3 col = vec3(0.0), c = vec3(0.0); float l = 0.0;
|
|
697
|
+
for (int y = 0; y < ${TY * 8}; y++) for (int x = 0; x < ${TX * 8}; x++) {
|
|
698
|
+
vec4 e = texelFetch(uL, ivec2(x, y), 0); float w = e.a; if (!(w > 0.0)) continue;
|
|
699
|
+
col += e.rgb; l += w;
|
|
700
|
+
int k = (x >> 3) + (y >> 3) * TILES.x;
|
|
701
|
+
c += w * vec3(ORIGIN.x + ((float(x & 7) + 0.5) / 8.0) * float(N.x) * CELL, ((float(y & 7) + 0.5) / 8.0) * float(N.y) * CELL, ORIGIN.z + (float(k) + 0.5) * CELL);
|
|
702
|
+
}
|
|
703
|
+
// 1 画素が受け持つ体積(m³)を掛けて、光の総量にする
|
|
704
|
+
float v = (float(N.x) * CELL / 8.0) * (float(N.y) * CELL / 8.0) * CELL;
|
|
705
|
+
if (uWhich == 0) o = vec4(col * v * 22.0, l * v);
|
|
706
|
+
else o = vec4(l > 1e-6 ? vec3(c.x / l, max(0.26, c.y / l), c.z / l) : vec3(0.0, 0.3, 0.0), l * v);
|
|
707
|
+
}`);
|
|
708
|
+
|
|
709
|
+
// ---------- 状態 ----------
|
|
710
|
+
// volScale は炎を描く解像度(画面に対する比)、substeps は 1 コマが 1/45 秒より長いときに流れを解く回数、
|
|
711
|
+
// rebuildFrames は薪と地面の描き直しを何コマに分けるか、day は昼の光の割合、mask は縁を透明にするか
|
|
712
|
+
const params = { speed: 20, exposure: 0, white: false, intensity: 0.8, wind: 0, iters: 12, paused: false, steps: 48, sparks: true, volScale: manual ? 1 : 0.5, substeps: 2, maxStep: 1 / 50, rebuildFrames: 1, day: 0, mask: false, ...options.params };
|
|
713
|
+
// 画面への収め方。zoom は拡大、center は視線の中心のずれ(画面の高さを 1 とする)、fit は縦長の画面で引くか
|
|
714
|
+
const view = { zoom: 1, center: [0, 0], fit: true, ...options.view };
|
|
715
|
+
const emit = (type, detail = {}) => options.onEvent?.(type, detail);
|
|
716
|
+
const sim = { vel: [target(NX * TX, NY * TY), target(NX * TX, NY * TY)], state: [target(NX * TX, NY * TY), target(NX * TX, NY * TY)], pressure: [target(NX * TX, NY * TY), target(NX * TX, NY * TY)], div: target(NX * TX, NY * TY), light: target(TX * 8, TY * 8), sum0: target(1, 1), sum1: target(1, 1) };
|
|
717
|
+
for (const t of sim.state) { gl.bindFramebuffer(gl.FRAMEBUFFER, t.fbo); gl.clearColor(300, 0, 1, 0); gl.clear(gl.COLOR_BUFFER_BIT); }
|
|
718
|
+
gl.clearColor(0, 0, 0, 0);
|
|
719
|
+
const swap = (pair) => { pair.reverse(); };
|
|
720
|
+
// GPU から値を読む道具。request() で読み出しを頼み、poll() が true を返したコマで pix に届く。描画は待たせない。
|
|
721
|
+
// read() はその場で読む(GPU を待つ)。焼き出しのときだけ使う
|
|
722
|
+
function reader(w, h) {
|
|
723
|
+
const pix = new Float32Array(w * h * 4); const buf = gl.createBuffer(); let sync = null;
|
|
724
|
+
gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf); gl.bufferData(gl.PIXEL_PACK_BUFFER, pix.byteLength, gl.STREAM_READ); gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
|
|
725
|
+
return {
|
|
726
|
+
pix,
|
|
727
|
+
read(fbo) { gl.bindFramebuffer(gl.FRAMEBUFFER, fbo); gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, pix); },
|
|
728
|
+
request(fbo) {
|
|
729
|
+
if (sync) return;
|
|
730
|
+
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo); gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf); gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, 0); gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
|
|
731
|
+
// ここでは flush しない。命令は、このコマの描画が終わるときにまとめて GPU へ送られる
|
|
732
|
+
sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
|
|
733
|
+
},
|
|
734
|
+
poll() {
|
|
735
|
+
if (!sync) return false;
|
|
736
|
+
const s = gl.clientWaitSync(sync, 0, 0);
|
|
737
|
+
if (s === gl.TIMEOUT_EXPIRED) return false;
|
|
738
|
+
gl.deleteSync(sync); sync = null;
|
|
739
|
+
if (s === gl.WAIT_FAILED) return false;
|
|
740
|
+
gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf); gl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, pix); gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
|
|
741
|
+
return true;
|
|
742
|
+
},
|
|
743
|
+
};
|
|
744
|
+
}
|
|
745
|
+
const light = { pos: [0, 0.3, 0], col: [0, 0, 0], lum: 0 }; const lightRead = [reader(1, 1), reader(1, 1)]; let lightAge = 9;
|
|
746
|
+
const cam = { ...ANGLES[0], target: [0, 0.22, 0] };
|
|
747
|
+
let scene = null, blooms = [], gFull = null, gBack = null, gLow = null, vol = null;
|
|
748
|
+
// 使い回す値を書く先。4 枚の画像に同時に書く
|
|
749
|
+
function gbuffer(w, h) {
|
|
750
|
+
const fbo = gl.createFramebuffer(); gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
|
|
751
|
+
const tex = [0, 1, 2, 3].map((i) => {
|
|
752
|
+
const t = gl.createTexture(); gl.bindTexture(gl.TEXTURE_2D, t);
|
|
753
|
+
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, w, h, 0, gl.RGBA, gl.HALF_FLOAT, null);
|
|
754
|
+
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
|
|
755
|
+
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
756
|
+
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.TEXTURE_2D, t, 0);
|
|
757
|
+
return t;
|
|
758
|
+
});
|
|
759
|
+
return { fbo, tex, w, h, valid: false };
|
|
760
|
+
}
|
|
761
|
+
const free = (t) => { if (!t) return; for (const x of t.tex.length ? t.tex : [t.tex]) gl.deleteTexture(x); gl.deleteFramebuffer(t.fbo); };
|
|
762
|
+
// 描く大きさ(画素)を決める。変わったときだけ、描く先を作り直す
|
|
763
|
+
let sizeKey = "";
|
|
764
|
+
function resize(w, h) {
|
|
765
|
+
w = Math.max(2, Math.round(w)); h = Math.max(2, Math.round(h));
|
|
766
|
+
const k = `${w}x${h}x${params.volScale}`;
|
|
767
|
+
if (k === sizeKey) return;
|
|
768
|
+
sizeKey = k;
|
|
769
|
+
for (const t of [scene, gFull, gBack, gLow, vol, ...blooms.flatMap((b) => [b.down, b.up])]) free(t);
|
|
770
|
+
canvas.width = w; canvas.height = h;
|
|
771
|
+
scene = target(w, h); blooms = [];
|
|
772
|
+
gFull = gbuffer(w, h); gBack = gbuffer(w, h); gLow = gbuffer(Math.max(2, Math.round(w * 0.4)), Math.max(2, Math.round(h * 0.4)));
|
|
773
|
+
vol = target(Math.max(2, Math.round(w * params.volScale)), Math.max(2, Math.round(h * params.volScale)));
|
|
774
|
+
fullKey = ""; fullStruct = ""; lowKey = ""; job = null;
|
|
775
|
+
let bw = w, bh = h;
|
|
776
|
+
for (let i = 0; i < 4; i++) { bw = Math.max(2, bw >> 1); bh = Math.max(2, bh >> 1); blooms.push({ down: target(bw, bh), up: target(bw, bh) }); }
|
|
777
|
+
}
|
|
778
|
+
// ---------- 薪の状態と、時間で燃え進む変化 ----------
|
|
779
|
+
// burn は燃え進み。0 が生木、0.1 で火が移り、0.8 で折れ、1.3 で熾になって消える。
|
|
780
|
+
// 実物の四つ割りの薪は 20 分ほどで燃え尽きるとして、等倍では 1 秒に 1/1000 ずつ進める。太い丸太はその 1/25 の速さ
|
|
781
|
+
const logs = LOGS.map((l, i) => ({ ...l, a: [...l.a], b: [...l.b], seed: (i * 0.618 + 0.17) % 1, burn: l.type === 0 ? 0.3 : i < 4 ? 0.5 : 0.28, slot: i - 2, anim: null }));
|
|
782
|
+
// 薪を置ける場所。下の段 2 つ、上の段 2 つ、その上に 1 つ
|
|
783
|
+
const SLOTS = [
|
|
784
|
+
{ a: [-0.2, 0.062, -0.04], b: [0.19, 0.066, -0.032] }, { a: [-0.17, 0.064, 0.03], b: [0.215, 0.06, 0.04] },
|
|
785
|
+
{ a: [-0.215, 0.118, -0.012], b: [0.17, 0.126, 0.012] }, { a: [-0.15, 0.115, 0.058], b: [0.225, 0.122, 0.03] },
|
|
786
|
+
{ a: [-0.19, 0.165, 0.03], b: [0.2, 0.17, -0.015] },
|
|
787
|
+
];
|
|
788
|
+
const fire = { bed: 0.25, boost: 0, message: "", low: false };
|
|
789
|
+
const logA = new Float32Array(MAX_LOGS * 4), logB = new Float32Array(MAX_LOGS * 4), logC = new Float32Array(MAX_LOGS * 4), logD = new Float32Array(MAX_LOGS * 4);
|
|
790
|
+
// 燃料のガスの出方: 火が移るまでは少なく、燃え進み 0.1〜0.7 で最も多く、炭になるにつれて減る
|
|
791
|
+
const fuelOf = (l) => { const b = l.burn; const phase = b < 0.1 ? 0.1 + b * 4 : b < 0.7 ? 1 : Math.max(0.12, 1 - (b - 0.7) * 1.45); return phase * l.heat * l.heat; };
|
|
792
|
+
function uploadLogs() {
|
|
793
|
+
logA.fill(0); logB.fill(0); logC.fill(0); logD.fill(0);
|
|
794
|
+
logs.forEach((l, i) => {
|
|
795
|
+
const dy = l.anim?.kind === "drop" ? (1 - l.anim.t * l.anim.t) * 0.25 : 0;
|
|
796
|
+
logA.set([l.a[0], l.a[1] + dy, l.a[2], l.r], i * 4); logB.set([l.b[0], l.b[1] + dy, l.b[2], l.type], i * 4);
|
|
797
|
+
logC.set([l.spin, l.bend, l.heat, l.seed], i * 4); logD.set([l.burn, l.anim?.kind === "drop" ? 0 : fuelOf(l), Math.max(0, 1 - l.burn / 0.08), 0], i * 4);
|
|
798
|
+
});
|
|
799
|
+
}
|
|
800
|
+
const setLogs = (s) => s.fv("uLogA", 4, logA).fv("uLogB", 4, logB).fv("uLogC", 4, logC).fv("uLogD", 4, logD).i("uLogN", logs.length).f("uBed", fire.bed);
|
|
801
|
+
// 薪と熾の形が変わったかを見分ける値。燃え進みは 0.01 刻みで見る
|
|
802
|
+
const shapeKey = () => logs.map((l) => `${Math.round(l.burn * 100)},${l.a[1].toFixed(3)},${l.b[1].toFixed(3)},${l.a[2].toFixed(3)},${l.anim ? l.anim.t.toFixed(2) : ""}`).join(";") + `|${fire.bed.toFixed(2)}`;
|
|
803
|
+
const bedTop = () => 0.02 + 0.04 * fire.bed;
|
|
804
|
+
function updateLogs(dt) {
|
|
805
|
+
const step = (dt * params.speed) / 1000;
|
|
806
|
+
for (let i = logs.length - 1; i >= 0; i--) {
|
|
807
|
+
const l = logs[i];
|
|
808
|
+
if (l.anim) {
|
|
809
|
+
l.anim.t = Math.min(1, l.anim.t + dt / l.anim.dur);
|
|
810
|
+
if (l.anim.kind === "sag") { const e = l.anim; const k = e.t * e.t; l[e.end][1] = e.from + (e.to - e.from) * k; }
|
|
811
|
+
if (l.anim.t >= 1) { if (l.anim.kind !== "sag") pop(8 + Math.floor(Math.random() * 6), 1.4, l); l.anim = null; }
|
|
812
|
+
continue;
|
|
813
|
+
}
|
|
814
|
+
// 火が弱いと、燃え進みも遅い
|
|
815
|
+
l.burn += step * (l.type === 0 ? 0.04 : 1) * (0.35 + 0.65 * Math.min(1, params.intensity / 0.8));
|
|
816
|
+
if (l.type === 0) { l.burn = Math.min(l.burn, 0.62); continue; }
|
|
817
|
+
// 折れる: 燃え進みが 0.8 を超えると、いちばん細った中ほどで 2 つに折れ、折れた端が熾の上へ落ちる
|
|
818
|
+
if (!l.broken && l.burn > 0.8 && logs.length < MAX_LOGS) {
|
|
819
|
+
const k = 0.42 + Math.random() * 0.16; const mid = l.a.map((v, j) => v + (l.b[j] - v) * k);
|
|
820
|
+
const gap = 0.012; const ax = [(l.b[0] - l.a[0]), (l.b[1] - l.a[1]), (l.b[2] - l.a[2])]; const len = Math.hypot(...ax); const u = ax.map((v) => v / len);
|
|
821
|
+
const left = { ...l, b: mid.map((v, j) => v - u[j] * gap), broken: true, seed: (l.seed + 0.31) % 1, slot: -1 };
|
|
822
|
+
const right = { ...l, a: mid.map((v, j) => v + u[j] * gap), broken: true, seed: (l.seed + 0.57) % 1, slot: -1 };
|
|
823
|
+
left.a = [...l.a]; right.b = [...l.b];
|
|
824
|
+
const to = bedTop() + l.r * 0.45;
|
|
825
|
+
left.anim = { kind: "sag", end: "b", t: 0, dur: 0.35, from: left.b[1], to: Math.min(left.b[1], to) };
|
|
826
|
+
right.anim = { kind: "sag", end: "a", t: 0, dur: 0.42, from: right.a[1], to: Math.min(right.a[1], to) };
|
|
827
|
+
// 外側の端も、支えを失って少し下がる
|
|
828
|
+
left.a[1] = Math.max(to, left.a[1] - 0.02); right.b[1] = Math.max(to, right.b[1] - 0.02);
|
|
829
|
+
logs.splice(i, 1, left, right);
|
|
830
|
+
pop(10 + Math.floor(Math.random() * 8), 1.5, { a: mid, b: mid });
|
|
831
|
+
emit("break");
|
|
832
|
+
continue;
|
|
833
|
+
}
|
|
834
|
+
// 熾になる: 燃え進みが 1.3 に達した薪は形を失い、熾の山に加わる
|
|
835
|
+
if (l.burn >= 1.3) { logs.splice(i, 1); fire.bed = Math.min(1, fire.bed + 0.09); pop(3, 0.8, l); emit("ember"); }
|
|
836
|
+
}
|
|
837
|
+
// 熾は、薪がなくなると少しずつ灰になって減る
|
|
838
|
+
const fed = logs.some((l) => l.type !== 0);
|
|
839
|
+
// 熾は、薪があるうちも量に比例して灰になる(くべ続けると 0.6〜0.7 でつり合う)
|
|
840
|
+
if (!fed) fire.bed = Math.max(0.05, fire.bed - step * 0.3); else fire.bed = Math.max(0.05, fire.bed - step * 0.3 * fire.bed);
|
|
841
|
+
// くべた薪がすべて熾になったら、1 回だけ知らせる
|
|
842
|
+
if (!fed && !fire.low) { fire.low = true; emit("low"); } else if (fed) fire.low = false;
|
|
843
|
+
fire.boost *= Math.exp(-dt / 2.5);
|
|
844
|
+
uploadLogs();
|
|
845
|
+
}
|
|
846
|
+
// 薪をくべる: 空いている場所に、四つ割りを 1 本置く。25cm 上から 0.3 秒で落ちる。置けたら true を返す
|
|
847
|
+
function stoke(auto = false) {
|
|
848
|
+
const used = new Set(logs.map((l) => l.slot));
|
|
849
|
+
const free = SLOTS.findIndex((_, i) => !used.has(i));
|
|
850
|
+
if (free < 0 || logs.length >= MAX_LOGS - 1) { fire.message = "置く場所がない。薪が燃えて折れるまで待つ"; return false; }
|
|
851
|
+
const sl = SLOTS[free]; const lift = Math.max(0, bedTop() - 0.03) * (free < 2 ? 1 : 0.5);
|
|
852
|
+
logs.push({ a: [sl.a[0] + (Math.random() - 0.5) * 0.03, sl.a[1] + lift, sl.a[2] + (Math.random() - 0.5) * 0.012], b: [sl.b[0] + (Math.random() - 0.5) * 0.03, sl.b[1] + lift, sl.b[2] + (Math.random() - 0.5) * 0.012], r: 0.034 + Math.random() * 0.006, type: Math.random() < 0.75 ? 2 : 1, spin: 3.3 + Math.random() * 2.2, bend: (Math.random() - 0.5) * 0.005, heat: 1, seed: Math.random(), burn: 0, slot: free, anim: { kind: "drop", t: 0, dur: 0.3 } });
|
|
853
|
+
fire.message = "";
|
|
854
|
+
emit("stoke", { auto });
|
|
855
|
+
return true;
|
|
856
|
+
}
|
|
857
|
+
// 熾を寄せる: 折れた薪を丸太の間の中央へ寄せて、熾の上に寝かせる。空気が入るので、数秒だけ火が強くなる
|
|
858
|
+
function tend() {
|
|
859
|
+
let n = 0;
|
|
860
|
+
for (const l of logs) {
|
|
861
|
+
if (!l.broken) continue;
|
|
862
|
+
const y = bedTop() + l.r * 0.5; const z = (n % 2 ? 1 : -1) * (0.012 + 0.02 * Math.random()); n++;
|
|
863
|
+
const cx = (l.a[0] + l.b[0]) / 2; const pull = cx * 0.25;
|
|
864
|
+
l.a = [l.a[0] - pull, y, z]; l.b = [l.b[0] - pull, y + (Math.random() - 0.5) * 0.01, z + (Math.random() - 0.5) * 0.02];
|
|
865
|
+
}
|
|
866
|
+
fire.boost = 0.5; pop(12 + Math.floor(Math.random() * 8), 1.3, null);
|
|
867
|
+
}
|
|
868
|
+
// 息を吹く: power(0〜1)の分だけ、数秒のあいだ火が強くなり、熾から火の粉が飛ぶ
|
|
869
|
+
function blow(power = 0.5) {
|
|
870
|
+
const k = Math.min(1, Math.max(0, power));
|
|
871
|
+
fire.boost = Math.max(fire.boost, k); pop(4 + Math.floor(k * 16), 0.8 + k, null);
|
|
872
|
+
}
|
|
873
|
+
// ---------- 火の粉 ----------
|
|
874
|
+
const sparks = []; let nextPop = 2; const probe = target(TX * 4, TY * 4); const probeRead = reader(TX * 4, TY * 4); const probePix = probeRead.pix; let probeAge = 9;
|
|
875
|
+
// 薪 src の上(なければ熾の上)から、count 個の火の粉を飛ばす
|
|
876
|
+
function pop(count, power, src) {
|
|
877
|
+
if (!params.sparks || params.white) return;
|
|
878
|
+
for (let i = 0; i < count; i++) {
|
|
879
|
+
const k = Math.random();
|
|
880
|
+
const p = src ? [src.a[0] + (src.b[0] - src.a[0]) * k, src.a[1] + (src.b[1] - src.a[1]) * k + 0.02, src.a[2] + (src.b[2] - src.a[2]) * k] : [(Math.random() - 0.5) * 0.36, bedTop() + 0.02, (Math.random() - 0.5) * 0.1];
|
|
881
|
+
const az = Math.random() * 6.2832, up = 0.4 + Math.random() * 0.9, sp = (0.5 + Math.random() * 1.4) * power;
|
|
882
|
+
sparks.push({ p, v: [Math.cos(az) * sp * 0.6, up * sp, Math.sin(az) * sp * 0.6], T: 1350 + Math.random() * 250, life: 0, max: 0.6 + Math.random() ** 2 * 2.4, m: 0.5 + Math.random() });
|
|
883
|
+
}
|
|
884
|
+
}
|
|
885
|
+
function gasVel(p) {
|
|
886
|
+
const gx = (p[0] - ORIGIN[0]) / (NX * CELL), gy = p[1] / (NY * CELL), gz = (p[2] - ORIGIN[2]) / (NZ * CELL);
|
|
887
|
+
if (gx < 0 || gx >= 1 || gy < 0 || gy >= 1 || gz < 0 || gz >= 1) return [0, 0, 0];
|
|
888
|
+
const k = Math.floor(gz * NZ); const x = (k % TX) * 4 + Math.floor(gx * 4), y = Math.floor(k / TX) * 4 + Math.floor(gy * 4);
|
|
889
|
+
const i = (y * TX * 4 + x) * 4; return [probePix[i], probePix[i + 1], probePix[i + 2]];
|
|
890
|
+
}
|
|
891
|
+
const planckJs = (T) => { const ref = 1 / (Math.exp(0.0143877 / (610e-9 * 1500)) - 1); return [610e-9, 550e-9, 465e-9].map((l) => 1 / ((l / 610e-9) ** 5 * (Math.exp(0.0143877 / (l * T)) - 1)) / ref); };
|
|
892
|
+
const sparkData = new Float32Array(300 * 10);
|
|
893
|
+
function updateSparks(dt, project) {
|
|
894
|
+
// 火の粉を運ぶ気流を、0.1〜0.2 秒おきに GPU から読む。届くのを待たず、届いたコマから使う
|
|
895
|
+
probeRead.poll();
|
|
896
|
+
if (++probeAge > (manual ? 2 : 5)) {
|
|
897
|
+
probeAge = 0; gl.bindFramebuffer(gl.READ_FRAMEBUFFER, sim.vel[0].fbo); gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, probe.fbo); gl.blitFramebuffer(0, 0, NX * TX, NY * TY, 0, 0, TX * 4, TY * 4, gl.COLOR_BUFFER_BIT, gl.NEAREST);
|
|
898
|
+
if (manual) probeRead.read(probe.fbo); else probeRead.request(probe.fbo);
|
|
899
|
+
}
|
|
900
|
+
// はぜる: 次に飛ぶまでの時間は指数分布。広葉樹の薪を想定して、平均 4 秒に 1 回、1〜4 個
|
|
901
|
+
nextPop -= dt;
|
|
902
|
+
if (nextPop <= 0) { const burning = logs.filter((l) => l.type !== 0 && l.burn > 0.1); if (burning.length && params.intensity > 0.05) { const count = 1 + Math.floor(Math.random() ** 2 * 4); pop(count, 1, burning[Math.floor(Math.random() * burning.length)]); if (params.sparks && !params.white) emit("pop", { count }); } nextPop = -Math.log(1 - Math.random()) * (2.4 / (0.15 + params.intensity)); }
|
|
903
|
+
let n = 0;
|
|
904
|
+
for (let i = sparks.length - 1; i >= 0; i--) {
|
|
905
|
+
const s = sparks[i]; s.life += dt;
|
|
906
|
+
if (s.life >= s.max || s.p[1] < 0) { sparks.splice(i, 1); continue; }
|
|
907
|
+
// 軽い炭のかけらは、気体の流れに 0.12 秒ほど遅れて追従し、重さでわずかに落ちる
|
|
908
|
+
const g = gasVel(s.p); const k = 1 - Math.exp(-dt / (0.12 * s.m));
|
|
909
|
+
for (let j = 0; j < 3; j++) { s.v[j] += (g[j] - s.v[j]) * k + (Math.random() - 0.5) * 2 * dt; }
|
|
910
|
+
s.v[1] -= 1.2 * s.m * dt;
|
|
911
|
+
for (let j = 0; j < 3; j++) s.p[j] += s.v[j] * dt;
|
|
912
|
+
// 小さいので、約 1 秒で 1500 K から 800 K まで冷える
|
|
913
|
+
s.T = 760 + (s.T - 760) * Math.exp(-dt / (0.9 * s.m));
|
|
914
|
+
if (n >= 300) continue;
|
|
915
|
+
const a = project(s.p), b = project([s.p[0] - s.v[0] / 30, s.p[1] - s.v[1] / 30, s.p[2] - s.v[2] / 30]);
|
|
916
|
+
if (!a || !b) continue;
|
|
917
|
+
const c = planckJs(s.T); const gain = 16 * Math.min(1, s.life / 0.03);
|
|
918
|
+
sparkData.set([b[0], b[1], c[0] * gain * 0.2, c[1] * gain * 0.2, c[2] * gain * 0.2, a[0], a[1], c[0] * gain, c[1] * gain, c[2] * gain], n * 10); n++;
|
|
919
|
+
}
|
|
920
|
+
return n;
|
|
921
|
+
}
|
|
922
|
+
function stepSim(dt) {
|
|
923
|
+
draw(ADVECT, sim.vel[1], (s) => s.tex("uVel", sim.vel[0]).tex("uSrc", sim.vel[0]).f("uDt", dt)); swap(sim.vel);
|
|
924
|
+
draw(ADVECT, sim.state[1], (s) => s.tex("uVel", sim.vel[0]).tex("uSrc", sim.state[0]).f("uDt", dt)); swap(sim.state);
|
|
925
|
+
draw(REACT, sim.state[1], (s) => setLogs(s.tex("uState", sim.state[0]).f("uDt", dt).f("uTime", time).f("uIntensity", params.intensity + fire.boost))); swap(sim.state);
|
|
926
|
+
draw(FORCE, sim.vel[1], (s) => setLogs(s.tex("uVel", sim.vel[0]).tex("uState", sim.state[0]).f("uDt", dt).f("uTime", time).f("uWind", params.wind))); swap(sim.vel);
|
|
927
|
+
draw(DIVERGENCE, sim.div, (s) => s.tex("uVel", sim.vel[0]));
|
|
928
|
+
for (let i = 0; i < params.iters; i++) { draw(JACOBI, sim.pressure[1], (s) => s.tex("uP", sim.pressure[0]).tex("uDiv", sim.div)); swap(sim.pressure); }
|
|
929
|
+
draw(GRADIENT, sim.vel[1], (s) => s.tex("uP", sim.pressure[0]).tex("uVel", sim.vel[0])); swap(sim.vel);
|
|
930
|
+
}
|
|
931
|
+
// 炎の光の色と重心を GPU の上でまとめる。合成はその画像を直に読むので、ここでは GPU を待たない。
|
|
932
|
+
// JS の側の light(明るさを外へ知らせるのに使う)には、0.1 秒ほど遅れて届く
|
|
933
|
+
function measureLight() {
|
|
934
|
+
draw(LIGHTMAP, sim.light, (s) => s.tex("uState", sim.state[0]));
|
|
935
|
+
draw(LIGHTSUM, sim.sum0, (s) => s.tex("uL", sim.light).i("uWhich", 0));
|
|
936
|
+
draw(LIGHTSUM, sim.sum1, (s) => s.tex("uL", sim.light).i("uWhich", 1));
|
|
937
|
+
const [r0, r1] = lightRead;
|
|
938
|
+
const take = () => { light.col = [r0.pix[0], r0.pix[1], r0.pix[2]]; light.lum = r0.pix[3]; if (r1.pix[3] > 0) light.pos = [r1.pix[0], r1.pix[1], r1.pix[2]]; };
|
|
939
|
+
if (manual) { r0.read(sim.sum0.fbo); r1.read(sim.sum1.fbo); take(); return; }
|
|
940
|
+
const got0 = r0.poll(), got1 = r1.poll(); if (got0 || got1) take();
|
|
941
|
+
if (++lightAge > 2) { lightAge = 0; r0.request(sim.sum0.fbo); r1.request(sim.sum1.fbo); }
|
|
942
|
+
}
|
|
943
|
+
uploadLogs();
|
|
944
|
+
let time = 0, last = 0, query = null;
|
|
945
|
+
// 焼き出し: mode 1 は炎の光と炎を抜いた絵、2 は炎の光だけ、3 は炎と火の粉だけ。light に色を入れると、炎の光をその値に固定する
|
|
946
|
+
const bake = { on: manual, mode: 0, light: null, t: 0 };
|
|
947
|
+
const stats = { gpuMs: null, rebuilt: 0 };
|
|
948
|
+
// 薪と地面の描き直し。fullKey / fullStruct は gFull を描いたときの状態、job は数コマに分けて描いている途中の仕事
|
|
949
|
+
let fullKey = "", fullStruct = "", lowKey = "", job = null;
|
|
950
|
+
// 見た目が大きく変わる状態(視点、薪の位置、落ちる・折れる動き)。燃え進みと熾の量は入れない
|
|
951
|
+
const structOf = (camKey) => `${camKey}|${logs.map((l) => `${l.a[1].toFixed(3)},${l.b[1].toFixed(3)},${l.a[2].toFixed(3)},${l.anim ? l.anim.t.toFixed(2) : ""}`).join(";")}`;
|
|
952
|
+
const ATTACH = [gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2, gl.COLOR_ATTACHMENT3];
|
|
953
|
+
|
|
954
|
+
function render(t) {
|
|
955
|
+
if (!scene) return;
|
|
956
|
+
const dt = Math.min(0.05, (t - last) / 1000 || 1 / 60); last = t; time += dt;
|
|
957
|
+
// カメラ: 中心のまわりを回る
|
|
958
|
+
const az = (cam.az * Math.PI) / 180, el = (cam.el * Math.PI) / 180;
|
|
959
|
+
const pos = [cam.target[0] + cam.dist * Math.cos(el) * Math.cos(az), cam.target[1] + cam.dist * Math.sin(el), cam.target[2] + cam.dist * Math.cos(el) * Math.sin(az)];
|
|
960
|
+
const fwd = [cam.target[0] - pos[0], cam.target[1] - pos[1], cam.target[2] - pos[2]]; const fl = Math.hypot(...fwd); fwd.forEach((v, i) => { fwd[i] = v / fl; });
|
|
961
|
+
const right = [-fwd[2], 0, fwd[0]]; const rl = Math.hypot(...right); right.forEach((v, i) => { right[i] = v / rl; });
|
|
962
|
+
const up = [right[1] * fwd[2] - right[2] * fwd[1], right[2] * fwd[0] - right[0] * fwd[2], right[0] * fwd[1] - right[1] * fwd[0]];
|
|
963
|
+
// 画面が縦長のときは、横に 0.75m が入るように引く(view.fit)
|
|
964
|
+
const aspect = canvas.width / canvas.height;
|
|
965
|
+
const focal = (0.5 / Math.tan((cam.fov * Math.PI) / 360)) * (view.fit ? Math.min(1, aspect / 1.1) : 1) * view.zoom;
|
|
966
|
+
const cx = view.center[0], cy = view.center[1];
|
|
967
|
+
|
|
968
|
+
// 作業台用: GPU の時間の目安を stats.gpuMs に入れる。Chrome では仕事の量を変えても値がほとんど動かないので、重さの判断には使わない
|
|
969
|
+
let q = null;
|
|
970
|
+
if (options.timing && timerExt && !query) { q = gl.createQuery(); gl.beginQuery(timerExt.TIME_ELAPSED_EXT, q); }
|
|
971
|
+
if (!params.paused) updateLogs(dt);
|
|
972
|
+
if (!params.paused && !params.white) {
|
|
973
|
+
// 流れは 1/50 秒より長い刻みでは解かない。1 コマが長いとき(30 コマ/秒)は substeps 回に分ける
|
|
974
|
+
const n = dt > 1 / 45 ? Math.max(1, params.substeps) : 1;
|
|
975
|
+
for (let i = 0; i < n; i++) stepSim(Math.min(dt / n, params.maxStep));
|
|
976
|
+
measureLight();
|
|
977
|
+
}
|
|
978
|
+
// 薪と地面は、視点、燃えた度合い、画面の大きさが変わったときだけ描き直す
|
|
979
|
+
const camOf = (c) => (s2, w, h) => s2.f("uRes", w, h).f("uCam", ...c.pos).f("uRight", ...c.right).f("uUp", ...c.up).f("uFwd", ...c.fwd).f("uFocal", c.focal).f("uCenter", c.cx, c.cy);
|
|
980
|
+
const camNow = { pos, right, up, fwd, focal, cx, cy };
|
|
981
|
+
const camUniforms = camOf(camNow);
|
|
982
|
+
const camKey = `${pos.map((v) => v.toFixed(4))}|${focal.toFixed(4)}|${cx},${cy}`;
|
|
983
|
+
const key = `${camKey}|${shapeKey()}`; const struct = structOf(camKey);
|
|
984
|
+
const busy = api.moving || logs.some((l) => l.anim);
|
|
985
|
+
const strips = Math.max(1, Math.round(params.rebuildFrames));
|
|
986
|
+
if (!job && key !== fullKey && !busy) job = { key, struct, y: 0, cam: camOf(camNow), A: logA.slice(), B: logB.slice(), C: logC.slice(), D: logD.slice(), n: logs.length, bed: fire.bed };
|
|
987
|
+
if (job) {
|
|
988
|
+
// 途中のコマでも形がずれないよう、仕事を始めたときの薪と視点で、下から帯ごとに描く
|
|
989
|
+
const y1 = Math.min(gBack.h, job.y + Math.ceil(gBack.h / strips));
|
|
990
|
+
gl.bindFramebuffer(gl.FRAMEBUFFER, gBack.fbo); gl.drawBuffers(ATTACH);
|
|
991
|
+
gl.enable(gl.SCISSOR_TEST); gl.scissor(0, job.y, gBack.w, y1 - job.y);
|
|
992
|
+
draw(SCENE, gBack, (s2) => job.cam(s2, gBack.w, gBack.h).fv("uLogA", 4, job.A).fv("uLogB", 4, job.B).fv("uLogC", 4, job.C).fv("uLogD", 4, job.D).i("uLogN", job.n).f("uBed", job.bed).f("uTime", 0).f("uWhite", 0));
|
|
993
|
+
gl.disable(gl.SCISSOR_TEST);
|
|
994
|
+
job.y = y1;
|
|
995
|
+
if (job.y >= gBack.h) { [gFull, gBack] = [gBack, gFull]; fullKey = job.key; fullStruct = job.struct; job = null; stats.rebuilt++; }
|
|
996
|
+
}
|
|
997
|
+
// 大きく変わった直後と、動いている間は、4 割の解像度でその場で描いたものを使う
|
|
998
|
+
let g = gFull;
|
|
999
|
+
if (fullStruct !== struct) {
|
|
1000
|
+
g = gLow;
|
|
1001
|
+
if (lowKey !== key) {
|
|
1002
|
+
gl.bindFramebuffer(gl.FRAMEBUFFER, gLow.fbo); gl.drawBuffers(ATTACH);
|
|
1003
|
+
draw(SCENE, gLow, (s2) => setLogs(camUniforms(s2, gLow.w, gLow.h).f("uTime", 0).f("uWhite", 0)));
|
|
1004
|
+
lowKey = key;
|
|
1005
|
+
}
|
|
1006
|
+
}
|
|
1007
|
+
if (!params.white) draw(VOLUME, vol, (s2) => camUniforms(s2, vol.w, vol.h).tex("uG1", g.tex[1]).tex("uState", sim.state[0]).f("uTime", time).i("uSteps", params.steps));
|
|
1008
|
+
draw(COMPOSITE, scene, (s2) => camUniforms(s2, scene.w, scene.h).tex("uG0", g.tex[0]).tex("uG1", g.tex[1]).tex("uG2", g.tex[2]).tex("uG3", g.tex[3]).tex("uVol", vol).tex("uLight0", sim.sum0).tex("uLight1", sim.sum1)
|
|
1009
|
+
.f("uTime", time).f("uWhite", params.white ? 1 : 0).f("uDay", params.day).f("uMask", params.mask ? 1 : 0)
|
|
1010
|
+
.f("uLightFix", bake.light ? 1 : 0).f("uLightPos", 0, 0.32, 0).f("uLightCol", ...(bake.light ?? [0, 0, 0])).i("uMode", bake.mode));
|
|
1011
|
+
// 火の粉を、炎の上から足して描く
|
|
1012
|
+
const project = (p) => {
|
|
1013
|
+
const d = [p[0] - pos[0], p[1] - pos[1], p[2] - pos[2]]; const z = d[0] * fwd[0] + d[1] * fwd[1] + d[2] * fwd[2]; if (z < 0.05) return null;
|
|
1014
|
+
return [(2 * ((focal * (d[0] * right[0] + d[1] * right[1] + d[2] * right[2])) / z - cx)) / aspect, 2 * ((focal * (d[0] * up[0] + d[1] * up[1] + d[2] * up[2])) / z - cy)];
|
|
1015
|
+
};
|
|
1016
|
+
const nSparks = params.paused ? 0 : updateSparks(dt, project);
|
|
1017
|
+
if (nSparks > 0 && !params.white && bake.mode !== 1 && bake.mode !== 2) {
|
|
1018
|
+
gl.bindFramebuffer(gl.FRAMEBUFFER, scene.fbo); gl.viewport(0, 0, scene.w, scene.h);
|
|
1019
|
+
gl.useProgram(SPARK); gl.bindVertexArray(sparkVao); gl.bindBuffer(gl.ARRAY_BUFFER, sparkBuf); gl.bufferData(gl.ARRAY_BUFFER, sparkData.subarray(0, nSparks * 10), gl.DYNAMIC_DRAW);
|
|
1020
|
+
gl.enable(gl.BLEND); gl.blendFunc(gl.ONE, gl.ONE); gl.drawArrays(gl.LINES, 0, nSparks * 2); gl.disable(gl.BLEND);
|
|
1021
|
+
}
|
|
1022
|
+
let src = scene;
|
|
1023
|
+
for (const b of blooms) { draw(DOWN, b.down, (s) => s.tex("uSrc", src).f("uTexel", 1 / src.w, 1 / src.h)); src = b.down; }
|
|
1024
|
+
for (let i = blooms.length - 2; i >= 0; i--) { const b = blooms[i]; draw(UP, b.up, (s) => s.tex("uSrc", src).tex("uBase", b.down).f("uTexel", 1 / src.w, 1 / src.h).f("uMix", 0.55)); src = b.up; }
|
|
1025
|
+
draw(FINAL, null, (s) => s.tex("uScene", scene).tex("uBloom", src).f("uExposure", 2 ** params.exposure).f("uBloomAmt", params.white ? 0.04 : 0.2).f("uTime", time).f("uMask", params.mask ? 1 : 0).f("uDay", params.day));
|
|
1026
|
+
if (q) { gl.endQuery(timerExt.TIME_ELAPSED_EXT); query = q; }
|
|
1027
|
+
else if (query && gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE)) { if (!gl.getParameter(timerExt.GPU_DISJOINT_EXT)) stats.gpuMs = gl.getQueryParameter(query, gl.QUERY_RESULT) / 1e6; gl.deleteQuery(query); query = null; }
|
|
1028
|
+
}
|
|
1029
|
+
|
|
1030
|
+
const api = {
|
|
1031
|
+
gl, params, view, cam, ANGLES, logs, fire, sparks, light, bake, stats,
|
|
1032
|
+
/** 視点を動かしている間は true にする。薪と地面を 4 割の解像度で毎コマ描く */
|
|
1033
|
+
moving: false,
|
|
1034
|
+
stoke, tend, blow, uploadLogs, resize, render,
|
|
1035
|
+
/** 流れだけを n 回進める(描かない)。始めに炎を育てるのに使う */
|
|
1036
|
+
warm(n = 1) { for (let i = 0; i < n; i++) { time += 1 / 50; stepSim(1 / 50); } },
|
|
1037
|
+
/**
|
|
1038
|
+
* 流れを n 回進めて GPU が終わるまで待ち、1 回あたりの時間(ms)を返す。GPU の速さを知るのに、始めに 1 回だけ使う。
|
|
1039
|
+
* GPU を待つあいだ画面が止まるので、毎コマは呼ばない
|
|
1040
|
+
*/
|
|
1041
|
+
bench(n = 5) {
|
|
1042
|
+
const px = new Float32Array(4);
|
|
1043
|
+
// 先にたまっている命令を終わらせてから測る
|
|
1044
|
+
gl.bindFramebuffer(gl.FRAMEBUFFER, sim.sum0.fbo); gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.FLOAT, px);
|
|
1045
|
+
const t0 = performance.now();
|
|
1046
|
+
api.warm(n);
|
|
1047
|
+
gl.bindFramebuffer(gl.FRAMEBUFFER, sim.state[0].fbo); gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.FLOAT, px);
|
|
1048
|
+
return (performance.now() - t0) / n;
|
|
1049
|
+
},
|
|
1050
|
+
/** 焼き出し用: 1/60 秒ずつ n コマ進めて描き、GPU が終わるまで待つ */
|
|
1051
|
+
advance(n = 1) { for (let i = 0; i < n; i++) { bake.t += 1000 / 60; render(bake.t); } gl.finish(); },
|
|
1052
|
+
/** GPU の資源を手放す。呼んだあとは使えない */
|
|
1053
|
+
dispose() { gl.getExtension("WEBGL_lose_context")?.loseContext(); },
|
|
1054
|
+
ready: null,
|
|
1055
|
+
};
|
|
1056
|
+
api.ready = new Promise((resolve, reject) => {
|
|
1057
|
+
const check = () => {
|
|
1058
|
+
try {
|
|
1059
|
+
if (gl.isContextLost()) throw new Error("WebGL のコンテキストが失われた");
|
|
1060
|
+
if (!programsDone()) { setTimeout(check, 16); return; }
|
|
1061
|
+
finishPrograms(); resolve(api);
|
|
1062
|
+
} catch (e) { reject(e); }
|
|
1063
|
+
};
|
|
1064
|
+
check();
|
|
1065
|
+
});
|
|
1066
|
+
return api;
|
|
1067
|
+
}
|