@tushar-br/desktop 1.0.173 → 1.0.174

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/core/types.d.ts

@@ -0,0 +1,93 @@
+import { Mapping, RenderTargetOptions } from 'three';
+export type Constructor = new (...args: any[]) => any;
+/**
+ * This is the Metadata stored in an encoded Gainmap which is used
+ * to decode it and return an HDR image
+ *
+ * @category Specs
+ * @group Specs
+ */
+export type GainMapMetadata = {
+    /**
+     * This is the gamma to apply to the stored map values.
+     * @defaultValue [1, 1, 1]
+     * @remarks
+     * * Typically you can use a gamma of 1.0.
+     * * You can use a different value if your gain map has a very uneven distribution of log_recovery(x, y) values.
+     *
+     *   For example, this might apply if a gain map has a lot of detail just above SDR range (represented as small log_recovery(x, y) values),
+     *   and a very large map_max_log2 for the top end of the HDR rendition's desired brightness (represented by large log_recovery(x, y) values).
+     *   In this case, you can use a map_gamma higher than 1.0 so that recovery(x, y) can precisely encode the detail in both the low end and high end of log_recovery(x, y).
+     */
+    gamma: [number, number, number];
+    /**
+     * This is log2 of the minimum display boost value for which the map is applied at all.
+     *
+     * @remarks
+     * * This value also affects how much to apply the gain map based on the display boost.
+     * * Must be 0.0 or greater.
+     *
+     * Logarithmic space
+     */
+    hdrCapacityMin: number;
+    /**
+     * Stores the value of hdr_capacity_max. This is log2 of the maximum display boost value for which the map is applied completely.
+     *
+     * @remarks
+     * * This value also affects how much to apply the gain map based on the display boost.
+     * * Must be greater than hdrCapacityMin.
+     * * Required.
+     *
+     * Logarithmic space
+     */
+    hdrCapacityMax: number;
+    /**
+     * This is the offset to apply to the SDR pixel values during gain map generation and application
+     * @defaultValue [1/64, 1/64, 1/64]
+     */
+    offsetSdr: [number, number, number];
+    /**
+     * This is the offset to apply to the HDR pixel values during gain map generation and application.
+     * @defaultValue [1/64, 1/64, 1/64]
+     */
+    offsetHdr: [number, number, number];
+    /**
+     * This is log2 of min content boost, which is the minimum allowed ratio of
+     * the linear luminance for the target HDR rendition relative to
+     * (divided by) that of the SDR image, at a given pixel.
+     */
+    gainMapMin: [number, number, number];
+    /**
+     * This is log2 of max content boost, which is the maximum allowed ratio of
+     * the linear luminance for the Target HDR rendition relative to
+     * (divided by) that of the SDR image, at a given pixel.
+     */
+    gainMapMax: [number, number, number];
+};
+export type GainMapMetadataExtended = GainMapMetadata & {
+    version: string;
+    maxContentBoost: number;
+    minContentBoost: number;
+};
+/**
+ *
+ */
+export type QuadRendererTextureOptions = Omit<RenderTargetOptions, 'type' | 'format' | 'colorSpace' | 'encoding' | 'depthTexture' | 'stencilBuffer' | 'depthBuffer' | 'internalFormat'> & {
+    /**
+     * @defaultValue 300
+     */
+    mapping?: Mapping;
+    /**
+     * @defaultValue 1
+     */
+    anisotropy?: number;
+};
+/**
+ * Accepted image format for textures.
+ * For many operations we need a texture based on an image with width & height.
+ * It could also be a canvas, the only thing we actually need is a width and a height
+ */
+export type TextureImageFormat = {
+    width: number;
+    height: number;
+};

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/decode/index.d.ts

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

package/staging_area/desktop/car gaem/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;
+}

package/staging_area/desktop/car gaem/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;

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/decode/shared/errors/GainMapNotFoundError.d.ts

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

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/decode/shared/errors/XMPMetadataNotFoundError.d.ts

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

package/staging_area/desktop/car gaem/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;
+}>;

package/staging_area/desktop/car gaem/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';

package/staging_area/desktop/car gaem/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;

package/staging_area/desktop/car gaem/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[]>;
+}

package/staging_area/desktop/car gaem/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;

package/staging_area/desktop/car gaem/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>;

package/staging_area/desktop/car gaem/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>>>;

package/staging_area/desktop/car gaem/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';

package/staging_area/desktop/car gaem/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>;
+}

package/staging_area/desktop/car gaem/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>;
+}

package/staging_area/desktop/car gaem/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>;
+}

package/staging_area/desktop/car gaem/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;
+}