Initial project import

node_modules/@monogrid/gainmap-js/dist/decode/index.d.ts

@@ -0,0 +1 @@
+export * from './webgl/index';

node_modules/@monogrid/gainmap-js/dist/decode/shared/Loader.d.ts

@@ -0,0 +1,59 @@
+import { HalfFloatType, LinearSRGBColorSpace, Loader, LoadingManager, Texture } from 'three';
+import { type GainMapMetadata, QuadRendererTextureOptions } from '../../core/types';
+import { DecodeParameters } from './types';
+/**
+ * Configuration for the loader base class
+ */
+export interface LoaderBaseConfig<TRenderer, TQuadRenderer, TMaterial> {
+    renderer?: TRenderer;
+    renderTargetOptions?: QuadRendererTextureOptions;
+    createMaterial: (params: DecodeParameters) => TMaterial;
+    createQuadRenderer: (params: {
+        width: number;
+        height: number;
+        type: typeof HalfFloatType;
+        colorSpace: typeof LinearSRGBColorSpace;
+        material: TMaterial;
+        renderer?: TRenderer;
+        renderTargetOptions?: QuadRendererTextureOptions;
+    }) => TQuadRenderer;
+}
+/**
+ * Shared base class for loaders that extracts common logic
+ */
+export declare abstract class LoaderBaseShared<TRenderer, TQuadRenderer, TMaterial, TUrl = string> extends Loader<TQuadRenderer, TUrl> {
+    private _renderer?;
+    private _renderTargetOptions?;
+    protected _internalLoadingManager: LoadingManager;
+    protected _config: LoaderBaseConfig<TRenderer, TQuadRenderer, TMaterial>;
+    constructor(config: LoaderBaseConfig<TRenderer, TQuadRenderer, TMaterial>, manager?: LoadingManager);
+    setRenderer(renderer: TRenderer): this;
+    setRenderTargetOptions(options: QuadRendererTextureOptions): this;
+    protected prepareQuadRenderer(): TQuadRenderer;
+    protected processImages(sdrBuffer: ArrayBuffer, gainMapBuffer?: ArrayBuffer, imageOrientation?: 'flipY' | 'from-image'): Promise<{
+        sdrImage: ImageBitmap | HTMLImageElement;
+        gainMapImage: ImageBitmap | HTMLImageElement | undefined;
+        needsFlip: boolean;
+    }>;
+    protected createTextures(sdrImage: ImageBitmap | HTMLImageElement, gainMapImage: ImageBitmap | HTMLImageElement | undefined, needsFlip: boolean): {
+        gainMap: Texture;
+        sdr: Texture;
+    };
+    protected updateQuadRenderer(quadRenderer: TQuadRenderer & {
+        width: number;
+        height: number;
+        material: TMaterial & {
+            gainMap: Texture;
+            sdr: Texture;
+            gainMapMin: [number, number, number];
+            gainMapMax: [number, number, number];
+            offsetHdr: [number, number, number];
+            offsetSdr: [number, number, number];
+            gamma: [number, number, number];
+            hdrCapacityMin: number;
+            hdrCapacityMax: number;
+            maxDisplayBoost: number;
+            needsUpdate: boolean;
+        };
+    }, sdrImage: ImageBitmap | HTMLImageElement, gainMap: Texture, sdr: Texture, metadata: GainMapMetadata): void;
+}

node_modules/@monogrid/gainmap-js/dist/decode/shared/decode.d.ts

@@ -0,0 +1,24 @@
+import { HalfFloatType, LinearSRGBColorSpace } from 'three';
+import { Constructor, QuadRendererTextureOptions } from '../../core';
+import { DecodeParametersWithRenderer } from './types';
+/**
+ * Configuration for decode function
+ */
+export interface DecodeConfig<TRenderer extends Constructor, TQuadRenderer, TMaterial> {
+    renderer: TRenderer;
+    createMaterial: (params: DecodeParametersWithRenderer<InstanceType<TRenderer>>) => TMaterial;
+    createQuadRenderer: (params: {
+        width: number;
+        height: number;
+        type: typeof HalfFloatType;
+        colorSpace: typeof LinearSRGBColorSpace;
+        material: TMaterial;
+        renderer: InstanceType<TRenderer>;
+        renderTargetOptions?: QuadRendererTextureOptions;
+    }) => TQuadRenderer;
+}
+/**
+ * Shared decode implementation factory
+ * Creates a decode function that prepares a QuadRenderer with the given parameters
+ */
+export declare function createDecodeFunction<TRenderer extends Constructor, TQuadRenderer, TMaterial>(config: DecodeConfig<TRenderer, TQuadRenderer, TMaterial>): (params: DecodeParametersWithRenderer<InstanceType<TRenderer>>) => TQuadRenderer;

node_modules/@monogrid/gainmap-js/dist/decode/shared/errors/GainMapNotFoundError.d.ts

@@ -0,0 +1,2 @@
+export declare class GainMapNotFoundError extends Error {
+}

node_modules/@monogrid/gainmap-js/dist/decode/shared/errors/XMPMetadataNotFoundError.d.ts

@@ -0,0 +1,2 @@
+export declare class XMPMetadataNotFoundError extends Error {
+}

