@takram/three-geospatial 0.0.1-alpha.7 → 0.0.1-alpha.8

package/src/shaders/index.ts

@@ -1,19 +1,21 @@
 import _cascadedShadowMaps from './cascadedShadowMaps.glsl?raw'
 import _depth from './depth.glsl?raw'
 import _generators from './generators.glsl?raw'
+import _interleavedGradientNoise from './interleavedGradientNoise.glsl?raw'
 import _math from './math.glsl?raw'
 import _packing from './packing.glsl?raw'
-import _poissonDisk from './poissonDisk.glsl?raw'
 import _raySphereIntersection from './raySphereIntersection.glsl?raw'
 import _transform from './transform.glsl?raw'
 import _turbo from './turbo.glsl?raw'
+import _vogelDisk from './vogelDisk.glsl?raw'
 
 export const cascadedShadowMaps: string = _cascadedShadowMaps
 export const depth: string = _depth
 export const generators: string = _generators
+export const interleavedGradientNoise = _interleavedGradientNoise
 export const math: string = _math
 export const packing: string = _packing
-export const poissonDisk: string = _poissonDisk
 export const raySphereIntersection: string = _raySphereIntersection
 export const transform: string = _transform
 export const turbo: string = _turbo
+export const vogelDisk = _vogelDisk

package/src/shaders/interleavedGradientNoise.glsl

@@ -0,0 +1,6 @@
+// Reference: https://advances.realtimerendering.com/s2014/index.html#_NEXT_GENERATION_POST
+
+float interleavedGradientNoise(const vec2 coord) {
+  const vec3 magic = vec3(0.06711056, 0.00583715, 52.9829189);
+  return fract(magic.z * fract(dot(coord, magic.xy)));
+}

package/src/shaders/vogelDisk.glsl

@@ -0,0 +1,8 @@
+// Reference: https://www.gamedev.net/tutorials/programming/graphics/contact-hardening-soft-shadows-made-fast-r4906/
+
+vec2 vogelDisk(const int index, const int sampleCount, const float phi) {
+  const float goldenAngle = 2.39996322972865332;
+  float r = sqrt(float(index) + 0.5) / sqrt(float(sampleCount));
+  float theta = float(index) * goldenAngle + phi;
+  return r * vec2(cos(theta), sin(theta));
+}

package/types/DataLoader.d.ts

@@ -7,15 +7,15 @@ import { Data3DTexture, DataTexture, Loader, TypedArray } from 'three';
 type ParameterProperties<T> = {
     [K in WritableKeysOf<T> as T[K] extends Callable ? never : K]: T[K];
 };
