11081259857

Committed 28 Sep 2024 05:02AM UTC coverage: 91.632% (-0.006%) from 91.638%

Build # 11081259857

Build Type

Pull #9192

github

Committed by

web-flow

Commit Message

Merge 4ba83d00f into eac6f42d5

Pull Request Pull Request #9192: Generic module props handling in Layer class

Run Details

6738 of 7374 branches covered (91.38%)

Branch coverage included in aggregate %.

179 of 184 new or added lines in 25 files covered. (97.28%)

5 existing lines in 1 file now uncovered.

54646 of 59616 relevant lines covered (91.66%)

14721.36 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.69

/modules/core/src/shaderlib/shadow/shadow.ts

// deck.gl
// SPDX-License-Identifier: MIT
// Copyright (c) vis.gl contributors

import {COORDINATE_SYSTEM, PROJECTION_MODE} from '../../lib/constants';
import project from '../project/project';
import {Vector3, Matrix4} from '@math.gl/core';
import type {NumericArray} from '@math.gl/core';
import memoize from '../../utils/memoize';
import {pixelsToWorld} from '@math.gl/web-mercator';

import type {Texture} from '@luma.gl/core';
import {ShaderModule} from '@luma.gl/shadertools';
import type Viewport from '../../viewports/viewport';
import type {ProjectUniforms} from '../project/viewport-uniforms';

const uniformBlock = /* glsl */ `
uniform shadowUniforms {
  bool drawShadowMap;
  bool useShadowMap;
  vec4 color;
  highp int lightId;
  float lightCount;
  mat4 viewProjectionMatrix0;
  mat4 viewProjectionMatrix1;
  vec4 projectCenter0;
  vec4 projectCenter1;
} shadow;
`;

const vertex = /* glsl */ `
const int max_lights = 2;

out vec3 shadow_vPosition[max_lights];

vec4 shadow_setVertexPosition(vec4 position_commonspace) {
  mat4 viewProjectionMatrices[max_lights];
  viewProjectionMatrices[0] = shadow.viewProjectionMatrix0;
  viewProjectionMatrices[1] = shadow.viewProjectionMatrix1;
  vec4 projectCenters[max_lights];
  projectCenters[0] = shadow.projectCenter0;
  projectCenters[1] = shadow.projectCenter1;

  if (shadow.drawShadowMap) {
    return project_common_position_to_clipspace(position_commonspace, viewProjectionMatrices[shadow.lightId], projectCenters[shadow.lightId]);
  }
  if (shadow.useShadowMap) {
    for (int i = 0; i < max_lights; i++) {
      if(i < int(shadow.lightCount)) {
        vec4 shadowMap_position = project_common_position_to_clipspace(position_commonspace, viewProjectionMatrices[i], projectCenters[i]);
        shadow_vPosition[i] = (shadowMap_position.xyz / shadowMap_position.w + 1.0) / 2.0;
      }
    }
  }
  return gl_Position;
}
`;

const vs = `
${uniformBlock}
${vertex}
`;

const fragment = /* glsl */ `
const int max_lights = 2;
uniform sampler2D shadow_uShadowMap0;
uniform sampler2D shadow_uShadowMap1;

in vec3 shadow_vPosition[max_lights];

const vec4 bitPackShift = vec4(1.0, 255.0, 65025.0, 16581375.0);
const vec4 bitUnpackShift = 1.0 / bitPackShift;
const vec4 bitMask = vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0,  0.0);

float shadow_getShadowWeight(vec3 position, sampler2D shadowMap) {
  vec4 rgbaDepth = texture(shadowMap, position.xy);

  float z = dot(rgbaDepth, bitUnpackShift);
  return smoothstep(0.001, 0.01, position.z - z);
}

vec4 shadow_filterShadowColor(vec4 color) {
  if (shadow.drawShadowMap) {
    vec4 rgbaDepth = fract(gl_FragCoord.z * bitPackShift);
    rgbaDepth -= rgbaDepth.gbaa * bitMask;
    return rgbaDepth;
  }
  if (shadow.useShadowMap) {
    float shadowAlpha = 0.0;
    shadowAlpha += shadow_getShadowWeight(shadow_vPosition[0], shadow_uShadowMap0);
    if(shadow.lightCount > 1.0) {
      shadowAlpha += shadow_getShadowWeight(shadow_vPosition[1], shadow_uShadowMap1);
    }
    shadowAlpha *= shadow.color.a / shadow.lightCount;
    float blendedAlpha = shadowAlpha + color.a * (1.0 - shadowAlpha);

    return vec4(
      mix(color.rgb, shadow.color.rgb, shadowAlpha / blendedAlpha),
      blendedAlpha
    );
  }
  return color;
}
`;

