react-native-shine 0.7.0 → 0.8.0

package/lib/typescript/src/enums/effectPresets.d.ts

@@ -1,14 +1,293 @@
+import { precomputeColorMaskBindGroupLayout, type ColorMaskArraySchema } from './../shaders/bindGroupLayouts';
+import { type DeepPartial, type ExtractEffectOptions, type UnwrapLayout } from '../types/types';
+import type { StorageFlag, TgpuBindGroup, TgpuBuffer, TgpuComputeFn, TgpuRoot, TgpuTexture, UniformFlag, ValidateUniformSchema } from 'typegpu';
+export declare const blend: GPUBlendState;
 export declare const Effects: {
-    readonly REVERSE_HOLO: {
-        readonly name: "reverseHolo";
-        readonly options: {
+    readonly glare: import("../types/types").EffectDefinition<readonly [{
+        readonly schema: import("typegpu/data").WgslStruct<{
+            glareColor: import("typegpu/data").WgslStruct<{
+                hueShiftAngleMax: import("typegpu/data").F32;
+                hueShiftAngleMin: import("typegpu/data").F32;
+                hueBlendPower: import("typegpu/data").F32;
+            }>;
+            glowPower: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+            lightIntensity: import("typegpu/data").F32;
+            glareIntensity: import("typegpu/data").F32;
+        }>;
+        readonly defaultOptions: {
+            readonly glowPower: 0.5;
+            readonly glareIntensity: 0.4;
+            readonly lightIntensity: 1.1;
+            readonly glareColor: {
+                readonly hueBlendPower: 1;
+                readonly hueShiftAngleMin: -30;
+                readonly hueShiftAngleMax: 30;
+            };
+        };
+    }]> & {
+        buffers: readonly [{
+            schema: import("typegpu/data").WgslStruct<{
+                glareColor: import("typegpu/data").WgslStruct<{
+                    hueShiftAngleMax: import("typegpu/data").F32;
+                    hueShiftAngleMin: import("typegpu/data").F32;
+                    hueBlendPower: import("typegpu/data").F32;
+                }>;
+                glowPower: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+                lightIntensity: import("typegpu/data").F32;
+                glareIntensity: import("typegpu/data").F32;
+            }>;
+            defaultOptions: {
+                glareColor: {
+                    hueShiftAngleMax: number;
+                    hueShiftAngleMin: number;
+                    hueBlendPower: number;
+                };
+                glowPower: number;
+                lightIntensity: number;
+                glareIntensity: number;
+            };
+        }];
+    };
+    readonly reverseHolo: import("../types/types").EffectDefinition<readonly [{
+        readonly schema: import("typegpu/data").WgslStruct<{
+            glareColor: import("typegpu/data").WgslStruct<{
+                hueShiftAngleMax: import("typegpu/data").F32;
+                hueShiftAngleMin: import("typegpu/data").F32;
+                hueBlendPower: import("typegpu/data").F32;
+            }>;
+            glowPower: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+            lightIntensity: import("typegpu/data").F32;
+            glareIntensity: import("typegpu/data").F32;
+        }>;
+        readonly defaultOptions: {
+            readonly glowPower: 0.5;
+            readonly glareIntensity: 0.4;
+            readonly lightIntensity: 1.1;
+            readonly glareColor: {
+                readonly hueBlendPower: 1;
+                readonly hueShiftAngleMin: -30;
+                readonly hueShiftAngleMax: 30;
+            };
+        };
+    }, {
+        readonly schema: import("typegpu/data").WgslStruct<{
+            redChannel: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+            greenChannel: import("typegpu/data").F32;
+            blueChannel: import("typegpu/data").F32;
+            hue: import("typegpu/data").F32;
+            saturation: import("typegpu/data").F32;
+            value: import("typegpu/data").F32;
+        }>;
+        readonly defaultOptions: {
             readonly redChannel: 1;
             readonly greenChannel: 0;
             readonly blueChannel: 0;
+            readonly hue: 0;
+            readonly saturation: 0;
+            readonly value: 0;
+        };
+    }]> & {
+        buffers: readonly [{
+            schema: import("typegpu/data").WgslStruct<{
+                glareColor: import("typegpu/data").WgslStruct<{
+                    hueShiftAngleMax: import("typegpu/data").F32;
+                    hueShiftAngleMin: import("typegpu/data").F32;
+                    hueBlendPower: import("typegpu/data").F32;
+                }>;
+                glowPower: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+                lightIntensity: import("typegpu/data").F32;
+                glareIntensity: import("typegpu/data").F32;
+            }>;
+            defaultOptions: {
+                glareColor: {
+                    hueShiftAngleMax: number;
+                    hueShiftAngleMin: number;
+                    hueBlendPower: number;
+                };
+                glowPower: number;
+                lightIntensity: number;
+                glareIntensity: number;
+            };
+        }, {
+            schema: import("typegpu/data").WgslStruct<{
+                redChannel: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+                greenChannel: import("typegpu/data").F32;
+                blueChannel: import("typegpu/data").F32;
+                hue: import("typegpu/data").F32;
+                saturation: import("typegpu/data").F32;
+                value: import("typegpu/data").F32;
+            }>;
+            defaultOptions: {
+                redChannel: number;
+                greenChannel: number;
+                blueChannel: number;
+                hue: number;
+                saturation: number;
+                value: number;
+            };
+        }];
+    };
+    readonly holo: import("../types/types").EffectDefinition<readonly [{
+        readonly schema: import("typegpu/data").WgslStruct<{
+            directionDegree: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+            shift: import("typegpu/data").F32;
+            rotationShiftPower: import("typegpu/data").F32;
+            holoSize: import("typegpu/data").F32;
+            holoMultiplier: import("typegpu/data").F32;
+            holoEaseSize: import("typegpu/data").F32;
+            holoVisibility: import("typegpu/data").F32;
+            holoSaturation: import("typegpu/data").F32;
+        }>;
+        readonly defaultOptions: {
+            readonly directionDegree: 45;
+            readonly shift: 0.1;
+            readonly rotationShiftPower: 0.6;
+            readonly holoSize: 0.12;
+            readonly holoMultiplier: 2.5;
+            readonly holoEaseSize: 0.2;
+            readonly holoVisibility: 0.88;
+            readonly holoSaturation: 0.5;
         };
+    }]> & {
+        buffers: readonly [{
+            schema: import("typegpu/data").WgslStruct<{
+                directionDegree: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+                shift: import("typegpu/data").F32;
+                rotationShiftPower: import("typegpu/data").F32;
+                holoSize: import("typegpu/data").F32;
+                holoMultiplier: import("typegpu/data").F32;
+                holoEaseSize: import("typegpu/data").F32;
+                holoVisibility: import("typegpu/data").F32;
+                holoSaturation: import("typegpu/data").F32;
+            }>;
+            defaultOptions: {
+                directionDegree: number;
+                shift: number;
+                rotationShiftPower: number;
+                holoSize: number;
+                holoMultiplier: number;
+                holoEaseSize: number;
+                holoVisibility: number;
+                holoSaturation: number;
+            };
+        }];
     };
-    readonly HOLO: {
-        readonly name: "holo";
+    readonly doubleHolo: {
+        fragment: import("typegpu").TgpuFragmentFn<{
+            uv: import("typegpu/data").Vec2f;
+        }, import("typegpu/data").Vec4f>;
+        buffers: readonly [{
+            readonly schema: import("typegpu/data").WgslStruct<{
+                directionDegree: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+                shift: import("typegpu/data").F32;
+                rotationShiftPower: import("typegpu/data").F32;
+                holoSize: import("typegpu/data").F32;
+                holoMultiplier: import("typegpu/data").F32;
+                holoEaseSize: import("typegpu/data").F32;
+                holoVisibility: import("typegpu/data").F32;
+                holoSaturation: import("typegpu/data").F32;
+            }>;
+            readonly defaultOptions: {
+                readonly directionDegree: 45;
+                readonly shift: 0.1;
+                readonly rotationShiftPower: 0.6;
+                readonly holoSize: 0.12;
+                readonly holoMultiplier: 2.5;
+                readonly holoEaseSize: 0.2;
+                readonly holoVisibility: 0.88;
+                readonly holoSaturation: 0.5;
+            };
+        }] & readonly [{
+            schema: import("typegpu/data").WgslStruct<{
+                directionDegree: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+                shift: import("typegpu/data").F32;
+                rotationShiftPower: import("typegpu/data").F32;
+                holoSize: import("typegpu/data").F32;
+                holoMultiplier: import("typegpu/data").F32;
+                holoEaseSize: import("typegpu/data").F32;
+                holoVisibility: import("typegpu/data").F32;
+                holoSaturation: import("typegpu/data").F32;
+            }>;
+            defaultOptions: {
+                directionDegree: number;
+                shift: number;
+                rotationShiftPower: number;
+                holoSize: number;
+                holoMultiplier: number;
+                holoEaseSize: number;
+                holoVisibility: number;
+                holoSaturation: number;
+            };
+        }];
+        bindGroupCreator: (argument: import("../types/types").BindGroupCreatorArgument, buffers: readonly [TgpuBuffer<import("typegpu/data").WgslStruct<{
+            directionDegree: import("typegpu/data").Decorated<import("typegpu/data").F32, [import("typegpu/data").Align<16>]>;
+            shift: import("typegpu/data").F32;
+            rotationShiftPower: import("typegpu/data").F32;
+            holoSize: import("typegpu/data").F32;
+            holoMultiplier: import("typegpu/data").F32;
+            holoEaseSize: import("typegpu/data").F32;
+            holoVisibility: import("typegpu/data").F32;
+            holoSaturation: import("typegpu/data").F32;
+        }>> & UniformFlag]) => TgpuBindGroup[];
+        blend?: GPUBlendState;
+    };
+    readonly glareFlare: import("../types/types").EffectDefinition<readonly [{
+        readonly schema: import("typegpu/data").WgslStruct<{
+            flareIntensity: import("typegpu/data").F32;
+            spotIntensity: import("typegpu/data").F32;
+            ringIntensity: import("typegpu/data").F32;
+            rayIntensity: import("typegpu/data").F32;
+            falloff: import("typegpu/data").F32;
+            rayCount: import("typegpu/data").F32;
+        }>;
+        readonly defaultOptions: {
+            flareIntensity: number;
+            spotIntensity: number;
+            ringIntensity: number;
+            rayIntensity: number;
+            falloff: number;
+            rayCount: number;
+        };
+    }]> & {
+        buffers: readonly [{
+            schema: import("typegpu/data").WgslStruct<{
+                flareIntensity: import("typegpu/data").F32;
+                spotIntensity: import("typegpu/data").F32;
+                ringIntensity: import("typegpu/data").F32;
+                rayIntensity: import("typegpu/data").F32;
+                falloff: import("typegpu/data").F32;
+                rayCount: import("typegpu/data").F32;
+            }>;
+            defaultOptions: {
+                flareIntensity: number;
+                spotIntensity: number;
+                ringIntensity: number;
+                rayIntensity: number;
+                falloff: number;
+                rayCount: number;
+            };
+        }];
+    };
+};
+export type Effect = {
+    [K in keyof typeof Effects]: {
+        name: K;
+        options?: DeepPartial<ExtractEffectOptions<(typeof Effects)[K]>>;
     };
+}[keyof typeof Effects];
+export type ComputePipelineInput = {
+    compute: TgpuComputeFn;
+    buffers: {
+        schema: ValidateUniformSchema<any>;
+        defaultOptions: any;
+    }[];
+    storageTexture: TgpuTexture<{
+        format: 'rgba8unorm';
+        size: readonly number[];
+    }> & StorageFlag;
+    bindGroupCreator: (root: TgpuRoot, storageTexture: TgpuTexture<{
+        format: 'rgba8unorm';
+        size: readonly number[];
+    }> & StorageFlag, colorMaskBuffer: TgpuBuffer<ColorMaskArraySchema> & UniformFlag) => TgpuBindGroup<UnwrapLayout<typeof precomputeColorMaskBindGroupLayout>>;
 };
 //# sourceMappingURL=effectPresets.d.ts.map

package/lib/typescript/src/enums/effectPresets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"effectPresets.d.ts","sourceRoot":"","sources":["../../../../src/enums/effectPresets.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;CAQuB,CAAC"}
+{"version":3,"file":"effectPresets.d.ts","sourceRoot":"","sources":["../../../../src/enums/effectPresets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kCAAkC,EAClC,KAAK,oBAAoB,EAC1B,MAAM,+BAA+B,CAAC;AAavC,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAQxB,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,UAAU,EACV,aAAa,EACb,QAAQ,EACR,WAAW,EACX,WAAW,EACX,qBAAqB,EACtB,MAAM,SAAS,CAAC;AASjB,eAAO,MAAM,KAAK,EAAE,aAWnB,CAAC;AAmDF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMV,CAAC;AAEX,MAAM,MAAM,MAAM,GAAG;KAClB,CAAC,IAAI,MAAM,OAAO,OAAO,GAAG;QAC3B,IAAI,EAAE,CAAC,CAAC;QACR,OAAO,CAAC,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAClE;CACF,CAAC,MAAM,OAAO,OAAO,CAAC,CAAC;AACxB,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE;QACP,MAAM,EAAE,qBAAqB,CAAC,GAAG,CAAC,CAAC;QACnC,cAAc,EAAE,GAAG,CAAC;KACrB,EAAE,CAAC;IACJ,cAAc,EAAE,WAAW,CAAC;QAC1B,MAAM,EAAE,YAAY,CAAC;QACrB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;KACzB,CAAC,GACA,WAAW,CAAC;IACd,gBAAgB,EAAE,CAChB,IAAI,EAAE,QAAQ,EACd,cAAc,EAAE,WAAW,CAAC;QAC1B,MAAM,EAAE,YAAY,CAAC;QACrB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;KACzB,CAAC,GACA,WAAW,EACb,eAAe,EAAE,UAAU,CAAC,oBAAoB,CAAC,GAAG,WAAW,KAC5D,aAAa,CAAC,YAAY,CAAC,OAAO,kCAAkC,CAAC,CAAC,CAAC;CAC7E,CAAC"}

package/lib/typescript/src/shaders/bindGroupLayouts.d.ts

@@ -1,11 +1,15 @@
 import * as d from 'typegpu/data';
-export declare const textureBindGroupLayout: import("typegpu").TgpuBindGroupLayout<{
+export declare const rotationSchema: d.Vec3f;
+export declare const sharedBindGroupLayout: import("typegpu").TgpuBindGroupLayout<{
     texture: {
         texture: d.WgslTexture2d<d.F32>;
     };
     sampler: {
         sampler: "filtering";
     };
+    rot: {
+        uniform: d.Vec3f;
+    };
 }>;
 export declare const maskTextureBindGroupLayout: import("typegpu").TgpuBindGroupLayout<{
     texture: {
@@ -15,11 +19,6 @@ export declare const maskTextureBindGroupLayout: import("typegpu").TgpuBindGroup
         sampler: "filtering";
     };
 }>;
-export declare const rotationBindGroupLayout: import("typegpu").TgpuBindGroupLayout<{
-    vec: {
-        uniform: d.Vec3f;
-    };
-}>;
 export declare const glareSchema: d.WgslStruct<{
     glareColor: d.WgslStruct<{
         hueShiftAngleMax: d.F32;
@@ -51,19 +50,15 @@ export declare const colorMaskSchema: d.WgslStruct<{
         upper: d.Vec3f;
         lower: d.Vec3f;
     }>;
-    hueToleranceRange: d.WgslStruct<{
-        upper: d.F32;
-        lower: d.F32;
-    }>;
+    hueStart: d.F32;
+    hueRange: d.F32;
     useHSV: d.Decorated<d.U32, [d.Align<16>]>;
-    brightnessTolerance: d.F32;
-    saturationTolerance: d.F32;
-    lowSaturationThreshold: d.F32;
-    lowBrightnessThreshold: d.F32;
+    minLimits: d.Vec2f;
+    maxLimits: d.Vec2f;
     debugMode: d.U32;
 }>;
-export type ColorMaskSchema = typeof colorMaskSchema;
-export declare const COLOR_MASK_MAX_COUNT = 16;
+export type ColorMaskSchema = d.Infer<typeof colorMaskSchema>;
+export declare const COLOR_MASK_MAX_COUNT = 8;
 export declare const colorMaskArraySchema: d.WgslStruct<{
     masks: d.WgslArray<d.WgslStruct<{
         baseColor: d.Vec3f;
@@ -71,15 +66,11 @@ export declare const colorMaskArraySchema: d.WgslStruct<{
             upper: d.Vec3f;
             lower: d.Vec3f;
         }>;
-        hueToleranceRange: d.WgslStruct<{
-            upper: d.F32;
-            lower: d.F32;
-        }>;
+        hueStart: d.F32;
+        hueRange: d.F32;
         useHSV: d.Decorated<d.U32, [d.Align<16>]>;
-        brightnessTolerance: d.F32;
-        saturationTolerance: d.F32;
-        lowSaturationThreshold: d.F32;
-        lowBrightnessThreshold: d.F32;
+        minLimits: d.Vec2f;
+        maxLimits: d.Vec2f;
         debugMode: d.U32;
     }>>;
     usedMaskCount: d.I32;
@@ -95,15 +86,11 @@ export declare const colorMaskBindGroupLayout: import("typegpu").TgpuBindGroupLa
                     upper: d.Vec3f;
                     lower: d.Vec3f;
                 }>;
-                hueToleranceRange: d.WgslStruct<{
-                    upper: d.F32;
-                    lower: d.F32;
-                }>;
+                hueStart: d.F32;
+                hueRange: d.F32;
                 useHSV: d.Decorated<d.U32, [d.Align<16>]>;
-                brightnessTolerance: d.F32;
-                saturationTolerance: d.F32;
-                lowSaturationThreshold: d.F32;
-                lowBrightnessThreshold: d.F32;
+                minLimits: d.Vec2f;
+                maxLimits: d.Vec2f;
                 debugMode: d.U32;
             }>>;
             usedMaskCount: d.I32;
@@ -144,7 +131,65 @@ export declare const reverseHoloDetectionChannelFlagsBindGroupLayout: import("ty
         }>;
     };
 }>;
-export type BufferSchemas = ReverseHoloDetectionChannelFlagsSchema | ColorMaskSchema | GlareSchema;
+export declare const holoSchema: d.WgslStruct<{
+    directionDegree: d.Decorated<d.F32, [d.Align<16>]>;
+    shift: d.F32;
+    rotationShiftPower: d.F32;
+    holoSize: d.F32;
+    holoMultiplier: d.F32;
+    holoEaseSize: d.F32;
+    holoVisibility: d.F32;
+    holoSaturation: d.F32;
+}>;
+export type HoloSchema = typeof holoSchema;
+export declare const holoBindGroupLayout: import("typegpu").TgpuBindGroupLayout<{
+    holoOptions: {
+        uniform: d.WgslStruct<{
+            directionDegree: d.Decorated<d.F32, [d.Align<16>]>;
+            shift: d.F32;
+            rotationShiftPower: d.F32;
+            holoSize: d.F32;
+            holoMultiplier: d.F32;
+            holoEaseSize: d.F32;
+            holoVisibility: d.F32;
+            holoSaturation: d.F32;
+        }>;
+    };
+}>;
+export declare const glareFlareSchema: d.WgslStruct<{
+    flareIntensity: d.F32;
+    spotIntensity: d.F32;
+    ringIntensity: d.F32;
+    rayIntensity: d.F32;
+    falloff: d.F32;
+    rayCount: d.F32;
+}>;
+export type glareFlareSchema = typeof glareFlareSchema;
+export declare const glareFlareBindGroupLayout: import("typegpu").TgpuBindGroupLayout<{
+    glareFlare: {
+        uniform: d.WgslStruct<{
+            flareIntensity: d.F32;
+            spotIntensity: d.F32;
+            ringIntensity: d.F32;
+            rayIntensity: d.F32;
+            falloff: d.F32;
+            rayCount: d.F32;
+        }>;
+    };
+}>;
+export declare const precomputeTextureSchema: d.WgslStorageTexture2d<"rgba8unorm", "read-write">;
+export type PrecomputeTextureSchema = typeof precomputeTextureSchema;
+export declare const precomputeColorMaskBindGroupLayout: import("typegpu").TgpuBindGroupLayout<{
+    colorMaskStorage: {
+        storageTexture: d.WgslStorageTexture2d<"rgba8unorm", "read-write">;
+    };
+}>;
+export declare const precomputeColorMaskOutputBindGroupLayout: import("typegpu").TgpuBindGroupLayout<{
+    colorMaskOutput: {
+        texture: d.WgslTexture2d<d.F32>;
+    };
+}>;
+export type BufferSchemas = d.Vec3f | ReverseHoloDetectionChannelFlagsSchema | ColorMaskArraySchema | GlareSchema;
 export declare const bufferData: {
     readonly rotation: {
         readonly schema: d.Vec3f;
@@ -171,15 +216,11 @@ export declare const bufferData: {
                     upper: d.Vec3f;
                     lower: d.Vec3f;
                 }>;
-                hueToleranceRange: d.WgslStruct<{
-                    upper: d.F32;
-                    lower: d.F32;
-                }>;
+                hueStart: d.F32;
+                hueRange: d.F32;
                 useHSV: d.Decorated<d.U32, [d.Align<16>]>;
-                brightnessTolerance: d.F32;
-                saturationTolerance: d.F32;
-                lowSaturationThreshold: d.F32;
-                lowBrightnessThreshold: d.F32;
+                minLimits: d.Vec2f;
+                maxLimits: d.Vec2f;
                 debugMode: d.U32;
             }>>;
             usedMaskCount: d.I32;

package/lib/typescript/src/shaders/bindGroupLayouts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bindGroupLayouts.d.ts","sourceRoot":"","sources":["../../../../src/shaders/bindGroupLayouts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,sBAAsB;;;;;;;EAGjC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;EAGrC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;EAElC,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;EAStB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC;AAE7C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;EAE/B,CAAC;AAGH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;EAgB1B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;AAErD,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;EAI/B,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC;AAE/D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;EAEnC,CAAC;AAEH,eAAO,MAAM,sCAAsC;;;;;;;EAOjD,CAAC;AAEH,MAAM,MAAM,sCAAsC,GAChD,OAAO,sCAAsC,CAAC;AAEhD,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;EAIxD,CAAC;AAEL,MAAM,MAAM,aAAa,GACrB,sCAAsC,GACtC,eAAe,GACf,WAAW,CAAC;AAEhB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC"}
+{"version":3,"file":"bindGroupLayouts.d.ts","sourceRoot":"","sources":["../../../../src/shaders/bindGroupLayouts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,cAAc,SAAU,CAAC;AAEtC,eAAO,MAAM,qBAAqB;;;;;;;;;;EAIhC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;EAGrC,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;EAStB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC;AAE7C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;EAE/B,CAAC;AAGH,eAAO,MAAM,eAAe;;;;;;;;;;;;EAY1B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;EAI/B,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC;AAE/D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;EAEnC,CAAC;AAEH,eAAO,MAAM,sCAAsC;;;;;;;EAOjD,CAAC;AAEH,MAAM,MAAM,sCAAsC,GAChD,OAAO,sCAAsC,CAAC;AAEhD,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;EAIxD,CAAC;AAEL,eAAO,MAAM,UAAU;;;;;;;;;EASrB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC;AAE3C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;EAE9B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;EAO3B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AAEvD,eAAO,MAAM,yBAAyB;;;;;;;;;;;EAEpC,CAAC;AAEH,eAAO,MAAM,uBAAuB,oDAGnC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC;AAErE,eAAO,MAAM,kCAAkC;;;;EAI7C,CAAC;AAEH,eAAO,MAAM,wCAAwC;;;;EAInD,CAAC;AAEH,MAAM,MAAM,aAAa,GACrB,CAAC,CAAC,KAAK,GACP,sCAAsC,GACtC,oBAAoB,GACpB,WAAW,CAAC;AAEhB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC"}