node_modules/@monogrid/gainmap-js/dist/decode/shared/extract.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Extracts XMP Metadata and the gain map recovery image
+ * from a single JPEG file.
+ *
+ * @category Decoding Functions
+ * @group Decoding Functions
+ * @param jpegFile an `Uint8Array` containing and encoded JPEG file
+ * @returns an sdr `Uint8Array` compressed in JPEG, a gainMap `Uint8Array` compressed in JPEG and the XMP parsed XMP metadata
+ * @throws Error if XMP Metadata is not found
+ * @throws Error if Gain map image is not found
+ * @example
+ * import { FileLoader } from 'three'
+ * import { extractGainmapFromJPEG } from '@monogrid/gainmap-js'
+ *
+ * const jpegFile = await new FileLoader()
+ *  .setResponseType('arraybuffer')
+ *  .loadAsync('image.jpg')
+ *
+ * const { sdr, gainMap, metadata } = extractGainmapFromJPEG(jpegFile)
+ */
+export declare const extractGainmapFromJPEG: (jpegFile: Uint8Array<ArrayBuffer>) => Promise<{
+    sdr: Uint8Array<ArrayBuffer>;
+    gainMap: Uint8Array<ArrayBuffer>;
+    metadata: import("..").GainMapMetadata;
+}>;

node_modules/@monogrid/gainmap-js/dist/decode/shared/index.d.ts

@@ -0,0 +1,8 @@
+export * from './decode';
+export * from './errors/GainMapNotFoundError';
+export * from './errors/XMPMetadataNotFoundError';
+export * from './extract';
+export * from './Loader';
+export * from './types';
+export * from './utils/extractXMP';
+export * from './utils/MPFExtractor';

node_modules/@monogrid/gainmap-js/dist/decode/shared/types.d.ts

@@ -0,0 +1,43 @@
+import { Texture } from 'three';
+import { GainMapMetadata, QuadRendererTextureOptions, TextureImageFormat } from '../../core';
+/**
+ * Parameters related to the display used for decoding
+ */
+export type GainmapDecodingParameters = {
+    /**
+     * The maximum available boost supported by a display, at a given point in time.
+     *
+     * @remarks
+     * This value can change over time based on device settings and other factors,
+     * such as ambient light conditions, or how many bright pixels are on the screen.
+     *
+     * Non Logarithmic space
+     */
+    maxDisplayBoost: number;
+};
+/**
+ * Parameters for generic decoding
+ */
+export type DecodeParameters = {
+    /**
+     * A Texture containing the SDR Rendition
+     */
+    sdr: Texture<TextureImageFormat>;
+    /**
+     * A Texture containing the GainMap recovery image
+     */
+    gainMap: Texture<TextureImageFormat>;
+} & GainmapDecodingParameters & GainMapMetadata;
+/**
+ * Parameters for decode function
+ */
+export type DecodeParametersWithRenderer<TRenderer> = {
+    /**
+     * The renderer used to decode the GainMap
+     */
+    renderer: TRenderer;
+    /**
+     * Options to use when creating the output renderTarget
+     */
+    renderTargetOptions?: QuadRendererTextureOptions;
+} & DecodeParameters & GainmapDecodingParameters & GainMapMetadata;

node_modules/@monogrid/gainmap-js/dist/decode/shared/utils/MPFExtractor.d.ts

@@ -0,0 +1,21 @@
+export type MPFExtractorOptions = {
+    debug: boolean;
+    extractFII: boolean;
+    extractNonFII: boolean;
+};
+/**
+ * MPF Extractor (Multi Picture Format Extractor)
+ * By Henrik S Nilsson 2019
+ *
+ * Extracts images stored in images based on the MPF format (found here: https://www.cipa.jp/e/std/std-sec.html
+ * under "CIPA DC-007-Translation-2021 Multi-Picture Format"
+ *
+ * Overly commented, and without intention of being complete or production ready.
+ * Created to extract depth maps from iPhone images, and to learn about image metadata.
+ * Kudos to: Phil Harvey (exiftool), Jaume Sanchez (android-lens-blur-depth-extractor)
+ */
+export declare class MPFExtractor {
+    options: MPFExtractorOptions;
+    constructor(options?: Partial<MPFExtractorOptions>);
+    extract(imageArrayBuffer: Uint8Array<ArrayBuffer>): Promise<Blob[]>;
+}

node_modules/@monogrid/gainmap-js/dist/decode/shared/utils/extractXMP.d.ts

@@ -0,0 +1,2 @@
+import { GainMapMetadata } from '../../../core/types';
+export declare const extractXMP: (input: Uint8Array) => GainMapMetadata | undefined;

node_modules/@monogrid/gainmap-js/dist/decode/shared/utils/get-html-image-from-blob.d.ts

@@ -0,0 +1,7 @@
+/**
+ * private function, async get image from blob
+ *
+ * @param blob
+ * @returns
+ */
+export declare const getHTMLImageFromBlob: (blob: Blob) => Promise<HTMLImageElement>;

node_modules/@monogrid/gainmap-js/dist/decode/webgl/decode.d.ts

