@amg555/frameforge-mcp 2.7.6 → 2.7.7

package/.agent/skills/faceless-shorts/styles/deep-dive/example/vendor/addons/postprocessing/UnrealBloomPass.js

@@ -1,415 +0,0 @@
-import {
-	AdditiveBlending,
-	Color,
-	HalfFloatType,
-	MeshBasicMaterial,
-	ShaderMaterial,
-	UniformsUtils,
-	Vector2,
-	Vector3,
-	WebGLRenderTarget
-} from 'three';
-import { Pass, FullScreenQuad } from './Pass.js';
-import { CopyShader } from '../shaders/CopyShader.js';
-import { LuminosityHighPassShader } from '../shaders/LuminosityHighPassShader.js';
-
-/**
- * UnrealBloomPass is inspired by the bloom pass of Unreal Engine. It creates a
- * mip map chain of bloom textures and blurs them with different radii. Because
- * of the weighted combination of mips, and because larger blurs are done on
- * higher mips, this effect provides good quality and performance.
- *
- * Reference:
- * - https://docs.unrealengine.com/latest/INT/Engine/Rendering/PostProcessEffects/Bloom/
- */
-class UnrealBloomPass extends Pass {
-
-	constructor( resolution, strength, radius, threshold ) {
-
-		super();
-
-		this.strength = ( strength !== undefined ) ? strength : 1;
-		this.radius = radius;
-		this.threshold = threshold;
-		this.resolution = ( resolution !== undefined ) ? new Vector2( resolution.x, resolution.y ) : new Vector2( 256, 256 );
-
-		// create color only once here, reuse it later inside the render function
-		this.clearColor = new Color( 0, 0, 0 );
-
-		// render targets
-		this.renderTargetsHorizontal = [];
-		this.renderTargetsVertical = [];
-		this.nMips = 5;
-		let resx = Math.round( this.resolution.x / 2 );
-		let resy = Math.round( this.resolution.y / 2 );
-
-		this.renderTargetBright = new WebGLRenderTarget( resx, resy, { type: HalfFloatType } );
-		this.renderTargetBright.texture.name = 'UnrealBloomPass.bright';
-		this.renderTargetBright.texture.generateMipmaps = false;
-
-		for ( let i = 0; i < this.nMips; i ++ ) {
-
-			const renderTargetHorizontal = new WebGLRenderTarget( resx, resy, { type: HalfFloatType } );
-
-			renderTargetHorizontal.texture.name = 'UnrealBloomPass.h' + i;
-			renderTargetHorizontal.texture.generateMipmaps = false;
-
-			this.renderTargetsHorizontal.push( renderTargetHorizontal );
-
-			const renderTargetVertical = new WebGLRenderTarget( resx, resy, { type: HalfFloatType } );
-
-			renderTargetVertical.texture.name = 'UnrealBloomPass.v' + i;
-			renderTargetVertical.texture.generateMipmaps = false;
-
-			this.renderTargetsVertical.push( renderTargetVertical );
-
-			resx = Math.round( resx / 2 );
-
-			resy = Math.round( resy / 2 );
-
-		}
-
-		// luminosity high pass material
-
-		const highPassShader = LuminosityHighPassShader;
-		this.highPassUniforms = UniformsUtils.clone( highPassShader.uniforms );
-
-		this.highPassUniforms[ 'luminosityThreshold' ].value = threshold;
-		this.highPassUniforms[ 'smoothWidth' ].value = 0.01;
-
-		this.materialHighPassFilter = new ShaderMaterial( {
-			uniforms: this.highPassUniforms,
-			vertexShader: highPassShader.vertexShader,
-			fragmentShader: highPassShader.fragmentShader
-		} );
-
-		// gaussian blur materials
-
-		this.separableBlurMaterials = [];
-		const kernelSizeArray = [ 3, 5, 7, 9, 11 ];
-		resx = Math.round( this.resolution.x / 2 );
-		resy = Math.round( this.resolution.y / 2 );
-
-		for ( let i = 0; i < this.nMips; i ++ ) {
-
-			this.separableBlurMaterials.push( this.getSeperableBlurMaterial( kernelSizeArray[ i ] ) );
-
-			this.separableBlurMaterials[ i ].uniforms[ 'invSize' ].value = new Vector2( 1 / resx, 1 / resy );
-
-			resx = Math.round( resx / 2 );
-
-			resy = Math.round( resy / 2 );
-
-		}
-
-		// composite material
-
-		this.compositeMaterial = this.getCompositeMaterial( this.nMips );
-		this.compositeMaterial.uniforms[ 'blurTexture1' ].value = this.renderTargetsVertical[ 0 ].texture;
-		this.compositeMaterial.uniforms[ 'blurTexture2' ].value = this.renderTargetsVertical[ 1 ].texture;
-		this.compositeMaterial.uniforms[ 'blurTexture3' ].value = this.renderTargetsVertical[ 2 ].texture;
-		this.compositeMaterial.uniforms[ 'blurTexture4' ].value = this.renderTargetsVertical[ 3 ].texture;
-		this.compositeMaterial.uniforms[ 'blurTexture5' ].value = this.renderTargetsVertical[ 4 ].texture;
-		this.compositeMaterial.uniforms[ 'bloomStrength' ].value = strength;
-		this.compositeMaterial.uniforms[ 'bloomRadius' ].value = 0.1;
-
-		const bloomFactors = [ 1.0, 0.8, 0.6, 0.4, 0.2 ];
-		this.compositeMaterial.uniforms[ 'bloomFactors' ].value = bloomFactors;
-		this.bloomTintColors = [ new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ) ];
-		this.compositeMaterial.uniforms[ 'bloomTintColors' ].value = this.bloomTintColors;
-
-		// blend material
-
-		const copyShader = CopyShader;
-
-		this.copyUniforms = UniformsUtils.clone( copyShader.uniforms );
-
-		this.blendMaterial = new ShaderMaterial( {
-			uniforms: this.copyUniforms,
-			vertexShader: copyShader.vertexShader,
-			fragmentShader: copyShader.fragmentShader,
-			blending: AdditiveBlending,
-			depthTest: false,
-			depthWrite: false,
-			transparent: true
-		} );
-
-		this.enabled = true;
-		this.needsSwap = false;
-
-		this._oldClearColor = new Color();
-		this.oldClearAlpha = 1;
-
-		this.basic = new MeshBasicMaterial();
-
-		this.fsQuad = new FullScreenQuad( null );
-
-	}
-
-	dispose() {
-
-		for ( let i = 0; i < this.renderTargetsHorizontal.length; i ++ ) {
-
-			this.renderTargetsHorizontal[ i ].dispose();
-
-		}
-
-		for ( let i = 0; i < this.renderTargetsVertical.length; i ++ ) {
-
-			this.renderTargetsVertical[ i ].dispose();
-
-		}
-
-		this.renderTargetBright.dispose();
-
-		//
-
-		for ( let i = 0; i < this.separableBlurMaterials.length; i ++ ) {
-
-			this.separableBlurMaterials[ i ].dispose();
-
-		}
-
-		this.compositeMaterial.dispose();
-		this.blendMaterial.dispose();
-		this.basic.dispose();
-
-		//
-
-		this.fsQuad.dispose();
-
-	}
-
-	setSize( width, height ) {
-
-		let resx = Math.round( width / 2 );
-		let resy = Math.round( height / 2 );
-
-		this.renderTargetBright.setSize( resx, resy );
-
-		for ( let i = 0; i < this.nMips; i ++ ) {
-
-			this.renderTargetsHorizontal[ i ].setSize( resx, resy );
-			this.renderTargetsVertical[ i ].setSize( resx, resy );
-
-			this.separableBlurMaterials[ i ].uniforms[ 'invSize' ].value = new Vector2( 1 / resx, 1 / resy );
-
-			resx = Math.round( resx / 2 );
-			resy = Math.round( resy / 2 );
-
-		}
-
-	}
-
-	render( renderer, writeBuffer, readBuffer, deltaTime, maskActive ) {
-
-		renderer.getClearColor( this._oldClearColor );
-		this.oldClearAlpha = renderer.getClearAlpha();
-		const oldAutoClear = renderer.autoClear;
-		renderer.autoClear = false;
-
-		renderer.setClearColor( this.clearColor, 0 );
-
-		if ( maskActive ) renderer.state.buffers.stencil.setTest( false );
-
-		// Render input to screen
-
-		if ( this.renderToScreen ) {
-
-			this.fsQuad.material = this.basic;
-			this.basic.map = readBuffer.texture;
-
-			renderer.setRenderTarget( null );
-			renderer.clear();
-			this.fsQuad.render( renderer );
-
-		}
-
-		// 1. Extract Bright Areas
-
-		this.highPassUniforms[ 'tDiffuse' ].value = readBuffer.texture;
-		this.highPassUniforms[ 'luminosityThreshold' ].value = this.threshold;
-		this.fsQuad.material = this.materialHighPassFilter;
-
-		renderer.setRenderTarget( this.renderTargetBright );
-		renderer.clear();
-		this.fsQuad.render( renderer );
-
-		// 2. Blur All the mips progressively
-
-		let inputRenderTarget = this.renderTargetBright;
-
-		for ( let i = 0; i < this.nMips; i ++ ) {
-
-			this.fsQuad.material = this.separableBlurMaterials[ i ];
-
-			this.separableBlurMaterials[ i ].uniforms[ 'colorTexture' ].value = inputRenderTarget.texture;
-			this.separableBlurMaterials[ i ].uniforms[ 'direction' ].value = UnrealBloomPass.BlurDirectionX;
-			renderer.setRenderTarget( this.renderTargetsHorizontal[ i ] );
-			renderer.clear();
-			this.fsQuad.render( renderer );
-
-			this.separableBlurMaterials[ i ].uniforms[ 'colorTexture' ].value = this.renderTargetsHorizontal[ i ].texture;
-			this.separableBlurMaterials[ i ].uniforms[ 'direction' ].value = UnrealBloomPass.BlurDirectionY;
-			renderer.setRenderTarget( this.renderTargetsVertical[ i ] );
-			renderer.clear();
-			this.fsQuad.render( renderer );
-
-			inputRenderTarget = this.renderTargetsVertical[ i ];
-
-		}
-
-		// Composite All the mips
-
-		this.fsQuad.material = this.compositeMaterial;
-		this.compositeMaterial.uniforms[ 'bloomStrength' ].value = this.strength;
-		this.compositeMaterial.uniforms[ 'bloomRadius' ].value = this.radius;
-		this.compositeMaterial.uniforms[ 'bloomTintColors' ].value = this.bloomTintColors;
-
-		renderer.setRenderTarget( this.renderTargetsHorizontal[ 0 ] );
-		renderer.clear();
-		this.fsQuad.render( renderer );
-
-		// Blend it additively over the input texture
-
-		this.fsQuad.material = this.blendMaterial;
-		this.copyUniforms[ 'tDiffuse' ].value = this.renderTargetsHorizontal[ 0 ].texture;
-
-		if ( maskActive ) renderer.state.buffers.stencil.setTest( true );
-
-		if ( this.renderToScreen ) {
-
-			renderer.setRenderTarget( null );
-			this.fsQuad.render( renderer );
-
-		} else {
-
-			renderer.setRenderTarget( readBuffer );
-			this.fsQuad.render( renderer );
-
-		}
-
-		// Restore renderer settings
-
-		renderer.setClearColor( this._oldClearColor, this.oldClearAlpha );
-		renderer.autoClear = oldAutoClear;
-
-	}
-
-	getSeperableBlurMaterial( kernelRadius ) {
-
-		const coefficients = [];
-
-		for ( let i = 0; i < kernelRadius; i ++ ) {
-
-			coefficients.push( 0.39894 * Math.exp( - 0.5 * i * i / ( kernelRadius * kernelRadius ) ) / kernelRadius );
-
-		}
-
-		return new ShaderMaterial( {
-
-			defines: {
-				'KERNEL_RADIUS': kernelRadius
-			},
-
-			uniforms: {
-				'colorTexture': { value: null },
-				'invSize': { value: new Vector2( 0.5, 0.5 ) }, // inverse texture size
-				'direction': { value: new Vector2( 0.5, 0.5 ) },
-				'gaussianCoefficients': { value: coefficients } // precomputed Gaussian coefficients
-			},
-
-			vertexShader:
-				`varying vec2 vUv;
-				void main() {
-					vUv = uv;
-					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-				}`,
-
-			fragmentShader:
-				`#include <common>
-				varying vec2 vUv;
-				uniform sampler2D colorTexture;
-				uniform vec2 invSize;
-				uniform vec2 direction;
-				uniform float gaussianCoefficients[KERNEL_RADIUS];
-
-				void main() {
-					float weightSum = gaussianCoefficients[0];
-					vec3 diffuseSum = texture2D( colorTexture, vUv ).rgb * weightSum;
-					for( int i = 1; i < KERNEL_RADIUS; i ++ ) {
-						float x = float(i);
-						float w = gaussianCoefficients[i];
-						vec2 uvOffset = direction * invSize * x;
-						vec3 sample1 = texture2D( colorTexture, vUv + uvOffset ).rgb;
-						vec3 sample2 = texture2D( colorTexture, vUv - uvOffset ).rgb;
-						diffuseSum += (sample1 + sample2) * w;
-						weightSum += 2.0 * w;
-					}
-					gl_FragColor = vec4(diffuseSum/weightSum, 1.0);
-				}`
-		} );
-
-	}
-
-	getCompositeMaterial( nMips ) {
-
-		return new ShaderMaterial( {
-
-			defines: {
-				'NUM_MIPS': nMips
-			},
-
-			uniforms: {
-				'blurTexture1': { value: null },
-				'blurTexture2': { value: null },
-				'blurTexture3': { value: null },
-				'blurTexture4': { value: null },
-				'blurTexture5': { value: null },
-				'bloomStrength': { value: 1.0 },
-				'bloomFactors': { value: null },
-				'bloomTintColors': { value: null },
-				'bloomRadius': { value: 0.0 }
-			},
-
-			vertexShader:
-				`varying vec2 vUv;
-				void main() {
-					vUv = uv;
-					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-				}`,
-
-			fragmentShader:
-				`varying vec2 vUv;
-				uniform sampler2D blurTexture1;
-				uniform sampler2D blurTexture2;
-				uniform sampler2D blurTexture3;
-				uniform sampler2D blurTexture4;
-				uniform sampler2D blurTexture5;
-				uniform float bloomStrength;
-				uniform float bloomRadius;
-				uniform float bloomFactors[NUM_MIPS];
-				uniform vec3 bloomTintColors[NUM_MIPS];
-
-				float lerpBloomFactor(const in float factor) {
-					float mirrorFactor = 1.2 - factor;
-					return mix(factor, mirrorFactor, bloomRadius);
-				}
-
-				void main() {
-					gl_FragColor = bloomStrength * ( lerpBloomFactor(bloomFactors[0]) * vec4(bloomTintColors[0], 1.0) * texture2D(blurTexture1, vUv) +
-						lerpBloomFactor(bloomFactors[1]) * vec4(bloomTintColors[1], 1.0) * texture2D(blurTexture2, vUv) +
-						lerpBloomFactor(bloomFactors[2]) * vec4(bloomTintColors[2], 1.0) * texture2D(blurTexture3, vUv) +
-						lerpBloomFactor(bloomFactors[3]) * vec4(bloomTintColors[3], 1.0) * texture2D(blurTexture4, vUv) +
-						lerpBloomFactor(bloomFactors[4]) * vec4(bloomTintColors[4], 1.0) * texture2D(blurTexture5, vUv) );
-				}`
-		} );
-
-	}
-
-}
-
-UnrealBloomPass.BlurDirectionX = new Vector2( 1.0, 0.0 );
-UnrealBloomPass.BlurDirectionY = new Vector2( 0.0, 1.0 );
-
-export { UnrealBloomPass };