-export type DataTextureParameters = Omit<Partial<ParameterProperties<DataTexture>>, 'image'> & {
+export interface DataTextureParameters extends Omit<Partial<ParameterProperties<DataTexture>>, 'image'> {
     width?: number;
     height?: number;
-};
-export type Data3DTextureParameters = Omit<Partial<ParameterProperties<Data3DTexture>>, 'image'> & {
+}
+export interface Data3DTextureParameters extends Omit<Partial<ParameterProperties<Data3DTexture>>, 'image'> {
     width?: number;
     height?: number;
     depth?: number;
-};
+}
 export declare abstract class DataLoader<T extends DataTexture | Data3DTexture = DataTexture | Data3DTexture, U extends TypedArray = TypedArray> extends Loader<T> {
     abstract readonly Texture: Class<T>;
     abstract readonly TypedArrayLoader: Class<TypedArrayLoader<U>>;

package/types/bufferGeometry.d.ts

@@ -1,5 +1,6 @@
 import { BufferGeometry } from 'three';
 
-export type BufferGeometryLike = Pick<BufferGeometry, 'attributes' | 'index' | 'boundingBox' | 'boundingSphere'>;
+export interface BufferGeometryLike extends Pick<BufferGeometry, 'attributes' | 'index' | 'boundingBox' | 'boundingSphere'> {
+}
 export declare function toBufferGeometryLike(geometry: BufferGeometry): [BufferGeometryLike, ArrayBuffer[]];
 export declare function fromBufferGeometryLike(input: BufferGeometryLike, result?: BufferGeometry<import('three').NormalBufferAttributes>): BufferGeometry;

package/types/decorators.d.ts

@@ -0,0 +1,22 @@
+import { Material } from 'three';
+
+interface EffectLike {
+    defines: Map<string, string>;
+}
+export declare function define(name: string): <T extends Material | EffectLike, K extends keyof T>(target: T[K] extends boolean ? T : never, propertyKey: K) => void;
+export interface DefineIntDecoratorOptions {
+    min?: number;
+    max?: number;
+}
+export declare function defineInt(name: string, { min, max }?: DefineIntDecoratorOptions): <T extends Material | EffectLike, K extends keyof T>(target: T[K] extends number ? T : never, propertyKey: K) => void;
+export interface DefineFloatDecoratorOptions {
+    min?: number;
+    max?: number;
+    precision?: number;
+}
+export declare function defineFloat(name: string, { min, max, precision }?: DefineFloatDecoratorOptions): <T extends Material | EffectLike, K extends keyof T>(target: T[K] extends number ? T : never, propertyKey: K) => void;
+export interface DefineExpressionDecoratorOptions {
+    validate?: (value: string) => boolean;
+}
+export declare function defineExpression(name: string, { validate }?: DefineExpressionDecoratorOptions): <T extends Material | EffectLike, K extends keyof T>(target: T[K] extends string ? T : never, propertyKey: K) => void;
+export {};

package/types/index.d.ts

@@ -3,6 +3,7 @@ export * from './assertions';
 export * from './bufferGeometry';
 export * from './constants';
 export * from './DataLoader';
+export * from './decorators';
 export * from './defineShorthand';
 export * from './Ellipsoid';
 export * from './EllipsoidGeometry';

package/types/r3f/types.d.ts

@@ -16,6 +16,6 @@ export type PassThoughInstanceProps<RefType, Args extends readonly any[], Props>
     [K in NonFunctionKeys<Props> as K extends WritableNonExtendableKeysOf<Props> ? K : never]: Props[K];
 }>, NodeProps<RefType, Args>>;
 export type ExpandNestedProps<T, Prop extends keyof T & string> = {
-    [K in keyof T[Prop] as K extends string ? `${Prop}-${K}` : never]: T[Prop][K];
+    [K in keyof NonNullable<T[Prop]> as K extends string ? `${Prop}-${K}` : 'never']: NonNullable<T[Prop]>[K];
 };
 export {};

package/types/shaders/index.d.ts

@@ -1,9 +1,10 @@
 export declare const cascadedShadowMaps: string;
 export declare const depth: string;
 export declare const generators: string;
+export declare const interleavedGradientNoise: string;
 export declare const math: string;
 export declare const packing: string;
-export declare const poissonDisk: string;
 export declare const raySphereIntersection: string;
 export declare const transform: string;
 export declare const turbo: string;
+export declare const vogelDisk: string;

package/src/shaders/poissonDisk.glsl

@@ -1,23 +0,0 @@
-// TODO: Maybe switch to Vogel disk with IGN:
-// https://www.gamedev.net/tutorials/programming/graphics/contact-hardening-soft-shadows-made-fast-r4906/
-// Taken from: https://developer.download.nvidia.com/whitepapers/2008/PCSS_Integration.pdf
-const vec2 poissonDisk[16] = vec2[16](
-  vec2(-0.94201624, -0.39906216),
-  vec2(0.94558609, -0.76890725),
-  vec2(-0.094184101, -0.9293887),
-  vec2(0.34495938, 0.2938776),
-  vec2(-0.91588581, 0.45771432),
-  vec2(-0.81544232, -0.87912464),
-  vec2(-0.38277543, 0.27676845),
-  vec2(0.97484398, 0.75648379),
-  vec2(0.44323325, -0.97511554),
-  vec2(0.53742981, -0.4737342),
-  vec2(-0.26496911, -0.41893023),
-  vec2(0.79197514, 0.19090188),
-  vec2(-0.2418884, 0.99706507),
-  vec2(-0.81409955, 0.9143759),
-  vec2(0.19984126, 0.78641367),
-  vec2(0.14383161, -0.1410079)
-);
-
-#define POISSON_DISK_COUNT (16)