@@ -0,0 +1,60 @@
+import { HalfFloatType, WebGLRenderer } from 'three';
+import { QuadRenderer } from '../../core/QuadRenderer';
+import { DecodeParametersWithRenderer } from '../shared';
+import { GainMapDecoderMaterial } from './materials/GainMapDecoderMaterial';
+/**
+ * Decodes a gain map using a WebGL RenderTarget
+ *
+ * @category Decoding Functions
+ * @group Decoding Functions
+ * @example
+ * import { decode } from '@monogrid/gainmap-js'
+ * import {
+ *   Mesh,
+ *   MeshBasicMaterial,
+ *   PerspectiveCamera,
+ *   PlaneGeometry,
+ *   Scene,
+ *   TextureLoader,
+ *   WebGLRenderer
+ * } from 'three'
+ *
+ * const renderer = new WebGLRenderer()
+ *
+ * const textureLoader = new TextureLoader()
+ *
+ * // load SDR Representation
+ * const sdr = await textureLoader.loadAsync('sdr.jpg')
+ * // load Gain map recovery image
+ * const gainMap = await textureLoader.loadAsync('gainmap.jpg')
+ * // load metadata
+ * const metadata = await (await fetch('metadata.json')).json()
+ *
+ * const result = decode({
+ *   sdr,
+ *   gainMap,
+ *   // this allows to use `result.renderTarget.texture` directly
+ *   renderer,
+ *   // this will restore the full HDR range
+ *   maxDisplayBoost: Math.pow(2, metadata.hdrCapacityMax),
+ *   ...metadata
+ * })
+ *
+ * const scene = new Scene()
+ * // `result` can be used to populate a Texture
+ * const mesh = new Mesh(
+ *   new PlaneGeometry(),
+ *   new MeshBasicMaterial({ map: result.renderTarget.texture })
+ * )
+ * scene.add(mesh)
+ * renderer.render(scene, new PerspectiveCamera())
+ *
+ * // result must be manually disposed
+ * // when you are done using it
+ * result.dispose()
+ *
+ * @param params
+ * @returns
+ * @throws {Error} if the WebGLRenderer fails to render the gain map
+ */
+export declare const decode: (params: DecodeParametersWithRenderer<WebGLRenderer>) => InstanceType<typeof QuadRenderer<typeof HalfFloatType, InstanceType<typeof GainMapDecoderMaterial>>>;

node_modules/@monogrid/gainmap-js/dist/decode/webgl/index.d.ts

@@ -0,0 +1,8 @@
+export * from '../../core/QuadRenderer';
+export * from '../../core/types';
+export * from '../shared';
+export * from './decode';
+export * from './loaders/GainMapLoader';
+export * from './loaders/HDRJPGLoader';
+export { HDRJPGLoader as JPEGRLoader } from './loaders/HDRJPGLoader';
+export * from './materials/GainMapDecoderMaterial';

node_modules/@monogrid/gainmap-js/dist/decode/webgl/loaders/GainMapLoader.d.ts