package/.agent/skills/faceless-shorts/styles/deep-dive/example/vendor/addons/shaders/BokehShader.js

@@ -1,145 +0,0 @@
-/**
- * Depth-of-field shader with bokeh
- * ported from GLSL shader by Martins Upitis
- * http://artmartinsh.blogspot.com/2010/02/glsl-lens-blur-filter-with-bokeh.html
- */
-
-const BokehShader = {
-
-	name: 'BokehShader',
-
-	defines: {
-		'DEPTH_PACKING': 1,
-		'PERSPECTIVE_CAMERA': 1,
-	},
-
-	uniforms: {
-
-		'tColor': { value: null },
-		'tDepth': { value: null },
-		'focus': { value: 1.0 },
-		'aspect': { value: 1.0 },
-		'aperture': { value: 0.025 },
-		'maxblur': { value: 0.01 },
-		'nearClip': { value: 1.0 },
-		'farClip': { value: 1000.0 },
-
-	},
-
-	vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-
-	fragmentShader: /* glsl */`
-
-		#include <common>
-
-		varying vec2 vUv;
-
-		uniform sampler2D tColor;
-		uniform sampler2D tDepth;
-
-		uniform float maxblur; // max blur amount
-		uniform float aperture; // aperture - bigger values for shallower depth of field
-
-		uniform float nearClip;
-		uniform float farClip;
-
-		uniform float focus;
-		uniform float aspect;
-
-		#include <packing>
-
-		float getDepth( const in vec2 screenPosition ) {
-			#if DEPTH_PACKING == 1
-			return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
-			#else
-			return texture2D( tDepth, screenPosition ).x;
-			#endif
-		}
-
-		float getViewZ( const in float depth ) {
-			#if PERSPECTIVE_CAMERA == 1
-			return perspectiveDepthToViewZ( depth, nearClip, farClip );
-			#else
-			return orthographicDepthToViewZ( depth, nearClip, farClip );
-			#endif
-		}
-
-
-		void main() {
-
-			vec2 aspectcorrect = vec2( 1.0, aspect );
-
-			float viewZ = getViewZ( getDepth( vUv ) );
-
-			float factor = ( focus + viewZ ); // viewZ is <= 0, so this is a difference equation
-
-			vec2 dofblur = vec2 ( clamp( factor * aperture, -maxblur, maxblur ) );
-
-			vec2 dofblur9 = dofblur * 0.9;
-			vec2 dofblur7 = dofblur * 0.7;
-			vec2 dofblur4 = dofblur * 0.4;
-
-			vec4 col = vec4( 0.0 );
-
-			col += texture2D( tColor, vUv.xy );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur );
-
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur9 );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur9 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur9 );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur9 );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur9 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur9 );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur9 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur9 );
-
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur7 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur7 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur7 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur7 );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur7 );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur7 );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur7 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur7 );
-
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur4 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.4,   0.0  ) * aspectcorrect ) * dofblur4 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur4 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur4 );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur4 );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur4 );
-			col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur4 );
-			col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur4 );
-
-			gl_FragColor = col / 41.0;
-			gl_FragColor.a = 1.0;
-
-		}`
-
-};
-
-export { BokehShader };