const fs = `
${uniformBlock}
${fragment}
`;

const getMemoizedViewportCenterPosition = memoize(getViewportCenterPosition);
const getMemoizedViewProjectionMatrices = memoize(getViewProjectionMatrices);

const DEFAULT_SHADOW_COLOR: NumberArray4 = [0, 0, 0, 1.0];
const VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];

type ShadowModuleProps = {
  viewport: Viewport;
  shadowEnabled?: boolean;
  drawToShadowMap?: boolean;
  shadowMaps?: Texture[];
  dummyShadowMap: Texture;
  shadowColor?: NumberArray4;
  shadowMatrices?: Matrix4[];
  shadowLightId?: number;
};

type ShadowModuleUniforms = {
  drawShadowMap: boolean;
  useShadowMap: boolean;
  color?: NumberArray4;
  lightId?: number;
  lightCount?: number;
  viewProjectionMatrix0?: NumberArray16;
  viewProjectionMatrix1?: NumberArray16;
  projectCenter0?: NumberArray4;
  projectCenter1?: NumberArray4;
};

type ShadowModuleBindings = {
  shadow_uShadowMap0: Texture;
  shadow_uShadowMap1: Texture;
};

function screenToCommonSpace(xyz: number[], pixelUnprojectionMatrix: number[]): number[] {
  const [x, y, z] = xyz;
  const coord = pixelsToWorld([x, y, z], pixelUnprojectionMatrix);

  if (Number.isFinite(z)) {
    return coord;
  }
  return [coord[0], coord[1], 0];
}

function getViewportCenterPosition({
  viewport,
  center
}: {
  viewport: Viewport;
  center: NumericArray;
}): NumericArray {
  return new Matrix4(viewport.viewProjectionMatrix).invert().transform(center);
}

function getViewProjectionMatrices({
  viewport,
  shadowMatrices
}: {
  viewport: Viewport;
  shadowMatrices: Matrix4[];
}): Matrix4[] {
  const projectionMatrices: Matrix4[] = [];
  const pixelUnprojectionMatrix = viewport.pixelUnprojectionMatrix;
  const farZ = viewport.isGeospatial ? undefined : 1;
  const corners = [
    [0, 0, farZ], // top left ground
    [viewport.width, 0, farZ], // top right ground
    [0, viewport.height, farZ], // bottom left ground
    [viewport.width, viewport.height, farZ], // bottom right ground
    [0, 0, -1], // top left near
    [viewport.width, 0, -1], // top right near
    [0, viewport.height, -1], // bottom left near
    [viewport.width, viewport.height, -1] // bottom right near
  ].map(pixel =>
    // @ts-expect-error z may be undefined
    screenToCommonSpace(pixel, pixelUnprojectionMatrix)
  );

  for (const shadowMatrix of shadowMatrices) {
    const viewMatrix = shadowMatrix.clone().translate(new Vector3(viewport.center).negate());
    const positions = corners.map(corner => viewMatrix.transform(corner));
    const projectionMatrix = new Matrix4().ortho({
      left: Math.min(...positions.map(position => position[0])),
      right: Math.max(...positions.map(position => position[0])),
      bottom: Math.min(...positions.map(position => position[1])),
      top: Math.max(...positions.map(position => position[1])),
      near: Math.min(...positions.map(position => -position[2])),
      far: Math.max(...positions.map(position => -position[2]))
    });
    projectionMatrices.push(projectionMatrix.multiplyRight(shadowMatrix));
  }
  return projectionMatrices;
}

