@tushar-br/desktop 1.0.173 → 1.0.174

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

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

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

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

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

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

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

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

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