package/.agent/skills/faceless-shorts/styles/deep-dive/example/vendor/addons/shaders/CopyShader.js

@@ -1,45 +0,0 @@
-/**
- * Full-screen textured quad shader
- */
-
-const CopyShader = {
-
-	name: 'CopyShader',
-
-	uniforms: {
-
-		'tDiffuse': { value: null },
-		'opacity': { value: 1.0 }
-
-	},
-
-	vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-
-	fragmentShader: /* glsl */`
-
-		uniform float opacity;
-
-		uniform sampler2D tDiffuse;
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vec4 texel = texture2D( tDiffuse, vUv );
-			gl_FragColor = opacity * texel;
-
-
-		}`
-
-};
-
-export { CopyShader };

package/.agent/skills/faceless-shorts/styles/deep-dive/example/vendor/addons/shaders/LuminosityHighPassShader.js

@@ -1,64 +0,0 @@
-import {
-	Color
-} from 'three';
-
-/**
- * Luminosity
- * http://en.wikipedia.org/wiki/Luminosity
- */
-
-const LuminosityHighPassShader = {
-
-	name: 'LuminosityHighPassShader',
-
-	shaderID: 'luminosityHighPass',
-
-	uniforms: {
-
-		'tDiffuse': { value: null },
-		'luminosityThreshold': { value: 1.0 },
-		'smoothWidth': { value: 1.0 },
-		'defaultColor': { value: new Color( 0x000000 ) },
-		'defaultOpacity': { value: 0.0 }
-
-	},
-
-	vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-
-	fragmentShader: /* glsl */`
-
-		uniform sampler2D tDiffuse;
-		uniform vec3 defaultColor;
-		uniform float defaultOpacity;
-		uniform float luminosityThreshold;
-		uniform float smoothWidth;
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vec4 texel = texture2D( tDiffuse, vUv );
-
-			float v = luminance( texel.xyz );
-
-			vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );
-
-			float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );
-
-			gl_FragColor = mix( outputColor, texel, alpha );
-
-		}`
-
-};
-
-export { LuminosityHighPassShader };