Line data Source code
1 : import type { Point2D } from '@comfyorg/shared-frontend-utils/geometry'
2 : import * as THREE from 'three'
3 : import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader'
4 : import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader'
5 : import { computed, onUnmounted, ref, shallowRef, watch } from 'vue'
6 :
7 : import type { ChromaticityCoords, GamutName } from '@/renderer/hdr/colorGamut'
8 : import {
9 : detectGamutFromChromaticities,
10 : gamutToSrgbMatrix
11 : } from '@/renderer/hdr/colorGamut'
12 : import {
13 : HDR_VIEWER_FRAGMENT_SHADER,
14 : HDR_VIEWER_VERTEX_SHADER
15 : } from '@/renderer/hdr/hdrViewerShader'
16 : import type { ChannelHistograms, ImageStats } from '@/renderer/hdr/hdrStats'
17 : import {
18 : computeChannelHistograms,
19 : computeImageStats
20 : } from '@/renderer/hdr/hdrStats'
21 : import { WebGLViewport } from '@comfyorg/viewport3d/three/WebGLViewport'
22 : import { getImageFilenameFromUrl } from '@/utils/hdrFormatUtil'
23 :
24 2 : const MIN_ZOOM = 0.05
25 2 : const MAX_ZOOM = 64
26 2 : const CHECKER_CSS_PX = 8
27 :
28 : export type ChannelMode = 'rgb' | 'r' | 'g' | 'b' | 'a' | 'luminance'
29 :
30 2 : export const CHANNEL_MODES: ChannelMode[] = [
31 : 'rgb',
32 : 'r',
33 : 'g',
34 : 'b',
35 : 'a',
36 : 'luminance'
37 : ]
38 :
39 2 : const CHANNEL_INDEX: Record<ChannelMode, number> = {
40 : rgb: 0,
41 : r: 1,
42 : g: 2,
43 : b: 3,
44 : a: 4,
45 : luminance: 5
46 : }
47 :
48 : interface PixelReadout extends Point2D {
49 : r: number
50 : g: number
51 : b: number
52 : a: number | null
53 : }
54 :
55 : interface ExrTexData {
56 : header?: { chromaticities?: ChromaticityCoords }
57 : }
58 :
59 2 : function createLoader(url: string) {
60 : const filename = getImageFilenameFromUrl(url)
61 2 : if (filename?.toLowerCase().endsWith('.hdr')) return new RGBELoader()
62 2 : const loader = new EXRLoader()
63 2 : loader.setDataType(THREE.FloatType)
64 2 : return loader
65 : }
66 :
67 2 : function makeReader(
68 : data: ArrayLike<number>,
69 : type: THREE.TextureDataType
70 : ): (index: number) => number {
71 2 : if (type === THREE.HalfFloatType) {
72 0 : return (index) => THREE.DataUtils.fromHalfFloat(data[index])
73 : }
74 2 : return (index) => data[index]
75 : }
76 :
77 2 : function loadHdrTexture(
78 : url: string
79 : ): Promise<{ texture: THREE.DataTexture; gamut: GamutName }> {
80 2 : return new Promise((resolve, reject) => {
81 2 : createLoader(url).load(
82 : url,
83 : (texture, texData) => {
84 2 : const chromaticities = (texData as ExrTexData).header?.chromaticities
85 2 : resolve({
86 : texture,
87 : gamut: detectGamutFromChromaticities(chromaticities)
88 : })
89 : },
90 : undefined,
91 : reject
92 : )
93 : })
94 : }
95 :
96 2 : export function useHdrViewer() {
97 2 : const exposureStops = ref(0)
98 2 : const dither = ref(true)
99 2 : const clipWarnings = ref(false)
100 2 : const checkerboard = ref(true)
101 2 : const gamut = ref<GamutName>('sRGB')
102 2 : const channel = ref<ChannelMode>('rgb')
103 2 : const loading = ref(true)
104 2 : const error = ref<string | null>(null)
105 2 : const dimensions = ref<string | null>(null)
106 2 : const stats = ref<ImageStats | null>(null)
107 2 : const histograms = shallowRef<ChannelHistograms | null>(null)
108 2 : const pixel = ref<PixelReadout | null>(null)
109 :
110 2 : const histogram = computed<Uint32Array | null>(() => {
111 4 : const channelHistograms = histograms.value
112 4 : if (!channelHistograms) return null
113 4 : switch (channel.value) {
114 : case 'r':
115 0 : return channelHistograms.r
116 : case 'g':
117 0 : return channelHistograms.g
118 : case 'b':
119 0 : return channelHistograms.b
120 : case 'a':
121 0 : return channelHistograms.a
122 : default:
123 2 : return channelHistograms.luminance
124 : }
125 : })
126 :
127 2 : const containerRef = shallowRef<HTMLElement | null>(null)
128 :
129 2 : let renderer: THREE.WebGLRenderer | null = null
130 2 : let viewport: WebGLViewport | null = null
131 2 : let scene: THREE.Scene | null = null
132 2 : let camera: THREE.OrthographicCamera | null = null
133 2 : let material: THREE.ShaderMaterial | null = null
134 2 : let mesh: THREE.Mesh | null = null
135 2 : let texture: THREE.Texture | null = null
136 2 : let imageAspect = 1
137 2 : let frameRequested = false
138 :
139 2 : let readSample: ((index: number) => number) | null = null
140 2 : let imageWidth = 0
141 2 : let imageHeight = 0
142 2 : let imageChannels = 4
143 :
144 2 : const raycaster = new THREE.Raycaster()
145 2 : const pointerNdc = new THREE.Vector2()
146 :
147 10 : function requestRender() {
148 10 : if (!renderer || frameRequested) return
149 5 : frameRequested = true
150 5 : requestAnimationFrame(() => {
151 5 : frameRequested = false
152 5 : if (renderer && scene && camera) renderer.render(scene, camera)
153 : })
154 : }
155 :
156 10 : function containerSize() {
157 10 : const el = containerRef.value
158 10 : return {
159 : width: el?.clientWidth || 1,
160 : height: el?.clientHeight || 1
161 : }
162 : }
163 :
164 4 : function updateProjection() {
165 4 : if (!camera) return
166 4 : const { width, height } = containerSize()
167 4 : const halfH = 0.5
168 4 : const halfW = (0.5 * width) / height
169 4 : camera.left = -halfW
170 4 : camera.right = halfW
171 4 : camera.top = halfH
172 4 : camera.bottom = -halfH
173 4 : camera.updateProjectionMatrix()
174 : }
175 :
176 2 : function fitView() {
177 2 : if (!camera) return
178 2 : const { width, height } = containerSize()
179 2 : const containerAspect = width / height
180 2 : camera.zoom = Math.min(1, containerAspect / imageAspect)
181 2 : camera.position.set(0, 0, 1)
182 2 : camera.updateProjectionMatrix()
183 2 : requestRender()
184 : }
185 :
186 4 : function applyUniforms() {
187 4 : if (!material) return
188 4 : material.uniforms.uGain.value = Math.pow(2, exposureStops.value)
189 4 : material.uniforms.uDither.value = dither.value
190 4 : material.uniforms.uClipWarnings.value = clipWarnings.value
191 4 : material.uniforms.uCheckerboard.value = checkerboard.value
192 4 : material.uniforms.uChannel.value = CHANNEL_INDEX[channel.value]
193 4 : const m = gamutToSrgbMatrix(gamut.value)
194 4 : ;(material.uniforms.uGamutToSRGB.value as THREE.Matrix3).set(
195 : m[0],
196 : m[1],
197 : m[2],
198 : m[3],
199 : m[4],
200 : m[5],
201 : m[6],
202 : m[7],
203 : m[8]
204 : )
205 4 : requestRender()
206 : }
207 :
208 2 : function buildScene() {
209 2 : renderer = new THREE.WebGLRenderer({ antialias: false, alpha: false })
210 2 : viewport = new WebGLViewport(renderer)
211 2 : renderer.outputColorSpace = THREE.LinearSRGBColorSpace
212 2 : renderer.setPixelRatio(window.devicePixelRatio)
213 2 : renderer.setClearColor(0x0a0a0a, 1)
214 :
215 2 : scene = new THREE.Scene()
216 2 : camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0.1, 10)
217 2 : camera.position.set(0, 0, 1)
218 :
219 2 : material = new THREE.ShaderMaterial({
220 : glslVersion: THREE.GLSL3,
221 : vertexShader: HDR_VIEWER_VERTEX_SHADER,
222 : fragmentShader: HDR_VIEWER_FRAGMENT_SHADER,
223 : uniforms: {
224 : uImage: { value: null },
225 : uGamutToSRGB: { value: new THREE.Matrix3() },
226 : uGain: { value: 1 },
227 : uChannel: { value: 0 },
228 : uDither: { value: true },
229 : uClipWarnings: { value: false },
230 : uClipRange: { value: new THREE.Vector2(0, 1) },
231 : uCheckerboard: { value: true },
232 : uCheckerSize: { value: CHECKER_CSS_PX * renderer.getPixelRatio() }
233 : }
234 : })
235 :
236 2 : mesh = new THREE.Mesh(new THREE.PlaneGeometry(1, 1), material)
237 2 : scene.add(mesh)
238 : }
239 :
240 4 : function resize() {
241 4 : if (!renderer) return
242 4 : const { width, height } = containerSize()
243 4 : renderer.setSize(width, height, false)
244 4 : updateProjection()
245 4 : requestRender()
246 : }
247 :
248 2 : function setTexture(loaded: THREE.DataTexture) {
249 2 : if (!material || !mesh) return
250 2 : loaded.colorSpace = THREE.LinearSRGBColorSpace
251 2 : loaded.minFilter = THREE.LinearFilter
252 2 : loaded.magFilter = THREE.LinearFilter
253 2 : loaded.needsUpdate = true
254 :
255 2 : const { width, height, data } = loaded.image
256 2 : texture = loaded
257 2 : imageAspect = width / height
258 2 : mesh.scale.set(imageAspect, 1, 1)
259 2 : material.uniforms.uImage.value = loaded
260 2 : dimensions.value = `${width} x ${height}`
261 :
262 2 : if (!data) return
263 2 : imageWidth = width
264 2 : imageHeight = height
265 2 : imageChannels = data.length / (width * height)
266 2 : readSample = makeReader(data, loaded.type)
267 2 : stats.value = computeImageStats(readSample, data.length, imageChannels)
268 2 : histograms.value = computeChannelHistograms(
269 : readSample,
270 : data.length,
271 : imageChannels
272 : )
273 : }
274 :
275 2 : async function mount(container: HTMLElement, url: string) {
276 2 : containerRef.value = container
277 2 : loading.value = true
278 2 : error.value = null
279 :
280 2 : try {
281 2 : buildScene()
282 2 : container.appendChild(renderer!.domElement)
283 2 : renderer!.domElement.classList.add('block', 'size-full')
284 2 : resize()
285 2 : applyUniforms()
286 2 : attachInteractions(renderer!.domElement)
287 2 : viewport!.observeResize(container, resize)
288 :
289 2 : const { texture: loaded, gamut: detectedGamut } =
290 : await loadHdrTexture(url)
291 2 : if (!material || !mesh) {
292 0 : loaded.dispose()
293 0 : return
294 : }
295 2 : gamut.value = detectedGamut
296 2 : setTexture(loaded)
297 2 : applyUniforms()
298 2 : fitView()
299 : } catch (e) {
300 0 : error.value = e instanceof Error ? e.message : String(e)
301 0 : dispose()
302 : } finally {
303 2 : loading.value = false
304 : }
305 : }
306 :
307 0 : function normalizeExposure() {
308 0 : const max = stats.value?.max ?? 0
309 0 : exposureStops.value = max > 0 ? -Math.log2(max) : 0
310 : }
311 :
312 2 : function attachInteractions(canvas: HTMLCanvasElement) {
313 2 : canvas.addEventListener('wheel', onWheel, { passive: false })
314 2 : canvas.addEventListener('pointerdown', onPointerDown)
315 2 : canvas.addEventListener('pointermove', onHoverMove)
316 2 : canvas.addEventListener('pointerleave', onHoverLeave)
317 : }
318 :
319 0 : function onWheel(event: WheelEvent) {
320 0 : if (!camera) return
321 0 : event.preventDefault()
322 0 : const factor = Math.exp(-event.deltaY * 0.001)
323 0 : const nextZoom = THREE.MathUtils.clamp(
324 : camera.zoom * factor,
325 : MIN_ZOOM,
326 : MAX_ZOOM
327 : )
328 0 : camera.zoom = nextZoom
329 0 : camera.updateProjectionMatrix()
330 0 : requestRender()
331 : }
332 :
333 2 : let dragStart: (Point2D & { camX: number; camY: number }) | null = null
334 :
335 0 : function onPointerDown(event: PointerEvent) {
336 0 : if (!camera) return
337 0 : dragStart = {
338 : x: event.clientX,
339 : y: event.clientY,
340 : camX: camera.position.x,
341 : camY: camera.position.y
342 : }
343 0 : window.addEventListener('pointermove', onPointerMove)
344 0 : window.addEventListener('pointerup', onPointerUp)
345 : }
346 :
347 0 : function onPointerMove(event: PointerEvent) {
348 0 : if (!camera || !dragStart) return
349 0 : const { height } = containerSize()
350 0 : const worldPerPixel = 1 / (height * camera.zoom)
351 0 : camera.position.x =
352 : dragStart.camX - (event.clientX - dragStart.x) * worldPerPixel
353 0 : camera.position.y =
354 : dragStart.camY + (event.clientY - dragStart.y) * worldPerPixel
355 0 : requestRender()
356 : }
357 :
358 0 : function onPointerUp() {
359 0 : dragStart = null
360 0 : window.removeEventListener('pointermove', onPointerMove)
361 0 : window.removeEventListener('pointerup', onPointerUp)
362 : }
363 :
364 0 : function onHoverMove(event: PointerEvent) {
365 0 : if (!camera || !mesh || !renderer || dragStart || !readSample) return
366 0 : const rect = renderer.domElement.getBoundingClientRect()
367 0 : pointerNdc.x = ((event.clientX - rect.left) / rect.width) * 2 - 1
368 0 : pointerNdc.y = -(((event.clientY - rect.top) / rect.height) * 2 - 1)
369 0 : raycaster.setFromCamera(pointerNdc, camera)
370 0 : const hit = raycaster.intersectObject(mesh).at(0)
371 0 : if (!hit?.uv) {
372 0 : pixel.value = null
373 0 : return
374 : }
375 0 : const col = THREE.MathUtils.clamp(
376 : Math.floor(hit.uv.x * imageWidth),
377 : 0,
378 : imageWidth - 1
379 : )
380 0 : const row = THREE.MathUtils.clamp(
381 : Math.floor(hit.uv.y * imageHeight),
382 : 0,
383 : imageHeight - 1
384 : )
385 0 : const base = (row * imageWidth + col) * imageChannels
386 0 : pixel.value = {
387 : x: col,
388 : y: imageHeight - 1 - row,
389 : r: readSample(base),
390 : g: readSample(base + 1),
391 : b: readSample(base + 2),
392 : a: imageChannels === 4 ? readSample(base + 3) : null
393 : }
394 : }
395 :
396 0 : function onHoverLeave() {
397 0 : pixel.value = null
398 : }
399 :
400 0 : function dispose() {
401 0 : window.removeEventListener('pointermove', onPointerMove)
402 0 : window.removeEventListener('pointerup', onPointerUp)
403 :
404 0 : if (renderer) {
405 0 : renderer.domElement.removeEventListener('wheel', onWheel)
406 0 : renderer.domElement.removeEventListener('pointerdown', onPointerDown)
407 0 : renderer.domElement.removeEventListener('pointermove', onHoverMove)
408 0 : renderer.domElement.removeEventListener('pointerleave', onHoverLeave)
409 : }
410 0 : viewport?.disposeRenderer()
411 0 : texture?.dispose()
412 0 : material?.dispose()
413 0 : mesh?.geometry.dispose()
414 :
415 0 : renderer = null
416 0 : viewport = null
417 0 : scene = null
418 0 : camera = null
419 0 : material = null
420 0 : mesh = null
421 0 : texture = null
422 0 : readSample = null
423 : }
424 :
425 2 : watch(
426 : [exposureStops, dither, clipWarnings, checkerboard, gamut, channel],
427 : applyUniforms
428 : )
429 :
430 2 : onUnmounted(dispose)
431 :
432 2 : return {
433 : exposureStops,
434 : dither,
435 : clipWarnings,
436 : checkerboard,
437 : gamut,
438 : channel,
439 : loading,
440 : error,
441 : dimensions,
442 : stats,
443 : histogram,
444 : pixel,
445 : mount,
446 : dispose,
447 : fitView,
448 : normalizeExposure
449 : }
450 : }
|