/* eslint-disable camelcase */

// eslint-disable-next-line complexity
function createShadowUniforms(
  opts: Partial<ShadowModuleProps>
): ShadowModuleBindings & ShadowModuleUniforms {
  const {shadowEnabled = true} = opts;
  if (!shadowEnabled || !opts.shadowMatrices || !opts.shadowMatrices.length) {
    return {
      drawShadowMap: false,
      useShadowMap: false,
      shadow_uShadowMap0: opts.dummyShadowMap!,
      shadow_uShadowMap1: opts.dummyShadowMap!
    };
  }
  const projectUniforms = project.getUniforms(opts) as ProjectUniforms;
  const center = getMemoizedViewportCenterPosition({
    viewport: opts.viewport!,
    center: projectUniforms.center
  });

  const projectCenters: NumericArray[] = [];
  const viewProjectionMatrices = getMemoizedViewProjectionMatrices({
    shadowMatrices: opts.shadowMatrices,
    viewport: opts.viewport!
  }).slice();

  for (let i = 0; i < opts.shadowMatrices.length; i++) {
    const viewProjectionMatrix = viewProjectionMatrices[i];
    const viewProjectionMatrixCentered = viewProjectionMatrix
      .clone()
      .translate(new Vector3(opts.viewport!.center).negate());

    if (
      projectUniforms.coordinateSystem === COORDINATE_SYSTEM.LNGLAT &&
      projectUniforms.projectionMode === PROJECTION_MODE.WEB_MERCATOR
    ) {
      viewProjectionMatrices[i] = viewProjectionMatrixCentered;
      projectCenters[i] = center;
    } else {
      viewProjectionMatrices[i] = viewProjectionMatrix
        .clone()
        .multiplyRight(VECTOR_TO_POINT_MATRIX);
      projectCenters[i] = viewProjectionMatrixCentered.transform(center);
    }
  }

  const uniforms: ShadowModuleUniforms & ShadowModuleBindings = {
    drawShadowMap: Boolean(opts.drawToShadowMap),
    useShadowMap: opts.shadowMaps ? opts.shadowMaps.length > 0 : false,
    color: opts.shadowColor || DEFAULT_SHADOW_COLOR,
    lightId: opts.shadowLightId || 0,
    lightCount: opts.shadowMatrices.length,
    shadow_uShadowMap0: opts.dummyShadowMap!,
    shadow_uShadowMap1: opts.dummyShadowMap!
  };

  for (let i = 0; i < viewProjectionMatrices.length; i++) {
    uniforms[`viewProjectionMatrix${i}`] = viewProjectionMatrices[i];
    uniforms[`projectCenter${i}`] = projectCenters[i];
  }

  for (let i = 0; i < 2; i++) {
    uniforms[`shadow_uShadowMap${i}`] =
      (opts.shadowMaps && opts.shadowMaps[i]) || opts.dummyShadowMap;
  }
  return uniforms;
}

export default {
  name: 'shadow',
  dependencies: [project],
  vs,
  fs,
  inject: {
    'vs:DECKGL_FILTER_GL_POSITION': `
    position = shadow_setVertexPosition(geometry.position);
    `,
    'fs:DECKGL_FILTER_COLOR': `
    color = shadow_filterShadowColor(color);
    `
  },
  getUniforms: createShadowUniforms,
  uniformTypes: {
    drawShadowMap: 'f32',
    useShadowMap: 'f32',
    color: 'vec4<f32>',
    lightId: 'i32',
    lightCount: 'f32',
    viewProjectionMatrix0: 'mat4x4<f32>',
    viewProjectionMatrix1: 'mat4x4<f32>',
    projectCenter0: 'vec4<f32>',
    projectCenter1: 'vec4<f32>'
  }
} as const satisfies ShaderModule<ShadowModuleProps, ShadowModuleUniforms, ShadowModuleBindings>;

