Halaman utama Jelajahi Bantuan
Daftar Masuk
samien
/
three.js
cermin dari https://github.com/mrdoob/three.js.git
1
0
Fork 0
Berkas Masalah 0 Wiki
Jelajahi Sumber

Examples : Add TSL VFX Linked particles (#29354)

* Examples : Add TSL VFX Linked particles

Adds WebGPU/TSL VFX Linked particles example.

* Removed unused imports
ULuIQ12 1 tahun lalu
induk
c5819a3cc8
melakukan
643f88cd6e
4 mengubah file dengan 457 tambahan dan 0 penghapusan
Unified View Tampilkan Statistik Diff
  1. 1 0
      examples/files.json
  2. TEMPAT SAMPAH
      examples/screenshots/webgpu_tsl_vfx_linkedparticles.jpg
  3. 455 0
      examples/webgpu_tsl_vfx_linkedparticles.html
  4. 1 0
      test/e2e/puppeteer.js

+ 1 - 0
examples/files.json
Tampilan Berkas 

@@ -425,6 +425,7 @@
 
 		"webgpu_tsl_raging_sea",
 
 		"webgpu_tsl_raging_sea",
 
 		"webgpu_tsl_transpiler",
 
 		"webgpu_tsl_transpiler",
 
 		"webgpu_tsl_vfx_flames",
 
 		"webgpu_tsl_vfx_flames",
 
+		"webgpu_tsl_vfx_linkedparticles",
 
 		"webgpu_tsl_vfx_tornado",
 
 		"webgpu_tsl_vfx_tornado",
 
 		"webgpu_video_panorama",
 
 		"webgpu_video_panorama",
 
 		"webgpu_volume_cloud",
 
 		"webgpu_volume_cloud",

TEMPAT SAMPAH
examples/screenshots/webgpu_tsl_vfx_linkedparticles.jpg
Tampilan Berkas


+ 455 - 0
examples/webgpu_tsl_vfx_linkedparticles.html
Tampilan Berkas 

@@ -0,0 +1,455 @@
 
+<!DOCTYPE html>
 
+<html lang="en">
 
+	<head>
 
+		<title>three.js webgpu - VFX Linked particles</title>
 
+		<meta charset="utf-8">
 
+		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
 
+		<link type="text/css" rel="stylesheet" href="main.css">
 
+	</head>
 
+	<body>
 
+
 
+		<div id="info">
 
+			<a href="https://threejs.org" target="_blank" rel="noopener">three.js webgpu</a> - VFX Linked particles
 
+			<br>
 
+			Based on <a href="https://github.com/ULuIQ12/webgpu-tsl-linkedparticles" target="_blank" rel="noopener">this experiment</a> by Christophe Choffel
 
+		</div>
 
+
 
+		<script type="importmap">
 
+			{
 
+				"imports": {
 
+					"three": "../build/three.webgpu.js",
 
+					"three/tsl": "../build/three.webgpu.js",
 
+					"three/addons/": "./jsm/"
 
+				}
 
+			}
 
+		</script>
 
+
 
+		<script type="module">
 
+
 
+			import * as THREE from 'three';
 
+			import { atan2, cos, float, max, min, mix, PI, PI2, sin, vec2, vec3, bloom, color, Fn, hash, hue, If, instanceIndex, Loop, mx_fractal_noise_float, mx_fractal_noise_vec3, pass, pcurve, storage, timerDelta, timerGlobal, uv, uniform } from 'three/tsl';
 
+
 
+			import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 
+			import { GUI } from 'three/addons/libs/lil-gui.module.min.js';
 
+			import WebGPU from 'three/addons/capabilities/WebGPU.js';
 
+
 
+			let camera, scene, renderer, postProcessing, controls, clock, light;
 
+
 
+			let updateParticles, spawnParticles; // TSL compute nodes
 
+			let getInstanceColor; // TSL function
 
+
 
+			const screenPointer = new THREE.Vector2();
 
+			const scenePointer = new THREE.Vector3();
 
+			const raycastPlane = new THREE.Plane( new THREE.Vector3( 0, 0, 1 ), 0 );
 
+			const raycaster = new THREE.Raycaster();
 
+
 
+			const nbParticles = Math.pow( 2, 13 );
 
+
 
+			const timeScale = uniform( 1.0 );
 
+			const particleLifetime = uniform( 0.5 );
 
+			const particleSize = uniform( 1.0 );
 
+			const linksWidth = uniform( 0.005 );
 
+
 
+			const colorOffset = uniform( 0.0 );
 
+			const colorVariance = uniform( 2.0 );
 
+			const colorRotationSpeed = uniform( 1.0 );
 
+
 
+			const spawnIndex = uniform( 0 );
 
+			const nbToSpawn = uniform( 5 );
 
+			const spawnPosition = uniform( vec3( 0.0 ) );
 
+			const previousSpawnPosition = uniform( vec3( 0.0 ) );
 
+
 
+			const turbFrequency = uniform( 0.5 );
 
+			const turbAmplitude = uniform( 0.5 );
 
+			const turbOctaves = uniform( 2 );
 
+			const turbLacunarity = uniform( 2.0 );
 
+			const turbGain = uniform( 0.5 );
 
+			const turbFriction = uniform( 0.01 );
 
+
 
+			init();
 
+
 
+			function init() {
 
+
 
+				if ( WebGPU.isAvailable() === false ) {
 
+
 
+					document.body.appendChild( WebGPU.getErrorMessage() );
 
+
 
+					throw new Error( 'No WebGPU support' );
 
+
 
+				}
 
+
 
+				camera = new THREE.PerspectiveCamera( 60, window.innerWidth / window.innerHeight, 0.1, 200 );
 
+				camera.position.set( 0, 0, 10 );
 
+
 
+				scene = new THREE.Scene();
 
+
 
+				clock = new THREE.Clock();
 
+
 
+				// renderer
 
+
 
+				renderer = new THREE.WebGPURenderer( { antialias: true } );
 
+				renderer.setClearColor( 0x14171a );
 
+				renderer.setPixelRatio( window.devicePixelRatio );
 
+				renderer.setSize( window.innerWidth, window.innerHeight );
 
+				renderer.setAnimationLoop( animate );
 
+				document.body.appendChild( renderer.domElement );
 
+
 
+				// TSL function
 
+				// current color from index
 
+				getInstanceColor = /*#__PURE__*/ Fn( ( [ i ] ) => {
 
+
 
+					return hue( color( 0x0000ff ), colorOffset.add( mx_fractal_noise_float( i.toFloat().mul( .1 ), 2, 2.0, 0.5, colorVariance ) ) );
 
+
 
+				} );
 
+
 
+				// Particles
 
+				// storage buffers
 
+				const particlePositions = storage( new THREE.StorageInstancedBufferAttribute( nbParticles, 4 ), 'vec4', nbParticles );
 
+				const particleVelocities = storage( new THREE.StorageInstancedBufferAttribute( nbParticles, 4 ), 'vec4', nbParticles );
 
+
 
+				// init particles buffers
 
+				renderer.compute( /*#__PURE__*/ Fn( () => {
 
+
 
+					particlePositions.element( instanceIndex ).xyz.assign( vec3( 10000.0 ) );
 
+					particlePositions.element( instanceIndex ).w.assign( vec3( - 1.0 ) ); // life is stored in w component; x<0 means dead
 
+
 
+				} )().compute( nbParticles ) );
 
+
 
+				// particles output
 
+				const particleQuadSize = 0.05;
 
+				const particleGeom = new THREE.PlaneGeometry( particleQuadSize, particleQuadSize );
 
+
 
+				const particleMaterial = new THREE.SpriteNodeMaterial();
 
+				particleMaterial.transparent = true;
 
+				particleMaterial.blending = THREE.AdditiveBlending;
 
+				particleMaterial.depthWrite = false;
 
+				particleMaterial.positionNode = particlePositions.toAttribute();
 
+				particleMaterial.scaleNode = vec2( particleSize );
 
+				particleMaterial.rotationNode = atan2( particleVelocities.toAttribute().y, particleVelocities.toAttribute().x );
 
+
 
+				particleMaterial.colorNode = /*#__PURE__*/ Fn( () => {
 
+
 
+					const life = particlePositions.toAttribute().w;
 
+					const modLife = pcurve( life.oneMinus(), 8.0, 1.0 );
 
+					const pulse = pcurve(
 
+						sin( hash( instanceIndex ).mul( PI2 ).add( timerGlobal( 0.5 ).mul( PI2 ) ) ).mul( 0.5 ).add( 0.5 ),
 
+						0.25,
 
+						0.25
 
+					).mul( 10.0 ).add( 1.0 );
 
+
 
+					return getInstanceColor( instanceIndex ).mul( pulse.mul( modLife ) );
 
+
 
+				} )();
 
+
 
+				particleMaterial.opacityNode = /*#__PURE__*/ Fn( () => {
 
+
 
+					const circle = uv().xy.sub( 0.5 ).length().step( 0.5 );
 
+					const life = particlePositions.toAttribute().w;
 
+
 
+					return circle.mul( life );
 
+
 
+				} )();
 
+
 
+				const particleMesh = new THREE.InstancedMesh( particleGeom, particleMaterial, nbParticles );
 
+				particleMesh.instanceMatrix.setUsage( THREE.DynamicDrawUsage );
 
+				particleMesh.frustumCulled = false;
 
+
 
+				scene.add( particleMesh );
 
+
 
+				// Links between particles
 
+				// first, we define the indices for the links, 2 quads per particle, the indexation is fixed
 
+				const linksIndices = [];
 
+				for ( let i = 0; i < nbParticles; i ++ ) {
 
+
 
+					const baseIndex = i * 8;
 
+					for ( let j = 0; j < 2; j ++ ) {
 
+
 
+						const offset = baseIndex + j * 4;
 
+						linksIndices.push( offset, offset + 1, offset + 2, offset, offset + 2, offset + 3 );
 
+
 
+					}
 
+
 
+				}
 
+
 
+				// storage buffers attributes for the links
 
+				const nbVertices = nbParticles * 8;
 
+				const linksVerticesSBA = new THREE.StorageBufferAttribute( nbVertices, 4 );
 
+				const linksColorsSBA = new THREE.StorageBufferAttribute( nbVertices, 4 );
 
+
 
+				// links output
 
+				const linksGeom = new THREE.BufferGeometry();
 
+				linksGeom.setAttribute( 'position', linksVerticesSBA );
 
+				linksGeom.setAttribute( 'color', linksColorsSBA );
 
+				linksGeom.setIndex( linksIndices );
 
+
 
+				const linksMaterial = new THREE.MeshBasicNodeMaterial();
 
+				linksMaterial.vertexColors = true;
 
+				linksMaterial.side = THREE.DoubleSide;
 
+				linksMaterial.transparent = true;
 
+				linksMaterial.depthWrite = false;
 
+				linksMaterial.depthTest = false;
 
+				linksMaterial.blending = THREE.AdditiveBlending;
 
+				linksMaterial.opacityNode = storage( linksColorsSBA, 'vec4', linksColorsSBA.count ).toAttribute().w;
 
+
 
+				const linksMesh = new THREE.Mesh( linksGeom, linksMaterial );
 
+				linksMesh.frustumCulled = false;
 
+				scene.add( linksMesh );
 
+
 
+				// compute nodes
 
+				updateParticles = /*#__PURE__*/ Fn( () => {
 
+
 
+					const position = particlePositions.element( instanceIndex ).xyz;
 
+					const life = particlePositions.element( instanceIndex ).w;
 
+					const velocity = particleVelocities.element( instanceIndex ).xyz;
 
+					const dt = timerDelta( 0.1 ).mul( timeScale );
 
+
 
+					If( life.greaterThan( 0.0 ), () => {
 
+
 
+						// first we update the particles positions and velocities
 
+						// velocity comes from a turbulence field, and is multiplied by the particle lifetime so that it slows down over time
 
+						const localVel = mx_fractal_noise_vec3( position.mul( turbFrequency ), turbOctaves, turbLacunarity, turbGain, turbAmplitude ).mul( life.add( .01 ) );
 
+						velocity.addAssign( localVel );
 
+						velocity.mulAssign( turbFriction.oneMinus() );
 
+						position.addAssign( velocity.mul( dt ) );
 
+
 
+						// then we decrease the lifetime
 
+						life.subAssign( dt.mul( particleLifetime.reciprocal() ) );
 
+
 
+						// then we find the two closest particles and set a quad to each of them
 
+						const closestDist1 = float( 10000.0 ).toVar();
 
+						const closestPos1 = vec3( 0.0 ).toVar();
 
+						const closestLife1 = float( 0.0 ).toVar();
 
+						const closestDist2 = float( 10000.0 ).toVar();
 
+						const closestPos2 = vec3( 0.0 ).toVar();
 
+						const closestLife2 = float( 0.0 ).toVar();
 
+
 
+						Loop( nbParticles, ( { i } ) => {
 
+
 
+							const otherPart = particlePositions.element( i );
 
+
 
+							If( i.notEqual( instanceIndex ).and( otherPart.w.greaterThan( 0.0 ) ), () => { // if not self and other particle is alive
 
+
 
+								const otherPosition = otherPart.xyz;
 
+								const dist = position.sub( otherPosition ).lengthSq();
 
+								const moreThanZero = dist.greaterThan( 0.0 );
 
+
 
+								If( dist.lessThan( closestDist1 ).and( moreThanZero ), () => {
 
+
 
+									closestDist1.assign( dist );
 
+									closestPos1.assign( otherPosition.xyz );
 
+									closestLife1.assign( otherPart.w );
 
+
 
+								} ).ElseIf( dist.lessThan( closestDist2 ).and( moreThanZero ), () => {
 
+
 
+									closestDist2.assign( dist );
 
+									closestPos2.assign( otherPosition.xyz );
 
+									closestLife2.assign( otherPart.w );
 
+
 
+								} );
 
+
 
+							} );
 
+
 
+						} );
 
+
 
+						// then we update the links correspondingly
 
+						const linksPositions = storage( linksVerticesSBA, 'vec4', linksVerticesSBA.count );
 
+						const linksColors = storage( linksColorsSBA, 'vec4', linksColorsSBA.count );
 
+						const firstLinkIndex = instanceIndex.mul( 8 );
 
+						const secondLinkIndex = firstLinkIndex.add( 4 );
 
+
 
+						// positions link 1
 
+						linksPositions.element( firstLinkIndex ).xyz.assign( position );
 
+						linksPositions.element( firstLinkIndex ).y.addAssign( linksWidth );
 
+						linksPositions.element( firstLinkIndex.add( 1 ) ).xyz.assign( position );
 
+						linksPositions.element( firstLinkIndex.add( 1 ) ).y.addAssign( linksWidth.negate() );
 
+						linksPositions.element( firstLinkIndex.add( 2 ) ).xyz.assign( closestPos1 );
 
+						linksPositions.element( firstLinkIndex.add( 2 ) ).y.addAssign( linksWidth.negate() );
 
+						linksPositions.element( firstLinkIndex.add( 3 ) ).xyz.assign( closestPos1 );
 
+						linksPositions.element( firstLinkIndex.add( 3 ) ).y.addAssign( linksWidth );
 
+
 
+						// positions link 2
 
+						linksPositions.element( secondLinkIndex ).xyz.assign( position );
 
+						linksPositions.element( secondLinkIndex ).y.addAssign( linksWidth );
 
+						linksPositions.element( secondLinkIndex.add( 1 ) ).xyz.assign( position );
 
+						linksPositions.element( secondLinkIndex.add( 1 ) ).y.addAssign( linksWidth.negate() );
 
+						linksPositions.element( secondLinkIndex.add( 2 ) ).xyz.assign( closestPos2 );
 
+						linksPositions.element( secondLinkIndex.add( 2 ) ).y.addAssign( linksWidth.negate() );
 
+						linksPositions.element( secondLinkIndex.add( 3 ) ).xyz.assign( closestPos2 );
 
+						linksPositions.element( secondLinkIndex.add( 3 ) ).y.addAssign( linksWidth );
 
+
 
+						// colors are the same for all vertices of both quads
 
+						const linkColor = getInstanceColor( instanceIndex );
 
+
 
+						// store the minimum lifetime of the closest particles in the w component of colors
 
+						const l1 = max( 0.0, min( closestLife1, life ) ).pow( 0.8 ); // pow is here to apply a slight curve to the opacity
 
+						const l2 = max( 0.0, min( closestLife2, life ) ).pow( 0.8 );
 
+
 
+						Loop( 4, ( { i } ) => {
 
+
 
+							linksColors.element( firstLinkIndex.add( i ) ).xyz.assign( linkColor );
 
+							linksColors.element( firstLinkIndex.add( i ) ).w.assign( l1 );
 
+							linksColors.element( secondLinkIndex.add( i ) ).xyz.assign( linkColor );
 
+							linksColors.element( secondLinkIndex.add( i ) ).w.assign( l2 );
 
+
 
+						} );
 
+
 
+					} );
 
+
 
+				} )().compute( nbParticles );
 
+
 
+				spawnParticles = /*#__PURE__*/ Fn( () => {
 
+
 
+					const particleIndex = spawnIndex.add( instanceIndex ).mod( nbParticles ).toInt();
 
+					const position = particlePositions.element( particleIndex ).xyz;
 
+					const life = particlePositions.element( particleIndex ).w;
 
+					const velocity = particleVelocities.element( particleIndex ).xyz;
 
+
 
+					life.assign( 1.0 ); // sets it alive
 
+
 
+					// random spherical direction
 
+					const rRange = float( 0.01 );
 
+					const rTheta = hash( particleIndex ).mul( PI2 );
 
+					const rPhi = hash( particleIndex.add( 1 ) ).mul( PI );
 
+					const rx = sin( rTheta ).mul( cos( rPhi ) );
 
+					const ry = sin( rTheta ).mul( sin( rPhi ) );
 
+					const rz = cos( rTheta );
 
+					const rDir = vec3( rx, ry, rz );
 
+
 
+					// position is interpolated between the previous cursor position and the current one over the number of particles spawned
 
+					const pos = mix( previousSpawnPosition, spawnPosition, instanceIndex.toFloat().div( nbToSpawn.sub( 1 ).toFloat() ).clamp() );
 
+					position.assign( pos.add( rDir.mul( rRange ) ) );
 
+
 
+					// start in that direction
 
+					velocity.assign( rDir.mul( 5.0 ) );
 
+
 
+				} )().compute( nbToSpawn.value );
 
+
 
+
 
+				// background , an inverted icosahedron
 
+				const backgroundGeom = new THREE.IcosahedronGeometry( 100, 5 ).applyMatrix4( new THREE.Matrix4().makeScale( - 1, 1, 1 ) );
 
+				const backgroundMaterial = new THREE.MeshStandardNodeMaterial();
 
+				backgroundMaterial.roughness = 0.4;
 
+				backgroundMaterial.metalness = 0.9;
 
+				backgroundMaterial.flatShading = true;
 
+				backgroundMaterial.colorNode = color( 0x0 );
 
+
 
+				const backgroundMesh = new THREE.Mesh( backgroundGeom, backgroundMaterial );
 
+				scene.add( backgroundMesh );
 
+
 
+				// light for the background
 
+				light = new THREE.PointLight( 0xffffff, 3000 );
 
+				scene.add( light );
 
+
 
+				// post processing
 
+
 
+				postProcessing = new THREE.PostProcessing( renderer );
 
+
 
+				const scenePass = pass( scene, camera );
 
+				const scenePassColor = scenePass.getTextureNode( 'output' );
 
+
 
+				const bloomPass = bloom( scenePassColor, 0.75, 0.1, 0.5 );
 
+
 
+				postProcessing.outputNode = scenePassColor.add( bloomPass );
 
+
 
+				// controls
 
+
 
+				controls = new OrbitControls( camera, renderer.domElement );
 
+				controls.enableDamping = true;
 
+				controls.autoRotate = true;
 
+				controls.maxDistance = 75;
 
+				window.addEventListener( 'resize', onWindowResize );
 
+
 
+				// pointer handling
 
+
 
+				window.addEventListener( 'pointermove', onPointerMove );
 
+
 
+				// GUI
 
+
 
+				const gui = new GUI();
 
+
 
+				gui.add( controls, 'autoRotate' ).name( 'Auto Rotate' );
 
+				gui.add( controls, 'autoRotateSpeed', - 10.0, 10.0, 0.01 ).name( 'Auto Rotate Speed' );				
+
 
+				const partFolder = gui.addFolder( 'Particles' );
 
+				partFolder.add( timeScale, 'value', 0.0, 4.0, 0.01 ).name( 'timeScale' );
 
+				partFolder.add( nbToSpawn, 'value', 1, 100, 1 ).name( 'Spawn rate' );
 
+				partFolder.add( particleSize, 'value', 0.01, 3.0, 0.01 ).name( 'Size' );
 
+				partFolder.add( particleLifetime, 'value', 0.01, 2.0, 0.01 ).name( 'Lifetime' );
 
+				partFolder.add( linksWidth, 'value', 0.001, 0.1, 0.001 ).name( 'Links width' );
 
+				partFolder.add( colorVariance, 'value', 0.0, 10.0, 0.01 ).name( 'Color variance' );
 
+				partFolder.add( colorRotationSpeed, 'value', 0.0, 5.0, 0.01 ).name( 'Color rotation speed' );
 
+
 
+				const turbFolder = gui.addFolder( 'Turbulence' );
 
+				turbFolder.add( turbFriction, 'value', 0.0, 0.3, 0.01 ).name( 'Friction' );
 
+				turbFolder.add( turbFrequency, 'value', 0.0, 1.0, 0.01 ).name( 'Frequency' );
 
+				turbFolder.add( turbAmplitude, 'value', 0.0, 10.0, 0.01 ).name( 'Amplitude' );
 
+				turbFolder.add( turbOctaves, 'value', 1, 9, 1 ).name( 'Octaves' );
 
+				turbFolder.add( turbLacunarity, 'value', 1.0, 5.0, 0.01 ).name( 'Lacunarity' );
 
+				turbFolder.add( turbGain, 'value', 0.0, 1.0, 0.01 ).name( 'Gain' );
 
+
 
+				const bloomFolder = gui.addFolder( 'bloom' );
 
+				bloomFolder.add( bloomPass.threshold, 'value', 0, 2.0, 0.01 ).name( 'Threshold' );
 
+				bloomFolder.add( bloomPass.strength, 'value', 0, 10, 0.01 ).name( 'Strength' );
 
+				bloomFolder.add( bloomPass.radius, 'value', 0, 1, 0.01 ).name( 'Radius' );
 
+
 
+			}
 
+
 
+			function onWindowResize( e ) {
 
+
 
+				camera.aspect = window.innerWidth / window.innerHeight;
 
+				camera.updateProjectionMatrix();
 
+
 
+				renderer.setSize( window.innerWidth, window.innerHeight );
 
+
 
+			}
 
+
 
+			function onPointerMove( e ) {
 
+
 
+				screenPointer.x = ( e.clientX / window.innerWidth ) * 2 - 1;
 
+				screenPointer.y = - ( e.clientY / window.innerHeight ) * 2 + 1;
 
+
 
+			}
 
+
 
+			function updatePointer() {
 
+
 
+				raycaster.setFromCamera( screenPointer, camera );
 
+				raycaster.ray.intersectPlane( raycastPlane, scenePointer );
 
+
 
+			}
 
+
 
+			async function animate() {
 
+
 
+				// compute particles
 
+				await renderer.computeAsync( updateParticles );
 
+				await renderer.computeAsync( spawnParticles );
 
+
 
+				// update particle index for next spawn
 
+				spawnIndex.value = ( spawnIndex.value + nbToSpawn.value ) % nbParticles;
 
+
 
+				// update raycast plane to face camera
 
+				raycastPlane.normal.applyEuler( camera.rotation );
 
+				updatePointer();
 
+
 
+				// lerping spawn position
 
+				previousSpawnPosition.value.copy( spawnPosition.value );
 
+				spawnPosition.value.lerp( scenePointer, 0.1 );
 
+
 
+				// rotating colors
 
+				colorOffset.value += clock.getDelta() * colorRotationSpeed.value * timeScale.value;
 
+
 
+				const elapsedTime = clock.getElapsedTime();
 
+				light.position.set(
 
+					Math.sin( elapsedTime * 0.5 ) * 30,
 
+					Math.cos( elapsedTime * 0.3 ) * 30,
 
+					Math.sin( elapsedTime * 0.2 ) * 30,
 
+				);
 
+
 
+				controls.update();
 
+
 
+				postProcessing.renderAsync();
 
+
 
+			}
 
+
 
+		</script>
 
+	</body>
 
+</html>

+ 1 - 0
test/e2e/puppeteer.js
Tampilan Berkas 

@@ -148,6 +148,7 @@ const exceptionList = [
 
 	'webgpu_tsl_coffee_smoke',
 
 	'webgpu_tsl_coffee_smoke',
 
 	'webgpu_tsl_vfx_flames',
 
 	'webgpu_tsl_vfx_flames',
 
 	'webgpu_tsl_halftone',
 
 	'webgpu_tsl_halftone',
 
+	'webgpu_tsl_vfx_linkedparticles',
 
 	'webgpu_tsl_vfx_tornado',
 
 	'webgpu_tsl_vfx_tornado',
 
 	'webgpu_textures_anisotropy',
 
 	'webgpu_textures_anisotropy',

粤ICP备19079148号