@@ -0,0 +1,68 @@
+import { HalfFloatType } from 'three';
+import { QuadRenderer } from '../../../core/QuadRenderer';
+import { GainMapDecoderMaterial } from '../materials/GainMapDecoderMaterial';
+import { LoaderBaseWebGL } from './LoaderBaseWebGL';
+/**
+ * A Three.js Loader for the gain map format.
+ *
+ * @category Loaders
+ * @group Loaders
+ *
+ * @example
+ * import { GainMapLoader } from '@monogrid/gainmap-js'
+ * import {
+ *   EquirectangularReflectionMapping,
+ *   Mesh,
+ *   MeshBasicMaterial,
+ *   PerspectiveCamera,
+ *   PlaneGeometry,
+ *   Scene,
+ *   WebGLRenderer
+ * } from 'three'
+ *
+ * const renderer = new WebGLRenderer()
+ *
+ * const loader = new GainMapLoader(renderer)
+ *   .setRenderTargetOptions({ mapping: EquirectangularReflectionMapping })
+ *
+ * const result = await loader.loadAsync(['sdr.jpeg', 'gainmap.jpeg', 'metadata.json'])
+ * // `result` can be used to populate a Texture
+ *
+ * const scene = new Scene()
+ * const mesh = new Mesh(
+ *   new PlaneGeometry(),
+ *   new MeshBasicMaterial({ map: result.renderTarget.texture })
+ * )
+ * scene.add(mesh)
+ * renderer.render(scene, new PerspectiveCamera())
+ *
+ * // Starting from three.js r159
+ * // `result.renderTarget.texture` can
+ * // also be used as Equirectangular scene background
+ * //
+ * // it was previously needed to convert it
+ * // to a DataTexture with `result.toDataTexture()`
+ * scene.background = result.renderTarget.texture
+ *
+ * // result must be manually disposed
+ * // when you are done using it
+ * result.dispose()
+ *
+ */
+export declare class GainMapLoader extends LoaderBaseWebGL<[string, string, string]> {
+    /**
+     * Loads a gainmap using separate data
+     * * sdr image
+     * * gain map image
+     * * metadata json
+     *
+     * useful for webp gain maps
+     *
+     * @param urls An array in the form of [sdr.jpg, gainmap.jpg, metadata.json]
+     * @param onLoad Load complete callback, will receive the result
+     * @param onProgress Progress callback, will receive a `ProgressEvent`
+     * @param onError Error callback
+     * @returns
+     */
+    load([sdrUrl, gainMapUrl, metadataUrl]: [string, string, string], onLoad?: (data: QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>;
+}

node_modules/@monogrid/gainmap-js/dist/decode/webgl/loaders/HDRJPGLoader.d.ts

@@ -0,0 +1,64 @@
+import { HalfFloatType } from 'three';
+import { QuadRenderer } from '../../../core/QuadRenderer';
+import { GainMapDecoderMaterial } from '../materials/GainMapDecoderMaterial';
+import { LoaderBaseWebGL } from './LoaderBaseWebGL';
+/**
+ * A Three.js Loader for a JPEG with embedded gainmap metadata.
+ *
+ * @category Loaders
+ * @group Loaders
+ *
+ * @example
+ * import { HDRJPGLoader } from '@monogrid/gainmap-js'
+ * import {
+ *   EquirectangularReflectionMapping,
+ *   Mesh,
+ *   MeshBasicMaterial,
+ *   PerspectiveCamera,
+ *   PlaneGeometry,
+ *   Scene,
+ *   WebGLRenderer
+ * } from 'three'
+ *
+ * const renderer = new WebGLRenderer()
+ *
+ * const loader = new HDRJPGLoader(renderer)
+ *   .setRenderTargetOptions({ mapping: EquirectangularReflectionMapping })
+ *
+ * const result = await loader.loadAsync('gainmap.jpeg')
+ * // `result` can be used to populate a Texture
+ *
+ * const scene = new Scene()
+ * const mesh = new Mesh(
+ *   new PlaneGeometry(),
+ *   new MeshBasicMaterial({ map: result.renderTarget.texture })
+ * )
+ * scene.add(mesh)
+ * renderer.render(scene, new PerspectiveCamera())
+ *
+ * // Starting from three.js r159
+ * // `result.renderTarget.texture` can
+ * // also be used as Equirectangular scene background
+ * //
+ * // it was previously needed to convert it
+ * // to a DataTexture with `result.toDataTexture()`
+ * scene.background = result.renderTarget.texture
+ *
+ * // result must be manually disposed
+ * // when you are done using it
+ * result.dispose()
+ *
+ */
+export declare class HDRJPGLoader extends LoaderBaseWebGL<string> {
+    /**
+     * Loads a JPEG containing gain map metadata
+     * Renders a normal SDR image if gainmap data is not found
+     *
+     * @param url Path to a JPEG file containing embedded gain map metadata
+     * @param onLoad Load complete callback, will receive the result
+     * @param onProgress Progress callback, will receive a `ProgressEvent`
+     * @param onError Error callback
+     * @returns
+     */
+    load(url: string, onLoad?: (data: QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>;
+}

node_modules/@monogrid/gainmap-js/dist/decode/webgl/loaders/LoaderBaseWebGL.d.ts

@@ -0,0 +1,20 @@
+import { HalfFloatType, LoadingManager, type WebGLRenderer } from 'three';
+import { QuadRenderer } from '../../../core/QuadRenderer';
+import { type GainMapMetadata } from '../../../core/types';
+import { LoaderBaseShared } from '../../shared';
+import { GainMapDecoderMaterial } from '../materials/GainMapDecoderMaterial';
+/**
+ * Base class for WebGL loaders
+ * @template TUrl - The type of URL used to load resources
+ */
+export declare abstract class LoaderBaseWebGL<TUrl = string> extends LoaderBaseShared<WebGLRenderer, QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>, GainMapDecoderMaterial, TUrl> {
+    constructor(renderer?: WebGLRenderer, manager?: LoadingManager);
+    /**
+     * @private
+     * @param quadRenderer
+     * @param metadata
+     * @param sdrBuffer
+     * @param gainMapBuffer
+     */
+    protected render(quadRenderer: QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>, metadata: GainMapMetadata, sdrBuffer: ArrayBuffer, gainMapBuffer?: ArrayBuffer): Promise<void>;
+}

node_modules/@monogrid/gainmap-js/dist/decode/webgl/materials/GainMapDecoderMaterial.d.ts

@@ -0,0 +1,70 @@
+import { ShaderMaterial, Texture } from 'three';
+import { GainMapMetadata } from '../../../core/types';
+import { type GainmapDecodingParameters } from '../../shared';
+/**
+ * A Material which is able to decode the Gainmap into a full HDR Representation
+ *
+ * @category Materials
+ * @group Materials
+ */
+export declare class GainMapDecoderMaterial extends ShaderMaterial {
+    private _maxDisplayBoost;
+    private _hdrCapacityMin;
+    private _hdrCapacityMax;
+    /**
+     *
+     * @param params
+     */
+    constructor({ gamma, offsetHdr, offsetSdr, gainMapMin, gainMapMax, maxDisplayBoost, hdrCapacityMin, hdrCapacityMax, sdr, gainMap }: GainMapMetadata & GainmapDecodingParameters & {
+        sdr: Texture;
+        gainMap: Texture;
+    });
+    get sdr(): Texture;
+    set sdr(value: Texture);
+    get gainMap(): Texture;
+    set gainMap(value: Texture);
+    /**
+     * @see {@link GainMapMetadata.offsetHdr}
+     */
+    get offsetHdr(): [number, number, number];
+    set offsetHdr(value: [number, number, number]);
+    /**
+     * @see {@link GainMapMetadata.offsetSdr}
+     */
+    get offsetSdr(): [number, number, number];
+    set offsetSdr(value: [number, number, number]);
+    /**
+     * @see {@link GainMapMetadata.gainMapMin}
+     */
+    get gainMapMin(): [number, number, number];
+    set gainMapMin(value: [number, number, number]);
+    /**
+     * @see {@link GainMapMetadata.gainMapMax}
+     */
+    get gainMapMax(): [number, number, number];
+    set gainMapMax(value: [number, number, number]);
+    /**
+     * @see {@link GainMapMetadata.gamma}
+     */
+    get gamma(): [number, number, number];
+    set gamma(value: [number, number, number]);
+    /**
+     * @see {@link GainMapMetadata.hdrCapacityMin}
+     * @remarks Logarithmic space
+     */
+    get hdrCapacityMin(): number;
+    set hdrCapacityMin(value: number);
+    /**
+     * @see {@link GainMapMetadata.hdrCapacityMin}
+     * @remarks Logarithmic space
+     */
+    get hdrCapacityMax(): number;
+    set hdrCapacityMax(value: number);
+    /**
+     * @see {@link GainmapDecodingParameters.maxDisplayBoost}
+     * @remarks Non Logarithmic space
+     */
+    get maxDisplayBoost(): number;
+    set maxDisplayBoost(value: number);
+    private calculateWeight;
+}

node_modules/@monogrid/gainmap-js/dist/decode/webgpu/core/QuadRenderer.d.ts

@@ -0,0 +1,153 @@
+import { ByteType, ColorSpace, DataTexture, FloatType, HalfFloatType, IntType, Material, RenderTarget, ShortType, TextureDataType, UnsignedByteType, UnsignedInt248Type, UnsignedInt5999Type, UnsignedInt101111Type, UnsignedIntType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedShortType, WebGPURenderer } from 'three/webgpu';
+import { QuadRendererTextureOptions } from '../../../core/types';
+/**
+ * Utility Type that translates `three` texture types to their TypedArray counterparts.
+ *
+ * @category Utility
+ * @group Utility
+ */
+export type TextureDataTypeToBufferType<TType extends TextureDataType> = TType extends typeof UnsignedByteType ? Uint8ClampedArray<ArrayBuffer> : TType extends typeof ByteType ? Int8Array<ArrayBuffer> : TType extends typeof ShortType ? Int16Array<ArrayBuffer> : TType extends typeof UnsignedShortType ? Uint16Array<ArrayBuffer> : TType extends typeof IntType ? Int32Array<ArrayBuffer> : TType extends typeof UnsignedIntType ? Uint32Array<ArrayBuffer> : TType extends typeof FloatType ? Float32Array<ArrayBuffer> : TType extends typeof HalfFloatType ? Uint16Array<ArrayBuffer> : TType extends typeof UnsignedShort4444Type ? Uint16Array<ArrayBuffer> : TType extends typeof UnsignedShort5551Type ? Uint16Array<ArrayBuffer> : TType extends typeof UnsignedInt248Type ? Uint32Array<ArrayBuffer> : TType extends typeof UnsignedInt5999Type ? Uint32Array<ArrayBuffer> : TType extends typeof UnsignedInt101111Type ? Uint32Array<ArrayBuffer> : never;
+export type QuadRendererOptions<TType extends TextureDataType, TMaterial extends Material> = {
+    /**
+     * Width of the render target
+     */
+    width: number;
+    /**
+     * height of the renderTarget
+     */
+    height: number;
+    /**
+     * TextureDataType of the renderTarget
+     */
+    type: TType;
+    /**
+     * ColorSpace of the renderTarget
+     */
+    colorSpace: ColorSpace;
+    /**
+     * material to use for rendering
+     */
+    material: TMaterial;
+    /**
+     * Renderer instance to use
+     */
+    renderer?: WebGPURenderer;
+    /**
+     * Additional renderTarget options
+     */
+    renderTargetOptions?: QuadRendererTextureOptions;
+};
+/**
+ * Utility class used for rendering a texture with a material (WebGPU version)
+ *
+ * @category Core
+ * @group Core
+ */
+export declare class QuadRenderer<TType extends TextureDataType, TMaterial extends Material> {
+    private _renderer;
+    private _rendererIsDisposable;
+    private _material;
+    private _scene;
+    private _camera;
+    private _quad;
+    private _renderTarget;
+    private _width;
+    private _height;
+    private _type;
+    private _colorSpace;
+    private _supportsReadPixels;
+    /**
+     * Constructs a new QuadRenderer
+     *
+     * @param options Parameters for this QuadRenderer
+     */
+    constructor(options: QuadRendererOptions<TType, TMaterial>);
+    /**
+     * Instantiates a temporary renderer
+     *
+     * @returns
+     */
+    static instantiateRenderer(): WebGPURenderer;
+    /**
+     * Renders the input texture using the specified material
+     */
+    render: () => Promise<void>;
+    /**
+     * Obtains a Buffer containing the rendered texture.
+     *
+     * @throws Error if the browser cannot read pixels from this RenderTarget type.
+     * @returns a TypedArray containing RGBA values from this renderer
+     */
+    toArray(): Promise<TextureDataTypeToBufferType<TType>>;
+    /**
+     * Performs a readPixel operation in the renderTarget
+     * and returns a DataTexture containing the read data
+     *
+     * @param options options
+     * @returns
+     */
+    toDataTexture(options?: QuadRendererTextureOptions): Promise<DataTexture>;
+    /**
+     * If using a disposable renderer, it will dispose it.
+     */
+    disposeOnDemandRenderer(): void;
+    /**
+     * Will dispose of **all** assets used by this renderer.
+     *
+     *
+     * @param disposeRenderTarget will dispose of the renderTarget which will not be usable later
+     * set this to true if you passed the `renderTarget.texture` to a `PMREMGenerator`
+     * or are otherwise done with it.
+     *
+     * @example
+     * ```js
+     * const loader = new HDRJPGLoader(renderer)
+     * const result = await loader.loadAsync('gainmap.jpeg')
+     * const mesh = new Mesh(geometry, new MeshBasicMaterial({ map: result.renderTarget.texture }) )
+     * // DO NOT dispose the renderTarget here,
+     * // it is used directly in the material
+     * result.dispose()
+     * ```
+     *
+     * @example
+     * ```js
+     * const loader = new HDRJPGLoader(renderer)
+     * const pmremGenerator = new PMREMGenerator( renderer );
+     * const result = await loader.loadAsync('gainmap.jpeg')
+     * const envMap = pmremGenerator.fromEquirectangular(result.renderTarget.texture)
+     * const mesh = new Mesh(geometry, new MeshStandardMaterial({ envMap }) )
+     * // renderTarget can be disposed here
+     * // because it was used to generate a PMREM texture
+     * result.dispose(true)
+     * ```
+     */
+    dispose(disposeRenderTarget?: boolean): void;
+    /**
+     * Width of the texture
+     */
+    get width(): number;
+    set width(value: number);
+    /**
+     * Height of the texture
+     */
+    get height(): number;
+    set height(value: number);
+    /**
+     * The renderer used
+     */
+    get renderer(): WebGPURenderer;
+    /**
+     * The `RenderTarget` used.
+     */
+    get renderTarget(): RenderTarget;
+    set renderTarget(value: RenderTarget);
+    /**
+     * The `Material` used.
+     */
+    get material(): TMaterial;
+    /**
+     *
+     */
+    get type(): TType;
+    get colorSpace(): ColorSpace;
+}

node_modules/@monogrid/gainmap-js/dist/decode/webgpu/decode.d.ts

@@ -0,0 +1,60 @@
+import { HalfFloatType, WebGPURenderer } from 'three/webgpu';
+import { DecodeParametersWithRenderer } from '../shared';
+import { QuadRenderer } from './core/QuadRenderer';
+import { GainMapDecoderMaterial } from './materials/GainMapDecoderMaterial';
+/**
+ * Decodes a gain map using WebGPU RenderTarget
+ *
+ * @category Decoding Functions
+ * @group Decoding Functions
+ * @example
+ * import { decode } from '@monogrid/gainmap-js/webgpu'
+ * import {
+ *   Mesh,
+ *   MeshBasicMaterial,
+ *   PerspectiveCamera,
+ *   PlaneGeometry,
+ *   Scene,
+ *   TextureLoader,
+ *   WebGPURenderer
+ * } from 'three/webgpu'
+ *
+ * const renderer = new WebGPURenderer()
+ *
+ * const textureLoader = new TextureLoader()
+ *
+ * // load SDR Representation
+ * const sdr = await textureLoader.loadAsync('sdr.jpg')
+ * // load Gain map recovery image
+ * const gainMap = await textureLoader.loadAsync('gainmap.jpg')
+ * // load metadata
+ * const metadata = await (await fetch('metadata.json')).json()
+ *
+ * const result = await decode({
+ *   sdr,
+ *   gainMap,
+ *   // this allows to use `result.renderTarget.texture` directly
+ *   renderer,
+ *   // this will restore the full HDR range
+ *   maxDisplayBoost: Math.pow(2, metadata.hdrCapacityMax),
+ *   ...metadata
+ * })
+ *
+ * const scene = new Scene()
+ * // `result` can be used to populate a Texture
+ * const mesh = new Mesh(
+ *   new PlaneGeometry(),
+ *   new MeshBasicMaterial({ map: result.renderTarget.texture })
+ * )
+ * scene.add(mesh)
+ * renderer.render(scene, new PerspectiveCamera())
+ *
+ * // result must be manually disposed
+ * // when you are done using it
+ * result.dispose()
+ *
+ * @param params
+ * @returns
+ * @throws {Error} if the WebGPURenderer fails to render the gain map
+ */
+export declare const decode: (params: DecodeParametersWithRenderer<WebGPURenderer>) => Promise<InstanceType<typeof QuadRenderer<typeof HalfFloatType, InstanceType<typeof GainMapDecoderMaterial>>>>;

node_modules/@monogrid/gainmap-js/dist/decode/webgpu/index.d.ts

@@ -0,0 +1,8 @@
+export * from '../../core/types';
+export * from '../shared';
+export * from './core/QuadRenderer';
+export * from './decode';
+export * from './loaders/GainMapLoader';
+export * from './loaders/HDRJPGLoader';
+export { HDRJPGLoader as JPEGRLoader } from './loaders/HDRJPGLoader';
+export * from './materials/GainMapDecoderMaterial';

node_modules/@monogrid/gainmap-js/dist/decode/webgpu/loaders/GainMapLoader.d.ts

@@ -0,0 +1,69 @@
+import { HalfFloatType } from 'three/webgpu';
+import { QuadRenderer } from '../core/QuadRenderer';
+import { GainMapDecoderMaterial } from '../materials/GainMapDecoderMaterial';
+import { LoaderBaseWebGPU } from './LoaderBaseWebGPU';
+/**
+ * A Three.js Loader for the gain map format (WebGPU version).
+ *
+ * @category Loaders
+ * @group Loaders
+ *
+ * @example
+ * import { GainMapLoader } from '@monogrid/gainmap-js/webgpu'
+ * import {
+ *   EquirectangularReflectionMapping,
+ *   Mesh,
+ *   MeshBasicMaterial,
+ *   PerspectiveCamera,
+ *   PlaneGeometry,
+ *   Scene,
+ *   WebGPURenderer
+ * } from 'three/webgpu'
+ *
+ * const renderer = new WebGPURenderer()
+ * await renderer.init()
+ *
+ * const loader = new GainMapLoader(renderer)
+ *   .setRenderTargetOptions({ mapping: EquirectangularReflectionMapping })
+ *
+ * const result = await loader.loadAsync(['sdr.jpeg', 'gainmap.jpeg', 'metadata.json'])
+ * // `result` can be used to populate a Texture
+ *
+ * const scene = new Scene()
+ * const mesh = new Mesh(
+ *   new PlaneGeometry(),
+ *   new MeshBasicMaterial({ map: result.renderTarget.texture })
+ * )
+ * scene.add(mesh)
+ * renderer.render(scene, new PerspectiveCamera())
+ *
+ * // Starting from three.js r159
+ * // `result.renderTarget.texture` can
+ * // also be used as Equirectangular scene background
+ * //
+ * // it was previously needed to convert it
+ * // to a DataTexture with `result.toDataTexture()`
+ * scene.background = result.renderTarget.texture
+ *
+ * // result must be manually disposed
+ * // when you are done using it
+ * result.dispose()
+ *
+ */
+export declare class GainMapLoader extends LoaderBaseWebGPU<[string, string, string]> {
+    /**
+     * Loads a gainmap using separate data
+     * * sdr image
+     * * gain map image
+     * * metadata json
+     *
+     * useful for webp gain maps
+     *
+     * @param urls An array in the form of [sdr.jpg, gainmap.jpg, metadata.json]
+     * @param onLoad Load complete callback, will receive the result
+     * @param onProgress Progress callback, will receive a `ProgressEvent`
+     * @param onError Error callback
+     * @returns
+     */
+    load([sdrUrl, gainMapUrl, metadataUrl]: [string, string, string], onLoad?: (data: QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>;
+}

node_modules/@monogrid/gainmap-js/dist/decode/webgpu/loaders/HDRJPGLoader.d.ts

@@ -0,0 +1,65 @@
+import { HalfFloatType } from 'three/webgpu';
+import { QuadRenderer } from '../core/QuadRenderer';
+import { GainMapDecoderMaterial } from '../materials/GainMapDecoderMaterial';
+import { LoaderBaseWebGPU } from './LoaderBaseWebGPU';
+/**
+ * A Three.js Loader for a JPEG with embedded gainmap metadata (WebGPU version).
+ *
+ * @category Loaders
+ * @group Loaders
+ *
+ * @example
+ * import { HDRJPGLoader } from '@monogrid/gainmap-js/webgpu'
+ * import {
+ *   EquirectangularReflectionMapping,
+ *   Mesh,
+ *   MeshBasicMaterial,
+ *   PerspectiveCamera,
+ *   PlaneGeometry,
+ *   Scene,
+ *   WebGPURenderer
+ * } from 'three/webgpu'
+ *
+ * const renderer = new WebGPURenderer()
+ * await renderer.init()
+ *
+ * const loader = new HDRJPGLoader(renderer)
+ *   .setRenderTargetOptions({ mapping: EquirectangularReflectionMapping })
+ *
+ * const result = await loader.loadAsync('gainmap.jpeg')
+ * // `result` can be used to populate a Texture
+ *
+ * const scene = new Scene()
+ * const mesh = new Mesh(
+ *   new PlaneGeometry(),
+ *   new MeshBasicMaterial({ map: result.renderTarget.texture })
+ * )
+ * scene.add(mesh)
+ * renderer.render(scene, new PerspectiveCamera())
+ *
+ * // Starting from three.js r159
+ * // `result.renderTarget.texture` can
+ * // also be used as Equirectangular scene background
+ * //
+ * // it was previously needed to convert it
+ * // to a DataTexture with `result.toDataTexture()`
+ * scene.background = result.renderTarget.texture
+ *
+ * // result must be manually disposed
+ * // when you are done using it
+ * result.dispose()
+ *
+ */
+export declare class HDRJPGLoader extends LoaderBaseWebGPU<string> {
+    /**
+     * Loads a JPEG containing gain map metadata
+     * Renders a normal SDR image if gainmap data is not found
+     *
+     * @param url Path to a JPEG file containing embedded gain map metadata
+     * @param onLoad Load complete callback, will receive the result
+     * @param onProgress Progress callback, will receive a `ProgressEvent`
+     * @param onError Error callback
+     * @returns
+     */
+    load(url: string, onLoad?: (data: QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>;
+}

node_modules/@monogrid/gainmap-js/dist/decode/webgpu/loaders/LoaderBaseWebGPU.d.ts

@@ -0,0 +1,20 @@
+import { HalfFloatType, LoadingManager, WebGPURenderer } from 'three/webgpu';
+import { type GainMapMetadata } from '../../../core/types';
+import { LoaderBaseShared } from '../../shared';
+import { QuadRenderer } from '../core/QuadRenderer';
+import { GainMapDecoderMaterial } from '../materials/GainMapDecoderMaterial';
+/**
+ * Base class for WebGPU loaders
+ * @template TUrl - The type of URL used to load resources
+ */
+export declare abstract class LoaderBaseWebGPU<TUrl = string> extends LoaderBaseShared<WebGPURenderer, QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>, GainMapDecoderMaterial, TUrl> {
+    constructor(renderer?: WebGPURenderer, manager?: LoadingManager);
+    /**
+     * @private
+     * @param quadRenderer
+     * @param metadata
+     * @param sdrBuffer
+     * @param gainMapBuffer
+     */
+    protected render(quadRenderer: QuadRenderer<typeof HalfFloatType, GainMapDecoderMaterial>, metadata: GainMapMetadata, sdrBuffer: ArrayBuffer, gainMapBuffer?: ArrayBuffer): Promise<void>;
+}

node_modules/@monogrid/gainmap-js/dist/decode/webgpu/materials/GainMapDecoderMaterial.d.ts

@@ -0,0 +1,78 @@
+import { MeshBasicNodeMaterial, Texture } from 'three/webgpu';
+import { GainMapMetadata } from '../../../core/types';
+import { type GainmapDecodingParameters } from '../../shared';
+/**
+ * A Material which is able to decode the Gainmap into a full HDR Representation using TSL (Three.js Shading Language)
+ *
+ * @category Materials
+ * @group Materials
+ */
+export declare class GainMapDecoderMaterial extends MeshBasicNodeMaterial {
+    private _maxDisplayBoost;
+    private _hdrCapacityMin;
+    private _hdrCapacityMax;
+    private _gammaUniform;
+    private _offsetHdrUniform;
+    private _offsetSdrUniform;
+    private _gainMapMinUniform;
+    private _gainMapMaxUniform;
+    private _weightFactorUniform;
+    private _sdrTexture;
+    private _gainMapTexture;
+    /**
+     *
+     * @param params
+     */
+    constructor({ gamma, offsetHdr, offsetSdr, gainMapMin, gainMapMax, maxDisplayBoost, hdrCapacityMin, hdrCapacityMax, sdr, gainMap }: GainMapMetadata & GainmapDecodingParameters & {
+        sdr: Texture;
+        gainMap: Texture;
+    });
+    get sdr(): Texture;
+    set sdr(value: Texture);
+    get gainMap(): Texture;
+    set gainMap(value: Texture);
+    /**
+     * @see {@link GainMapMetadata.offsetHdr}
+     */
+    get offsetHdr(): [number, number, number];
+    set offsetHdr(value: [number, number, number]);
+    /**
+     * @see {@link GainMapMetadata.offsetSdr}
+     */
+    get offsetSdr(): [number, number, number];
+    set offsetSdr(value: [number, number, number]);
+    /**
+     * @see {@link GainMapMetadata.gainMapMin}
+     */
+    get gainMapMin(): [number, number, number];
+    set gainMapMin(value: [number, number, number]);
+    /**
+     * @see {@link GainMapMetadata.gainMapMax}
+     */
+    get gainMapMax(): [number, number, number];
+    set gainMapMax(value: [number, number, number]);
+    /**
+     * @see {@link GainMapMetadata.gamma}
+     */
+    get gamma(): [number, number, number];
+    set gamma(value: [number, number, number]);
+    /**
+     * @see {@link GainMapMetadata.hdrCapacityMin}
+     * @remarks Logarithmic space
+     */
+    get hdrCapacityMin(): number;
+    set hdrCapacityMin(value: number);
+    /**
+     * @see {@link GainMapMetadata.hdrCapacityMax}
+     * @remarks Logarithmic space
+     */
+    get hdrCapacityMax(): number;
+    set hdrCapacityMax(value: number);
+    /**
+     * @see {@link GainmapDecodingParameters.maxDisplayBoost}
+     * @remarks Non Logarithmic space
+     */
+    get maxDisplayBoost(): number;
+    set maxDisplayBoost(value: number);
+    private calculateWeight;
+}