// TODO replace with type from math.gl
type NumberArray4 = [number, number, number, number];
type NumberArray16 = [
  number,
  number,
  number,
  number,
  number,
  number,
  number,
  number,
  number,
  number,
  number,
  number,
  number,
  number,
  number,
  number
];

1	// deck.gl	1✔
2	// SPDX-License-Identifier: MIT	1✔
3	// Copyright (c) vis.gl contributors	1✔
4		1✔
5	import {COORDINATE_SYSTEM, PROJECTION_MODE} from '../../lib/constants';	1✔
6	import project from '../project/project';	1✔
7	import {Vector3, Matrix4} from '@math.gl/core';	1✔
8	import type {NumericArray} from '@math.gl/core';	1✔
9	import memoize from '../../utils/memoize';	1✔
10	import {pixelsToWorld} from '@math.gl/web-mercator';	1✔
11		1✔
12	import type {Texture} from '@luma.gl/core';	1✔
13	import {ShaderModule} from '@luma.gl/shadertools';	1✔
14	import type Viewport from '../../viewports/viewport';	1✔
15	import type {ProjectUniforms} from '../project/viewport-uniforms';	1✔
16		1✔
17	const uniformBlock = /* glsl */ `	1✔
18	uniform shadowUniforms {	1✔
19	bool drawShadowMap;	1✔
20	bool useShadowMap;	1✔
21	vec4 color;	1✔
22	highp int lightId;	1✔
23	float lightCount;	1✔
24	mat4 viewProjectionMatrix0;	1✔
25	mat4 viewProjectionMatrix1;	1✔
26	vec4 projectCenter0;	1✔
27	vec4 projectCenter1;	1✔
28	} shadow;	1✔
29	`;	1✔
30		1✔
31	const vertex = /* glsl */ `	1✔
32	const int max_lights = 2;	1✔
33		1✔
34	out vec3 shadow_vPosition[max_lights];	1✔
35		1✔
36	vec4 shadow_setVertexPosition(vec4 position_commonspace) {	1✔
37	mat4 viewProjectionMatrices[max_lights];	1✔
38	viewProjectionMatrices[0] = shadow.viewProjectionMatrix0;	1✔
39	viewProjectionMatrices[1] = shadow.viewProjectionMatrix1;	1✔
40	vec4 projectCenters[max_lights];	1✔
41	projectCenters[0] = shadow.projectCenter0;	1✔
42	projectCenters[1] = shadow.projectCenter1;	1✔
43		1✔
44	if (shadow.drawShadowMap) {	1✔
45	return project_common_position_to_clipspace(position_commonspace, viewProjectionMatrices[shadow.lightId], projectCenters[shadow.lightId]);	1✔
46	}	1✔
47	if (shadow.useShadowMap) {	1✔
48	for (int i = 0; i < max_lights; i++) {	1✔
49	if(i < int(shadow.lightCount)) {	1✔
50	vec4 shadowMap_position = project_common_position_to_clipspace(position_commonspace, viewProjectionMatrices[i], projectCenters[i]);	1✔
51	shadow_vPosition[i] = (shadowMap_position.xyz / shadowMap_position.w + 1.0) / 2.0;	1✔
52	}	1✔
53	}	1✔
54	}	1✔
55	return gl_Position;	1✔
56	}	1✔
57	`;	1✔
58		1✔
59	const vs = `	1✔
60	${uniformBlock}	1✔
61	${vertex}	1✔
62	`;	1✔
63		1✔
64	const fragment = /* glsl */ `	1✔
65	const int max_lights = 2;	1✔
66	uniform sampler2D shadow_uShadowMap0;	1✔
67	uniform sampler2D shadow_uShadowMap1;	1✔
68		1✔
69	in vec3 shadow_vPosition[max_lights];	1✔
70		1✔
71	const vec4 bitPackShift = vec4(1.0, 255.0, 65025.0, 16581375.0);	1✔
72	const vec4 bitUnpackShift = 1.0 / bitPackShift;	1✔
73	const vec4 bitMask = vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 0.0);	1✔
74		1✔
75	float shadow_getShadowWeight(vec3 position, sampler2D shadowMap) {	1✔
76	vec4 rgbaDepth = texture(shadowMap, position.xy);	1✔
77		1✔
78	float z = dot(rgbaDepth, bitUnpackShift);	1✔
79	return smoothstep(0.001, 0.01, position.z - z);	1✔
80	}	1✔
81		1✔
82	vec4 shadow_filterShadowColor(vec4 color) {	1✔
83	if (shadow.drawShadowMap) {	1✔
84	vec4 rgbaDepth = fract(gl_FragCoord.z * bitPackShift);	1✔
85	rgbaDepth -= rgbaDepth.gbaa * bitMask;	1✔
86	return rgbaDepth;	1✔
87	}	1✔
88	if (shadow.useShadowMap) {	1✔
89	float shadowAlpha = 0.0;	1✔
90	shadowAlpha += shadow_getShadowWeight(shadow_vPosition[0], shadow_uShadowMap0);	1✔
91	if(shadow.lightCount > 1.0) {	1✔
92	shadowAlpha += shadow_getShadowWeight(shadow_vPosition[1], shadow_uShadowMap1);	1✔
93	}	1✔
94	shadowAlpha *= shadow.color.a / shadow.lightCount;	1✔
95	float blendedAlpha = shadowAlpha + color.a * (1.0 - shadowAlpha);	1✔
96		1✔
97	return vec4(	1✔
98	mix(color.rgb, shadow.color.rgb, shadowAlpha / blendedAlpha),	1✔
99	blendedAlpha	1✔
100	);	1✔
101	}	1✔
102	return color;	1✔
103	}	1✔
104	`;	1✔
105		1✔
106	const fs = `	1✔
107	${uniformBlock}	1✔
108	${fragment}	1✔
109	`;	1✔
110		1✔
111	const getMemoizedViewportCenterPosition = memoize(getViewportCenterPosition);	1✔
112	const getMemoizedViewProjectionMatrices = memoize(getViewProjectionMatrices);	1✔
113		1✔
114	const DEFAULT_SHADOW_COLOR: NumberArray4 = [0, 0, 0, 1.0];	1✔
115	const VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];	1✔
116		1✔
117	type ShadowModuleProps = {	1✔
118	viewport: Viewport;	1✔
119	shadowEnabled?: boolean;	1✔
120	drawToShadowMap?: boolean;	1✔
121	shadowMaps?: Texture[];	1✔
122	dummyShadowMap: Texture;	1✔
123	shadowColor?: NumberArray4;	1✔
124	shadowMatrices?: Matrix4[];	1✔
125	shadowLightId?: number;	1✔
126	};	1✔
127		1✔
128	type ShadowModuleUniforms = {	1✔
129	drawShadowMap: boolean;	1✔
130	useShadowMap: boolean;	1✔
131	color?: NumberArray4;	1✔
132	lightId?: number;	1✔
133	lightCount?: number;	1✔
134	viewProjectionMatrix0?: NumberArray16;	1✔
135	viewProjectionMatrix1?: NumberArray16;	1✔
136	projectCenter0?: NumberArray4;	1✔
137	projectCenter1?: NumberArray4;	1✔
138	};	1✔
139		1✔
140	type ShadowModuleBindings = {	1✔
141	shadow_uShadowMap0: Texture;	1✔
142	shadow_uShadowMap1: Texture;	1✔
143	};	1✔
144		1✔
145	function screenToCommonSpace(xyz: number[], pixelUnprojectionMatrix: number[]): number[] {	32✔
146	const [x, y, z] = xyz;	32✔
147	const coord = pixelsToWorld([x, y, z], pixelUnprojectionMatrix);	32✔
148		32✔
149	if (Number.isFinite(z)) {	32✔
150	return coord;	20✔
151	}	20✔
152	return [coord[0], coord[1], 0];	12✔
153	}	12✔
154		1✔
155	function getViewportCenterPosition({	4✔
156	viewport,	4✔
157	center	4✔
158	}: {	4✔
159	viewport: Viewport;	4✔
160	center: NumericArray;	4✔
161	}): NumericArray {	4✔
162	return new Matrix4(viewport.viewProjectionMatrix).invert().transform(center);	4✔
163	}	4✔
164		1✔
165	function getViewProjectionMatrices({	4✔
166	viewport,	4✔
167	shadowMatrices	4✔
168	}: {	4✔
169	viewport: Viewport;	4✔
170	shadowMatrices: Matrix4[];	4✔
171	}): Matrix4[] {	4✔
172	const projectionMatrices: Matrix4[] = [];	4✔
173	const pixelUnprojectionMatrix = viewport.pixelUnprojectionMatrix;	4✔
174	const farZ = viewport.isGeospatial ? undefined : 1;	4✔
175	const corners = [	4✔
176	[0, 0, farZ], // top left ground	4✔
177	[viewport.width, 0, farZ], // top right ground	4✔
178	[0, viewport.height, farZ], // bottom left ground	4✔
179	[viewport.width, viewport.height, farZ], // bottom right ground	4✔
180	[0, 0, -1], // top left near	4✔
181	[viewport.width, 0, -1], // top right near	4✔
182	[0, viewport.height, -1], // bottom left near	4✔
183	[viewport.width, viewport.height, -1] // bottom right near	4✔
184	].map(pixel =>	4✔
185	// @ts-expect-error z may be undefined	32✔
186	screenToCommonSpace(pixel, pixelUnprojectionMatrix)	32✔
187	);	4✔
188		4✔
189	for (const shadowMatrix of shadowMatrices) {	4✔
190	const viewMatrix = shadowMatrix.clone().translate(new Vector3(viewport.center).negate());	4✔
191	const positions = corners.map(corner => viewMatrix.transform(corner));	4✔
192	const projectionMatrix = new Matrix4().ortho({	4✔
193	left: Math.min(...positions.map(position => position[0])),	4✔
194	right: Math.max(...positions.map(position => position[0])),	4✔
195	bottom: Math.min(...positions.map(position => position[1])),	4✔
196	top: Math.max(...positions.map(position => position[1])),	4✔
197	near: Math.min(...positions.map(position => -position[2])),	4✔
198	far: Math.max(...positions.map(position => -position[2]))	4✔
199	});	4✔
200	projectionMatrices.push(projectionMatrix.multiplyRight(shadowMatrix));	4✔
201	}	4✔
202	return projectionMatrices;	4✔
203	}	4✔
204		1✔
205	/* eslint-disable camelcase */	1✔
206		1✔
207	// eslint-disable-next-line complexity	1✔
208	function createShadowUniforms(	8✔
209	opts: Partial<ShadowModuleProps>	8✔
210	): ShadowModuleBindings & ShadowModuleUniforms {	8✔
211	const {shadowEnabled = true} = opts;	8✔
212	if (!shadowEnabled \|\| !opts.shadowMatrices \|\| !opts.shadowMatrices.length) {	8!
UNCOV 213	return {	×
UNCOV 214	drawShadowMap: false,	×
UNCOV 215	useShadowMap: false,	×
NEW 216	shadow_uShadowMap0: opts.dummyShadowMap!,	×
NEW 217	shadow_uShadowMap1: opts.dummyShadowMap!	×
UNCOV 218	};	×
UNCOV 219	}	×
220	const projectUniforms = project.getUniforms(opts) as ProjectUniforms;	8✔
221	const center = getMemoizedViewportCenterPosition({	8✔
222	viewport: opts.viewport!,	8✔
223	center: projectUniforms.center	8✔
224	});	8✔
225		8✔
226	const projectCenters: NumericArray[] = [];	8✔
227	const viewProjectionMatrices = getMemoizedViewProjectionMatrices({	8✔
228	shadowMatrices: opts.shadowMatrices,	8✔
229	viewport: opts.viewport!	8✔
230	}).slice();	8✔
231		8✔
232	for (let i = 0; i < opts.shadowMatrices.length; i++) {	8✔
233	const viewProjectionMatrix = viewProjectionMatrices[i];	8✔
234	const viewProjectionMatrixCentered = viewProjectionMatrix	8✔
235	.clone()	8✔
236	.translate(new Vector3(opts.viewport!.center).negate());	8✔
237		8✔
238	if (	8✔
239	projectUniforms.coordinateSystem === COORDINATE_SYSTEM.LNGLAT &&	8✔
240	projectUniforms.projectionMode === PROJECTION_MODE.WEB_MERCATOR	7✔
241	) {	8✔
242	viewProjectionMatrices[i] = viewProjectionMatrixCentered;	6✔
243	projectCenters[i] = center;	6✔
244	} else {	8✔
245	viewProjectionMatrices[i] = viewProjectionMatrix	2✔
246	.clone()	2✔
247	.multiplyRight(VECTOR_TO_POINT_MATRIX);	2✔
248	projectCenters[i] = viewProjectionMatrixCentered.transform(center);	2✔
249	}	2✔
250	}	8✔
251		8✔
252	const uniforms: ShadowModuleUniforms & ShadowModuleBindings = {	8✔
253	drawShadowMap: Boolean(opts.drawToShadowMap),	8✔
254	useShadowMap: opts.shadowMaps ? opts.shadowMaps.length > 0 : false,	8✔
255	color: opts.shadowColor \|\| DEFAULT_SHADOW_COLOR,	8✔
256	lightId: opts.shadowLightId \|\| 0,	8✔
257	lightCount: opts.shadowMatrices.length,	8✔
258	shadow_uShadowMap0: opts.dummyShadowMap!,	8✔
259	shadow_uShadowMap1: opts.dummyShadowMap!	8✔
260	};	8✔
261		8✔
262	for (let i = 0; i < viewProjectionMatrices.length; i++) {	8✔
263	uniforms[`viewProjectionMatrix${i}`] = viewProjectionMatrices[i];	8✔
264	uniforms[`projectCenter${i}`] = projectCenters[i];	8✔
265	}	8✔
266		8✔
267	for (let i = 0; i < 2; i++) {	8✔
268	uniforms[`shadow_uShadowMap${i}`] =	16✔
269	(opts.shadowMaps && opts.shadowMaps[i]) \|\| opts.dummyShadowMap;	16✔
270	}	16✔
271	return uniforms;	8✔
272	}	8✔
273		1✔
274	export default {	1✔
275	name: 'shadow',	1✔
276	dependencies: [project],	1✔
277	vs,	1✔
278	fs,	1✔
279	inject: {	1✔
280	'vs:DECKGL_FILTER_GL_POSITION': `	1✔
281	position = shadow_setVertexPosition(geometry.position);	1✔
282	`,	1✔
283	'fs:DECKGL_FILTER_COLOR': `	1✔
284	color = shadow_filterShadowColor(color);	1✔
285	`	1✔
286	},	1✔
287	getUniforms: createShadowUniforms,	1✔
288	uniformTypes: {	1✔
289	drawShadowMap: 'f32',	1✔
290	useShadowMap: 'f32',	1✔
291	color: 'vec4<f32>',	1✔
292	lightId: 'i32',	1✔
293	lightCount: 'f32',	1✔
294	viewProjectionMatrix0: 'mat4x4<f32>',	1✔
295	viewProjectionMatrix1: 'mat4x4<f32>',	1✔
296	projectCenter0: 'vec4<f32>',	1✔
297	projectCenter1: 'vec4<f32>'	1✔
298	}	1✔
299	} as const satisfies ShaderModule<ShadowModuleProps, ShadowModuleUniforms, ShadowModuleBindings>;	1✔
300		1✔
301	// TODO replace with type from math.gl	1✔
302	type NumberArray4 = [number, number, number, number];	1✔
303	type NumberArray16 = [	1✔
304	number,	1✔
305	number,	1✔
306	number,	1✔
307	number,	1✔
308	number,	1✔
309	number,	1✔
310	number,	1✔
311	number,	1✔
312	number,	1✔
313	number,	1✔
314	number,	1✔
315	number,	1✔
316	number,	1✔
317	number,	1✔
318	number,	1✔
319	number	1✔
320	];	1✔

visgl / deck.gl / 11081259857

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous