@viggle/splat-engine-three 0.1.1 → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +38 -0
- package/README.md +133 -20
- package/dist/chunks/chunk-BHNNSHJG.js +22298 -0
- package/dist/chunks/chunk-BHNNSHJG.js.map +7 -0
- package/dist/index.js +221 -3
- package/dist/types/anim/animation-conversion.d.ts +2 -2
- package/dist/types/anim/keyframe-splines.d.ts +17 -41
- package/dist/types/animation.d.ts +84 -28
- package/dist/types/armature.d.ts +280 -2
- package/dist/types/character.d.ts +120 -2
- package/dist/types/effects/index.d.ts +12 -0
- package/dist/types/effects/outlines/outline-effect.d.ts +98 -0
- package/dist/types/effects/outlines/outline-shaders.d.ts +14 -0
- package/dist/types/effects/pixelart/pixelart-effect.d.ts +152 -0
- package/dist/types/effects/pixelart/pixelart-shaders.d.ts +31 -0
- package/dist/types/effects/postfx/base-capturing-pass.d.ts +109 -0
- package/dist/types/effects/postfx/camera-frame.d.ts +103 -0
- package/dist/types/effects/postfx/frame-renderer.d.ts +32 -0
- package/dist/types/effects/postfx/frame-shaders.d.ts +19 -0
- package/dist/types/effects/postfx/mask.d.ts +44 -0
- package/dist/types/effects/postfx/postfx.d.ts +144 -0
- package/dist/types/effects/postfx/program.d.ts +74 -0
- package/dist/types/effects/postfx/uniforms.d.ts +24 -0
- package/dist/types/effects/postfx/webgl-program.d.ts +6 -0
- package/dist/types/effects/postfx/webgpu-program.d.ts +3 -0
- package/dist/types/effects/vfx/data-types.d.ts +100 -0
- package/dist/types/effects/vfx/index.d.ts +37 -0
- package/dist/types/effects/vfx/json-vfx-prefab.d.ts +94 -0
- package/dist/types/effects/vfx/layer-renderer.d.ts +118 -0
- package/dist/types/effects/vfx/layers/mesh.d.ts +124 -0
- package/dist/types/effects/vfx/layers/particle.d.ts +90 -0
- package/dist/types/effects/vfx/layers/shader.d.ts +130 -0
- package/dist/types/effects/vfx/layers/shared.d.ts +40 -0
- package/dist/types/effects/vfx/layers/sprite.d.ts +45 -0
- package/dist/types/effects/vfx/pool.d.ts +51 -0
- package/dist/types/effects/vfx/prefab.d.ts +48 -0
- package/dist/types/effects/vfx/prewarm.d.ts +17 -0
- package/dist/types/effects/vfx/stage.d.ts +115 -0
- package/dist/types/effects/vfx/webgpu-register.d.ts +2 -0
- package/dist/types/effects/webgpu-register.d.ts +2 -0
- package/dist/types/engine.d.ts +18 -0
- package/dist/types/environment.d.ts +96 -8
- package/dist/types/index.d.ts +33 -6
- package/dist/types/loader/animation/animation-glb.d.ts +4 -4
- package/dist/types/loader/character/load.d.ts +6 -1
- package/dist/types/loader/environment/lod-bundle.d.ts +123 -0
- package/dist/types/loader/environment/spz-decode.d.ts +88 -0
- package/dist/types/loader/environment/spz.d.ts +28 -0
- package/dist/types/loader/shared/asset-fetch.d.ts +11 -0
- package/dist/types/loader/shared/asset-loader.d.ts +86 -0
- package/dist/types/loader/shared/bin-cache.d.ts +41 -14
- package/dist/types/loader/shared/decode-worker.d.ts +27 -0
- package/dist/types/loader/shared/glb.d.ts +30 -0
- package/dist/types/loader/shared/inflate.d.ts +9 -0
- package/dist/types/loader/shared/pack-splats-task.d.ts +17 -0
- package/dist/types/loader/shared/sog-decode.d.ts +81 -0
- package/dist/types/loader/shared/sog.d.ts +17 -0
- package/dist/types/math.d.ts +7 -0
- package/dist/types/physics/ammo.d.ts +210 -0
- package/dist/types/physics/index.d.ts +11 -0
- package/dist/types/physics/joints.d.ts +157 -0
- package/dist/types/physics/physics-world.d.ts +193 -0
- package/dist/types/physics/rigid-body.d.ts +361 -0
- package/dist/types/presets/camera/camera-preset.d.ts +43 -0
- package/dist/types/presets/camera/third-person-camera.d.ts +63 -0
- package/dist/types/presets/character/body-shape.d.ts +109 -0
- package/dist/types/presets/character/character-reveal.d.ts +90 -0
- package/dist/types/presets/character/socket-loadout.d.ts +61 -0
- package/dist/types/presets/index.d.ts +13 -0
- package/dist/types/presets/vfx/mesh-flash.d.ts +51 -0
- package/dist/types/presets/visual/bone-overlay.d.ts +57 -0
- package/dist/types/proxy/environment-input.d.ts +30 -0
- package/dist/types/proxy/environment-source.d.ts +39 -0
- package/dist/types/proxy/proxy-debug.d.ts +106 -0
- package/dist/types/proxy/splat-source.d.ts +42 -0
- package/dist/types/proxy/voxelizer.d.ts +383 -0
- package/dist/types/relight/backend.d.ts +101 -0
- package/dist/types/relight/index.d.ts +6 -0
- package/dist/types/relight/relight-pass.d.ts +367 -0
- package/dist/types/relight/relight-placeholder.d.ts +2 -0
- package/dist/types/relight/relight-shaders.d.ts +4 -0
- package/dist/types/relight/shadow-bias.d.ts +26 -0
- package/dist/types/relight/splat-relight.d.ts +741 -0
- package/dist/types/relight/webgl-backend.d.ts +3 -0
- package/dist/types/relight/webgpu/backend.d.ts +3 -0
- package/dist/types/relight/webgpu-register.d.ts +2 -0
- package/dist/types/scene.d.ts +241 -0
- package/dist/types/skeletal/animation-player.d.ts +31 -3
- package/dist/types/skeletal/body-parts.d.ts +55 -0
- package/dist/types/skeletal/ragdoll-config.d.ts +115 -0
- package/dist/types/skeletal/ragdoll.d.ts +283 -0
- package/dist/types/skeletal/skeleton.d.ts +9 -2
- package/dist/types/splat/backend.d.ts +2 -0
- package/dist/types/splat/color-modifier.d.ts +78 -0
- package/dist/types/splat/cut-groups.d.ts +27 -0
- package/dist/types/splat/relight-binding.d.ts +39 -0
- package/dist/types/splat/reveal-bake.d.ts +43 -0
- package/dist/types/splat/reveal-look.d.ts +64 -0
- package/dist/types/splat/splat-mesh.d.ts +1 -0
- package/dist/types/splat/splat.d.ts +154 -0
- package/dist/types/splat/webgl/shaders.d.ts +5 -1
- package/dist/types/splat/webgl/splat-mesh.d.ts +4 -0
- package/dist/types/splat/webgpu/radix-sort.d.ts +3 -0
- package/dist/types/splat/webgpu/splat-mesh.d.ts +23 -0
- package/dist/types/three/splat-character.d.ts +28 -0
- package/dist/types/three/spz-loader.d.ts +35 -0
- package/dist/types/types.d.ts +6 -0
- package/dist/webgpu.js +1123 -154
- package/dist/webgpu.js.map +4 -4
- package/package.json +6 -2
- package/dist/chunks/chunk-WN5WBKM4.js +0 -8606
- package/dist/chunks/chunk-WN5WBKM4.js.map +0 -7
package/dist/webgpu.js
CHANGED
|
@@ -1,11 +1,65 @@
|
|
|
1
1
|
import {
|
|
2
|
+
ALL_BODY_PARTS,
|
|
2
3
|
Animation,
|
|
3
4
|
Armature,
|
|
5
|
+
BODYGROUP_DEFAULT,
|
|
6
|
+
BODYGROUP_DYNAMIC,
|
|
7
|
+
BODYGROUP_ENGINE_1,
|
|
8
|
+
BODYGROUP_ENGINE_2,
|
|
9
|
+
BODYGROUP_ENGINE_3,
|
|
10
|
+
BODYGROUP_KINEMATIC,
|
|
11
|
+
BODYGROUP_NONE,
|
|
12
|
+
BODYGROUP_STATIC,
|
|
13
|
+
BODYGROUP_TRIGGER,
|
|
14
|
+
BODYGROUP_USER_1,
|
|
15
|
+
BODYGROUP_USER_2,
|
|
16
|
+
BODYGROUP_USER_3,
|
|
17
|
+
BODYGROUP_USER_4,
|
|
18
|
+
BODYGROUP_USER_5,
|
|
19
|
+
BODYGROUP_USER_6,
|
|
20
|
+
BODYGROUP_USER_7,
|
|
21
|
+
BODYGROUP_USER_8,
|
|
22
|
+
BODYMASK_ALL,
|
|
23
|
+
BODYMASK_NONE,
|
|
24
|
+
BODYMASK_NOT_STATIC,
|
|
25
|
+
BODYMASK_NOT_STATIC_KINEMATIC,
|
|
26
|
+
BODYMASK_STATIC,
|
|
27
|
+
BODY_PART_SLUGS,
|
|
28
|
+
BaseCapturingPass,
|
|
29
|
+
BodyPart,
|
|
30
|
+
BodyShapeVariant,
|
|
31
|
+
BoneOverlay,
|
|
32
|
+
CameraFrame,
|
|
4
33
|
Character,
|
|
5
34
|
CharacterBundleError,
|
|
35
|
+
DEFAULT_ENV_REVEAL_LOOK,
|
|
36
|
+
DEFAULT_HUMANOID_RAGDOLL,
|
|
37
|
+
DEFAULT_REVEAL_LOOK,
|
|
38
|
+
DEFAULT_REVEAL_PRESET,
|
|
39
|
+
DEFAULT_SHADER_FRAGMENT,
|
|
40
|
+
DEFAULT_SHADER_FRAGMENT_WGSL,
|
|
41
|
+
ENVIRONMENT_DEFAULT_LOD,
|
|
42
|
+
ENVIRONMENT_PROXY_DEFAULTS,
|
|
6
43
|
EngineDisposedError,
|
|
7
44
|
Environment,
|
|
45
|
+
JsonVfxInstance,
|
|
46
|
+
JsonVfxPrefab,
|
|
47
|
+
LOWER_BODY_BONE_NAMES,
|
|
48
|
+
MeshFlash,
|
|
49
|
+
MeshLayerRenderer,
|
|
50
|
+
NUM_BODY_PARTS,
|
|
51
|
+
OutlineEffect,
|
|
52
|
+
ParticleLayerRenderer,
|
|
53
|
+
PhysicsWorld,
|
|
54
|
+
PixelartEffect,
|
|
8
55
|
PointLight,
|
|
56
|
+
Pose,
|
|
57
|
+
PostFX,
|
|
58
|
+
Ragdoll,
|
|
59
|
+
RigidBody,
|
|
60
|
+
Scene,
|
|
61
|
+
SceneDestroyedError,
|
|
62
|
+
ShaderLayerRenderer,
|
|
9
63
|
SkyLight,
|
|
10
64
|
Splat,
|
|
11
65
|
SplatCharacter,
|
|
@@ -14,25 +68,509 @@ import {
|
|
|
14
68
|
SplatMesh,
|
|
15
69
|
SplatPLYLoader,
|
|
16
70
|
SplatQuality,
|
|
71
|
+
SplatRelight,
|
|
72
|
+
SplatSPZLoader,
|
|
73
|
+
SpriteLayerRenderer,
|
|
17
74
|
SunLight,
|
|
75
|
+
TONEMAP_ACES,
|
|
76
|
+
TONEMAP_ACES2,
|
|
77
|
+
TONEMAP_FILMIC,
|
|
78
|
+
TONEMAP_HEJL,
|
|
79
|
+
TONEMAP_LINEAR,
|
|
80
|
+
TONEMAP_NEUTRAL,
|
|
81
|
+
TONEMAP_NONE,
|
|
82
|
+
ThirdPersonCamera,
|
|
83
|
+
UPPER_BODY_BONE_NAMES,
|
|
18
84
|
VSplatLoader,
|
|
85
|
+
VfxLayerRegistry,
|
|
86
|
+
VfxPool,
|
|
87
|
+
VfxStage,
|
|
19
88
|
WebGLSplatBackend,
|
|
89
|
+
alphaFromLogits,
|
|
90
|
+
assignUniform,
|
|
20
91
|
beginFrameTimings,
|
|
92
|
+
bodyPartLabel,
|
|
93
|
+
buildBoneToGroup,
|
|
94
|
+
buildProxyMesh,
|
|
95
|
+
buildStretch,
|
|
96
|
+
buildVfxQuadMesh,
|
|
97
|
+
buildVfxRingMesh,
|
|
98
|
+
buildVfxSphereMesh,
|
|
99
|
+
buildVfxSpikeMesh,
|
|
100
|
+
buildVoxelGrid,
|
|
101
|
+
cachedFetch,
|
|
102
|
+
classifyBone,
|
|
103
|
+
clearAnimRootRotation,
|
|
104
|
+
computeBoneStretch,
|
|
105
|
+
createConeTwistJoint,
|
|
106
|
+
createGeneric6DofJoint,
|
|
107
|
+
createHingeJoint,
|
|
21
108
|
decodeCharacterBundle,
|
|
109
|
+
decodeSplatFile,
|
|
110
|
+
decodeSpz,
|
|
111
|
+
defaultLayerRegistry,
|
|
112
|
+
defaultProxySettings,
|
|
22
113
|
effectiveMinPixelSize,
|
|
114
|
+
extractSurface,
|
|
115
|
+
getRelightPlaceholder,
|
|
116
|
+
getVfxMesh,
|
|
117
|
+
indexAssetCache,
|
|
118
|
+
initialUniformValue,
|
|
119
|
+
installFetchInterceptor,
|
|
120
|
+
isCached,
|
|
121
|
+
isSocketRemoval,
|
|
23
122
|
loadCharacterBundle,
|
|
24
123
|
loadCharacterBundleFromBytes,
|
|
124
|
+
loadGlbFromUrl,
|
|
125
|
+
loadSplatAsset,
|
|
126
|
+
loadSplatSource,
|
|
25
127
|
makeRegionMask,
|
|
128
|
+
mergeSocketLoadout,
|
|
26
129
|
packSplats,
|
|
27
130
|
parseGaussianPly,
|
|
131
|
+
playReveal,
|
|
132
|
+
prewarmJsonVfxPrefabs,
|
|
28
133
|
pruneSplats,
|
|
29
|
-
|
|
30
|
-
|
|
134
|
+
registerPostFXWebGPUBackend,
|
|
135
|
+
registerRelightWebGPUBackend,
|
|
136
|
+
registerShaderLayerWebGPU,
|
|
137
|
+
registerWebGPUBackend,
|
|
138
|
+
registerWebGPURendererFactory,
|
|
139
|
+
resolveBoneIndices,
|
|
140
|
+
setAssetFetch,
|
|
141
|
+
setBinFetch,
|
|
142
|
+
setGlbLoader,
|
|
143
|
+
setShareSplatResources,
|
|
144
|
+
uninstallFetchInterceptor,
|
|
145
|
+
validateShaderGLSL
|
|
146
|
+
} from "./chunks/chunk-BHNNSHJG.js";
|
|
31
147
|
|
|
32
|
-
// src/
|
|
148
|
+
// src/webgpu.ts
|
|
149
|
+
import { WebGPURenderer } from "three/webgpu";
|
|
150
|
+
|
|
151
|
+
// src/effects/postfx/webgpu-program.ts
|
|
33
152
|
import * as TSL from "three/tsl";
|
|
34
|
-
import {
|
|
35
|
-
|
|
153
|
+
import {
|
|
154
|
+
AddEquation,
|
|
155
|
+
CustomBlending,
|
|
156
|
+
DataTexture,
|
|
157
|
+
LinearSRGBColorSpace,
|
|
158
|
+
NoBlending,
|
|
159
|
+
NoToneMapping,
|
|
160
|
+
NodeMaterial,
|
|
161
|
+
NormalBlending,
|
|
162
|
+
OneFactor,
|
|
163
|
+
QuadMesh,
|
|
164
|
+
Vector2
|
|
165
|
+
} from "three/webgpu";
|
|
166
|
+
var { code, screenCoordinate, texture, sampler, uniform, wgslFn } = TSL;
|
|
167
|
+
var TEXTURE_DECL = /^\s*var\s+(\w+)\s*:\s*texture_2d<f32>\s*;[^\S\n]*(?:\/\/.*)?$/gm;
|
|
168
|
+
var SAMPLER_DECL = /^\s*var\s+(\w+)\s*:\s*sampler\s*;[^\S\n]*(?:\/\/.*)?$/gm;
|
|
169
|
+
var UNIFORM_DECL = /^\s*uniform\s+(\w+)\s*:\s*(\w+)\s*;[^\S\n]*(?:\/\/.*)?$/gm;
|
|
170
|
+
var ENTRY = /(?:@fragment\s+)?fn\s+fragmentMain\s*\(\s*input\s*:\s*FragmentInput\s*\)\s*->\s*FragmentOutput\s*\{/;
|
|
171
|
+
var WGSL_TYPES = {
|
|
172
|
+
f32: "float",
|
|
173
|
+
i32: "int",
|
|
174
|
+
vec2f: "vec2",
|
|
175
|
+
vec3f: "vec3",
|
|
176
|
+
vec4f: "vec4"
|
|
177
|
+
};
|
|
178
|
+
var PARAM_TYPES = {
|
|
179
|
+
float: "f32",
|
|
180
|
+
int: "i32",
|
|
181
|
+
vec2: "vec2f",
|
|
182
|
+
vec3: "vec3f",
|
|
183
|
+
vec4: "vec4f",
|
|
184
|
+
texture: "texture_2d<f32>",
|
|
185
|
+
sampler: "sampler"
|
|
186
|
+
};
|
|
187
|
+
function adaptWGSL(name, source) {
|
|
188
|
+
const uniforms = [];
|
|
189
|
+
let body = source.replace(TEXTURE_DECL, (_m, n) => {
|
|
190
|
+
uniforms.push({ name: n, type: "texture" });
|
|
191
|
+
return "";
|
|
192
|
+
}).replace(SAMPLER_DECL, (_m, n) => {
|
|
193
|
+
uniforms.push({ name: n, type: "sampler" });
|
|
194
|
+
return "";
|
|
195
|
+
}).replace(UNIFORM_DECL, (_m, n, t) => {
|
|
196
|
+
const type = WGSL_TYPES[t];
|
|
197
|
+
if (!type) throw new Error(`[PostFX] ${name}: unsupported WGSL uniform type '${t}' for '${n}'`);
|
|
198
|
+
uniforms.push({ name: n, type });
|
|
199
|
+
return "";
|
|
200
|
+
});
|
|
201
|
+
const entry = ENTRY.exec(body);
|
|
202
|
+
if (!entry) throw new Error(`[PostFX] ${name}: no 'fn fragmentMain(input: FragmentInput) -> FragmentOutput'`);
|
|
203
|
+
const prelude = body.slice(0, entry.index);
|
|
204
|
+
if (/\buniform\./.test(prelude)) {
|
|
205
|
+
throw new Error(`[PostFX] ${name}: uniforms can only be read inside fragmentMain; pass them to helpers as arguments`);
|
|
206
|
+
}
|
|
207
|
+
for (const u of uniforms) {
|
|
208
|
+
if (u.type === "sampler" && !uniforms.some((t) => t.type === "texture" && `${t.name}Sampler` === u.name)) {
|
|
209
|
+
throw new Error(`[PostFX] ${name}: sampler '${u.name}' must be named after its texture, as '<texture>Sampler'`);
|
|
210
|
+
}
|
|
211
|
+
}
|
|
212
|
+
const params = uniforms.map((u) => `${u.name}: ${PARAM_TYPES[u.type]}`);
|
|
213
|
+
body = body.slice(entry.index + entry[0].length).replace(/var\s+output\s*:\s*FragmentOutput\s*;/, "var output: vec4f;").replace(/\boutput\.color\b/g, "output").replace(/\buniform\.(\w+)/g, "$1").replace(/\binput\.position\b/g, "vec4f(fxFragCoord, 0.0, 1.0)").replace(/\binput\.vUv0\b/g, "vec2f(fxFragCoord.x / fxSize.x, 1.0 - fxFragCoord.y / fxSize.y)").replace(/\binput\.texUv\b/g, "(fxFragCoord / fxSize)");
|
|
214
|
+
const main = `fn fxMain(${["fxFragCoord: vec2f", "fxSize: vec2f", ...params].join(", ")}) -> vec4f {${body}`;
|
|
215
|
+
return { main, prelude, uniforms };
|
|
216
|
+
}
|
|
217
|
+
var PLACEHOLDER = new DataTexture(new Uint8Array(4), 1, 1);
|
|
218
|
+
PLACEHOLDER.needsUpdate = true;
|
|
219
|
+
var WebGPUPostFXProgram = class {
|
|
220
|
+
_renderer;
|
|
221
|
+
_material;
|
|
222
|
+
_quad;
|
|
223
|
+
_values = /* @__PURE__ */ new Map();
|
|
224
|
+
_size;
|
|
225
|
+
constructor(renderer, source) {
|
|
226
|
+
this._renderer = renderer;
|
|
227
|
+
const { main, prelude, uniforms } = adaptWGSL(source.name, source.wgsl);
|
|
228
|
+
const includes = prelude.trim() ? [code(prelude)] : [];
|
|
229
|
+
const fn = wgslFn(main, includes);
|
|
230
|
+
this._size = uniform(new Vector2(1, 1));
|
|
231
|
+
const args = { fxFragCoord: screenCoordinate, fxSize: this._size };
|
|
232
|
+
const textures = /* @__PURE__ */ new Map();
|
|
233
|
+
for (const u of uniforms) {
|
|
234
|
+
if (u.type !== "texture") continue;
|
|
235
|
+
const node = texture(PLACEHOLDER);
|
|
236
|
+
textures.set(u.name, node);
|
|
237
|
+
args[u.name] = node;
|
|
238
|
+
this._values.set(u.name, node);
|
|
239
|
+
}
|
|
240
|
+
for (const u of uniforms) {
|
|
241
|
+
if (u.type === "texture") continue;
|
|
242
|
+
if (u.type === "sampler") {
|
|
243
|
+
args[u.name] = sampler(textures.get(u.name.slice(0, -"Sampler".length)));
|
|
244
|
+
continue;
|
|
245
|
+
}
|
|
246
|
+
const node = u.type === "int" ? uniform(0, "int") : uniform(initialUniformValue(u.type));
|
|
247
|
+
args[u.name] = node;
|
|
248
|
+
this._values.set(u.name, node);
|
|
249
|
+
}
|
|
250
|
+
const material = new NodeMaterial();
|
|
251
|
+
material.name = source.name;
|
|
252
|
+
material.fragmentNode = fn(args);
|
|
253
|
+
material.depthTest = false;
|
|
254
|
+
material.depthWrite = false;
|
|
255
|
+
const blend = source.blend ?? "none";
|
|
256
|
+
material.transparent = blend !== "none";
|
|
257
|
+
material.blending = blend === "add" ? CustomBlending : blend === "alpha" ? NormalBlending : NoBlending;
|
|
258
|
+
material.blendEquation = AddEquation;
|
|
259
|
+
material.blendSrc = OneFactor;
|
|
260
|
+
material.blendDst = OneFactor;
|
|
261
|
+
material.blendSrcAlpha = OneFactor;
|
|
262
|
+
material.blendDstAlpha = OneFactor;
|
|
263
|
+
this._material = material;
|
|
264
|
+
this._quad = new QuadMesh(material);
|
|
265
|
+
}
|
|
266
|
+
set(name, value) {
|
|
267
|
+
const holder = this._values.get(name);
|
|
268
|
+
if (!holder) return;
|
|
269
|
+
assignUniform(holder, holder.isTextureNode ? value ?? PLACEHOLDER : value);
|
|
270
|
+
}
|
|
271
|
+
draw(target) {
|
|
272
|
+
const r = this._renderer;
|
|
273
|
+
const autoClear = r.autoClear;
|
|
274
|
+
const colorSpace = r.outputColorSpace;
|
|
275
|
+
const toneMapping = r.toneMapping;
|
|
276
|
+
r.autoClear = false;
|
|
277
|
+
r.setRenderTarget(target);
|
|
278
|
+
if (!target) {
|
|
279
|
+
r.outputColorSpace = LinearSRGBColorSpace;
|
|
280
|
+
r.toneMapping = NoToneMapping;
|
|
281
|
+
}
|
|
282
|
+
if (target) this._size.value.set(target.width, target.height);
|
|
283
|
+
else r.getDrawingBufferSize(this._size.value);
|
|
284
|
+
this._quad.render(r);
|
|
285
|
+
r.outputColorSpace = colorSpace;
|
|
286
|
+
r.toneMapping = toneMapping;
|
|
287
|
+
r.autoClear = autoClear;
|
|
288
|
+
}
|
|
289
|
+
dispose() {
|
|
290
|
+
this._material.dispose();
|
|
291
|
+
}
|
|
292
|
+
};
|
|
293
|
+
var webgpuPostFXBackend = {
|
|
294
|
+
createProgram: (renderer, source) => new WebGPUPostFXProgram(renderer, source)
|
|
295
|
+
};
|
|
296
|
+
|
|
297
|
+
// src/effects/webgpu-register.ts
|
|
298
|
+
function registerEffectsWebGPU() {
|
|
299
|
+
registerPostFXWebGPUBackend(webgpuPostFXBackend);
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
// src/effects/vfx/webgpu-register.ts
|
|
303
|
+
import * as TSL2 from "three/tsl";
|
|
304
|
+
import { NodeMaterial as NodeMaterial2, Vector2 as Vector22, Vector3, Vector4 } from "three/webgpu";
|
|
305
|
+
var {
|
|
306
|
+
asin,
|
|
307
|
+
atan,
|
|
308
|
+
cameraProjectionMatrix,
|
|
309
|
+
cameraViewMatrix,
|
|
310
|
+
clamp,
|
|
311
|
+
cross,
|
|
312
|
+
float,
|
|
313
|
+
length,
|
|
314
|
+
mix,
|
|
315
|
+
modelWorldMatrix,
|
|
316
|
+
normalize,
|
|
317
|
+
normalLocal,
|
|
318
|
+
positionLocal,
|
|
319
|
+
sRGBTransferEOTF,
|
|
320
|
+
uniform: uniform2,
|
|
321
|
+
uv,
|
|
322
|
+
varying,
|
|
323
|
+
vec2,
|
|
324
|
+
vec3,
|
|
325
|
+
vec4,
|
|
326
|
+
wgslFn: wgslFn2
|
|
327
|
+
} = TSL2;
|
|
328
|
+
function uniformFor(value) {
|
|
329
|
+
if (typeof value === "number") return uniform2(value);
|
|
330
|
+
switch (value.length) {
|
|
331
|
+
case 2:
|
|
332
|
+
return uniform2(new Vector22(value[0], value[1]));
|
|
333
|
+
case 3:
|
|
334
|
+
return uniform2(new Vector3(value[0], value[1], value[2]));
|
|
335
|
+
case 4:
|
|
336
|
+
return uniform2(new Vector4(value[0], value[1], value[2], value[3]));
|
|
337
|
+
default:
|
|
338
|
+
throw new Error(`[VFX] shader layer uniforms are float or vec2-4; got ${value.length} values`);
|
|
339
|
+
}
|
|
340
|
+
}
|
|
341
|
+
function assign(node, value) {
|
|
342
|
+
if (typeof value === "number") node.value = value;
|
|
343
|
+
else node.value.fromArray(value);
|
|
344
|
+
}
|
|
345
|
+
function vertexStage(material, geometry) {
|
|
346
|
+
if (geometry === "billboard") {
|
|
347
|
+
const center = modelWorldMatrix.element(3).xyz;
|
|
348
|
+
const sx = length(modelWorldMatrix.element(0).xyz);
|
|
349
|
+
const sy = length(modelWorldMatrix.element(1).xyz);
|
|
350
|
+
const camRight = vec3(cameraViewMatrix.element(0).x, cameraViewMatrix.element(1).x, cameraViewMatrix.element(2).x);
|
|
351
|
+
const camUp = vec3(cameraViewMatrix.element(0).y, cameraViewMatrix.element(1).y, cameraViewMatrix.element(2).y);
|
|
352
|
+
const worldPos = center.add(camRight.mul(positionLocal.x.mul(sx))).add(camUp.mul(positionLocal.y.mul(sy)));
|
|
353
|
+
material.vertexNode = cameraProjectionMatrix.mul(cameraViewMatrix).mul(vec4(worldPos, 1));
|
|
354
|
+
return {
|
|
355
|
+
vUv: varying(uv()),
|
|
356
|
+
vLocalPos: varying(positionLocal),
|
|
357
|
+
vWorldPos: varying(worldPos),
|
|
358
|
+
vNormal: varying(normalize(cross(camRight, camUp)))
|
|
359
|
+
};
|
|
360
|
+
}
|
|
361
|
+
const world = modelWorldMatrix.mul(vec4(positionLocal, 1));
|
|
362
|
+
material.vertexNode = cameraProjectionMatrix.mul(cameraViewMatrix).mul(world);
|
|
363
|
+
const vNormal = varying(normalize(modelWorldMatrix.mul(vec4(normalLocal, 0)).xyz));
|
|
364
|
+
if (geometry === "sphere") {
|
|
365
|
+
const d = normalize(positionLocal);
|
|
366
|
+
return {
|
|
367
|
+
vUv: varying(vec2(
|
|
368
|
+
atan(d.z, d.x).div(6.28318530718).add(0.5),
|
|
369
|
+
asin(clamp(d.y, -1, 1)).div(3.14159265359).add(0.5)
|
|
370
|
+
)),
|
|
371
|
+
vLocalPos: varying(positionLocal),
|
|
372
|
+
vWorldPos: varying(world.xyz),
|
|
373
|
+
vNormal
|
|
374
|
+
};
|
|
375
|
+
}
|
|
376
|
+
return { vUv: varying(uv()), vLocalPos: varying(positionLocal), vWorldPos: varying(world.xyz), vNormal };
|
|
377
|
+
}
|
|
378
|
+
function wgslMaterial(layer, geometry) {
|
|
379
|
+
const material = new NodeMaterial2();
|
|
380
|
+
material.name = `VfxShader_${layer.id}_${geometry}`;
|
|
381
|
+
const uniforms = {
|
|
382
|
+
uTime: uniform2(0),
|
|
383
|
+
uProgress: uniform2(0),
|
|
384
|
+
uDuration: uniform2(layer.duration ?? 0),
|
|
385
|
+
uOpacity: uniform2(layer.opacity ?? 1)
|
|
386
|
+
};
|
|
387
|
+
for (const [name, spec] of Object.entries(layer.uniforms ?? {})) {
|
|
388
|
+
if (spec && spec.value != null) uniforms[name] = uniformFor(spec.value);
|
|
389
|
+
}
|
|
390
|
+
const outputLinear = uniform2(0);
|
|
391
|
+
const source = layer.fragmentWGSL.replace(/\bfn\s+main\s*\(/, "fn vfxShaderMain(");
|
|
392
|
+
const fragment = wgslFn2(source)({ ...vertexStage(material, geometry), ...uniforms });
|
|
393
|
+
const color = vec4(fragment);
|
|
394
|
+
material.fragmentNode = vec4(mix(color.rgb, sRGBTransferEOTF(color.rgb), float(outputLinear)), color.a);
|
|
395
|
+
return {
|
|
396
|
+
material,
|
|
397
|
+
set(name, value) {
|
|
398
|
+
const node = uniforms[name];
|
|
399
|
+
if (node) assign(node, value);
|
|
400
|
+
},
|
|
401
|
+
beforeRender(renderer, _mesh, _camera) {
|
|
402
|
+
const r = renderer;
|
|
403
|
+
const target = r.getRenderTarget();
|
|
404
|
+
const encodedOnOutput = target ? target.isPostProcessingRenderTarget === true : r.needsFrameBufferTarget === true;
|
|
405
|
+
outputLinear.value = encodedOnOutput ? 1 : 0;
|
|
406
|
+
}
|
|
407
|
+
};
|
|
408
|
+
}
|
|
409
|
+
function registerVfxWebGPU() {
|
|
410
|
+
registerShaderLayerWebGPU(wgslMaterial);
|
|
411
|
+
}
|
|
412
|
+
|
|
413
|
+
// src/relight/webgpu/backend.ts
|
|
414
|
+
import * as TSL3 from "three/tsl";
|
|
415
|
+
import {
|
|
416
|
+
HalfFloatType,
|
|
417
|
+
LightingModel,
|
|
418
|
+
LinearFilter,
|
|
419
|
+
MeshLambertNodeMaterial,
|
|
420
|
+
NodeMaterial as NodeMaterial3,
|
|
421
|
+
QuadMesh as QuadMesh2,
|
|
422
|
+
RGBAFormat,
|
|
423
|
+
RenderTarget,
|
|
424
|
+
Vector3 as Vector32,
|
|
425
|
+
Vector4 as Vector42
|
|
426
|
+
} from "three/webgpu";
|
|
427
|
+
var { Fn, dot, float: float2, max, normalView, normalWorld, reference, sqrt, texture: texture2, uniform: uniform3, uv: uv2, vec2: vec22, vec3: vec32, vec4: vec42 } = TSL3;
|
|
428
|
+
var RelightLightingModel = class extends LightingModel {
|
|
429
|
+
direct({ lightDirection, lightColor, lightNode, reflectedLight }, builder) {
|
|
430
|
+
let color = lightColor;
|
|
431
|
+
if (lightNode.light.isPointLight) {
|
|
432
|
+
const range = lightNode.cutoffDistanceNode;
|
|
433
|
+
const d = lightNode.getLightVector(builder).length();
|
|
434
|
+
const falloff = range.greaterThan(0).select(max(range.sub(d).div(range), 0), float2(1));
|
|
435
|
+
color = lightNode.colorNode.mul(falloff);
|
|
436
|
+
}
|
|
437
|
+
const dotNL = normalView.dot(lightDirection).clamp();
|
|
438
|
+
reflectedLight.directDiffuse.addAssign(dotNL.mul(color));
|
|
439
|
+
}
|
|
440
|
+
};
|
|
441
|
+
var RelightProxyMaterial = class extends MeshLambertNodeMaterial {
|
|
442
|
+
/** Marks the receivers the key light's {@link keyLightBias} applies to. */
|
|
443
|
+
isRelightProxyMaterial = true;
|
|
444
|
+
constructor() {
|
|
445
|
+
super();
|
|
446
|
+
this.name = "relight-proxy";
|
|
447
|
+
this.fog = false;
|
|
448
|
+
this.toneMapped = false;
|
|
449
|
+
}
|
|
450
|
+
// No environment light: the proxy's output is direct light only, and the
|
|
451
|
+
// compose adds the ambient back. The scene's environment map stays set
|
|
452
|
+
// while the proxies render, because clearing it rebuilds every material.
|
|
453
|
+
setupEnvironment() {
|
|
454
|
+
return null;
|
|
455
|
+
}
|
|
456
|
+
// Typed as the parent's return, which narrows it to Phong.
|
|
457
|
+
setupLightingModel() {
|
|
458
|
+
return new RelightLightingModel();
|
|
459
|
+
}
|
|
460
|
+
};
|
|
461
|
+
function keyLightBias(light, proxyBias) {
|
|
462
|
+
const toLightNode = uniform3(proxyBias.toLight);
|
|
463
|
+
const slopeNode = uniform3(0).onRenderUpdate(() => proxyBias.slope);
|
|
464
|
+
const shadow = light.shadow;
|
|
465
|
+
const bias = reference("bias", "float", shadow);
|
|
466
|
+
const range = reference("far", "float", shadow.camera).sub(reference("near", "float", shadow.camera));
|
|
467
|
+
return Fn((builder) => {
|
|
468
|
+
if (!builder.material?.isRelightProxyMaterial) return bias;
|
|
469
|
+
const c = max(dot(normalWorld, toLightNode), 1e-3);
|
|
470
|
+
const tan = sqrt(max(float2(1).sub(c.mul(c)), 0)).div(c);
|
|
471
|
+
return dot(normalWorld, toLightNode).greaterThan(0).select(bias.sub(slopeNode.mul(tan).div(range)), bias);
|
|
472
|
+
})();
|
|
473
|
+
}
|
|
474
|
+
var LUMA = [0.2126, 0.7152, 0.0722];
|
|
475
|
+
var WebGPURelightComposer = class {
|
|
476
|
+
_lit = texture2(getRelightPlaceholder());
|
|
477
|
+
_raw = texture2(getRelightPlaceholder());
|
|
478
|
+
_params = uniform3(new Vector42());
|
|
479
|
+
_hasRaw = uniform3(0);
|
|
480
|
+
_ambient = uniform3(new Vector32());
|
|
481
|
+
_lighting = new NodeMaterial3();
|
|
482
|
+
_visibility = new NodeMaterial3();
|
|
483
|
+
_quad = new QuadMesh2(this._lighting);
|
|
484
|
+
constructor() {
|
|
485
|
+
const coord = uv2();
|
|
486
|
+
const params = this._params;
|
|
487
|
+
const tent = (src, radius) => {
|
|
488
|
+
const c = src.sample(coord);
|
|
489
|
+
const t = vec22(params.x, params.y).mul(radius);
|
|
490
|
+
const tap = (x, y) => src.sample(coord.add(t.mul(vec22(x, y))));
|
|
491
|
+
const sum = c.mul(4).add(tap(-1, -1)).add(tap(0, -1).mul(2)).add(tap(1, -1)).add(tap(-1, 0).mul(2)).add(tap(1, 0).mul(2)).add(tap(-1, 1)).add(tap(0, 1).mul(2)).add(tap(1, 1));
|
|
492
|
+
return radius.lessThanEqual(0).select(c, sum.div(16));
|
|
493
|
+
};
|
|
494
|
+
const luma = vec32(...LUMA);
|
|
495
|
+
const lit = tent(this._lit, params.z);
|
|
496
|
+
const cov = lit.a.clamp(0, 1);
|
|
497
|
+
const direct = cov.greaterThan(1e-4).select(lit.rgb.div(cov), vec32(0));
|
|
498
|
+
const raw = tent(this._raw, params.w);
|
|
499
|
+
const rawCov = raw.a.clamp(0, 1);
|
|
500
|
+
const unshadowed = rawCov.greaterThan(1e-4).select(raw.rgb.div(rawCov), vec32(0));
|
|
501
|
+
const total = dot(unshadowed, luma);
|
|
502
|
+
const reaching = dot(direct, luma);
|
|
503
|
+
const visibility = this._hasRaw.greaterThan(0.5).and(total.greaterThan(1e-4)).select(reaching.div(total).clamp(0, 1), float2(1));
|
|
504
|
+
this._lighting.name = "relight-compose-lighting";
|
|
505
|
+
this._lighting.fragmentNode = vec42(direct.add(this._ambient), cov);
|
|
506
|
+
this._visibility.name = "relight-compose-visibility";
|
|
507
|
+
this._visibility.fragmentNode = vec42(visibility, cov, 0, 1);
|
|
508
|
+
for (const material of [this._lighting, this._visibility]) {
|
|
509
|
+
material.depthTest = false;
|
|
510
|
+
material.depthWrite = false;
|
|
511
|
+
material.toneMapped = false;
|
|
512
|
+
material.fog = false;
|
|
513
|
+
}
|
|
514
|
+
}
|
|
515
|
+
render(renderer, lit, raw, lighting, visibility, params) {
|
|
516
|
+
const r = renderer;
|
|
517
|
+
this._lit.value = lit;
|
|
518
|
+
this._raw.value = raw ?? lit;
|
|
519
|
+
this._hasRaw.value = raw ? 1 : 0;
|
|
520
|
+
this._params.value.set(params.texelX, params.texelY, params.blurRadius, params.shadowBlurRadius);
|
|
521
|
+
this._ambient.value.copy(params.ambient);
|
|
522
|
+
this._quad.material = this._lighting;
|
|
523
|
+
r.setRenderTarget(lighting);
|
|
524
|
+
this._quad.render(r);
|
|
525
|
+
this._quad.material = this._visibility;
|
|
526
|
+
r.setRenderTarget(visibility);
|
|
527
|
+
this._quad.render(r);
|
|
528
|
+
}
|
|
529
|
+
dispose() {
|
|
530
|
+
this._lighting.dispose();
|
|
531
|
+
this._visibility.dispose();
|
|
532
|
+
}
|
|
533
|
+
};
|
|
534
|
+
var webgpuRelightBackend = {
|
|
535
|
+
// WebGPU target rows run top-down: NDC +1 lands in row 0, which `v = 0`
|
|
536
|
+
// samples, so the splat lookup's `uv = ndc * 0.5 + 0.5` reads the mirrored
|
|
537
|
+
// row unless it flips.
|
|
538
|
+
flipY: true,
|
|
539
|
+
proxyReadsEnvironment: false,
|
|
540
|
+
// The bias is taken on the key light instead (see keyLightBias).
|
|
541
|
+
createProxyMaterial() {
|
|
542
|
+
return new RelightProxyMaterial();
|
|
543
|
+
},
|
|
544
|
+
configureKeyLight(light, bias) {
|
|
545
|
+
light.shadow.biasNode = keyLightBias(light, bias);
|
|
546
|
+
},
|
|
547
|
+
createTarget(_renderer, width, height, depth) {
|
|
548
|
+
return new RenderTarget(width, height, {
|
|
549
|
+
type: HalfFloatType,
|
|
550
|
+
format: RGBAFormat,
|
|
551
|
+
// Bilinear, not point: an animated splat's screen position drifts across
|
|
552
|
+
// this texture every frame and a point read pops at texel boundaries.
|
|
553
|
+
minFilter: LinearFilter,
|
|
554
|
+
magFilter: LinearFilter,
|
|
555
|
+
generateMipmaps: false,
|
|
556
|
+
depthBuffer: depth,
|
|
557
|
+
stencilBuffer: false
|
|
558
|
+
});
|
|
559
|
+
},
|
|
560
|
+
createComposer() {
|
|
561
|
+
return new WebGPURelightComposer();
|
|
562
|
+
}
|
|
563
|
+
};
|
|
564
|
+
|
|
565
|
+
// src/relight/webgpu-register.ts
|
|
566
|
+
function registerRelightWebGPU() {
|
|
567
|
+
registerRelightWebGPUBackend(webgpuRelightBackend);
|
|
568
|
+
}
|
|
569
|
+
|
|
570
|
+
// src/splat/webgpu/lighting.ts
|
|
571
|
+
import * as TSL4 from "three/tsl";
|
|
572
|
+
import { Vector4 as Vector43 } from "three/webgpu";
|
|
573
|
+
var { Fn: Fn2, If, Loop, float: float3, int, length: length2, uniform: uniform4, uniformArray } = TSL4;
|
|
36
574
|
var MAX_POINT_LIGHTS = 16;
|
|
37
575
|
var WebGPULighting = class {
|
|
38
576
|
_engine;
|
|
@@ -47,12 +585,12 @@ var WebGPULighting = class {
|
|
|
47
585
|
_version = -1;
|
|
48
586
|
constructor(engine) {
|
|
49
587
|
this._engine = engine;
|
|
50
|
-
this._sunColor =
|
|
51
|
-
this._ambient =
|
|
52
|
-
this._sunIntensity =
|
|
53
|
-
this._pointCount =
|
|
54
|
-
this._pointPosRange = Array.from({ length: MAX_POINT_LIGHTS }, () => new
|
|
55
|
-
this._pointColor = Array.from({ length: MAX_POINT_LIGHTS }, () => new
|
|
588
|
+
this._sunColor = uniform4(engine.lightingUniforms.uSunColor.value);
|
|
589
|
+
this._ambient = uniform4(engine.lightingUniforms.uAmbientColor.value);
|
|
590
|
+
this._sunIntensity = uniform4(0);
|
|
591
|
+
this._pointCount = uniform4(0, "int");
|
|
592
|
+
this._pointPosRange = Array.from({ length: MAX_POINT_LIGHTS }, () => new Vector43());
|
|
593
|
+
this._pointColor = Array.from({ length: MAX_POINT_LIGHTS }, () => new Vector43());
|
|
56
594
|
this._pointPosRangeNode = uniformArray(this._pointPosRange, "vec4");
|
|
57
595
|
this._pointColorNode = uniformArray(this._pointColor, "vec4");
|
|
58
596
|
}
|
|
@@ -82,15 +620,15 @@ var WebGPULighting = class {
|
|
|
82
620
|
* range-attenuated point lights. With no lights it is exactly 1.
|
|
83
621
|
*/
|
|
84
622
|
litFactor(worldCenter) {
|
|
85
|
-
return
|
|
623
|
+
return Fn2(() => {
|
|
86
624
|
const lit = this._ambient.add(this._sunColor.mul(this._sunIntensity)).toVar();
|
|
87
625
|
Loop({ start: int(0), end: this._pointCount, type: "int", condition: "<" }, ({ i }) => {
|
|
88
626
|
const posRange = this._pointPosRangeNode.element(i);
|
|
89
627
|
const colorInt = this._pointColorNode.element(i);
|
|
90
|
-
const dist =
|
|
628
|
+
const dist = length2(posRange.xyz.sub(worldCenter)).toVar();
|
|
91
629
|
If(dist.lessThan(posRange.w), () => {
|
|
92
630
|
const t = dist.div(posRange.w);
|
|
93
|
-
const atten =
|
|
631
|
+
const atten = float3(1).sub(t.mul(t)).toVar();
|
|
94
632
|
lit.addAssign(colorInt.xyz.mul(colorInt.w).mul(atten.mul(atten)));
|
|
95
633
|
});
|
|
96
634
|
});
|
|
@@ -100,27 +638,27 @@ var WebGPULighting = class {
|
|
|
100
638
|
};
|
|
101
639
|
|
|
102
640
|
// src/splat/webgpu/splat-mesh.ts
|
|
103
|
-
import * as
|
|
641
|
+
import * as TSL6 from "three/tsl";
|
|
104
642
|
import {
|
|
105
643
|
BufferAttribute,
|
|
106
644
|
DoubleSide,
|
|
107
645
|
InstancedBufferGeometry,
|
|
108
646
|
Matrix3,
|
|
109
647
|
Matrix4,
|
|
110
|
-
NodeMaterial,
|
|
648
|
+
NodeMaterial as NodeMaterial4,
|
|
111
649
|
Quaternion,
|
|
112
650
|
SRGBColorSpace,
|
|
113
651
|
Sphere,
|
|
114
652
|
StorageBufferAttribute as StorageBufferAttribute2,
|
|
115
|
-
Vector2,
|
|
116
|
-
Vector3,
|
|
117
|
-
Vector4 as
|
|
653
|
+
Vector2 as Vector23,
|
|
654
|
+
Vector3 as Vector33,
|
|
655
|
+
Vector4 as Vector44
|
|
118
656
|
} from "three/webgpu";
|
|
119
657
|
|
|
120
658
|
// src/splat/webgpu/radix-sort.ts
|
|
121
|
-
import * as
|
|
659
|
+
import * as TSL5 from "three/tsl";
|
|
122
660
|
import { StorageBufferAttribute } from "three/webgpu";
|
|
123
|
-
var { Fn:
|
|
661
|
+
var { Fn: Fn3, If: If2, Loop: Loop2, atomicAdd, atomicStore, instanceIndex, storage, uint } = TSL5;
|
|
124
662
|
var SORT_KEY_BITS = 16;
|
|
125
663
|
var RADIX = 256;
|
|
126
664
|
var BLOCK = 256;
|
|
@@ -134,6 +672,8 @@ var GpuRadixSort = class {
|
|
|
134
672
|
resetNode;
|
|
135
673
|
/** Run, in order, after the pass that writes keys. */
|
|
136
674
|
sortNodes;
|
|
675
|
+
/** Every buffer the sort allocated, for the owner to free with its nodes. */
|
|
676
|
+
attributes;
|
|
137
677
|
_firstHistogram;
|
|
138
678
|
constructor(count) {
|
|
139
679
|
this.count = count;
|
|
@@ -147,6 +687,7 @@ var GpuRadixSort = class {
|
|
|
147
687
|
const digitAttribute = new StorageBufferAttribute(new Uint32Array(RADIX), 1);
|
|
148
688
|
const halfSortedAttribute = new StorageBufferAttribute(new Uint32Array(count), 1);
|
|
149
689
|
const orderAttribute = new StorageBufferAttribute(new Uint32Array(count), 1);
|
|
690
|
+
this.attributes = [keysAttribute, ...histogramAttributes, digitAttribute, halfSortedAttribute, orderAttribute];
|
|
150
691
|
this.keysWrite = storage(keysAttribute, "uint", count);
|
|
151
692
|
const keys = storage(keysAttribute, "uint", count).toReadOnly();
|
|
152
693
|
this.orderRead = storage(orderAttribute, "uint", count).toReadOnly();
|
|
@@ -156,13 +697,13 @@ var GpuRadixSort = class {
|
|
|
156
697
|
const halfSortedWrite = storage(halfSortedAttribute, "uint", count);
|
|
157
698
|
const halfSorted = storage(halfSortedAttribute, "uint", count).toReadOnly();
|
|
158
699
|
const orderWrite = storage(orderAttribute, "uint", count);
|
|
159
|
-
this.resetNode =
|
|
700
|
+
this.resetNode = Fn3(() => {
|
|
160
701
|
atomicStore(this._firstHistogram.element(instanceIndex), uint(0));
|
|
161
702
|
atomicStore(secondHistogramAtomic.element(instanceIndex), uint(0));
|
|
162
703
|
})().compute(histogramSize, [256]).setName("SplatSortReset");
|
|
163
704
|
const prefixBlocks = (pass) => {
|
|
164
705
|
const histogram = storage(histogramAttributes[pass], "uint", histogramSize);
|
|
165
|
-
return
|
|
706
|
+
return Fn3(() => {
|
|
166
707
|
const sum = uint(0).toVar();
|
|
167
708
|
Loop2({ start: 0, end: blocks, type: "uint", name: "b", condition: "<" }, ({ b }) => {
|
|
168
709
|
const slot = b.mul(RADIX).add(instanceIndex).toVar();
|
|
@@ -173,7 +714,7 @@ var GpuRadixSort = class {
|
|
|
173
714
|
digits.element(instanceIndex).assign(sum);
|
|
174
715
|
})().compute(RADIX, [64]).setName(`SplatSortPrefixBlocks${pass}`);
|
|
175
716
|
};
|
|
176
|
-
const prefixDigits = (pass) =>
|
|
717
|
+
const prefixDigits = (pass) => Fn3(() => {
|
|
177
718
|
const sum = uint(0).toVar();
|
|
178
719
|
Loop2({ start: 0, end: RADIX, type: "uint", name: "d", condition: "<" }, ({ d }) => {
|
|
179
720
|
const n = digits.element(d).toVar();
|
|
@@ -184,7 +725,7 @@ var GpuRadixSort = class {
|
|
|
184
725
|
const scatter = (pass, input, output) => {
|
|
185
726
|
const histogram = storage(histogramAttributes[pass], "uint", histogramSize);
|
|
186
727
|
const digitBases = storage(digitAttribute, "uint", RADIX).toReadOnly();
|
|
187
|
-
return
|
|
728
|
+
return Fn3(() => {
|
|
188
729
|
const first = instanceIndex.mul(BLOCK).toVar();
|
|
189
730
|
Loop2({ start: 0, end: BLOCK, type: "uint", name: "j", condition: "<" }, ({ j }) => {
|
|
190
731
|
const position = first.add(j).toVar();
|
|
@@ -200,7 +741,7 @@ var GpuRadixSort = class {
|
|
|
200
741
|
});
|
|
201
742
|
})().compute(blocks, [64]).setName(`SplatSortScatter${pass}`);
|
|
202
743
|
};
|
|
203
|
-
const secondHistogramNode =
|
|
744
|
+
const secondHistogramNode = Fn3(() => {
|
|
204
745
|
const element = halfSorted.element(instanceIndex).toVar();
|
|
205
746
|
const digit = keys.element(element).shiftRight(uint(8)).bitAnd(uint(RADIX - 1)).toVar();
|
|
206
747
|
const block = instanceIndex.div(uint(BLOCK));
|
|
@@ -230,48 +771,58 @@ var GpuRadixSort = class {
|
|
|
230
771
|
// src/splat/webgpu/splat-mesh.ts
|
|
231
772
|
var {
|
|
232
773
|
Discard,
|
|
233
|
-
Fn:
|
|
774
|
+
Fn: Fn4,
|
|
234
775
|
If: If3,
|
|
235
776
|
Loop: Loop3,
|
|
236
|
-
clamp,
|
|
237
|
-
|
|
777
|
+
clamp: clamp2,
|
|
778
|
+
cos,
|
|
779
|
+
cross: cross2,
|
|
780
|
+
dot: dot2,
|
|
238
781
|
exp,
|
|
239
|
-
float:
|
|
782
|
+
float: float4,
|
|
783
|
+
fract,
|
|
240
784
|
instanceIndex: instanceIndex2,
|
|
241
|
-
|
|
785
|
+
int: int2,
|
|
786
|
+
ivec2,
|
|
787
|
+
length: length3,
|
|
242
788
|
log,
|
|
243
|
-
max,
|
|
789
|
+
max: max2,
|
|
244
790
|
min,
|
|
245
|
-
mix,
|
|
246
|
-
normalize,
|
|
791
|
+
mix: mix2,
|
|
792
|
+
normalize: normalize2,
|
|
247
793
|
positionGeometry,
|
|
248
794
|
select,
|
|
249
|
-
|
|
795
|
+
sin,
|
|
796
|
+
smoothstep,
|
|
797
|
+
sqrt: sqrt2,
|
|
250
798
|
storage: storage2,
|
|
799
|
+
texture: texture3,
|
|
800
|
+
textureLoad,
|
|
251
801
|
uint: uint2,
|
|
252
802
|
uintBitsToFloat,
|
|
253
|
-
uniform:
|
|
803
|
+
uniform: uniform5,
|
|
254
804
|
uniformArray: uniformArray2,
|
|
255
805
|
unpackHalf2x16,
|
|
256
806
|
uvec4,
|
|
257
807
|
varyingProperty,
|
|
258
|
-
vec2,
|
|
259
|
-
vec3,
|
|
260
|
-
vec4
|
|
261
|
-
|
|
808
|
+
vec2: vec23,
|
|
809
|
+
vec3: vec33,
|
|
810
|
+
vec4: vec43,
|
|
811
|
+
wgslFn: wgslFn3
|
|
812
|
+
} = TSL6;
|
|
262
813
|
var SORT_BINS = 1 << SORT_KEY_BITS;
|
|
263
814
|
var WORKGROUP_SIZE = 256;
|
|
264
815
|
var MAX_VARIANT_GROUPS = 64;
|
|
265
816
|
var EXP4 = Math.exp(-4);
|
|
266
817
|
var INV_EXP4 = 1 / (1 - EXP4);
|
|
267
|
-
var _position = new
|
|
818
|
+
var _position = new Vector33();
|
|
268
819
|
var _quaternion = new Quaternion();
|
|
269
|
-
var _scale = new
|
|
270
|
-
var _viewport = new
|
|
820
|
+
var _scale = new Vector33();
|
|
821
|
+
var _viewport = new Vector44();
|
|
271
822
|
var _sphere = new Sphere();
|
|
272
|
-
var _viewCenter = new
|
|
273
|
-
var _direction = new
|
|
274
|
-
var INPUT_SLOTS =
|
|
823
|
+
var _viewCenter = new Vector33();
|
|
824
|
+
var _direction = new Vector33();
|
|
825
|
+
var INPUT_SLOTS = 100;
|
|
275
826
|
var WebGPUSplatImpl = class {
|
|
276
827
|
geometry;
|
|
277
828
|
material;
|
|
@@ -290,37 +841,65 @@ var WebGPUSplatImpl = class {
|
|
|
290
841
|
_projectNodes = [];
|
|
291
842
|
/** The sort proper - needed only when the depth ORDER may have changed. */
|
|
292
843
|
_sortNodes = [];
|
|
844
|
+
/** Storage buffers the current build allocated. */
|
|
845
|
+
_buffers = [];
|
|
846
|
+
/** Nodes and buffers of builds since replaced, freed on the next frame. */
|
|
847
|
+
_retired = [];
|
|
848
|
+
/** The renderer that drew this splat, which owns its GPU buffers. */
|
|
849
|
+
_renderer = null;
|
|
293
850
|
// What the last compute run saw. Compared field by field each frame so an
|
|
294
851
|
// unchanged splat costs a draw call and nothing else.
|
|
295
852
|
_lastInputs = new Float64Array(INPUT_SLOTS).fill(NaN);
|
|
296
853
|
_inputs = new Float64Array(INPUT_SLOTS);
|
|
297
|
-
_lastSortDirection = new
|
|
854
|
+
_lastSortDirection = new Vector33(NaN, NaN, NaN);
|
|
298
855
|
_buildId = 0;
|
|
299
856
|
_sortedBuildId = -1;
|
|
300
857
|
_allNodes = null;
|
|
858
|
+
/** Relight texture nodes, re-pointed when the binding's textures change. */
|
|
859
|
+
_relightTex = null;
|
|
860
|
+
_relightShadowTex = null;
|
|
861
|
+
/** Cut texture nodes [offsets, pivots, rotations], re-pointed when a re-cut reallocates them. */
|
|
862
|
+
_cutTex = null;
|
|
863
|
+
/** True when the colour can change with no input this backend can see (a game hook). */
|
|
864
|
+
_alwaysProject = false;
|
|
865
|
+
/** Copies the game hook's uniform values into their nodes. */
|
|
866
|
+
_syncHook = null;
|
|
301
867
|
// Per-drawable uniforms, refreshed in onBeforeRender.
|
|
302
868
|
_u = {
|
|
303
|
-
model:
|
|
304
|
-
modelLinear:
|
|
305
|
-
modelRotation:
|
|
306
|
-
modelScale:
|
|
307
|
-
view:
|
|
308
|
-
viewRow0:
|
|
309
|
-
viewRow1:
|
|
310
|
-
viewRow2:
|
|
311
|
-
projection:
|
|
312
|
-
viewport:
|
|
313
|
-
minPixelSize:
|
|
869
|
+
model: uniform5(new Matrix4()),
|
|
870
|
+
modelLinear: uniform5(new Matrix3()),
|
|
871
|
+
modelRotation: uniform5(new Vector44(0, 0, 0, 1)),
|
|
872
|
+
modelScale: uniform5(new Vector33(1, 1, 1)),
|
|
873
|
+
view: uniform5(new Matrix4()),
|
|
874
|
+
viewRow0: uniform5(new Vector33()),
|
|
875
|
+
viewRow1: uniform5(new Vector33()),
|
|
876
|
+
viewRow2: uniform5(new Vector33()),
|
|
877
|
+
projection: uniform5(new Matrix4()),
|
|
878
|
+
viewport: uniform5(new Vector23(1, 1)),
|
|
879
|
+
minPixelSize: uniform5(0),
|
|
314
880
|
// 1 / the alpha a splat's quad is allowed to end at, carried as the
|
|
315
881
|
// reciprocal so the historic 1/255 cutoff arrives as exactly 255 and the
|
|
316
882
|
// two expressions it feeds reduce to what they were before the cutoff was
|
|
317
883
|
// a setting. See SplatQuality.quadAlphaCutoff.
|
|
318
|
-
alphaCutoffScale:
|
|
884
|
+
alphaCutoffScale: uniform5(255),
|
|
319
885
|
// x: far depth, y: 1 / (far - near), along the view axis.
|
|
320
|
-
sortRange:
|
|
321
|
-
tint:
|
|
322
|
-
grade:
|
|
323
|
-
|
|
886
|
+
sortRange: uniform5(new Vector23(1, 1)),
|
|
887
|
+
tint: uniform5(new Vector44(1, 1, 1, 0)),
|
|
888
|
+
grade: uniform5(new Vector23(1, 1)),
|
|
889
|
+
// x opacity, y reveal amount, z reveal inverse, w cut amount.
|
|
890
|
+
effects: uniform5(new Vector44(1, 1, 0, 0)),
|
|
891
|
+
revealBand: uniform5(new Vector44()),
|
|
892
|
+
revealSketch: uniform5(new Vector44()),
|
|
893
|
+
revealTint: uniform5(new Vector44()),
|
|
894
|
+
relightVP: uniform5(new Matrix4()),
|
|
895
|
+
relightParams: uniform5(new Vector44()),
|
|
896
|
+
relightStrength: uniform5(0),
|
|
897
|
+
relightTint: uniform5(new Vector33(1, 1, 1)),
|
|
898
|
+
relightAmbient: uniform5(0),
|
|
899
|
+
relightShadowStrength: uniform5(0),
|
|
900
|
+
relightFlipY: uniform5(0),
|
|
901
|
+
relightDebug: uniform5(0),
|
|
902
|
+
outputLinear: uniform5(0),
|
|
324
903
|
variantMask: uniformArray2(this._variantMask, "float")
|
|
325
904
|
};
|
|
326
905
|
constructor(host, splat, lighting) {
|
|
@@ -332,7 +911,7 @@ var WebGPUSplatImpl = class {
|
|
|
332
911
|
geometry.setIndex([0, 1, 2, 0, 2, 3]);
|
|
333
912
|
geometry.instanceCount = splat.numSplats;
|
|
334
913
|
geometry.boundingSphere = new Sphere();
|
|
335
|
-
const material = new
|
|
914
|
+
const material = new NodeMaterial4();
|
|
336
915
|
material.name = "SplatMaterial";
|
|
337
916
|
material.transparent = true;
|
|
338
917
|
material.depthTest = true;
|
|
@@ -371,6 +950,10 @@ var WebGPUSplatImpl = class {
|
|
|
371
950
|
attribute.needsUpdate = true;
|
|
372
951
|
this.requestSort();
|
|
373
952
|
}
|
|
953
|
+
/** The relight textures are re-pointed every frame; a new binding only needs a rebuild when one turns on or off. */
|
|
954
|
+
syncRelight() {
|
|
955
|
+
this.requestSort();
|
|
956
|
+
}
|
|
374
957
|
syncVariantGroups() {
|
|
375
958
|
const attribute = this._groupAttribute;
|
|
376
959
|
const ids = this._splat.groupIds;
|
|
@@ -385,6 +968,15 @@ var WebGPUSplatImpl = class {
|
|
|
385
968
|
* palette outgrows its buffer.
|
|
386
969
|
*/
|
|
387
970
|
_build() {
|
|
971
|
+
if (this._projectNodes.length > 0) {
|
|
972
|
+
this._retired.push({ nodes: [...this._projectNodes, ...this._sortNodes], buffers: this._buffers });
|
|
973
|
+
}
|
|
974
|
+
const buffers = [];
|
|
975
|
+
this._buffers = buffers;
|
|
976
|
+
const track = (attribute) => {
|
|
977
|
+
buffers.push(attribute);
|
|
978
|
+
return attribute;
|
|
979
|
+
};
|
|
388
980
|
const splat = this._splat;
|
|
389
981
|
const count = splat.numSplats;
|
|
390
982
|
const packed = splat.packed;
|
|
@@ -406,15 +998,15 @@ var WebGPUSplatImpl = class {
|
|
|
406
998
|
splatData[o + 6] = srcC[i * 2];
|
|
407
999
|
splatData[o + 7] = srcC[i * 2 + 1];
|
|
408
1000
|
}
|
|
409
|
-
const splats = storage2(new StorageBufferAttribute2(splatData, 4), "uvec4", count * 2).toReadOnly();
|
|
1001
|
+
const splats = storage2(track(new StorageBufferAttribute2(splatData, 4)), "uvec4", count * 2).toReadOnly();
|
|
410
1002
|
this._paletteArray = splat.transformPalette.data;
|
|
411
|
-
this._paletteAttribute = new StorageBufferAttribute2(this._paletteArray, 4);
|
|
1003
|
+
this._paletteAttribute = track(new StorageBufferAttribute2(this._paletteArray, 4));
|
|
412
1004
|
this._paletteVersion = -1;
|
|
413
1005
|
const palette = storage2(this._paletteAttribute, "vec4", this._paletteArray.length / 4).toReadOnly();
|
|
414
1006
|
let bones = null;
|
|
415
1007
|
this._boneAttribute = null;
|
|
416
1008
|
if (skinned) {
|
|
417
|
-
this._boneAttribute = new StorageBufferAttribute2(packBoneInfluences(splat, new Uint32Array(count * 4)), 4);
|
|
1009
|
+
this._boneAttribute = track(new StorageBufferAttribute2(packBoneInfluences(splat, new Uint32Array(count * 4)), 4));
|
|
418
1010
|
bones = storage2(this._boneAttribute, "uvec4", count).toReadOnly();
|
|
419
1011
|
}
|
|
420
1012
|
let groupIds = null;
|
|
@@ -425,60 +1017,95 @@ var WebGPUSplatImpl = class {
|
|
|
425
1017
|
`WebGPUSplatBackend: ${splat.variantMask.length} variant groups requested, but this backend supports at most ${MAX_VARIANT_GROUPS}`
|
|
426
1018
|
);
|
|
427
1019
|
}
|
|
428
|
-
this._groupAttribute = new StorageBufferAttribute2(Uint32Array.from(splat.groupIds), 1);
|
|
1020
|
+
this._groupAttribute = track(new StorageBufferAttribute2(Uint32Array.from(splat.groupIds), 1));
|
|
429
1021
|
groupIds = storage2(this._groupAttribute, "uint", count).toReadOnly();
|
|
430
1022
|
}
|
|
431
|
-
const workAttribute = new StorageBufferAttribute2(new Float32Array(count * 12), 4);
|
|
1023
|
+
const workAttribute = track(new StorageBufferAttribute2(new Float32Array(count * 12), 4));
|
|
432
1024
|
const workWrite = storage2(workAttribute, "vec4", count * 3);
|
|
433
1025
|
const sort = new GpuRadixSort(count);
|
|
1026
|
+
buffers.push(...sort.attributes);
|
|
434
1027
|
const readPaletteRows = (slot) => {
|
|
435
1028
|
const base = slot.mul(3).toVar();
|
|
436
1029
|
const r0 = palette.element(base).toVar();
|
|
437
1030
|
const r1 = palette.element(base.add(1)).toVar();
|
|
438
1031
|
const r2 = palette.element(base.add(2)).toVar();
|
|
439
|
-
const empty =
|
|
440
|
-
|
|
441
|
-
|
|
1032
|
+
const empty = max2(
|
|
1033
|
+
length3(vec33(r0.x, r1.x, r2.x)),
|
|
1034
|
+
max2(length3(vec33(r0.y, r1.y, r2.y)), length3(vec33(r0.z, r1.z, r2.z)))
|
|
442
1035
|
).lessThanEqual(1e-4);
|
|
443
1036
|
return [
|
|
444
|
-
select(empty,
|
|
445
|
-
select(empty,
|
|
446
|
-
select(empty,
|
|
1037
|
+
select(empty, vec43(1, 0, 0, 0), r0),
|
|
1038
|
+
select(empty, vec43(0, 1, 0, 0), r1),
|
|
1039
|
+
select(empty, vec43(0, 0, 1, 0), r2)
|
|
447
1040
|
];
|
|
448
1041
|
};
|
|
449
|
-
const quatMul = (a, b) =>
|
|
1042
|
+
const quatMul = (a, b) => vec43(
|
|
450
1043
|
a.w.mul(b.x).add(a.x.mul(b.w)).add(a.y.mul(b.z)).sub(a.z.mul(b.y)),
|
|
451
1044
|
a.w.mul(b.y).sub(a.x.mul(b.z)).add(a.y.mul(b.w)).add(a.z.mul(b.x)),
|
|
452
1045
|
a.w.mul(b.z).add(a.x.mul(b.y)).sub(a.y.mul(b.x)).add(a.z.mul(b.w)),
|
|
453
1046
|
a.w.mul(b.w).sub(a.x.mul(b.x)).sub(a.y.mul(b.y)).sub(a.z.mul(b.z))
|
|
454
1047
|
);
|
|
455
|
-
const sRGBToLinear = (c) =>
|
|
456
|
-
c.mul(0.9478672986).add(0.0521327014).pow(
|
|
1048
|
+
const sRGBToLinear = (c) => mix2(
|
|
1049
|
+
c.mul(0.9478672986).add(0.0521327014).pow(vec33(2.4)),
|
|
457
1050
|
c.mul(0.0773993808),
|
|
458
|
-
c.lessThanEqual(
|
|
1051
|
+
c.lessThanEqual(vec33(0.04045))
|
|
459
1052
|
);
|
|
460
|
-
const
|
|
1053
|
+
const texWidth = packed.width;
|
|
1054
|
+
const splatTexel = (i) => ivec2(int2(i.mod(texWidth)), int2(i.div(texWidth)));
|
|
1055
|
+
const revealOn = splat.revealEnabled;
|
|
1056
|
+
const revealDistance = revealOn && skinned && splat.revealDistanceTexture ? texture3(splat.revealDistanceTexture) : null;
|
|
1057
|
+
const cutOn = splat.cutEnabled && !!groupIds && !!splat.groupOffsetsTexture;
|
|
1058
|
+
const cutOffsets = cutOn ? texture3(splat.groupOffsetsTexture) : null;
|
|
1059
|
+
const cutPivots = cutOn ? texture3(splat.groupPivotsTexture) : null;
|
|
1060
|
+
const cutRots = cutOn ? texture3(splat.groupRotsTexture) : null;
|
|
1061
|
+
this._cutTex = cutOn ? [cutOffsets, cutPivots, cutRots] : null;
|
|
1062
|
+
const relight = splat.relightBinding;
|
|
1063
|
+
this._relightTex = relight ? texture3(relight.texture) : null;
|
|
1064
|
+
this._relightShadowTex = relight ? texture3(relight.shadowTexture ?? relight.texture) : null;
|
|
1065
|
+
const relightTex = this._relightTex;
|
|
1066
|
+
const relightShadowTex = this._relightShadowTex;
|
|
1067
|
+
const hook = splat.colorModifier;
|
|
1068
|
+
const builtHook = hook ? buildColorHook(hook) : null;
|
|
1069
|
+
const hookFn = builtHook?.fn ?? null;
|
|
1070
|
+
this._syncHook = builtHook?.sync ?? null;
|
|
1071
|
+
this._alwaysProject = !!hookFn;
|
|
1072
|
+
const revealX = (i, reveal) => {
|
|
1073
|
+
const front = mix2(u.revealBand.x.negate(), u.revealBand.x.add(1), reveal);
|
|
1074
|
+
const d = revealDistance ? textureLoad(revealDistance, splatTexel(i)).x : float4(1);
|
|
1075
|
+
return front.sub(d);
|
|
1076
|
+
};
|
|
1077
|
+
const revealHot = (base) => {
|
|
1078
|
+
const LUMA2 = vec33(0.2126, 0.7152, 0.0722);
|
|
1079
|
+
const tint = u.revealTint.xyz;
|
|
1080
|
+
const floorLuma = max2(u.revealTint.w, 1e-4);
|
|
1081
|
+
const luma = dot2(base, LUMA2).toVar();
|
|
1082
|
+
const hot = clamp2(mix2(vec33(luma), base, 2.2).mul(1.9), 0, 1).toVar();
|
|
1083
|
+
hot.assign(clamp2(mix2(hot, tint.mul(max2(luma, 0.35)).mul(2), 0.3), 0, 1));
|
|
1084
|
+
const lift = clamp2(floorLuma.sub(dot2(hot, LUMA2)).div(floorLuma), 0, 1);
|
|
1085
|
+
return mix2(hot, tint, lift);
|
|
1086
|
+
};
|
|
1087
|
+
const projectNode = Fn4(() => {
|
|
461
1088
|
const tA = splats.element(instanceIndex2.mul(2)).toVar();
|
|
462
1089
|
const tB = splats.element(instanceIndex2.mul(2).add(1)).toVar();
|
|
463
1090
|
const modelCenter = uintBitsToFloat(tA.xyz).toVar();
|
|
464
1091
|
const rotXY = unpackHalf2x16(tA.w).toVar();
|
|
465
1092
|
const scaleXY = unpackHalf2x16(tB.x).toVar();
|
|
466
1093
|
const scaleZRotZ = unpackHalf2x16(tB.y).toVar();
|
|
467
|
-
const packedRot =
|
|
468
|
-
const srcRotation =
|
|
469
|
-
const srcScale =
|
|
470
|
-
const row0 =
|
|
471
|
-
const row1 =
|
|
472
|
-
const row2 =
|
|
1094
|
+
const packedRot = vec33(rotXY.x, rotXY.y, scaleZRotZ.y).toVar();
|
|
1095
|
+
const srcRotation = vec43(packedRot, sqrt2(max2(float4(0), float4(1).sub(dot2(packedRot, packedRot))))).toVar();
|
|
1096
|
+
const srcScale = vec33(scaleXY.x, scaleXY.y, scaleZRotZ.x).toVar();
|
|
1097
|
+
const row0 = vec43(1, 0, 0, 0).toVar();
|
|
1098
|
+
const row1 = vec43(0, 1, 0, 0).toVar();
|
|
1099
|
+
const row2 = vec43(0, 0, 1, 0).toVar();
|
|
473
1100
|
if (skinned) {
|
|
474
1101
|
const influences = bones.element(instanceIndex2).toVar();
|
|
475
1102
|
const idx = influences.bitAnd(uvec4(65535)).toVar();
|
|
476
|
-
const weights =
|
|
1103
|
+
const weights = vec43(influences.shiftRight(uvec4(16))).div(65535).toVar();
|
|
477
1104
|
const total = weights.x.add(weights.y).add(weights.z).add(weights.w).toVar();
|
|
478
1105
|
If3(total.greaterThan(1e-3), () => {
|
|
479
|
-
const b0 =
|
|
480
|
-
const b1 =
|
|
481
|
-
const b2 =
|
|
1106
|
+
const b0 = vec43(0).toVar();
|
|
1107
|
+
const b1 = vec43(0).toVar();
|
|
1108
|
+
const b2 = vec43(0).toVar();
|
|
482
1109
|
for (const k of ["x", "y", "z", "w"]) {
|
|
483
1110
|
If3(weights[k].greaterThan(1e-3), () => {
|
|
484
1111
|
const [p0, p1, p2] = readPaletteRows(idx[k]);
|
|
@@ -487,13 +1114,13 @@ var WebGPUSplatImpl = class {
|
|
|
487
1114
|
b2.addAssign(p2.mul(weights[k]));
|
|
488
1115
|
});
|
|
489
1116
|
}
|
|
490
|
-
const inv =
|
|
1117
|
+
const inv = float4(1).div(total);
|
|
491
1118
|
b0.mulAssign(inv);
|
|
492
1119
|
b1.mulAssign(inv);
|
|
493
1120
|
b2.mulAssign(inv);
|
|
494
|
-
const reasonable =
|
|
495
|
-
|
|
496
|
-
|
|
1121
|
+
const reasonable = max2(
|
|
1122
|
+
length3(vec33(b0.x, b1.x, b2.x)),
|
|
1123
|
+
max2(length3(vec33(b0.y, b1.y, b2.y)), length3(vec33(b0.z, b1.z, b2.z)))
|
|
497
1124
|
).greaterThan(1e-4);
|
|
498
1125
|
If3(reasonable, () => {
|
|
499
1126
|
row0.assign(b0);
|
|
@@ -502,39 +1129,54 @@ var WebGPUSplatImpl = class {
|
|
|
502
1129
|
});
|
|
503
1130
|
});
|
|
504
1131
|
}
|
|
505
|
-
const center4 =
|
|
506
|
-
const modelDeformed =
|
|
507
|
-
const
|
|
1132
|
+
const center4 = vec43(modelCenter, 1).toVar();
|
|
1133
|
+
const modelDeformed = vec33(dot2(row0, center4), dot2(row1, center4), dot2(row2, center4)).toVar();
|
|
1134
|
+
const sortCenter = cutOn ? modelDeformed.toVar() : null;
|
|
1135
|
+
if (cutOn) {
|
|
1136
|
+
const amount = u.effects.w;
|
|
1137
|
+
const gid = ivec2(int2(groupIds.element(instanceIndex2)), int2(0)).toVar();
|
|
1138
|
+
const offS = textureLoad(cutOffsets, gid).toVar();
|
|
1139
|
+
const pivot = textureLoad(cutPivots, gid).xyz.toVar();
|
|
1140
|
+
const rot = textureLoad(cutRots, gid).toVar();
|
|
1141
|
+
const angle = rot.w.mul(amount).toVar();
|
|
1142
|
+
const v = modelDeformed.sub(pivot).toVar();
|
|
1143
|
+
const c2 = cos(angle), sn = sin(angle);
|
|
1144
|
+
const turned = v.mul(c2).add(cross2(rot.xyz, v).mul(sn)).add(rot.xyz.mul(dot2(rot.xyz, v)).mul(float4(1).sub(c2)));
|
|
1145
|
+
modelDeformed.assign(pivot.add(turned.mul(mix2(float4(1), offS.w, amount))).add(offS.xyz.mul(amount)));
|
|
1146
|
+
const half = angle.mul(0.5);
|
|
1147
|
+
srcRotation.assign(quatMul(vec43(rot.xyz.mul(sin(half)), cos(half)), srcRotation));
|
|
1148
|
+
}
|
|
1149
|
+
const worldCenter = u.model.mul(vec43(modelDeformed, 1)).xyz.toVar();
|
|
508
1150
|
const worldRotation = quatMul(u.modelRotation, srcRotation).toVar();
|
|
509
1151
|
If3(worldRotation.w.lessThan(0), () => {
|
|
510
1152
|
worldRotation.assign(worldRotation.negate());
|
|
511
1153
|
});
|
|
512
1154
|
const worldScale = u.modelScale.mul(srcScale).toVar();
|
|
513
1155
|
if (skinned) {
|
|
514
|
-
const c0 = u.modelLinear.mul(
|
|
515
|
-
const c1 = u.modelLinear.mul(
|
|
516
|
-
const c2 = u.modelLinear.mul(
|
|
517
|
-
const s =
|
|
1156
|
+
const c0 = u.modelLinear.mul(vec33(row0.x, row1.x, row2.x)).toVar();
|
|
1157
|
+
const c1 = u.modelLinear.mul(vec33(row0.y, row1.y, row2.y)).toVar();
|
|
1158
|
+
const c2 = u.modelLinear.mul(vec33(row0.z, row1.z, row2.z)).toVar();
|
|
1159
|
+
const s = vec33(length3(c0), length3(c1), length3(c2)).toVar();
|
|
518
1160
|
If3(s.x.greaterThan(1e-5).and(s.y.greaterThan(1e-5)).and(s.z.greaterThan(1e-5)), () => {
|
|
519
1161
|
const x = c0.div(s.x).toVar();
|
|
520
1162
|
const y = c1.div(s.y).toVar();
|
|
521
1163
|
const z = c2.div(s.z).toVar();
|
|
522
|
-
const q =
|
|
1164
|
+
const q = vec43(0, 0, 0, 1).toVar();
|
|
523
1165
|
const trace = x.x.add(y.y).add(z.z).toVar();
|
|
524
1166
|
If3(trace.greaterThan(0), () => {
|
|
525
|
-
const k =
|
|
526
|
-
q.assign(
|
|
1167
|
+
const k = sqrt2(trace.add(1)).mul(2).toVar();
|
|
1168
|
+
q.assign(vec43(y.z.sub(z.y).div(k), z.x.sub(x.z).div(k), x.y.sub(y.x).div(k), k.mul(0.25)));
|
|
527
1169
|
}).ElseIf(x.x.greaterThan(y.y).and(x.x.greaterThan(z.z)), () => {
|
|
528
|
-
const k =
|
|
529
|
-
q.assign(
|
|
1170
|
+
const k = sqrt2(float4(1).add(x.x).sub(y.y).sub(z.z)).mul(2).toVar();
|
|
1171
|
+
q.assign(vec43(k.mul(0.25), y.x.add(x.y).div(k), z.x.add(x.z).div(k), y.z.sub(z.y).div(k)));
|
|
530
1172
|
}).ElseIf(y.y.greaterThan(z.z), () => {
|
|
531
|
-
const k =
|
|
532
|
-
q.assign(
|
|
1173
|
+
const k = sqrt2(float4(1).add(y.y).sub(x.x).sub(z.z)).mul(2).toVar();
|
|
1174
|
+
q.assign(vec43(y.x.add(x.y).div(k), k.mul(0.25), z.y.add(y.z).div(k), z.x.sub(x.z).div(k)));
|
|
533
1175
|
}).Else(() => {
|
|
534
|
-
const k =
|
|
535
|
-
q.assign(
|
|
1176
|
+
const k = sqrt2(float4(1).add(z.z).sub(x.x).sub(y.y)).mul(2).toVar();
|
|
1177
|
+
q.assign(vec43(z.x.add(x.z).div(k), z.y.add(y.z).div(k), k.mul(0.25), x.y.sub(y.x).div(k)));
|
|
536
1178
|
});
|
|
537
|
-
const composed =
|
|
1179
|
+
const composed = normalize2(quatMul(q, srcRotation)).toVar();
|
|
538
1180
|
If3(composed.w.lessThan(0), () => {
|
|
539
1181
|
composed.assign(composed.negate());
|
|
540
1182
|
});
|
|
@@ -544,68 +1186,131 @@ var WebGPUSplatImpl = class {
|
|
|
544
1186
|
worldScale.mulAssign(s);
|
|
545
1187
|
}
|
|
546
1188
|
}
|
|
1189
|
+
if (revealOn) {
|
|
1190
|
+
const reveal = u.effects.y;
|
|
1191
|
+
const inverse = u.effects.z.greaterThan(0.5);
|
|
1192
|
+
const x = revealX(instanceIndex2, reveal).toVar();
|
|
1193
|
+
const inBand = x.greaterThanEqual(0).and(x.lessThan(u.revealBand.x));
|
|
1194
|
+
const m = min(worldScale.x, min(worldScale.y, worldScale.z));
|
|
1195
|
+
const squashed = min(worldScale, vec33(m.mul(u.revealBand.z)));
|
|
1196
|
+
If3(inverse, () => {
|
|
1197
|
+
If3(inBand, () => {
|
|
1198
|
+
worldScale.assign(squashed);
|
|
1199
|
+
});
|
|
1200
|
+
}).ElseIf(reveal.lessThan(1), () => {
|
|
1201
|
+
If3(x.lessThan(0), () => {
|
|
1202
|
+
worldScale.mulAssign(u.revealSketch.z);
|
|
1203
|
+
}).ElseIf(inBand, () => {
|
|
1204
|
+
worldScale.assign(squashed);
|
|
1205
|
+
});
|
|
1206
|
+
});
|
|
1207
|
+
}
|
|
547
1208
|
const ortho = u.projection.element(3).w.equal(1);
|
|
548
|
-
const centerView = u.view.mul(
|
|
1209
|
+
const centerView = u.view.mul(vec43(worldCenter, 1)).toVar();
|
|
549
1210
|
const centerProj = u.projection.mul(centerView).toVar();
|
|
550
|
-
centerProj.z.assign(
|
|
1211
|
+
centerProj.z.assign(clamp2(centerProj.z, float4(0), centerProj.w.abs()));
|
|
551
1212
|
const qx = worldRotation.x, qy = worldRotation.y, qz = worldRotation.z, qw = worldRotation.w;
|
|
552
|
-
const m0 =
|
|
553
|
-
|
|
1213
|
+
const m0 = vec33(
|
|
1214
|
+
float4(1).sub(qy.mul(qy).add(qz.mul(qz)).mul(2)),
|
|
554
1215
|
qx.mul(qy).add(qw.mul(qz)).mul(2),
|
|
555
1216
|
qx.mul(qz).sub(qw.mul(qy)).mul(2)
|
|
556
1217
|
).mul(worldScale.x).toVar();
|
|
557
|
-
const m1 =
|
|
1218
|
+
const m1 = vec33(
|
|
558
1219
|
qx.mul(qy).sub(qw.mul(qz)).mul(2),
|
|
559
|
-
|
|
1220
|
+
float4(1).sub(qx.mul(qx).add(qz.mul(qz)).mul(2)),
|
|
560
1221
|
qy.mul(qz).add(qw.mul(qx)).mul(2)
|
|
561
1222
|
).mul(worldScale.y).toVar();
|
|
562
|
-
const m2 =
|
|
1223
|
+
const m2 = vec33(
|
|
563
1224
|
qx.mul(qz).add(qw.mul(qy)).mul(2),
|
|
564
1225
|
qy.mul(qz).sub(qw.mul(qx)).mul(2),
|
|
565
|
-
|
|
1226
|
+
float4(1).sub(qx.mul(qx).add(qy.mul(qy)).mul(2))
|
|
566
1227
|
).mul(worldScale.z).toVar();
|
|
567
1228
|
const focal = u.viewport.x.mul(u.projection.element(0).x).toVar();
|
|
568
|
-
const vp = select(ortho,
|
|
1229
|
+
const vp = select(ortho, vec33(0, 0, 1), centerView.xyz).toVar();
|
|
569
1230
|
const J1 = focal.div(vp.z).toVar();
|
|
570
1231
|
const J2 = vp.xy.mul(J1.negate().div(vp.z)).toVar();
|
|
571
1232
|
const t0 = u.viewRow0.mul(J1).add(u.viewRow2.mul(J2.x)).toVar();
|
|
572
1233
|
const t1 = u.viewRow1.mul(J1).add(u.viewRow2.mul(J2.y)).toVar();
|
|
573
|
-
const a =
|
|
574
|
-
const b =
|
|
575
|
-
const cov00 =
|
|
576
|
-
const cov01 =
|
|
577
|
-
const cov11 =
|
|
1234
|
+
const a = vec33(dot2(t0, m0), dot2(t0, m1), dot2(t0, m2)).toVar();
|
|
1235
|
+
const b = vec33(dot2(t1, m0), dot2(t1, m1), dot2(t1, m2)).toVar();
|
|
1236
|
+
const cov00 = dot2(a, a).toVar();
|
|
1237
|
+
const cov01 = dot2(a, b).toVar();
|
|
1238
|
+
const cov11 = dot2(b, b).toVar();
|
|
578
1239
|
const diagonal1 = cov00.add(0.3).toVar();
|
|
579
1240
|
const diagonal2 = cov11.add(0.3).toVar();
|
|
580
1241
|
const mid = diagonal1.add(diagonal2).mul(0.5).toVar();
|
|
581
|
-
const radius =
|
|
1242
|
+
const radius = length3(vec23(diagonal1.sub(diagonal2).mul(0.5), cov01)).toVar();
|
|
582
1243
|
const lambda1 = mid.add(radius).toVar();
|
|
583
|
-
const lambda2 =
|
|
584
|
-
const vmin = min(
|
|
585
|
-
const l1 = min(
|
|
586
|
-
const l2 = min(
|
|
587
|
-
const lmax =
|
|
588
|
-
const c =
|
|
589
|
-
const diagonalVector =
|
|
1244
|
+
const lambda2 = max2(mid.sub(radius), 0.1).toVar();
|
|
1245
|
+
const vmin = min(float4(1024), min(u.viewport.x, u.viewport.y)).toVar();
|
|
1246
|
+
const l1 = min(sqrt2(lambda1.mul(2)), vmin).mul(2).toVar();
|
|
1247
|
+
const l2 = min(sqrt2(lambda2.mul(2)), vmin).mul(2).toVar();
|
|
1248
|
+
const lmax = max2(l1, l2).toVar();
|
|
1249
|
+
const c = vec23(centerProj.w).div(u.viewport).toVar();
|
|
1250
|
+
const diagonalVector = normalize2(vec23(cov01, lambda1.sub(diagonal1))).toVar();
|
|
590
1251
|
const v1 = diagonalVector.mul(l1).mul(c).toVar();
|
|
591
|
-
const v2 =
|
|
1252
|
+
const v2 = vec23(diagonalVector.y, diagonalVector.x.negate()).mul(l2).mul(c).toVar();
|
|
592
1253
|
const colorRG = unpackHalf2x16(tB.z).toVar();
|
|
593
1254
|
const colorBA = unpackHalf2x16(tB.w).toVar();
|
|
594
|
-
const rgb =
|
|
1255
|
+
const rgb = vec33(colorRG.x, colorRG.y, colorBA.x).toVar();
|
|
595
1256
|
const alpha = colorBA.y.toVar();
|
|
596
1257
|
if (splat.antiAlias) {
|
|
597
1258
|
const detOrig = cov00.mul(cov11).sub(cov01.mul(cov01));
|
|
598
1259
|
const detBlur = diagonal1.mul(diagonal2).sub(cov01.mul(cov01));
|
|
599
|
-
alpha.mulAssign(
|
|
1260
|
+
alpha.mulAssign(sqrt2(max2(detOrig.div(detBlur), 0)));
|
|
600
1261
|
}
|
|
601
1262
|
rgb.mulAssign(lighting.litFactor(worldCenter));
|
|
602
|
-
|
|
1263
|
+
If3(u.tint.w.greaterThanEqual(0), () => {
|
|
1264
|
+
rgb.assign(mix2(rgb, u.tint.xyz, clamp2(u.tint.w, 0, 1)));
|
|
1265
|
+
}).Else(() => {
|
|
1266
|
+
rgb.assign(mix2(rgb, rgb.mul(u.tint.xyz), min(u.tint.w.negate(), 1)));
|
|
1267
|
+
});
|
|
1268
|
+
if (relightTex) applyRelight(u, relightTex, relightShadowTex, worldCenter, rgb, alpha);
|
|
603
1269
|
If3(u.grade.x.notEqual(1).or(u.grade.y.notEqual(1)), () => {
|
|
604
1270
|
const graded = rgb.sub(0.5).mul(u.grade.x).add(0.5).toVar();
|
|
605
|
-
const luma =
|
|
606
|
-
rgb.assign(
|
|
1271
|
+
const luma = dot2(graded, vec33(0.2126, 0.7152, 0.0722));
|
|
1272
|
+
rgb.assign(clamp2(mix2(vec33(luma), graded, u.grade.y), 0, 1));
|
|
607
1273
|
});
|
|
608
|
-
|
|
1274
|
+
if (revealOn) {
|
|
1275
|
+
const reveal = u.effects.y;
|
|
1276
|
+
const inverse = u.effects.z.greaterThan(0.5);
|
|
1277
|
+
If3(reveal.lessThan(1).or(inverse), () => {
|
|
1278
|
+
const x = revealX(instanceIndex2, reveal).toVar();
|
|
1279
|
+
const bandWidth = u.revealBand.x;
|
|
1280
|
+
const base = clamp2(rgb, 0, 1).toVar();
|
|
1281
|
+
const hot = revealHot(base).toVar();
|
|
1282
|
+
If3(inverse, () => {
|
|
1283
|
+
If3(x.greaterThanEqual(0), () => {
|
|
1284
|
+
const band = float4(1).sub(smoothstep(0, bandWidth, x));
|
|
1285
|
+
rgb.assign(mix2(base, hot, band));
|
|
1286
|
+
alpha.assign(band.mul(0.95));
|
|
1287
|
+
});
|
|
1288
|
+
}).ElseIf(x.greaterThanEqual(0), () => {
|
|
1289
|
+
const band = float4(1).sub(smoothstep(bandWidth.mul(u.revealBand.y), bandWidth, x)).toVar();
|
|
1290
|
+
rgb.assign(mix2(base, hot, band));
|
|
1291
|
+
alpha.assign(max2(alpha, band.mul(0.95)));
|
|
1292
|
+
}).Else(() => {
|
|
1293
|
+
const lead = u.revealSketch.x;
|
|
1294
|
+
const h = fract(sin(dot2(modelCenter, vec33(12.9898, 78.233, 37.719))).mul(43758.5453));
|
|
1295
|
+
const shown = x.greaterThanEqual(lead.negate()).and(h.lessThanEqual(u.revealSketch.y));
|
|
1296
|
+
rgb.assign(hot);
|
|
1297
|
+
alpha.assign(select(shown, smoothstep(lead.negate(), lead.mul(-0.7), x), float4(0)));
|
|
1298
|
+
});
|
|
1299
|
+
});
|
|
1300
|
+
}
|
|
1301
|
+
alpha.mulAssign(u.effects.x);
|
|
1302
|
+
if (hookFn) {
|
|
1303
|
+
const out = hookFn({
|
|
1304
|
+
center: worldCenter,
|
|
1305
|
+
modelCenter: modelDeformed,
|
|
1306
|
+
restCenter: modelCenter,
|
|
1307
|
+
splatIndex: instanceIndex2,
|
|
1308
|
+
color: vec43(rgb, alpha)
|
|
1309
|
+
}).toVar();
|
|
1310
|
+
rgb.assign(out.xyz);
|
|
1311
|
+
alpha.assign(out.w);
|
|
1312
|
+
}
|
|
1313
|
+
rgb.assign(max2(rgb, vec33(0)));
|
|
609
1314
|
If3(u.outputLinear.greaterThan(0.5), () => {
|
|
610
1315
|
rgb.assign(sRGBToLinear(rgb));
|
|
611
1316
|
});
|
|
@@ -619,11 +1324,11 @@ var WebGPUSplatImpl = class {
|
|
|
619
1324
|
culled.assign(culled.or(hidden));
|
|
620
1325
|
}
|
|
621
1326
|
const slot = instanceIndex2.mul(3).toVar();
|
|
622
|
-
workWrite.element(slot).assign(select(culled,
|
|
623
|
-
workWrite.element(slot.add(1)).assign(select(culled,
|
|
624
|
-
workWrite.element(slot.add(2)).assign(
|
|
625
|
-
const depth = centerView.z.negate();
|
|
626
|
-
const normalized =
|
|
1327
|
+
workWrite.element(slot).assign(select(culled, vec43(0, 0, 2, 1), centerProj));
|
|
1328
|
+
workWrite.element(slot.add(1)).assign(select(culled, vec43(0), vec43(v1, v2)));
|
|
1329
|
+
workWrite.element(slot.add(2)).assign(vec43(rgb, select(culled, float4(0), alpha)));
|
|
1330
|
+
const depth = (cutOn ? u.view.mul(u.model.mul(vec43(sortCenter, 1))).z : centerView.z).negate();
|
|
1331
|
+
const normalized = clamp2(u.sortRange.x.sub(depth).mul(u.sortRange.y), 0, 1);
|
|
627
1332
|
const key = uint2(normalized.mul(SORT_BINS - 1)).toVar();
|
|
628
1333
|
sort.keysWrite.element(instanceIndex2).assign(key);
|
|
629
1334
|
sort.countFirstDigit(instanceIndex2, key);
|
|
@@ -637,20 +1342,20 @@ var WebGPUSplatImpl = class {
|
|
|
637
1342
|
const gaussianUV = varyingProperty("vec2", "vGaussianUV");
|
|
638
1343
|
const gaussianColor = varyingProperty("vec4", "vGaussianColor");
|
|
639
1344
|
const material = this.material;
|
|
640
|
-
material.vertexNode =
|
|
1345
|
+
material.vertexNode = Fn4(() => {
|
|
641
1346
|
const slot = orderRead.element(instanceIndex2).mul(3).toVar();
|
|
642
1347
|
const centerProj = workRead.element(slot).toVar();
|
|
643
1348
|
const axes = workRead.element(slot.add(1)).toVar();
|
|
644
1349
|
const shade = workRead.element(slot.add(2)).toVar();
|
|
645
|
-
const clip = min(
|
|
1350
|
+
const clip = min(float4(1), sqrt2(log(max2(shade.w.mul(u.alphaCutoffScale), 1))).mul(0.5)).toVar();
|
|
646
1351
|
const corner = positionGeometry.xy.toVar();
|
|
647
1352
|
const offset = axes.xy.mul(corner.x).add(axes.zw.mul(corner.y)).mul(clip);
|
|
648
1353
|
gaussianUV.assign(corner.mul(clip));
|
|
649
1354
|
gaussianColor.assign(shade);
|
|
650
|
-
return centerProj.add(
|
|
1355
|
+
return centerProj.add(vec43(offset, 0, 0));
|
|
651
1356
|
})();
|
|
652
|
-
material.colorNode =
|
|
653
|
-
const A =
|
|
1357
|
+
material.colorNode = Fn4(() => {
|
|
1358
|
+
const A = dot2(gaussianUV, gaussianUV).toVar();
|
|
654
1359
|
If3(A.greaterThan(1), () => {
|
|
655
1360
|
Discard();
|
|
656
1361
|
});
|
|
@@ -658,7 +1363,7 @@ var WebGPUSplatImpl = class {
|
|
|
658
1363
|
If3(alpha.lessThan(1 / 255), () => {
|
|
659
1364
|
Discard();
|
|
660
1365
|
});
|
|
661
|
-
return
|
|
1366
|
+
return vec43(gaussianColor.xyz, alpha);
|
|
662
1367
|
})();
|
|
663
1368
|
material.needsUpdate = true;
|
|
664
1369
|
}
|
|
@@ -677,6 +1382,8 @@ var WebGPUSplatImpl = class {
|
|
|
677
1382
|
}
|
|
678
1383
|
/** Refresh this splat's uniforms and run whatever compute this frame needs. */
|
|
679
1384
|
_prepare(renderer, camera) {
|
|
1385
|
+
this._renderer = renderer;
|
|
1386
|
+
if (this._retired.length > 0) this._freeRetired();
|
|
680
1387
|
const splat = this._splat;
|
|
681
1388
|
const u = this._u;
|
|
682
1389
|
const palette = splat.transformPalette;
|
|
@@ -717,6 +1424,31 @@ var WebGPUSplatImpl = class {
|
|
|
717
1424
|
}
|
|
718
1425
|
u.tint.value.copy(splat.tint);
|
|
719
1426
|
u.grade.value.copy(splat.grade);
|
|
1427
|
+
u.effects.value.copy(splat.effects);
|
|
1428
|
+
u.revealBand.value.copy(splat.revealBand);
|
|
1429
|
+
u.revealSketch.value.copy(splat.revealSketch);
|
|
1430
|
+
u.revealTint.value.copy(splat.revealTint);
|
|
1431
|
+
this._syncHook?.();
|
|
1432
|
+
const cut = this._cutTex;
|
|
1433
|
+
if (cut) {
|
|
1434
|
+
if (cut[0].value !== splat.groupOffsetsTexture) cut[0].value = splat.groupOffsetsTexture;
|
|
1435
|
+
if (cut[1].value !== splat.groupPivotsTexture) cut[1].value = splat.groupPivotsTexture;
|
|
1436
|
+
if (cut[2].value !== splat.groupRotsTexture) cut[2].value = splat.groupRotsTexture;
|
|
1437
|
+
}
|
|
1438
|
+
const relight = splat.relightBinding;
|
|
1439
|
+
if (relight) {
|
|
1440
|
+
u.relightVP.value.copy(relight.viewProjection);
|
|
1441
|
+
u.relightParams.value.copy(relight.params);
|
|
1442
|
+
u.relightStrength.value = relight.strength;
|
|
1443
|
+
u.relightTint.value.copy(relight.tint);
|
|
1444
|
+
u.relightAmbient.value = relight.ambient;
|
|
1445
|
+
u.relightShadowStrength.value = relight.shadowStrength;
|
|
1446
|
+
u.relightFlipY.value = relight.flipY;
|
|
1447
|
+
u.relightDebug.value = relight.debug;
|
|
1448
|
+
if (this._relightTex && relight.texture && this._relightTex.value !== relight.texture) this._relightTex.value = relight.texture;
|
|
1449
|
+
const shadow = relight.shadowTexture ?? relight.texture;
|
|
1450
|
+
if (this._relightShadowTex && shadow && this._relightShadowTex.value !== shadow) this._relightShadowTex.value = shadow;
|
|
1451
|
+
}
|
|
720
1452
|
const mask = splat.variantMask;
|
|
721
1453
|
if (mask) for (let i = 0; i < mask.length; i++) this._variantMask[i] = mask[i];
|
|
722
1454
|
_sphere.copy(this.geometry.boundingSphere).applyMatrix4(world);
|
|
@@ -751,6 +1483,13 @@ var WebGPUSplatImpl = class {
|
|
|
751
1483
|
inputs[n++] = palette.version;
|
|
752
1484
|
inputs[n++] = this._buildId;
|
|
753
1485
|
inputs[n++] = splat.variantMaskVersion;
|
|
1486
|
+
for (const v of [splat.effects, splat.revealBand, splat.revealSketch, splat.revealTint]) {
|
|
1487
|
+
inputs[n++] = v.x;
|
|
1488
|
+
inputs[n++] = v.y;
|
|
1489
|
+
inputs[n++] = v.z;
|
|
1490
|
+
inputs[n++] = v.w;
|
|
1491
|
+
}
|
|
1492
|
+
inputs[n++] = relight ? relight.version : -1;
|
|
754
1493
|
const last = this._lastInputs;
|
|
755
1494
|
let changed = false;
|
|
756
1495
|
for (let i = 0; i < n; i++) {
|
|
@@ -759,7 +1498,7 @@ var WebGPUSplatImpl = class {
|
|
|
759
1498
|
break;
|
|
760
1499
|
}
|
|
761
1500
|
}
|
|
762
|
-
if (!changed) return;
|
|
1501
|
+
if (!changed && !this._alwaysProject && !relight) return;
|
|
763
1502
|
last.set(inputs);
|
|
764
1503
|
const me = world.elements;
|
|
765
1504
|
const fx = -ve[2], fy = -ve[6], fz = -ve[10];
|
|
@@ -780,7 +1519,24 @@ var WebGPUSplatImpl = class {
|
|
|
780
1519
|
dispose() {
|
|
781
1520
|
this.geometry.dispose();
|
|
782
1521
|
this.material.dispose();
|
|
783
|
-
|
|
1522
|
+
this._retired.push({ nodes: [...this._projectNodes, ...this._sortNodes], buffers: this._buffers });
|
|
1523
|
+
this._projectNodes = [];
|
|
1524
|
+
this._sortNodes = [];
|
|
1525
|
+
this._buffers = [];
|
|
1526
|
+
this._freeRetired();
|
|
1527
|
+
}
|
|
1528
|
+
/**
|
|
1529
|
+
* Dispose replaced compute nodes and free their storage buffers. three.js
|
|
1530
|
+
* frees a compute node's pipeline and bindings on dispose, but not the
|
|
1531
|
+
* buffers they read; those it only frees with a geometry they belong to.
|
|
1532
|
+
*/
|
|
1533
|
+
_freeRetired() {
|
|
1534
|
+
const attributes = this._renderer?._attributes;
|
|
1535
|
+
for (const { nodes, buffers } of this._retired) {
|
|
1536
|
+
for (const node of nodes) node.dispose?.();
|
|
1537
|
+
if (attributes) for (const buffer of buffers) attributes.delete(buffer);
|
|
1538
|
+
}
|
|
1539
|
+
this._retired.length = 0;
|
|
784
1540
|
}
|
|
785
1541
|
};
|
|
786
1542
|
function packBoneInfluences(splat, out) {
|
|
@@ -793,6 +1549,91 @@ function packBoneInfluences(splat, out) {
|
|
|
793
1549
|
}
|
|
794
1550
|
return out;
|
|
795
1551
|
}
|
|
1552
|
+
function applyRelight(u, tex, shadowTex, worldCenter, rgb, alpha) {
|
|
1553
|
+
const strength = clamp2(u.relightStrength, 0, 1).toVar();
|
|
1554
|
+
const shadowStrength = clamp2(u.relightShadowStrength, 0, 1).toVar();
|
|
1555
|
+
const debug = u.relightDebug.greaterThan(0.5);
|
|
1556
|
+
const debugVis = u.relightDebug.greaterThan(1.5);
|
|
1557
|
+
const clipPos = u.relightVP.mul(vec43(worldCenter, 1)).toVar();
|
|
1558
|
+
const uv3 = clipPos.xy.div(clipPos.w).mul(0.5).add(0.5).toVar();
|
|
1559
|
+
If3(u.relightFlipY.greaterThan(0.5), () => {
|
|
1560
|
+
uv3.y.assign(float4(1).sub(uv3.y));
|
|
1561
|
+
});
|
|
1562
|
+
const active = debug.or(strength.greaterThan(0)).or(shadowStrength.greaterThan(0));
|
|
1563
|
+
const valid = u.relightParams.w.greaterThan(0);
|
|
1564
|
+
const inFront = clipPos.w.greaterThan(0);
|
|
1565
|
+
const inside = uv3.x.greaterThanEqual(0).and(uv3.x.lessThanEqual(1)).and(uv3.y.greaterThanEqual(0)).and(uv3.y.lessThanEqual(1));
|
|
1566
|
+
If3(active, () => {
|
|
1567
|
+
If3(valid.not(), () => {
|
|
1568
|
+
If3(debug, () => {
|
|
1569
|
+
rgb.assign(vec33(1, 0, 1));
|
|
1570
|
+
alpha.assign(1);
|
|
1571
|
+
});
|
|
1572
|
+
}).ElseIf(inFront.not(), () => {
|
|
1573
|
+
If3(debug, () => {
|
|
1574
|
+
rgb.assign(vec33(1, 1, 0));
|
|
1575
|
+
alpha.assign(1);
|
|
1576
|
+
});
|
|
1577
|
+
}).ElseIf(inside.not(), () => {
|
|
1578
|
+
If3(debug, () => {
|
|
1579
|
+
rgb.assign(vec33(1, 0, 0));
|
|
1580
|
+
alpha.assign(1);
|
|
1581
|
+
});
|
|
1582
|
+
}).ElseIf(debugVis, () => {
|
|
1583
|
+
const dv = shadowTex.sample(uv3).level(0).xy.toVar();
|
|
1584
|
+
rgb.assign(select(dv.y.greaterThan(0), vec33(clamp2(dv.x, 0, 1)), vec33(1, 0, 1)));
|
|
1585
|
+
alpha.assign(1);
|
|
1586
|
+
}).ElseIf(debug, () => {
|
|
1587
|
+
const sm = tex.sample(uv3).level(0).toVar();
|
|
1588
|
+
const mirrored = tex.sample(vec23(uv3.x, float4(1).sub(uv3.y))).level(0).w;
|
|
1589
|
+
rgb.assign(select(sm.w.greaterThan(0), sm.xyz, select(mirrored.greaterThan(0), vec33(1, 0.5, 0), vec33(0, 0, 1))));
|
|
1590
|
+
alpha.assign(1);
|
|
1591
|
+
}).Else(() => {
|
|
1592
|
+
If3(strength.greaterThan(0), () => {
|
|
1593
|
+
const sm = tex.sample(uv3).level(0).toVar();
|
|
1594
|
+
const mask = clamp2(sm.w, 0, 1);
|
|
1595
|
+
const lit = max2(sm.xyz.mul(u.relightParams.z), vec33(u.relightAmbient)).mul(u.relightTint);
|
|
1596
|
+
rgb.assign(mix2(rgb, rgb.mul(lit), strength.mul(mask)));
|
|
1597
|
+
});
|
|
1598
|
+
If3(shadowStrength.greaterThan(0), () => {
|
|
1599
|
+
const v = shadowTex.sample(uv3).level(0).xy.toVar();
|
|
1600
|
+
rgb.mulAssign(mix2(float4(1), clamp2(v.x, 0, 1), shadowStrength.mul(clamp2(v.y, 0, 1))));
|
|
1601
|
+
});
|
|
1602
|
+
});
|
|
1603
|
+
});
|
|
1604
|
+
}
|
|
1605
|
+
function buildColorHook(hook) {
|
|
1606
|
+
const uniforms = {};
|
|
1607
|
+
const sources = Object.entries(hook.uniforms ?? {});
|
|
1608
|
+
for (const [name, u] of sources) uniforms[name] = uniform5(u.value);
|
|
1609
|
+
const sync = () => {
|
|
1610
|
+
for (const [name, u] of sources) {
|
|
1611
|
+
const node = uniforms[name];
|
|
1612
|
+
const v = u.value;
|
|
1613
|
+
if (typeof v === "object" && v !== null && typeof node.value?.copy === "function") node.value.copy(v);
|
|
1614
|
+
else node.value = v;
|
|
1615
|
+
}
|
|
1616
|
+
};
|
|
1617
|
+
if (hook.tsl) {
|
|
1618
|
+
const build = hook.tsl;
|
|
1619
|
+
return {
|
|
1620
|
+
sync,
|
|
1621
|
+
fn: (inputs) => build({
|
|
1622
|
+
center: inputs.center,
|
|
1623
|
+
modelCenter: inputs.modelCenter,
|
|
1624
|
+
restCenter: inputs.restCenter,
|
|
1625
|
+
splatIndex: inputs.splatIndex,
|
|
1626
|
+
color: inputs.color,
|
|
1627
|
+
uniforms
|
|
1628
|
+
})
|
|
1629
|
+
};
|
|
1630
|
+
}
|
|
1631
|
+
if (hook.wgsl) {
|
|
1632
|
+
const fn = wgslFn3(hook.wgsl);
|
|
1633
|
+
return { sync, fn: (inputs) => fn({ ...inputs, ...uniforms }) };
|
|
1634
|
+
}
|
|
1635
|
+
return { sync, fn: null };
|
|
1636
|
+
}
|
|
796
1637
|
|
|
797
1638
|
// src/splat/webgpu/backend.ts
|
|
798
1639
|
var WebGPUSplatBackend = class {
|
|
@@ -809,16 +1650,89 @@ var WebGPUSplatBackend = class {
|
|
|
809
1650
|
|
|
810
1651
|
// src/webgpu.ts
|
|
811
1652
|
registerWebGPUBackend(new WebGPUSplatBackend());
|
|
1653
|
+
registerEffectsWebGPU();
|
|
1654
|
+
registerVfxWebGPU();
|
|
1655
|
+
registerRelightWebGPU();
|
|
1656
|
+
registerWebGPURendererFactory(async (canvas, opts) => {
|
|
1657
|
+
const gpu = navigator.gpu;
|
|
1658
|
+
if (!gpu) return null;
|
|
1659
|
+
const renderer = new WebGPURenderer({
|
|
1660
|
+
canvas,
|
|
1661
|
+
antialias: opts.antialias ?? false,
|
|
1662
|
+
alpha: (opts.bgColor?.a ?? 1) < 1 || !!opts.preserveDrawingBuffer,
|
|
1663
|
+
powerPreference: opts.powerPreference === "low-power" ? "low-power" : "high-performance"
|
|
1664
|
+
});
|
|
1665
|
+
await renderer.init();
|
|
1666
|
+
if (renderer.backend.isWebGPUBackend !== true) {
|
|
1667
|
+
renderer.dispose();
|
|
1668
|
+
return null;
|
|
1669
|
+
}
|
|
1670
|
+
return renderer;
|
|
1671
|
+
});
|
|
812
1672
|
export {
|
|
1673
|
+
ALL_BODY_PARTS,
|
|
813
1674
|
Animation,
|
|
814
1675
|
Armature,
|
|
1676
|
+
BODYGROUP_DEFAULT,
|
|
1677
|
+
BODYGROUP_DYNAMIC,
|
|
1678
|
+
BODYGROUP_ENGINE_1,
|
|
1679
|
+
BODYGROUP_ENGINE_2,
|
|
1680
|
+
BODYGROUP_ENGINE_3,
|
|
1681
|
+
BODYGROUP_KINEMATIC,
|
|
1682
|
+
BODYGROUP_NONE,
|
|
1683
|
+
BODYGROUP_STATIC,
|
|
1684
|
+
BODYGROUP_TRIGGER,
|
|
1685
|
+
BODYGROUP_USER_1,
|
|
1686
|
+
BODYGROUP_USER_2,
|
|
1687
|
+
BODYGROUP_USER_3,
|
|
1688
|
+
BODYGROUP_USER_4,
|
|
1689
|
+
BODYGROUP_USER_5,
|
|
1690
|
+
BODYGROUP_USER_6,
|
|
1691
|
+
BODYGROUP_USER_7,
|
|
1692
|
+
BODYGROUP_USER_8,
|
|
1693
|
+
BODYMASK_ALL,
|
|
1694
|
+
BODYMASK_NONE,
|
|
1695
|
+
BODYMASK_NOT_STATIC,
|
|
1696
|
+
BODYMASK_NOT_STATIC_KINEMATIC,
|
|
1697
|
+
BODYMASK_STATIC,
|
|
1698
|
+
BODY_PART_SLUGS,
|
|
1699
|
+
BaseCapturingPass,
|
|
1700
|
+
BodyPart,
|
|
1701
|
+
BodyShapeVariant,
|
|
1702
|
+
BoneOverlay,
|
|
1703
|
+
CameraFrame,
|
|
815
1704
|
Character,
|
|
816
1705
|
CharacterBundleError,
|
|
1706
|
+
DEFAULT_ENV_REVEAL_LOOK,
|
|
1707
|
+
DEFAULT_HUMANOID_RAGDOLL,
|
|
1708
|
+
DEFAULT_REVEAL_LOOK,
|
|
1709
|
+
DEFAULT_REVEAL_PRESET,
|
|
1710
|
+
DEFAULT_SHADER_FRAGMENT,
|
|
1711
|
+
DEFAULT_SHADER_FRAGMENT_WGSL,
|
|
1712
|
+
ENVIRONMENT_DEFAULT_LOD,
|
|
1713
|
+
ENVIRONMENT_PROXY_DEFAULTS,
|
|
817
1714
|
EngineDisposedError,
|
|
818
1715
|
Environment,
|
|
1716
|
+
JsonVfxInstance,
|
|
1717
|
+
JsonVfxPrefab,
|
|
1718
|
+
LOWER_BODY_BONE_NAMES,
|
|
819
1719
|
MAX_POINT_LIGHTS,
|
|
820
1720
|
MAX_VARIANT_GROUPS,
|
|
1721
|
+
MeshFlash,
|
|
1722
|
+
MeshLayerRenderer,
|
|
1723
|
+
NUM_BODY_PARTS,
|
|
1724
|
+
OutlineEffect,
|
|
1725
|
+
ParticleLayerRenderer,
|
|
1726
|
+
PhysicsWorld,
|
|
1727
|
+
PixelartEffect,
|
|
821
1728
|
PointLight,
|
|
1729
|
+
Pose,
|
|
1730
|
+
PostFX,
|
|
1731
|
+
Ragdoll,
|
|
1732
|
+
RigidBody,
|
|
1733
|
+
Scene,
|
|
1734
|
+
SceneDestroyedError,
|
|
1735
|
+
ShaderLayerRenderer,
|
|
822
1736
|
SkyLight,
|
|
823
1737
|
Splat,
|
|
824
1738
|
SplatCharacter,
|
|
@@ -828,16 +1742,71 @@ export {
|
|
|
828
1742
|
SplatMesh,
|
|
829
1743
|
SplatPLYLoader,
|
|
830
1744
|
SplatQuality,
|
|
1745
|
+
SplatRelight,
|
|
1746
|
+
SplatSPZLoader,
|
|
1747
|
+
SpriteLayerRenderer,
|
|
831
1748
|
SunLight,
|
|
1749
|
+
TONEMAP_ACES,
|
|
1750
|
+
TONEMAP_ACES2,
|
|
1751
|
+
TONEMAP_FILMIC,
|
|
1752
|
+
TONEMAP_HEJL,
|
|
1753
|
+
TONEMAP_LINEAR,
|
|
1754
|
+
TONEMAP_NEUTRAL,
|
|
1755
|
+
TONEMAP_NONE,
|
|
1756
|
+
ThirdPersonCamera,
|
|
1757
|
+
UPPER_BODY_BONE_NAMES,
|
|
832
1758
|
VSplatLoader,
|
|
1759
|
+
VfxLayerRegistry,
|
|
1760
|
+
VfxPool,
|
|
1761
|
+
VfxStage,
|
|
833
1762
|
WebGLSplatBackend,
|
|
834
1763
|
WebGPUSplatBackend,
|
|
1764
|
+
alphaFromLogits,
|
|
1765
|
+
bodyPartLabel,
|
|
1766
|
+
buildBoneToGroup,
|
|
1767
|
+
buildProxyMesh,
|
|
1768
|
+
buildStretch,
|
|
1769
|
+
buildVfxQuadMesh,
|
|
1770
|
+
buildVfxRingMesh,
|
|
1771
|
+
buildVfxSphereMesh,
|
|
1772
|
+
buildVfxSpikeMesh,
|
|
1773
|
+
buildVoxelGrid,
|
|
1774
|
+
cachedFetch,
|
|
1775
|
+
classifyBone,
|
|
1776
|
+
clearAnimRootRotation,
|
|
1777
|
+
computeBoneStretch,
|
|
1778
|
+
createConeTwistJoint,
|
|
1779
|
+
createGeneric6DofJoint,
|
|
1780
|
+
createHingeJoint,
|
|
835
1781
|
decodeCharacterBundle,
|
|
1782
|
+
decodeSplatFile,
|
|
1783
|
+
decodeSpz,
|
|
1784
|
+
defaultLayerRegistry,
|
|
1785
|
+
defaultProxySettings,
|
|
1786
|
+
extractSurface,
|
|
1787
|
+
getVfxMesh,
|
|
1788
|
+
indexAssetCache,
|
|
1789
|
+
installFetchInterceptor,
|
|
1790
|
+
isCached,
|
|
1791
|
+
isSocketRemoval,
|
|
836
1792
|
loadCharacterBundle,
|
|
837
1793
|
loadCharacterBundleFromBytes,
|
|
1794
|
+
loadGlbFromUrl,
|
|
1795
|
+
loadSplatAsset,
|
|
1796
|
+
loadSplatSource,
|
|
838
1797
|
makeRegionMask,
|
|
1798
|
+
mergeSocketLoadout,
|
|
839
1799
|
packSplats,
|
|
840
1800
|
parseGaussianPly,
|
|
841
|
-
|
|
1801
|
+
playReveal,
|
|
1802
|
+
prewarmJsonVfxPrefabs,
|
|
1803
|
+
pruneSplats,
|
|
1804
|
+
resolveBoneIndices,
|
|
1805
|
+
setAssetFetch,
|
|
1806
|
+
setBinFetch,
|
|
1807
|
+
setGlbLoader,
|
|
1808
|
+
setShareSplatResources,
|
|
1809
|
+
uninstallFetchInterceptor,
|
|
1810
|
+
validateShaderGLSL
|
|
842
1811
|
};
|
|
843
1812
|
//# sourceMappingURL=webgpu.js.map
|